也许是最简洁版本，一篇文章上手Go语言

导读：Go语言是近年来最热门的编程语言，是Google开发的一种静态强类型、编译型、并发型，并具有垃圾回收功能的编程语言。Go语言同时具备开发效率高和执行效率高两大特点，被誉为云计算时代的C语言。本文作者通过一篇文章带你学会Go语言。

Go 语言是一门开源语言，能够轻松的构建简单，可靠，高效的软件。—— Golang

在很多语言中，解决给定的问题通常有多种方式。工程师需要花费大量的时间思考什么才是解决问题的最优解法。而在Golang中，问题的解法通常只有一种。

这一特性大大节约了工程师的时间，而且使得维护大型代码库变得更容易。在Golang中没有maps和filter这样"高消耗"的特性。

语言的特性带来更好的表现力也带来代价。

——Rob Pike

1. 开始动手

Golang由包组成。Golang编译器将main包编译为可执行文件，而非共享库。main包是应用的入口，通常被定义如下：

package main

下面看一个hello world 的例子，在Golang 的工作空间创建main.go文件。

1.1 工作空间

在Go语言中，工作空间由环境变量GOPATH定义。所有编写的代码需要在工作空间中。Go语言会在GOPATH和GOROOT的路径中搜索包。GoROOT是在安装的时候确定的安装路径。

下面来设置GOPATH，我们将~/workspace 加入工作空间。

# export env
export GOPATH=~/workspace
# go inside the workspace
cd ~/workspace

1.2 HELLO WORLD!

我们在刚才的工作空间下创建main.go 文件，代码如下：

package main
import (
    "fmt"
)
func main(){
    fmt.Println("Hello World!")
}

上面的例子中，fmt是Go内置的格式化I/O函数。

我们在Go语言中使用import关键字导入包，func main 是入口函数。Println是fmt包中函数，用于打印 "Hello World!"。

让我们开始运行该文件。众所周知Go是编译型语言，我们在运行之前先进行编译。

> go build main.go

这将会创建一个二进制运行文件main，我们现在来运行它：

> ./main
# Hello World!

另一种简单的方式是使用go run 命令：

go run main.go
# Hello World!

2. 变量

Go中的变量类型是显式指定的。Go语言是强类型语言，这意味着在变量声明的时候会检查变量类型。

变量定义如下所示：

var a int

在这个例子中，a的初始值被设置为0。用下面的方式可以定义并初始化变量。

var a = 1

这里的变量被编译器推断为int。更简单的变量定义如下所示：

message := "hello world"

我们也可以在同一行声明多个变量：

var b, c int = 2, 3

3.数据类型

3.1 NUMBER，STRING， BOOLEAN

int 的类型有 int， int8, int16, int32, int64, unit, unit8, unit16, unit 32, unit64, unitptr...

String类型使用byte序列存储数据，用关键字string来声明变量。

bool 关键字表示布尔类型。

Golang 也支持复数，用conplex64和complex128表示。

var a bool = true
vat b int = 1
var c string = "hello world"
var d float32 = 1.222
var x complex128 = cmplx.Sqrt(-5 +12i)
3.2 ARRAYS，SLICES，MAPS

Array 是同类型元素的数组。Array在声明的时候会指定长度且不能改变。一个数组的定义如下：

var a[5] int

也有多维数组，定义如下

var multiD [2][3]int

Slices 是能随时扩容的同类型元素的序列 。Slice的声明方式如下：

var b []int

这将会创建一个容量为0，长度为0的Slice。Slice也可以定义容量和长度，格式如下：

numbers := make([]int, 5, 10)

这个Slice初始长度为5，容量为10。

Slice是数组的封装，其内部实现是数组，slice有三个元素，容量，长度和指向内部数组的指针。

Slice的容量可以通过append 或者 copy函数增加。Append函数也能在数组的末尾添加元素，在容量不足的情况下会对slice扩容。

numbers = append(numbers， 1， 2, 3， 4)

另一种增加slice容量的方式是使用copy函数。Copy函数的原理是创建一个新的大容量的slice，并把原有的slice拷贝到新的slice中。

// 创建新的slice
number2 := make([]int, 15)
// 复制原有的slice到新的slice
copy(number2, nu
mber)

我们也可以创建slice的子slice。例子如下：

 package main

 import (
     "fmt"
 )

 func main() {
     // 初始化slice
     number2 := []int{1, 2, 3, 4}
     fmt.Println(number2) // -> [1 2 3 4]
     // 创建子slice
     slice1 := number2[2:]
     fmt.Println(slice1) // -> [3 4]
     slice2 := number2[:3]
     fmt.Println(slice2) // -> [1 2 3]
     slice3 := number2[1:4]
     fmt.Println(slice3) // -> [2 3 4]
 }

Go语言中的Map是键值对，定义如下：

var m map[string]int

m是定义的变量名，键的类型是string，值的类型是integers。Map中添加键值对的例子如下：

package main

 import (
     "fmt"
 )

 func main() {
     m := make(map[string]int)
     // 添加键值对
     m["clearity"] = 2
     m["simplicity"] = 3
     // 打印值
     fmt.Println(m["clearity"])   // -> 2
     fmt.Println(m["simplicity"]) // -> 3
 }

4. 类型转换

使用类型转换能够改变数据类型，例子如下：

package main

 import (
     "fmt"
 )

 func increment(i *int) {
     *i++
 }

 func main() {
     a := 1.1
     b := int(a)
     fmt.Println(b)
     //-> 1
 }

5. 条件表达式

5.1 IF ELSE

If else 的例子如下，需要注意的是花括号和条件表达式位于同一行。

package main

 import (
     "fmt"
 )

 func increment(i *int) {
     *i++
 }

 func main() {
     if num := 9; num < 0 {
         fmt.Println(num, "is negative")
     } else if num < 10 {
         fmt.Println(num, "has 1 digit")
     } else {
         fmt.Println(num, "has multiple digits")
     }
 }

5.2 SWITCH CASE

Switch case 能组织多条件表达式，例子如下：

package main

 import (
     "fmt"
 )

 func increment(i *int) {
     *i++
 }

 func main() {
     i := 2
     switch i {
     case 1:
         fmt.Println("one")
     case 2:
         fmt.Println("two")
     default:
         fmt.Println("none")
     }
 }

6. 循环

Golang中只有一个循环表达的关键字，不同形式的循环表达式如下：

package main

 import (
     "fmt"
 )

 func increment(i *int) {
     *i++
 }

 func main() {
     i := 0
     sum := 0
     for i < 10 {
         sum += 1
         i++
     }
     fmt.Println(sum)
 }

上面的例子和C语言中的while循环类似，更为正式的循环表达形式如下：

package main

 import (
     "fmt"
 )

 func increment(i *int) {
     *i++
 }

 func main() {
     sum := 0
     for i := 0; i < 10; i++ {
         sum += i
     }
     fmt.Println(sum)
 }

Go 语言中的死循环定义如下：

for {
}

7. 指针

Go 语言可以使用指针，指针存储变量的地址，指针用*来定义。指针的定义和所指数据的类型相关：

var ap *int

这里的ap是指向整型数据的指针，&用于获取所变量的地址。

a :=12
ap = &a

• 用于获取指针所指的地址的值。

  fmt.Println(*ap)
  // => 12

  指针通常用于将结构体做为参数传递。

1.传值通常意味着拷贝，意味着需要更多的内存。
2.使用指针传递时，在函数中改变的变量会传递给调用的方法或函数。

package main

 import (
     "fmt"
 )

 func increment(i *int) {
     *i++
 }

 func main() {
     i := 10
     increment(&i)
     fmt.Println(i)
 }

 //=> 11

8. 函数

main 包中main函数是golang 程序的入口。我们可以定义多个函数并调用。例如：

package main

 import (
     "fmt"
 )

 func add(a int, b int) int {
     c := a + b
     return c
 }

 func main() {
     fmt.Println(add(2, 1))
 }
 //=> 3

从上面的例子中我们可以看出,Golang 中的函数用func关键字加上函数名， 后面是附带数据类型的参数，最后是函数的返回类型。

函数的返回值可以被预先定义，例子如下：

package main

 import (
     "fmt"
 )

 func add(a int, b int) (c int) {
     c = a + b
     return
 }

 func main() {
     fmt.Println(add(2, 1))
 }
 //=> 3

这里c定义为返回值，因此变量c将会被自动返回，无需在函数最后的return中声明。

你也可以定义一个多个返回值的函数，使用，进行分割。

 package main

 import (
     "fmt"
 )

 func add(a int, b int) (int, string) {
     c := a + b
     return c, "successfully added"
 }

 func main() {
     sum, message := add(2, 1)
     fmt.Println(message)
     fmt.Println(sum)
 }

 //=> successfully added
 //=> 3

8. 方法，结构体，接口

Golang 不是完全的面向对象语言，但是支持很多面向对象的特性，例如有结构体，接口，方法等。

8.1 结构体

结构体是有类型，不同变量的集合。例如我们想定义Person类型，其中包含姓名，年龄，性别。例如：

type person struct {
    name String
    age int
    gender string
}

定义好了person结构体后，我们现在来使用它：

//方式 1: 指定属性和值
p = person{name: "Bob", age: 42, gender: "Male"}
//方式 2: 只指定值
person{"Bob", 42, "Male"}

我们可以使用.符号访问这些属性：

p.name
//=> Bob
p.age
//=> 42
p.gender
//=> Male

你也可是使用指针访问结构体的属性：

pp = &person{name: "Bob", age: 42, gender: "Male"}
pp.name
//=> Bob

8.2 方法

方法是一种带有接受器的特殊函数。接收器可以是值或者指针。例子如下：

package main

 import "fmt"

 // 定义结构体
 type person struct {
     name   string
     age    int
     gender string
 }

 // 定义方法
 func (p *person) describe() {
     fmt.Printf("%v is %v years old.", p.name, p.age)
 }

 func (p *person) setAge(age int) {
     p.age = age
 }

 func (p person) setName(name string) {
     p.name = name
 }

 func main() {
     pp := &person{name: "Bob", age: 42, gender: "Male"}
     pp.describe()
     // => Bob is 42 years old
     pp.setAge(45)
     fmt.Println(pp.age)
     //=> 45
     pp.setName("Hari")
     fmt.Println(pp.name)
     //=> Bob
 }

从上面的例子我们可以看出，使用.操作符调用方法，例如pp.describe。需要注意的是，接收器是指针的话，我们传递的是值的引用，这意味着我们在方法做修改将会反映到变量pp上。该不会创建对象的拷贝，将会节省内存。

从上面的例子我们可以看出，age的值被改变了，而name的值并没有改变。这是因为方法setName的接受器不是指针。

8.3 接口

Golang中的接口是方法的集合，接口有助于将同类型的属性组合起来，让我们一起来看一个anminal的接口。

 type animal interface {
     description() string
 }

这里的animal是接口类型，我们来创建两种类型的animal并实现接口。

package main

 import (
     "fmt"
 )

 type animal interface {
     description() string
 }

 type cat struct {
     Type  string
     Sound string
 }

 type snake struct {
     Type      string
     Poisonous bool
 }

 func (s snake) description() string {
     return fmt.Sprintf("Poisonous: %v", s.Poisonous)
 }

 func (c cat) description() string {
     return fmt.Sprintf("Sound: %v", c.Sound)
 }

 func main() {
     var a animal
     a = snake{Poisonous: true}
     fmt.Println(a.description())
     a = cat{Sound: "Meow!!!"}
     fmt.Println(a.description())
 }

 //=> Poisonous: true
 //=> Sound: Meow!!!

在main函数中，我们创建可一个animal类型的变量a。我们把 snake和cat类型赋值给animal，使用Println 输出a.description。

我们在cat和snake中使用不同的方式实现了describe方法，我们得到了不同类型的输出。

9.包

在Golang中，我们的代码在某个包下。main包是程序执行的入口。在Go中有很多内置的包，例如我们之前用过的fmt包。

Go 的包机制是大型软件的基础，能够将大型的工程分解成小部分。

—— Robert Griesemer

9.1 安装一个包

go get
// 例子
go get github.com/satori/go.uuid
安装的包保存在GOPATH的环境中，你可以在 $GOPATH/pkg 路径下看到安装的包。

9.2 创建一个自定义包

首先创建一个文件夹 custom_package:

> mkdir custom_package
> cd custom_package

创建自定义包的第一步是创建一个和包名相同的文件夹。我们要创建person包，因此我们在custom_package文件下创建person文件夹：

> mkdir person
> cd person

在该路径下创建一个文件person.go:

package person

 func Description(name string) string {
     return "The person name is: " + name
 }

 func secretName(name string) string {
     return "Do not share"
 }

现在我们来安装这个包，这样我们就可以导入和使用它了：

> go install

接下来我们返回custom_package 文件夹中，创建一个main.go:

 package main

 import (
     "custom_package/person"
     "fmt"
 )

 func main() {
     p := person.Description("Milap")
     fmt.Println(p)
 }

 // => The person name is: Milap

在这里，我们可以导入之前创建的包person，需要注意的是在person包中函数secretName不能被访问，这是因为Go中小写字母开头的函数是私有函数。

9.3 生成包文档

Golang中有内置的功能支持包文档。运行下面的命令将生成文档：

godoc person Description

这将会为Description 函数生成文档，想要在web服务器上查看文档需要运行下面的命令：

godoc -http=":8080"

现在打开链接http://localhost:8080/pkg/将会看到我们刚才看到的文档。

9.4 Go 中内置的包

9.4.1 fmt

fmt包实现可标准的I/O函数，我们在之前的包中用过其中的打印输出函数。

9.4.2 json

Golang中另一个内置的重要包的是json，它能够对JSON进行编解码。

编码

 package main

 import (
     "encoding/json"
     "fmt"
 )

 func main() {
     mapA := map[string]int{"apple": 5, "lettuce": 7}
     mapB, _ := json.Marshal(mapA)
     fmt.Println(string(mapB))
 }

解码

package main

 import (
     "encoding/json"
     "fmt"
 )

 type response struct {
     PageNumber int      json:"page"
     Fruits     []string json:"fruits"
 }

 func main() {
     str := {"page": 1, "fruits": ["apple", "peach"]}
     res := response{}
     json.Unmarshal([]byte(str), &res)
     fmt.Println(res.PageNumber)
 }

 //=> 1

解码的时候使用Unmarshal方法，第一个参数是json字节，第二个参数是要映射的结构体的地址。需要注意的是json中的“page”对应的是结构体中的PageNumber。

10. 错误处理

错误是程序中不应该出现的结果。假设我们编写一个API调用外部的服务。这个API可能成功也可能失败。当存在错误是，Golang程序能够识别：

resp, err := http.Get("http://example.com/")

对API的 调用可能成功也可能失败，我们可以通过检查错误是否为空来选择处理方式。

package main

 import (
     "fmt"
     "net/http"
 )

 func main() {
     resp, err := http.Get("http://example.com/")
     if err != nil {
         fmt.Println(err)
         return
     }
     fmt.Println(resp)
 }

10.1 从函数中返回自定义错误

当我们在自定义函数是，某些情况下会产生错误。我们可以使用error 对象返回这些错误：

package main

 import (
     "errors"
     "fmt"
 )

 func Increment(n int) (int, error) {
     if n < 0 {
         // return error object
         return 0, errors.New("math: cannot process negative number")
     }
     return (n + 1), nil
 }

 func main() {
     num := 5
     if inc, err := Increment(num); err != nil {
         fmt.Printf("Failed Number: %v, error message: %v", num, err)
     } else {
         fmt.Printf("Incremented Number: %v", inc)
     }
 }

 // => The person name is: Milap

Go 内置的包，外部的包都有处理错误的机制。因此我们调用的函数都有可能产生错误。这些错误不应该忽略而是应该向上面的例子那样被优雅的处理。

10.2 Panic

Panic是程序运行中突然产生未经处理的异常。在Go中，panic不是合理处理异常的方式，推荐使用error对象代替。当Panic产生时，程序将会暂停运行。当panic被defer之后，程序才能继续运行。

//Go
 package main

 import "fmt"

 func main() {
     f()
     fmt.Println("Returned normally from f.")
 }

 func f() {
     defer func() {
         if r := recover(); r != nil {
             fmt.Println("Recovered in f", r)
         }
     }()
     fmt.Println("Calling g.")
     g(0)
     fmt.Println("Returned normally from g.")
 }

 func g(i int) {
     if i > 3 {
         fmt.Println("Panicking!")
         panic(fmt.Sprintf("%v", i))
     }
     defer fmt.Println("Defer in g", i)
     fmt.Println("Printing in g", i)
     g(i + 1)
 }

10.3 Defer

Defer 在函数结尾一定会执行。在上面的函数中，使用panic() 暂停程序的运行，defer语句使程序执行结束时使用改行。Defer也可以用作我们想要在函数的结尾执行的语句，例如关闭文件。

11. 并发

Golong使用轻量级线程Go routies支持并发。

11.1 Go routine

Go routine 是能够并行运行的函数。创建Go routine 非常简单，只需要在函数前添加关键字go，这样函数就能够并行运行了。Go routines 是轻量级的，我们能够创建上千个Go routines。例如：

package main

 import (
     "fmt"
     "time"
 )

 func main() {
     go c()
     fmt.Println("I am main")
     time.Sleep(time.Second * 2)
 }

 func c() {
     time.Sleep(time.Second * 2)
     fmt.Println("I am concurrent")
 }

 //=> I am main
 //=> I am concurrent

上面的例子中，函数c是Go routine，能够并行运行。我们想要在多线程中共享资源，但是Golang并不支持。因为这会导致死锁和资源等待。Go 提供了另一种共享资源的方式：channel。

11.2 Channels

我们可以使用Channel在两个Go routine之间传递数据。创建channel之前需要制定接受的数据类型。例如我们创建了一个接受string类型的channel。

c := make(chan string)

有了这个channel之后，我们可以通过这个channel发送和接收string类型的数据。

 package main

 import "fmt"

 func main() {
     c := make(chan string)
     go func() { c <- "hello" }()
     msg := <-c
     fmt.Println(msg)
 }

 //=>"hello"

接收的channel一直等待发送的channel发送数据。

11.3 One way channel

有些情况下，我们希望Go routine 通过channel接收数据，但不发送数据，反之亦然。这时候我们可以创建一个one-way channel。例如：

package main

 import (
     "fmt"
 )

 func main() {
     ch := make(chan string)
     go sc(ch)
     fmt.Println(<-ch)
 }

 func sc(ch chan<- string) {
     ch <- "hello"
 }

上面例子中，sc是一个Go routine只能给channel发送数据而不能接受数据。

12. 使用selecct优化多个channel

有这样一种情况，一个函数等待多个channel，这时候我们可以使用select语句。例如：

package main

 import (
     "fmt"
     "time"
 )

 func main() {
     c1 := make(chan string)
     c2 := make(chan string)
     go speed1(c1)
     go speed2(c2)
     fmt.Println("The first to arrive is:")
     select {
     case s1 := <-c1:
         fmt.Println(s1)
     case s2 := <-c2:
         fmt.Println(s2)
     }
 }

 func speed1(ch chan string) {
     time.Sleep(2 * time.Second)
     ch <- "speed 1"
 }

 func speed2(ch chan string) {
     time.Sleep(1 * time.Second)
     ch <- "speed 2"
 }

上面例子中，main函数等待两个channel，c1和c2。使用select语句，先从channel中收到的数据会被打印出来。

12.1 Buffered channel

在Golang中可以创建buffered channel，当buffer满的时候，发送数据给channel将会被阻塞。例如:

package main

 import "fmt"

 func main() {
     ch := make(chan string, 2)
     ch <- "hello"
     ch <- "world"
     ch <- "!" // extra message in buffer
     fmt.Println(<-ch)
 }

 // => fatal error: all goroutines are asleep - deadlock!

Golang为什么如此成功？

简单。。。—— Rob-pike

13. 总结

我们学习Golang以 下的主要模块和特性：

1.变量，数据类型
2.Array，Slices和Map
3.函数
4.循环和条件语句
5.指针
6.包
7.方法，结构体和接口
8错误处理
9.并发——Go routines和channels
恭喜你，你已经对Go有了很好的理解。

One of my most productive days was throwing away 1,000 lines of code.

—— Ken Thompson

不要停下脚步，继续前进。思考一个小应用程序并开始动手。

原文链接：
https://milapneupane.com.np/2019/07/06/learning-golang-from-zero-to-hero/

本文作者Milap Neupane，由何朋朋翻译。转载本文请注明出处，欢迎更多小伙伴加入翻译及投稿文章的行列，详情请戳公众号菜单「联系我们」。

参考阅读：

• 终于有人把服务调用说清楚了
• 一文理解分布式服务架构下的混沌工程实践（含PPT）
• 从工具到社区，美图秀秀大规模性能优化实践
• 使用Spring 5实现响应式微服务架构，简洁版来了
• 一百人研发团队的难题：研发管理、绩效考核、组织文化和OKR

技术原创及架构实践文章，欢迎通过公众号菜单「联系我们」进行投稿。转载请注明来自高可用架构「ArchNotes」微信公众号及包含以下二维码。

高可用架构

改变互联网的构建方式

---