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

Posted 2021-04-05 高可用架构

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了也许是最简洁版本，一篇文章上手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 envexport GOPATH=~/workspace# go inside the workspacecd ~/workspace

1.2 HELLO WORLD!

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

package mainimport ( "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 = truevat b int = 1var c string = "hello world"var d float32 = 1.222var 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中。

// 创建新的slicenumber2 := make([]int, 15)// 复制原有的slice到新的slicecopy(number2, number)

我们也可以创建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. 指针

var ap *int

a :=12ap = &a

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

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

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

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//=> Bobp.age//=> 42p.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

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!