导读:
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...
[u开头表示无符号;uintptr 是一种无符号的整数类型,没有指定具体的bit大小但是足以容纳指针。 uintptr类型只有在底层编程是才需要,特别是Go语言和C语言函数库或操作系统接口相交互的地方。]
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, 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")
}
}
5.3 循环
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 {
}
6.指针
Go 语言可以使用指针,指针存储变量的地址,指针用*来定义。指针的定义和所指数据的类型相关:
var ap *int
这里的ap是指向整型数据的指针,&用于获取所变量的地址。
a :=12
ap = &a
* 用于获取指针所指的地址的值。
fmt.Println(*ap)
// => 12
指针通常用于将结构体做为参数传递。
传值通常意味着拷贝,意味着需要更多的内存。
使用指针传递时,在函数中改变的变量会传递给调用的方法或函数。
package main
import (
"fmt"
)
func increment(i *int) {
*i++
}
func main() {
i := 10
increment(&i)
fmt.Println(i) //=> 11
}
7.函数
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) //=> successfully added
fmt.Println(sum) //=> 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以 下的主要模块和特性:
- 列表项目
- 变量,数据类型
- Array,Slices和Map
- 函数
- 循环和条件语句
- 指针
- 包
- 方法,结构体和接口
- 错误处理
- 并发——Go routines和channels
恭喜你,你已经对Go有了很好的理解。
One of my most productive days was throwing away 1,000 lines of code.
—— Ken Thompson
不要停下脚步,继续前进。思考一个小应用程序并开始动手。
原文链接:
原创: Milap Neupane 高可用架构
https://mp.weixin.qq.com/s?__...
https://milapneupane.com.np/2...
本文作者Milap Neupane,由何朋朋翻译。转载本文请注明出处,欢迎更多小伙伴加入翻译及投稿文章的行列,详情请戳公众号菜单「联系我们」。
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用
。你还可以使用@
来通知其他用户。