【Go入门教程2】内置基础类型（Boolean、数值、字符串、错误类型），分组，iota枚举，array（数值），slice（切片），map（字典），make/new操作，零值

这小节我们将要介绍如何定义变量、常量、Go 内置类型以及 Go 程序设计中的一些技巧。

定义变量

Go 语言里面定义变量有多种方式。

使用 var 关键字是 Go 最基本的定义变量方式，与 C 语言不同的是 Go 把变量类型放在变量名后面：

// 定义一个名称为“variableName”，类型为"type"的变量

var variableName type

定义多个变量

// 定义三个类型都是“type”的变量

var vname1, vname2, vname3 type

定义变量并初始化值

// 初始化“variableName”的变量为“value”值，类型是“type”

var variableName type = value

同时初始化多个变量

/*

    定义三个类型都是"type"的变量,并且分别初始化为相应的值

    vname1 为 v1，vname2 为 v2，vname3 为 v3

*/

var vname1, vname2, vname3 type = v1, v2, v3

你是不是觉得上面这样的定义有点繁琐？没关系，因为 Go 语言的设计者也发现了，有一种写法可以让它变得简单一点。我们可以直接忽略类型声明，那么上面的代码变成这样了：

/*

    定义三个变量，它们分别初始化为相应的值

    vname1 为v1，vname2 为 v2，vname3 为 v3

    然后 Go 会根据其相应值的类型来帮你初始化它们

*/

var vname1, vname2, vname3 = v1, v2, v3

你觉得上面的还是有些繁琐？好吧，我也觉得。让我们继续简化：

/*

    定义三个变量，它们分别初始化为相应的值

    vname1 为 v1，vname2 为 v2，vname3 为 v3

    编译器会根据初始化的值自动推导出相应的类型

*/

vname1, vname2, vname3 := v1, v2, v3

现在是不是看上去非常简洁了？ := 这个符号直接取代了 var 和 type，这种形式叫做 简短声明。不过它有一个限制，那就是它只能用在函数内部；在函数外部使用则会无法编译通过，所以一般用 var 方式来定义全局变量。

_（下划线）是个特殊的变量名，任何赋予它的值都会被丢弃。在这个例子中，我们将值 35 赋予 b，并同时丢弃 34：

_, b := 34, 35

Go 对于已声明但未使用的变量会在编译阶段报错，比如下面的代码就会产生一个错误：声明了i但未使用。

package main

func main() {

    var i int

}

常量

所谓常量，也就是在程序编译阶段就确定下来的值，而程序在运行时无法改变该值。在 Go 程序中，常量可定义为数值、布尔值或字符串等类型。

它的语法如下：

const constantName = value

// 如果需要，也可以明确指定常量的类型：

const Pi float32 = 3.1415926

下面是一些常量声明的例子：

const Pi = 3.1415926

const i = 10000

const MaxThread = 10

const prefix = "astaxie_"

Go 常量和一般程序语言不同的是，可以指定相当多的小数位数(例如 200 位)，若指定给 float32 自动缩短为 32bit，指定给 float64 自动缩短为 64bit，详情参考链接

内置基础类型

Boolean

在 Go 中，布尔值的类型为 bool，值是 true 或 false，默认为 false。

// 示例代码

var isActive bool  // 全局变量声明

var enabled, disabled = true, false  // 忽略类型的声明

func test() {

    var available bool  // 一般声明

    valid := false      // 简短声明

    available = true    // 赋值操作

}

数值类型

整数类型有无符号和带符号两种。Go 同时支持 int 和 uint，这两种类型的长度相同，但具体长度取决于不同编译器的实现。Go里面也有直接定义好位数的类型：rune, int8, int16, int32, int64 和 byte, uint8, uint16, uint32, uint64。其中 rune 是 int32 的别称，byte 是 uint8 的别称。

需要注意的一点是，这些类型的变量之间不允许互相赋值或操作，不然会在编译时引起编译器报错。

如下的代码会产生错误：invalid operation: a + b (mismatched types int8 and int32)

var a int8

var b int32

c := a + b

另外，尽管 int 的长度是 32 bit, 但 int 与 int32 并不可以互用。

浮点数的类型有 float32 和 float64 两种（没有 float 类型），默认是 float64。

这就是全部吗？No！Go 还支持复数。它的默认类型是 complex128（64 位实数 +64 位虚数）。如果需要小一些的，也有 complex64 (32 位实数 + 32 位虚数)。复数的形式为 RE + IMi，其中RE是实数部分，IM 是虚数部分，而最后的i是虚数单位。下面是一个使用复数的例子：

var c complex64 = 5 + 5i

//output: (5 + 5i)

fmt.Printf("Value is: %v", c)

字符串

我们在上一节中讲过，Go 中的字符串都是采用UTF-8字符集编码。字符串是用一对双引号（""）或反引号（` `）括起来定义，它的类型是 string。

// 示例代码

var frenchHello string  // 声明变量为字符串的一般方法

var emptyString string = ""  // 声明了一个字符串变量，初始化为空字符串

func test() {

    no, yes, maybe := "no", "yes", "maybe"  // 简短声明，同时声明多个变量

    japaneseHello := "Konichiwa"  // 同上

    frenchHello = "Bonjour"  // 常规赋值

}

在 Go 中（局部）字符串是不可变的，例如下面的代码编译时会报错：cannot assign to s[0]

var s string = "hello"

s[0] = 'c'

但如果真的想要修改怎么办呢？下面的代码可以实现：

s := "hello"

c := []byte(s)  // 将字符串 s 转换为 []byte 类型

c[0] = 'c'

s2 := string(c)  // 再转换回 string 类型

fmt.Printf("%s\n", s2)

// 但是可以 整体重新赋值

s = "52php.cnblogs.com"

fmt.Printf("%s\n", s)

Go 中可以使用 + 操作符来连接两个字符串：

s := "hello,"

m := " world"

a := s + m

fmt.Printf("%s\n", a)

修改字符串也可写为：

s := "hello"

s = "c" + s[1:] // 字符串虽不能更改，但可进行切片操作

fmt.Printf("%s\n", s)

如果要声明一个多行的字符串怎么办？可以通过`来声明：

m := `hello

    world`

` 括起的字符串为 Raw 字符串，即字符串在代码中的形式就是打印时的形式，它没有字符转义，换行也将原样输出。例如本例中会输出：

hello
world

错误类型

Go 内置有一个 error 类型，专门用来处理错误信息，Go 的 package 里面还专门有一个包 errors 来处理错误：

err := errors.New("emit macho dwarf: elf header corrupted")

if err != nil {

    fmt.Print(err)

}

Go 数据底层的存储

下面这张图来源于 Russ Cox Blog 中一篇介绍 Go数据结构的文章，大家可以看到这些基础类型底层都是分配了一块内存，然后存储了相应的值。

图 2.1 Go 数据格式的存储

一些技巧

分组声明

在 Go 语言中，同时声明多个常量、变量，或者导入多个包时，可采用分组的方式进行声明。

例如下面的代码：

import "fmt"

import "os"

const i = 100

const pi = 3.1415

const prefix = "Go_"

var i int

var pi float32

var prefix string

可以分组写成如下形式：

import(

    "fmt"

    "os"

)

const(

    i = 100

    pi = 3.1415

    prefix = "Go_"

)

var(

    i int

    pi float32

    prefix string

)

iota 枚举

Go 里面有一个关键字 iota，这个关键字用来声明enum的时候采用，它默认开始值是 0，const 中每增加一行加 1：

const(

    x = iota  // x == 0

    y = iota  // y == 1

    z = iota  // z == 2

    w  // 常量声明省略值时，默认和之前一个值的字面相同。这里隐式地说w = iota，因此w == 3。其实上面y和z可同样不用"= iota"

)

const v = iota // 每遇到一个const关键字，iota就会重置，此时v == 0

const (

  e, f, g = iota, iota, iota // e=0,f=0,g=0 iota在同一行值相同

)

const （

    a = iota    a=0

    b = "B"

    c = iota    // c=2

    d,e,f = iota,iota,iota // d=3,e=3,f=3

    g //g = 4

）

除非被显式设置为其它值或 iota，每个 const 分组的第一个常量被默认设置为它的 0 值，第二及后续的常量被默认设置为它前面那个常量的值，如果前面那个常量的值是 iota，则它也被设置为 iota。

Go 程序设计的一些规则

Go 之所以会那么简洁，是因为它有一些默认的行为：

大写字母开头的变量是可导出的，也就是其它包可以读取的，是公有变量；小写字母开头的就是不可导出的，是私有变量。
大写字母开头的函数也是一样，相当于 class 中的带 public 关键词的公有函数；小写字母开头的就是有 private 关键词的私有函数。

array、slice、map

array

array 就是数组，它的定义方式如下：

var arr [n]type

在 [n]type 中，n 表示数组的长度，type 表示存储元素的类型。对数组的操作和其它语言类似，都是通过[]来进行读取或赋值：

var arr [10]int  // 声明了一个 int 类型的数组

arr[0] = 42      // 数组下标是从 0 开始的

arr[1] = 13      // 赋值操作

fmt.Printf("The first element is %d\n", arr[0])  // 获取数据，返回 42

fmt.Printf("The last element is %d\n", arr[9]) //返回未赋值的最后一个元素，默认返回 0

由于长度也是数组类型的一部分，因此 [3]int 与 [4]int 是不同的类型，数组也就不能改变长度。数组之间的赋值是值的赋值，即当把一个数组作为参数传入函数的时候，传入的其实是该数组的副本，而不是它的指针。如果要使用指针，那么就需要用到后面介绍的 slice 类型了。

数组可以使用另一种:=来声明

a := [3]int{1, 2, 3} // 声明了一个长度为 3 的 int 数组

b := [10]int{1, 2, 3} // 声明了一个长度为 10 的 int 数组，其中前三个元素初始化为 1、2、3，其它默认为 0

c := [...]int{4, 5, 6} // 可以省略长度而采用`...`的方式，Go 会自动根据元素个数来计算长度

也许你会说，我想数组里面的值还是数组，能实现吗？当然咯，Go 支持嵌套数组，即多维数组。比如下面的代码就声明了一个二维数组：

// 声明了一个二维数组，该数组以两个数组作为元素，其中每个数组中又有 4 个 int 类型的元素

doubleArray := [2][4]int{[4]int{1, 2, 3, 4}, [4]int{5, 6, 7, 8}}

// 上面的声明可以简化，直接忽略内部的类型

easyArray := [2][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}}

数组的分配如下所示：

图2.2 多维数组的映射关系

slice

在很多应用场景中，数组并不能满足我们的需求。在初始定义数组时，我们并不知道需要多大的数组，因此我们就需要“动态数组”。在 Go 里面这种数据结构叫 slice

slice 并不是真正意义上的动态数组，而是一个引用类型。slice 总是指向一个底层 array，slice 的声明也可以像 array 一样，只是不需要长度。

// 和声明 array 一样，只是少了长度

var fslice []int

接下来我们可以声明一个slice，并初始化数据，如下所示：

slice := []byte {'a', 'b', 'c', 'd'}

slice 可以从一个数组或一个已经存在的slice中再次声明。

slice 通过 array[i:j] 来获取，其中 i 是数组的开始位置，j 是结束位置，但不包含 array[j]，它的长度是 j-i。

// 声明一个含有 10 个元素元素类型为 byte 的数组

var ar = [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}

// 声明两个含有 byte 的 slice

var a, b []byte

// a 指向数组的第 3 个元素开始，并到第五个元素结束，

a = ar[2:5]

// 现在a含有的元素: ar[2]、ar[3]和ar[4]

// b 是数组 ar 的另一个 slice

b = ar[3:5]

// b 的元素是：ar[3] 和 ar[4]

注意 slice 和数组在声明时的区别：声明数组时，方括号内写明了数组的长度或使用...自动计算长度，而声明 slice 时，方括号内没有任何字符。

它们的数据结构如下所示

图2.3 slice 和 array 的对应关系图

slice 有一些简便的操作

slice 的默认开始位置是 0，ar[:n] 等价于 ar[0:n]
slice 的第二个序列默认是数组的长度，ar[n:] 等价于 ar[n:len(ar)]
如果从一个数组里面直接获取 slice，可以这样 ar[:]，因为默认第一个序列是 0，第二个是数组的长度，即等价于 ar[0:len(ar)]

下面这个例子展示了更多关于slice的操作：

// 声明一个数组

var array = [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}

// 声明两个slice

var aSlice, bSlice []byte

// 演示一些简便操作

aSlice = array[:3] // 等价于aSlice = array[0:3] aSlice包含元素: a,b,c

aSlice = array[5:] // 等价于aSlice = array[5:10] aSlice包含元素: f,g,h,i,j

aSlice = array[:]  // 等价于aSlice = array[0:10] 这样aSlice包含了全部的元素

// 从slice中获取slice

aSlice = array[3:7]  // aSlice包含元素: d,e,f,g，len=4，cap=7

bSlice = aSlice[1:3] // bSlice 包含aSlice[1], aSlice[2] 也就是含有: e,f

bSlice = aSlice[:3]  // bSlice 包含 aSlice[0], aSlice[1], aSlice[2] 也就是含有: d,e,f

bSlice = aSlice[0:5] // 对slice的slice可以在cap范围内扩展，此时bSlice包含：d,e,f,g,h

bSlice = aSlice[:]   // bSlice包含所有aSlice的元素: d,e,f,g

slice 是引用类型，所以当引用改变其中元素的值时，其它的所有引用都会改变该值，例如上面的 aSlice 和 bSlice，如果修改了 aSlice 中元素的值，那么 bSlice 相对应的值也会改变。

从概念上面来说 slice 像一个结构体，这个结构体包含了三个元素：

一个指针，指向数组中 slice 指定的开始位置
长度，即 slice 的长度

最大长度，也就是 slice 开始位置到数组的最后位置的长度

Array_a := [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}

Slice_a := Array_a[2:5]

上面代码的真正存储结构如下图所示

图2.4 slice 对应数组的信息

对于slice有几个有用的内置函数：

len 获取 slice 的长度
cap 获取 slice 的最大容量
append 向 slice 里面追加一个或者多个元素，然后返回一个和 slice 一样类型的 slice
copy 函数 copy 从源 slice 的 src 中复制元素到目标 dst，并且返回复制的元素的个数

注：append 函数会改变 slice 所引用的数组的内容，从而影响到引用同一数组的其它 slice。但当 slice 中没有剩余空间（即(cap-len) == 0）时，此时将动态分配新的数组空间。返回的 slice 数组指针将指向这个空间，而原数组的内容将保持不变；其它引用此数组的 slice 则不受影响。

从 Go1.2 开始 slice 支持了三个参数的 slice，之前我们一直采用这种方式在 slice 或者 array 基础上来获取一个 slice

var array [10]int

slice := array[2:4]

这个例子里面 slice 的容量是 8，新版本里面可以指定这个容量

slice = array[2:4:7]

【注意】第三个参数，表示切片能用底层数组的最大索引号

上面这个的容量就是 7-2，即 5。这样这个产生的新的 slice 就没办法访问最后的三个元素。

如果 slice 是这样的形式 array[:i:j]，即第一个参数为空，默认值就是 0。

相关文章：

数组和切片（array、slice）

map

map 也就是 Python 中字典的概念，它的格式为 map[keyType]valueType

我们看下面的代码，map 的读取和设置也类似 slice 一样，通过 key 来操作，只是 slice 的 index 只能是｀int｀类型，而 map 多了很多类型，可以是 int，可以是 string 及所有完全定义了 == 与 != 操作的类型。

// 声明一个 key 是字符串，值为int的字典，这种方式的声明需要在使用之前使用 make 初始化

var numbers map[string]int

// 另一种map的声明方式

numbers := make(map[string]int)

numbers["one"] = 1  // 赋值

numbers["ten"] = 10 // 赋值

numbers["three"] = 3

fmt.Println("第三个数字是: ", numbers["three"]) // 读取数据

// 打印出来如:第三个数字是: 3

这个 map 就像我们平常看到的表格一样，左边列是 key，右边列是值

使用 map 过程中需要注意的几点：

map 是无序的，每次打印出来的 map 都会不一样，它不能通过 index 获取，而必须通过 key 获取
map 的长度是不固定的，也就是和 slice 一样，也是一种引用类型
内置的 len 函数同样适用于 map，返回 map 拥有的 key 的数量
map 的值可以很方便的修改，通过 numbers["one"]=11 可以很容易的把 key 为 one 的字典值改为 11
map 和其他基本型别不同，它不是 thread-safe，在多个 go-routine 存取时，必须使用 mutex lock 机制

map 的初始化可以通过 key:val 的方式初始化值，同时 map 内置有判断是否存在 key 的方式

通过 delete 删除 map 的元素：

// 初始化一个字典

rating := map[string]float32{"C":5, "Go":4.5, "Python":4.5, "C++":2 }

// map 有两个返回值，第二个返回值，如果不存在 key，那么 ok 为 false，如果存在 ok 为 true

csharpRating, ok := rating["C#"]

if ok {

    fmt.Println("C# is in the map and its rating is ", csharpRating)

} else {

    fmt.Println("We have no rating associated with C# in the map")

}

delete(rating, "C")  // 删除 key 为 C 的元素

上面说过了，map 也是一种引用类型，如果两个 map 同时指向一个底层，那么一个改变，另一个也相应的改变：

m := make(map[string]string)

m["Hello"] = "Bonjour"

m1 := m

m1["Hello"] = "Salut"  // 现在 m["hello"] 的值已经是 Salut 了

make、new 操作

make 用于内建类型（map、slice 和 channel）的内存分配。new 用于各种类型的内存分配。

内建函数 new 本质上说跟其它语言中的同名函数功能一样：new(T) 分配了零值填充的 T 类型的内存空间，并且返回其地址，即一个 *T 类型的值。用 Go 的术语说，它返回了一个指针，指向新分配的类型T的零值。有一点非常重要：

new 返回指针。

内建函数 make(T, args) 与 new(T) 有着不同的功能，make 只能创建 slice、map 和 channel，并且返回一个有初始值(非零)的T类型，而不是 *T。本质来讲，导致这三个类型有所不同的原因是指向数据结构的引用在使用前必须被初始化。例如，一个 slice，是一个包含指向数据（内部 array）的指针、长度和容量的三项描述符；在这些项目被初始化之前，slice 为 nil。对于 slice、map 和 channel 来说，make 初始化了内部的数据结构，填充适当的值。

make 返回初始化后的（非零）值。

下面这个图详细的解释了 new 和 make 之间的区别。

图2.5 make 和 new 对应底层的内存分配

零值

关于“零值”，所指并非是空值，而是一种“变量未填充前”的默认值，通常为 0。此处罗列部分类型的“零值”

int     0

int8    0

int32   0

int64   0

uint    0x0

rune    0 // rune 的实际类型是 int32

byte    0x0 // byte 的实际类型是 uint8

float32 0 // 长度为 4 byte

float64 0 // 长度为 8 byte

bool    false

string  ""

摘自：

https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/02.2.md

巴特西