go语言获取一月的日期 go 获取当前时间

如何使用Go语言实现远程执行命令

一般命令

创新互联公司一直通过网站建设和网站营销帮助企业获得更多客户资源。 以"深度挖掘，量身打造，注重实效"的一站式服务，以成都网站制作、做网站、外贸营销网站建设、移动互联产品、全网营销推广服务为核心业务。十多年网站制作的经验，使用新网站建设技术，全新开发出的标准网站，不但价格便宜而且实用、灵活，特别适合中小公司网站制作。网站管理系统简单易用，维护方便，您可以完全操作网站资料，是中小公司快速网站建设的选择。

所谓一般命令，就是在一定时间内会执行完的命令。比如 grep, cat 等等。 执行命令的步骤是：连接，执行，获取结果

连接

连接包含了认证，可以使用 password 或者 sshkey 2种方式来认证。下面的示例为了简单，使用了密码认证的方式来完成连接。

import (

"fmt"

"time"

"golang.org/x/crypto/ssh"

)

func connect(user, password, host string, port int) (*ssh.Session, error) {

var (

auth []ssh.AuthMethod

addr string

clientConfig *ssh.ClientConfig

client *ssh.Client

session *ssh.Session

err error

)

// get auth method

auth = make([]ssh.AuthMethod, 0)

auth = append(auth, ssh.Password(password))

clientConfig = ssh.ClientConfig{

User: user,

Auth: auth,

Timeout: 30 * time.Second,

}

// connet to ssh

addr = fmt.Sprintf("%s:%d", host, port)

if client, err = ssh.Dial("tcp", addr, clientConfig); err != nil {

return nil, err

}

// create session

if session, err = client.NewSession(); err != nil {

return nil, err

}

return session, nil

}

连接的方法很简单，只要提供登录主机的 用户*， *密码*， *主机名或者IP*， *SSH端口

执行，命令获取结果

连接成功后，执行命令很简单

import (

"fmt"

"log"

"os"

"time"

"golang.org/x/crypto/ssh"

)

func main() {

session, err := connect("root", "xxxxx", "127.0.0.1", 22)

if err != nil {

log.Fatal(err)

}

defer session.Close()

session.Run("ls /; ls /abc")

}

上面代码运行之后，虽然命令正常执行了，但是没有正常输出的结果，也没有异常输出的结果。 要想显示结果，需要将 session 的 Stdout 和 Stderr 重定向 修改 func main 为如下：

func main() {

session, err := connect("root", "xxxxx", "127.0.0.1", 22)

if err != nil {

log.Fatal(err)

}

defer session.Close()

session.Stdout = os.Stdout

session.Stderr = os.Stderr

session.Run("ls /; ls /abc")

}

这样就能在屏幕上显示正常，异常的信息了。

交互式命令

上面的方式无法远程执行交互式命令，比如 top ， 远程编辑一个文件，比如 vi /etc/nginx/nginx.conf 如果要支持交互式的命令，需要当前的terminal来接管远程的 PTY。

func main() {

session, err := connect("root", "olordjesus", "dockers.iotalabs.io", 2210)

if err != nil {

log.Fatal(err)

}

defer session.Close()

fd := int(os.Stdin.Fd())

oldState, err := terminal.MakeRaw(fd)

if err != nil {

panic(err)

}

defer terminal.Restore(fd, oldState)

// excute command

session.Stdout = os.Stdout

session.Stderr = os.Stderr

session.Stdin = os.Stdin

termWidth, termHeight, err := terminal.GetSize(fd)

if err != nil {

panic(err)

}

// Set up terminal modes

modes := ssh.TerminalModes{

ssh.ECHO: 1, // enable echoing

ssh.TTY_OP_ISPEED: 14400, // input speed = 14.4kbaud

ssh.TTY_OP_OSPEED: 14400, // output speed = 14.4kbaud

}

// Request pseudo terminal

if err := session.RequestPty("xterm-256color", termHeight, termWidth, modes); err != nil {

log.Fatal(err)

}

session.Run("top")

}

golang之context详解

为什么需要context

在go服务器中，对于每个请求的request都是在单独的goroutine中进行的，处理一个request也可能设计多个goroutine之间的交互， 使用context可以使开发者方便的在这些goroutine里传递request相关的数据、取消goroutine的signal或截止日期

在并发程序中，由于超时、取消操作或者一些异常情况，往往需要进行抢占操作或者中断后续操作。熟悉channel的朋友应该都见过使用done channel来处理此类问题。比如以下这个例子：

上述例子中定义了一个buffer为0的channel done, 子协程运行着定时任务。如果主协程需要在某个时刻发送消息通知子协程中断任务退出，那么就可以让子协程监听这个done channel，一旦主协程关闭done channel，那么子协程就可以推出了，这样就实现了主协程通知子协程的需求。这很好，但是这也是有限的。

如果我们可以在简单的通知上附加传递额外的信息来控制取消：为什么取消，或者有一个它必须要完成的最终期限，更或者有多个取消选项，我们需要根据额外的信息来判断选择执行哪个取消选项。

考虑下面这种情况：假如主协程中有多个任务1, 2, …m，主协程对这些任务有超时控制；而其中任务1又有多个子任务1, 2, …n，任务1对这些子任务也有自己的超时控制，那么这些子任务既要感知主协程的取消信号，也需要感知任务1的取消信号。

如果还是使用done channel的用法，我们需要定义两个done channel，子任务们需要同时监听这两个done channel。嗯，这样其实好像也还行哈。但是如果层级更深，如果这些子任务还有子任务，那么使用done channel的方式将会变得非常繁琐且混乱。

我们需要一种优雅的方案来实现这样一种机制：

上层任务取消后，所有的下层任务都会被取消；中间某一层的任务取消后，只会将当前任务的下层任务取消，而不会影响上层的任务以及同级任务。

这个时候context就派上用场了。我们首先看看context的结构设计和实现原理。

context接口

先看Context接口结构，看起来非常简单。

}

Context接口包含四个方法：

Deadline返回绑定当前context的任务被取消的截止时间；如果没有设定期限，将返回ok == false。

Done 当绑定当前context的任务被取消时，将返回一个关闭的channel；如果当前context不会被取消，将返回nil。

Err 如果Done返回的channel没有关闭，将返回nil;如果Done返回的channel已经关闭，将返回非空的值表示任务结束的原因。如果是context被取消，Err将返回Canceled；如果是context超时，Err将返回DeadlineExceeded。

Value 返回context存储的键值对中当前key对应的值，如果没有对应的key,则返回nil。

可以看到Done方法返回的channel正是用来传递结束信号以抢占并中断当前任务；Deadline方法指示一段时间后当前goroutine是否会被取消；以及一个Err方法，来解释goroutine被取消的原因；而Value则用于获取特定于当前任务树的额外信息。而context所包含的额外信息键值对是如何存储的呢？其实可以想象一颗树，树的每个节点可能携带一组键值对,如果当前节点上无法找到key所对应的值，就会向上去父节点里找，直到根节点。

emptyCtx

emptyCtx是一个int类型的变量，但实现了context的接口。emptyCtx没有超时时间，不能取消，也不能存储任何额外信息，所以emptyCtx用来作为context树的根节点。

Background和TODO只是用于不同场景下： Background通常被用于主函数、初始化以及测试中，作为一个顶层的context，也就是说一般我们创建的context都是基于Background；而TODO是在不确定使用什么context的时候才会使用。

用法 ：

Go 语言到底适合干什么？

Go语言主要用作服务器端开发，其定位是用来开发“大型软件”的，适合于需要很多程序员一起开发，并且开发周期较长的大型软件和支持云计算的网络服务。

Go语言融合了传统编译型语言的高效性和脚本语言的易用性和富于表达性，不仅提高了项目的开发速度，而且后期维护起来也非常轻松。

编译器

当前有两个Go编译器分支，分别为官方编译器gc和gccgo。官方编译器在初期使用C写成，后用Go重写从而实现自举。Gccgo是一个使用标准GCC作为后端的Go编译器。

官方编译器支持跨平台编译（但不支持CGO），允许将源代码编译为可在目标系统、架构上执行的二进制文件。

彻底理解Golang Map

本文目录如下，阅读本文后，将一网打尽下面Golang Map相关面试题

Go中的map是一个指针，占用8个字节，指向hmap结构体; 源码 src/runtime/map.go 中可以看到map的底层结构

每个map的底层结构是hmap，hmap包含若干个结构为bmap的bucket数组。每个bucket底层都采用链表结构。接下来，我们来详细看下map的结构

bmap 就是我们常说的“桶”，一个桶里面会最多装 8 个 key，这些 key 之所以会落入同一个桶，是因为它们经过哈希计算后，哈希结果是“一类”的，关于key的定位我们在map的查询和插入中详细说明。在桶内，又会根据 key 计算出来的 hash 值的高 8 位来决定 key 到底落入桶内的哪个位置（一个桶内最多有8个位置)。

bucket内存数据结构可视化如下：

注意到 key 和 value 是各自放在一起的，并不是 key/value/key/value/... 这样的形式。源码里说明这样的好处是在某些情况下可以省略掉 padding字段，节省内存空间。

当 map 的 key 和 value 都不是指针，并且 size 都小于 128 字节的情况下，会把 bmap 标记为不含指针，这样可以避免 gc 时扫描整个 hmap。但是，我们看 bmap 其实有一个 overflow 的字段，是指针类型的，破坏了 bmap 不含指针的设想，这时会把 overflow 移动到 extra 字段来。

map是个指针，底层指向hmap，所以是个引用类型

golang 有三个常用的高级类型 slice 、map、channel, 它们都是 引用类型 ，当引用类型作为函数参数时，可能会修改原内容数据。

golang 中没有引用传递，只有值和指针传递。所以 map 作为函数实参传递时本质上也是值传递，只不过因为 map 底层数据结构是通过指针指向实际的元素存储空间，在被调函数中修改 map，对调用者同样可见，所以 map 作为函数实参传递时表现出了引用传递的效果。

因此，传递 map 时，如果想修改map的内容而不是map本身，函数形参无需使用指针

map 底层数据结构是通过指针指向实际的元素 存储空间 ，这种情况下，对其中一个map的更改，会影响到其他map

map 在没有被修改的情况下，使用 range 多次遍历 map 时输出的 key 和 value 的顺序可能不同。这是 Go 语言的设计者们有意为之，在每次 range 时的顺序被随机化，旨在提示开发者们，Go 底层实现并不保证 map 遍历顺序稳定，请大家不要依赖 range 遍历结果顺序。

map 本身是无序的，且遍历时顺序还会被随机化，如果想顺序遍历 map，需要对 map key 先排序，再按照 key 的顺序遍历 map。

map默认是并发不安全的，原因如下：

Go 官方在经过了长时间的讨论后，认为 Go map 更应适配典型使用场景（不需要从多个 goroutine 中进行安全访问），而不是为了小部分情况（并发访问），导致大部分程序付出加锁代价（性能），决定了不支持。

场景: 2个协程同时读和写，以下程序会出现致命错误：fatal error: concurrent map writes

如果想实现map线程安全，有两种方式：

方式一：使用读写锁 map + sync.RWMutex

方式二：使用golang提供的 sync.Map

sync.map是用读写分离实现的，其思想是空间换时间。和map+RWLock的实现方式相比，它做了一些优化：可以无锁访问read map，而且会优先操作read map，倘若只操作read map就可以满足要求(增删改查遍历)，那就不用去操作write map(它的读写都要加锁)，所以在某些特定场景中它发生锁竞争的频率会远远小于map+RWLock的实现方式。

golang中map是一个kv对集合。底层使用hash table，用链表来解决冲突 ，出现冲突时，不是每一个key都申请一个结构通过链表串起来，而是以bmap为最小粒度挂载，一个bmap可以放8个kv。在哈希函数的选择上，会在程序启动时，检测 cpu 是否支持 aes，如果支持，则使用 aes hash，否则使用 memhash。

map有3钟初始化方式，一般通过make方式创建

map的创建通过生成汇编码可以知道，make创建map时调用的底层函数是 runtime.makemap 。如果你的map初始容量小于等于8会发现走的是 runtime.fastrand 是因为容量小于8时不需要生成多个桶，一个桶的容量就可以满足

makemap函数会通过 fastrand 创建一个随机的哈希种子，然后根据传入的 hint 计算出需要的最小需要的桶的数量，最后再使用 makeBucketArray 创建用于保存桶的数组，这个方法其实就是根据传入的 B 计算出的需要创建的桶数量在内存中分配一片连续的空间用于存储数据，在创建桶的过程中还会额外创建一些用于保存溢出数据的桶，数量是 2^(B-4) 个。初始化完成返回hmap指针。

找到一个 B，使得 map 的装载因子在正常范围内

Go 语言中读取 map 有两种语法：带 comma 和 不带 comma。当要查询的 key 不在 map 里，带 comma 的用法会返回一个 bool 型变量提示 key 是否在 map 中；而不带 comma 的语句则会返回一个 value 类型的零值。如果 value 是 int 型就会返回 0，如果 value 是 string 类型，就会返回空字符串。

map的查找通过生成汇编码可以知道，根据 key 的不同类型，编译器会将查找函数用更具体的函数替换，以优化效率：

函数首先会检查 map 的标志位 flags。如果 flags 的写标志位此时被置 1 了，说明有其他协程在执行“写”操作，进而导致程序 panic。这也说明了 map 对协程是不安全的。

key经过哈希函数计算后，得到的哈希值如下（主流64位机下共 64 个 bit 位）：

m: 桶的个数

从buckets 通过 hash m 得到对应的bucket，如果bucket正在扩容，并且没有扩容完成，则从oldbuckets得到对应的bucket

计算hash所在桶编号：

用上一步哈希值最后的 5 个 bit 位，也就是 01010 ，值为 10，也就是 10 号桶（范围是0~31号桶）

计算hash所在的槽位:

用上一步哈希值哈希值的高8个bit 位，也就是 10010111 ，转化为十进制，也就是151，在 10 号 bucket 中寻找** tophash 值（HOB hash）为 151* 的 槽位**，即为key所在位置，找到了 2 号槽位，这样整个查找过程就结束了。

如果在 bucket 中没找到，并且 overflow 不为空，还要继续去 overflow bucket 中寻找，直到找到或是所有的 key 槽位都找遍了，包括所有的 overflow bucket。

通过上面找到了对应的槽位，这里我们再详细分析下key/value值是如何获取的：

bucket 里 key 的起始地址就是 unsafe.Pointer(b)+dataOffset。第 i 个 key 的地址就要在此基础上跨过 i 个 key 的大小；而我们又知道，value 的地址是在所有 key 之后，因此第 i 个 value 的地址还需要加上所有 key 的偏移。

通过汇编语言可以看到，向 map 中插入或者修改 key，最终调用的是 mapassign 函数。

实际上插入或修改 key 的语法是一样的，只不过前者操作的 key 在 map 中不存在，而后者操作的 key 存在 map 中。

mapassign 有一个系列的函数，根据 key 类型的不同，编译器会将其优化为相应的“快速函数”。

我们只用研究最一般的赋值函数 mapassign 。

map的赋值会附带着map的扩容和迁移，map的扩容只是将底层数组扩大了一倍，并没有进行数据的转移，数据的转移是在扩容后逐步进行的，在迁移的过程中每进行一次赋值（access或者delete）会至少做一次迁移工作。

1.判断map是否为nil

每一次进行赋值/删除操作时，只要oldbuckets != nil 则认为正在扩容，会做一次迁移工作，下面会详细说下迁移过程

根据上面查找过程，查找key所在位置，如果找到则更新，没找到则找空位插入即可

经过前面迭代寻找动作，若没有找到可插入的位置，意味着需要扩容进行插入，下面会详细说下扩容过程

通过汇编语言可以看到，向 map 中删除 key，最终调用的是 mapdelete 函数

删除的逻辑相对比较简单，大多函数在赋值操作中已经用到过，核心还是找到 key 的具体位置。寻找过程都是类似的，在 bucket 中挨个 cell 寻找。找到对应位置后，对 key 或者 value 进行“清零”操作，将 count 值减 1，将对应位置的 tophash 值置成 Empty

再来说触发 map 扩容的时机：在向 map 插入新 key 的时候，会进行条件检测，符合下面这 2 个条件，就会触发扩容：

1、装载因子超过阈值

源码里定义的阈值是 6.5 (loadFactorNum/loadFactorDen)，是经过测试后取出的一个比较合理的因子

我们知道，每个 bucket 有 8 个空位，在没有溢出，且所有的桶都装满了的情况下，装载因子算出来的结果是 8。因此当装载因子超过 6.5 时，表明很多 bucket 都快要装满了，查找效率和插入效率都变低了。在这个时候进行扩容是有必要的。

对于条件 1，元素太多，而 bucket 数量太少，很简单：将 B 加 1，bucket 最大数量( 2^B )直接变成原来 bucket 数量的 2 倍。于是，就有新老 bucket 了。注意，这时候元素都在老 bucket 里，还没迁移到新的 bucket 来。新 bucket 只是最大数量变为原来最大数量的 2 倍( 2^B * 2 ) 。

2、overflow 的 bucket 数量过多

在装载因子比较小的情况下，这时候 map 的查找和插入效率也很低，而第 1 点识别不出来这种情况。表面现象就是计算装载因子的分子比较小，即 map 里元素总数少，但是 bucket 数量多（真实分配的 bucket 数量多，包括大量的 overflow bucket）

不难想像造成这种情况的原因：不停地插入、删除元素。先插入很多元素，导致创建了很多 bucket，但是装载因子达不到第 1 点的临界值，未触发扩容来缓解这种情况。之后，删除元素降低元素总数量，再插入很多元素，导致创建很多的 overflow bucket，但就是不会触发第 1 点的规定，你能拿我怎么办？overflow bucket 数量太多，导致 key 会很分散，查找插入效率低得吓人，因此出台第 2 点规定。这就像是一座空城，房子很多，但是住户很少，都分散了，找起人来很困难

对于条件 2，其实元素没那么多，但是 overflow bucket 数特别多，说明很多 bucket 都没装满。解决办法就是开辟一个新 bucket 空间，将老 bucket 中的元素移动到新 bucket，使得同一个 bucket 中的 key 排列地更紧密。这样，原来，在 overflow bucket 中的 key 可以移动到 bucket 中来。结果是节省空间，提高 bucket 利用率，map 的查找和插入效率自然就会提升。

由于 map 扩容需要将原有的 key/value 重新搬迁到新的内存地址，如果有大量的 key/value 需要搬迁，会非常影响性能。因此 Go map 的扩容采取了一种称为“渐进式”的方式，原有的 key 并不会一次性搬迁完毕，每次最多只会搬迁 2 个 bucket。

上面说的 hashGrow() 函数实际上并没有真正地“搬迁”，它只是分配好了新的 buckets，并将老的 buckets 挂到了 oldbuckets 字段上。真正搬迁 buckets 的动作在 growWork() 函数中，而调用 growWork() 函数的动作是在 mapassign 和 mapdelete 函数中。也就是插入或修改、删除 key 的时候，都会尝试进行搬迁 buckets 的工作。先检查 oldbuckets 是否搬迁完毕，具体来说就是检查 oldbuckets 是否为 nil。

如果未迁移完毕，赋值/删除的时候，扩容完毕后（预分配内存），不会马上就进行迁移。而是采取 增量扩容 的方式，当有访问到具体 bukcet 时，才会逐渐的进行迁移（将 oldbucket 迁移到 bucket）

nevacuate 标识的是当前的进度，如果都搬迁完，应该和2^B的长度是一样的

在evacuate 方法实现是把这个位置对应的bucket，以及其冲突链上的数据都转移到新的buckets上。

转移的判断直接通过tophash 就可以，判断tophash中第一个hash值即可

遍历的过程，就是按顺序遍历 bucket，同时按顺序遍历 bucket 中的 key。

map遍历是无序的，如果想实现有序遍历，可以先对key进行排序

为什么遍历 map 是无序的？

如果发生过迁移，key 的位置发生了重大的变化，有些 key 飞上高枝，有些 key 则原地不动。这样，遍历 map 的结果就不可能按原来的顺序了。

如果就一个写死的 map，不会向 map 进行插入删除的操作，按理说每次遍历这样的 map 都会返回一个固定顺序的 key/value 序列吧。但是 Go 杜绝了这种做法，因为这样会给新手程序员带来误解，以为这是一定会发生的事情，在某些情况下，可能会酿成大错。

Go 做得更绝，当我们在遍历 map 时，并不是固定地从 0 号 bucket 开始遍历，每次都是从一个**随机值序号的 bucket 开始遍历，并且是从这个 bucket 的一个 随机序号的 cell **开始遍历。这样，即使你是一个写死的 map，仅仅只是遍历它，也不太可能会返回一个固定序列的 key/value 对了。

从PHP 到Golang 的笔记 ( 转 )

———文章来源 YamiOdymel/PHP-to-Golang

PHP和模块之间的关系令人感到烦躁，假设你要读取 yaml 档案，你需要有一个 yaml 的模块，为此，你还需要将其编译然后将编译后的模块摆放至指定位置，之后换了一台伺服器你还要重新编译，这点到现在还是没有改善；顺带一提之后出了PHP 7效能确实提升了许多（比Python 3快了些），但PHP仍令我感到臃肿，我觉得是时候

（转行）了。

PHP 和Golang 的效能我想毋庸置疑是后者比较快（而且是以倍数来算），也许有的人会认为两种不应该被放在一起比较，但Golang 本身就是偏向Web 开发的，所以这也是为什么我考虑转用Golang 的原因，起初我的考虑有几个：Node.js 和Rust 还有最终被选定的Golang；先谈谈Node.js 吧。

Node.js的效能可以说是快上PHP 3.5倍至6倍左右 ，而且撰写的语言还是JavaScript，蒸蚌，如此一来就不需要学习新语言了！搭配Babel更可以说是万能，不过那跟「跳跳虎」一样的Async逻辑还有那恐怖的Callback Hell，有人认为前者是种优点，这点我不否认，但是对学习PHP的我来说太过于"Mind Fuck"，至于后者的Callback Hell虽然有Promise，但是那又是另一个「Then Hell」的故事了。相较于Golang之下，Node.js似乎就没有那么吸引我了。你确实可以用Node.js写出很多东西，不过那V8引擎的效能仍然有限，而且要学习新的事物，不就应该是「全新」的吗;)？

题外话： 为什么Node.js不适合大型和商业专案？

在抛弃改用Node.js 之后我曾经花了一天的时间尝试Rust 和Iron 框架，嗯⋯⋯Rust 太强大了，强大到让我觉得Rust 不应该用在这里，这想法也许很蠢，但Rust 让我觉得适合更应该拿来用在系统或者是部分底层的地方，而不应该是网路服务。

Golang是我最终的选择，主要在于我花了一天的时间来研究的时候意外地发现Golang夭寿简洁（ 关键字只有25个 ），相较之下Rust太过于「强大」令我怯步；而且Golang带有许多工具，例如 go fmt 会自动帮你整理程式码、 go doc 会自动帮你生产文件、 go test 可以自动单元测试并生产覆盖率报表、也有 go get 套件管理工具（虽然没有版本功能），不过都很实用，而且也不需要加上分号（ ; ），真要说不好的地方⋯⋯大概就是强迫你花括号不能换行放吧（没错，我就是花括号会换行放的人）。

当我在撰写这份文件的时候 我会先假设你有一定的基础 ，你可以先阅读下列的手册，他们都很不错。

你能够在PHP 里面想建立一个变数的时候就直接建立，夭寿赞，是吗？

蒸蚌！那么Golang 呢？在Golang 中变数分为几类：「新定义」、「预先定义」、「自动新定义」、「覆盖」。让我们来看看范例：

在PHP中你会很常用到 echo 来显示文字，像这样。

然而在Golang中你会需要 fmt 套件，关于「什么是套件」的说明你可以在文章下述了解。

这很简单，而且两个语言的用法相差甚少，下面这是PHP：

只是Golang 稍微聒噪了一点，你必须在函式后面宣告他最后会回传什么资料型别。

在PHP 中你要回传多个资料你就会用上阵列，然后将资料放入阵列里面，像这样。

然而在Golang 中你可以不必用到一个阵列，函式可以一次回传多个值：

两个语言的撰写方式不尽相同。

主要是PHP 的阵列能做太多事情了，所以在PHP 里面要储存什么用阵列就好了。

在Golang里⋯⋯没有这么万能的东西，首先要先了解Golang中有这些型态： array , slice , map , interface ，

你他妈的我到底看了三洨，首先你要知道Golang是个强型别语言，意思是你的阵列中 只能有一种型态 ，什么意思？当你决定这个阵列是用来摆放字串资料的时候，你就只能在里面放字串。没有数值、没有布林值，就像你没有女朋友一样。

先撇开PHP 的「万能阵列」不管，Golang 中的阵列既单纯却又十分脑残，在定义一个阵列的时候，你必须给他一个长度还有其内容存放的资料型态，你的阵列内容不一定要填满其长度，但是你的阵列内容不能超过你当初定义的长度。

切片⋯⋯这听起来也许很奇怪，但是你确实可以「切」他，让我们先谈谈「切片」比起「阵列」要好在哪里：「你不用定义其最大长度，而且你可以直接赋予值」，没了。

我们刚才有提到你可以「切」他，记得吗？这有点像是PHP中的 array_slice() ，但是Golang直接让Slice「内建」了这个用法，其用法是： slice[开始:结束] 。

在PHP中倒是没有那么方便，在下列PHP范例中你需要不断地使用 array_slice() 。

你可以把「映照」看成是一个有键名和键值的阵列，但是记住：「你需要事先定义其键名、键值的资料型态」，这仍限制你没办法在映照中存放多种不同型态的资料。

在Golang里可就没这么简单了，你需要先用 make() 宣告 map 。

也许你不喜欢「接口」这个词，但用「介面」我怕会误导大众，所以，是的，接下来我会继续称其为「接口」。还记得你可以在PHP 的关联阵列里面存放任何型态的资料吗，像下面这样？

现在你有福了！正因为Golang中的 interface{} 可以接受任何内容，所以你可以把它拿来存放任何型态的资料。

有时候你也许会有个不定值的变数，在PHP 里你可以直接将一个变数定义成字串、数值、空值、就像你那变心的女友一样随时都在变。

在Golang中你必须给予变数一个指定的资料型别，不过还记得刚才提到的：「Golang中有个 interface{} 能够 存放任何事物 」吗（ 虽然也不是真的任何事物啦⋯⋯ ）？

当我们程式中不需要继续使用到某个资源或是发生错误的时候，我们索性会将其关闭或是抛弃来节省资源开销，例如PHP 里的读取档案：

在Golang中，你可以使用 defer 来在函式结束的时候自动执行某些程式(其执行方向为反向)。所以你就不需要在函式最后面结束最前面的资源。

defer 可以被称为「推迟执行」，实际上就是在函式结束后会「反序」执行的东西，例如你按照了这样的顺序定义 defer ： A-B-C-D ，那么执行的顺序其实会是 D-C-B-A ，这用在程式结束时还蛮有用的，让我们看看Golang如何改善上述范例。

这东西很邪恶，不是吗？又不是在写BASIC，不过也许有时候你会在PHP 用上呢。但是拜托，不要。

Golang中仅有 for 一种回圈但却能够达成 foreach 、 while 、 for 多种用法。普通 for 回圈写法在两个语言中都十分相近。

在Golang请记得：如果你的 i 先前并不存在，那么你就需要定义它，所以下面这个范例你会看见 i := 0 。

在PHP里， foreach() 能够直接给你值和键名，用起来十分简单。

Golang里面虽然仅有 for() 但却可以使用 range 达成和PHP一样的 foreach 方式。

一个 while(条件) 回圈在PHP里面可以不断地执行区块中的程式，直到 条件 为 false 为止。

在Golang里也有相同的做法，但仍是透过 for 回圈，请注意这个 for 回圈并没有任何的分号（ ; ），而且一个没有条件的 for 回圈会一直被执行。

PHP中有 do .. while() 回圈可以先做区块中的动作。

在Golang中则没有相关函式，但是你可以透过一个无止尽的 for 回圈加上条件式来让他结束回圈。

要是你真的希望完全符合像是PHP那样的设计方式，或者你可以在Golang中使用很邪恶的 goto 。

在PHP中我们可以透过 date() 像这样取得目前的日期。

在Golang就稍微有趣点了，因为Golang中并不是以 Y-m-d 这种格式做为定义，而是 1 、 2 、 3 ，这令你需要去翻阅文件，才能够知道 1 的定义是代表什么。

俗话说：「爆炸就是艺术」，可爱的PHP用词真的很大胆，像是： explode() （爆炸）、 die() （死掉），回归正传，如果你想在PHP里面将字串切割成阵列，你可以这么做。

简单的就让一个字串给「爆炸」了，那么Golang 呢？

对了，记得引用 strings 套件。

这真的是很常用到的功能，就像物件一样有着键名和键值，在PHP 里面你很简单的就能靠阵列（Array）办到。

真是太棒了，那么Golang呢？用 map 是差不多啦。如果有必要的话，你可以稍微复习一下先前提到的「多资料储存型态－Stores」。

你很常会在PHP里面用 isset() 检查一个索引是否存在，不是吗？

在Golang里面很简单的能够这样办到（仅适用于 map ）。

指针（有时也做参照）是一个像是「变数别名」的方法，这种方法让你不用整天覆盖旧的变数，让我们假设 A = 1; B = A; 这个时候 B 会复制一份 A 且两者不相干，倘若你希望修改 B 的时候实际上也会修改到 A 的值，就会需要指针。

指针比起复制一个变数，他会建立一个指向到某个变数的记忆体位置，这也就是为什么你改变指针，实际上是在改变某个变数。

在Golang你需要用上 * 还有 符号。

有些时候你会回传一个阵列，这个阵列里面可能有资料还有错误代号，而你会用条件式判断错误代号是否非空值。

在Golang中函式可以一次回传多个值。为此，你不需要真的回传一个阵列，不过要注意的是你将会回传一个属于 error 资料型态的错误，所以你需要引用 errors 套件来帮助你做这件事。

该注意的是Golang没有 try .. catch ，因为 Golang推荐这种错误处理方式 ，你应该在每一次执行可能会发生错误的程式时就处理错误，而非后来用 try 到处包覆你的程式。

在 if 条件式里宣告变数会让你只能在 if 内部使用这个变数，而不会污染到全域范围。

也许你在PHP中更常用的会是 try .. catch ，在大型商业逻辑时经常看见如此地用法，实际上这种用法令人感到聒噪（因为你会需要一堆 try 区块）：

Golang中并没有 try .. catch ，实际上Golang也 不鼓励这种行为 （Golang推荐逐一处理错误的方式），倘若你真想办倒像是捕捉异常这样的方式，你确实可以使用Golang中另类处理错误的方式（可以的话尽量避免使用这种方式）： panic() , recover() , defer 。

你可以把 panic() 当作是 throw （丢出错误），而这跟PHP的 exit() 有87%像，一但你执行了 panic() 你的程式就会宣告而终，但是别担心，因为程式结束的时候会呼叫 defer ，所以我们接下来要在 defer 停止 panic() 。

关于 defer 上述已经有提到了，他是一个反向执行的宣告，会在函式结束后被执行，当你呼叫了 panic() 结束程式的时候，也就会开始执行 defer ，所以我们要在 defer 内使用 recover() 让程式不再继续进行结束动作，这就像是捕捉异常。

recover() 可以看作 catch （捕捉），我们要在 defer 里面用 recover() 解决 panic() ，如此一来程式就会回归正常而不会被结束。

还记得在PHP里要引用一堆档案的日子吗？到处可见的 require() 或是 include() ？到了Golang这些都不见了，取而代之的是「套件（Package）」。现在让我们来用PHP解释一下。

这看起来很正常对吧？但假设你有一堆档案，这马上就成了 Include Hell ，让我们看看Golang怎么透过「套件」解决这个问题。

「 蛤？？？杀小？？？ 」你可能如此地说道。是的， main.go 中除了引用 fmt 套件（ 为了要输出结果用的套件 ）之外完全没有引用到 a.go 。

「 蛤？？？杀小？？？？？？ 」你仿佛回到了几秒钟前的自己。

既然没有引用其他档案，为什么 main.go 可以输出 foo 呢？注意到了吗， 两者都是属于 main 套件 ，因此 他们共享同一个区域 ，所以接下来要介绍的是什么叫做「套件」。

套件是每一个 .go 档案都必须声明在Golang原始码中最开端的东西，像下面这样：

这意味着目前的档案是属于 main 套件（ 你也可以依照你的喜好命名 ），那么要如何让同个套件之间的函式沟通呢？

接着是Golang；注意！你不需要引用任何档案，因为下列两个档案同属一个套件。

一个由「套件」所掌握的世界，比起PHP的 include() 和 require() 还要好太多了，对吗？

在Golang 中没有引用单独档案的方式，你必须汇入一整个套件，而且你要记住：「一定你汇入了，你就一定要使用它」，像下面这样。

假如你不希望使用你汇入的套件，你只是为了要触发那个套件的 main() 函式而引用的话⋯⋯，那么你可以在前面加上一个底线（ _ ）。

如果你的套件出现了名称冲突，你可以在套件来源前面给他一个新的名称。

现在你知道可以汇入套件了，那么什么是「汇出」？同个套件内的函式还有共享变数确实可以直接用，但那 并不表示可以给其他套件使用 ，其方法取决于 函式／变数的「开头大小写」 。

是的。 Golang依照一个函式／变数的开头大小写决定这个东西是否可供「汇出」 。

这用在区别函式的时候格外有用，因为小写开头的任何事物都是不供汇出的，反之，大写开头的任何事物都是用来汇出供其他套件使用的。

一开始可能会觉得这是什么奇异的规定，但写久之后，你就能发现比起JavaScript和Python以「底线为开头的命名方式」还要来得更好；比起成天宣告 public 、 private 、 protected 还要来得更快。

在Golang 中没有类别，但有所谓的「建构体（Struct）」和「接口（Interface）」，这就能够满足几乎所有的需求了，这也是为什么我认为Golang 很简洁却又很强大的原因。

让我们先用PHP 建立一个类别，然后看看Golang 怎么解决这个问题。

虽然Golang没有类别，但是「建构体（Struct）」就十分地堪用了，首先你要知道在Golang中「类别」的成员还有方法都是在「类别」外面所定义的，这跟PHP在类别内定义的方式有所不同，在Golang中还有一点，那就是他们没有 public 、 private 、 protected 的种类。

在PHP中，当有一个类别被 new 的时候会自动执行该类别内的建构子（ __construct() ），通常你会用这个来初始化一些类别内部的值。

但是在Golang 里因为没有类别，也就没有建构子，不巧的是建构体本身也不带有建构子的特性，这个时候你只能自己在外部建立一个建构用函式。

让我们假设你有两个类别，你会把其中一个类别传入到另一个类别里面使用，废话不多说！先上个PHP 范例（为了简短篇幅我省去了换行）。

在Golang中你也有相同的用法，但是请记得：「 任何东西都是在「类别」外完成建构的 」。

在PHP 中没有相关的范例，这部分会以刚才「嵌入」章节中的Golang 范例作为解说对象。

你可以看见Golang在进行 Foo 嵌入 Bar 的时候，会自动将 Foo 的成员暴露在 Bar 底下，那么假设「双方之间有相同的成员名称」呢？

这个时候被嵌入的成员就会被「遮蔽」，下面是个实际范例，还有你如何解决遮蔽问题：

虽然都是呼叫同一个函式，但是这个函式可以针对不同的资料来源做出不同的举动，这就是多形。你也能够把这看作是：「讯息的意义由接收者定义，而不是传送者」。

目前PHP 中没有真正的「多形」，不过你仍可以做出同样的东西。

嗯⋯⋯那么Golang呢？实际上更简单而且更有条理了，在Golang中有 interface 可以帮忙完成这个工作。

如果你对Interface还不熟悉，可以试着查看「 解释Golang中的Interface到底是什么 」文章。

谢谢你看到这里，可惜这篇文章却没有说出Golang 最重要的卖点：「Goroutine」和「Channel」