lostecho/build-web-application-with-golang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Modified some sentence.

Browse Source
This commit is contained in:
Oling Cat
2012-09-20 16:25:16 +08:00
parent 0a4fb93e0a
commit 9e4612acd5
5 changed files with 289 additions and 290 deletions
Download Patch File Download Diff File Expand all files Collapse all files

308
2.2.md
View File

@@ -1,59 +1,59 @@
#2.2 Go基础
这小节我们将要介绍如何定义变量、常量；Go内置类型以及一些Go设计中的技巧
这小节我们将要介绍如何定义变量、常量、Go内置类型以及一些Go设计中的技巧。
##定义变量
Go语言里面定义变量有好几种方式。
最基本的定义变量如下，Go变量定义，它的类型是跟在变量后面的，而不是像C一样放前面
最基本的定义变量如下，Go变量定义，它的类型是跟在变量后面的，而不是像C一样放前面：
//定义一个名称为“variable_name”、类型为"type"的变量
var variable_name type
//定义一个名称为“variableName”，类型为"type"的变量
var variableName type
定义多个变量
//定义三个类型都是"type"的三个变量
var vname1,vname2,vname3 type
//定义三个类型都是“type”的三个变量
var vname1, vname2, vname3 type
定义变量并且带有初始化的值
//初始化“variable_name”的变量为“value”值，类型是"type"
var variable_name type = value
//初始化“variableName”的变量为“value”值，类型是“type”
var variableName type = value
同时初始化多个变量
/*
定义三个类型都是"type"的三个变量,并且他们分别初始化相应的值
定义三个类型都是"type"的三个变量,并且它们分别初始化相应的值
vname1为v1，vname2为v2，vname3为v3
*/
var vname1,vname2,vname3 type= v1, v2, v3
var vname1, vname2, vname3 type= v1, v2, v3
你是不是觉得上面这样的定义有点复杂，没关系，因为Go语言的设计者也发现这样复杂了，我们来让它变得简单一点，我们可以直接忽略类型这个申明，那么上面的什么变成了如下
你是不是觉得上面这样的定义有点复杂，没关系，因为Go语言的设计者也发现这样复杂了，我们来让它变得简单一点。我们可以直接忽略类型声明，那么上面的东西变成了如下
/*
定义三个变量，他们分别初始化相应的值
定义三个变量，它们分别初始化相应的值
vname1为v1，vname2为v2，vname3为v3
然后他们的类型自动根据初始化的值来确定相应的类型，Go会帮你做这件事
然后它们的类型自动根据初始化的值来确定相应的类型，Go会帮你做这件事
*/
var vname1,vname2,vname3= v1, v2, v3
var vname1, vname2, vname3 = v1, v2, v3
你还是觉得上面的复杂？好吧，我也觉得是，让我们继续简化
/*
定义三个变量，他们分别初始化相应的值
定义三个变量，它们分别初始化相应的值
vname1为v1，vname2为v2，vname3为v3
编译器会根据初始化的值自动推导出相应的类型
*/
vname1,vname2,vname3 := v1, v2, v3
现在是不是看上去非常的简单了，`:=`这个定义直接替代了`var`和`type`,这样的代码是不是很简洁，但是:=有一个限制，那就是它只能用在函数内部，在函数外部使用则不能编译通过。比如用以定义全局变量。
vname1, vname2, vname3 := v1, v2, v3
一个特殊的变量名是`_`（下划线）。任何赋给它的值都被丢弃。在这个例子中，将赋值35赋值给b，同时丢弃34。
现在是不是看上去非常的简单了？`:=`这个定义直接替代了`var`和`type`，这样的代码是不是很简洁？但是`:=`有一个限制，那就是它只能用在函数内部，在函数外部使用则不能编译通过，比如用以定义全局变量。
一个特殊的变量名是`_`（下划线），任何赋给它的值都会被丢弃。在这个例子中，将值`35`赋予`b`，同时丢弃`34`。
_, b := 34, 35
Go的编译器对申明却未使用的变量会在编译阶段报错。下面的代码会产生一个错误：申明了i却未使用
Go的编译器对声明却未使用的变量会在编译阶段报错。下面的代码会产生一个错误：声明了i却未使用
package main
@@ -63,57 +63,55 @@ Go的编译器对申明却未使用的变量会在编译阶段报错。下面的
##常量
所谓常量，也就是在编译阶段就确定下来的值，程序运行时无法改变该值，GO程序里面，常量定义可以是数字类型、Bool、字符串
所谓常量，也就是在编译阶段就确定下来的值，程序运行时无法改变该值，Go程序里面，常量定义可以是数值、布尔或字符串等类型。
它的语法如下
const constant_name = value
下面是一些申明的例子
const constantName = value
const PI = 3.1415927
下面是一些声明的例子
const Pi = 3.1415927
const i = 10000
const Max_Thread = 10
const MaxThread = 10
const prefix = 'astaxie_'
当然如果需要，可以明确指定常量的类型：
当然如果需要，也可以明确指定常量的类型：
const PI float32 = 3.1415927
const PI float32 = 3.1415926
##内置基础类型
###Boolean
对于布尔值，在GO中, 它的类型是:`bool` 可以有的值是:`true`或`false`。默认为`false`
对于布尔值，在Go中，它的类型是`bool`，可用的值是`true`或`false`，默认为`false`。
//示例代码
var isactive bool
var enabled, disabled = true, false //忽略类型的申明
var isactive bool
var enabled, disabled = true, false //忽略类型的声明
func test(){
var available bool //一般的申明
valid := false //忽略var和type的申明
var available bool //一般的声明
valid := false //忽略var和type的声明
available = true //赋值操作
}
###数字类型
对于整数类型，有无符号和有符号两种，GO同时支持`int`和`uint`，这两种类型的长度相同，但具体长度取决于编译器的实现。当前的gc和gccgo编译器在32位和64位平台上都使用32位来表示`int`和`uint`，但未来在64位平台上可能增加到64位。GO里面也有直接定义好位数的类型`rune`, `int8`, `int16`, `int32`, `int64`和`byte`, `uint8`, `uint16`, `uint32`, `uint64`。目前`rune`是`int`的别称,将来会改为`int32`的别称。`byte`是`uint8`的别称。
对于整数类型，有无符号和带符号两种。Go同时支持`int`和`uint`，这两种类型的长度相同，但具体长度取决于编译器的实现。当前的gc和gccgo编译器在32位和64位平台上都使用32位来表示`int`和`uint`，但未来在64位平台上可能增加到64位。Go里面也有直接定义好位数的类型`rune`, `int8`, `int16`, `int32`, `int64`和`byte`, `uint8`, `uint16`, `uint32`, `uint64`。`rune`是`int32`的别称，`byte`是`uint8`的别称。
>注意一点就是这些类型之间的变量不允许相互之间赋值、操作，不然会引起编译器的错误。
>
>如下的代码会出现错误
>
>
> var a int8
>
> var b int32
>
> c:=a + b
浮点类型的值有`float32`和`float64`(没有`float`类型)。
浮点类型的值有`float32`和`float64`（没有`float`类型）。
这就是全部吗？NO！Go支持复数。它的变量类型是`complex128`（64位实数，64位虚数）。如果需要小一些的，还有`complex64`(32位实数，32位虚数)。复数写为`re + imi`，`re`是实数部分，`im`是虚数部分，而`i`是标记。使用复数的一个例子：
这就是全部吗？No！Go支持复数。它的变量类型是`complex128`（64位实数，64位虚数）。如果需要小一些的，还有`complex64`(32位实数，32位虚数)。复数写为`re + imi`，`re`是实数部分，`im`是虚数部分，而`i`是标记。使用复数的一个例子：
var c complex64 = 5+5i;
@@ -123,71 +121,71 @@ Go的编译器对申明却未使用的变量会在编译阶段报错。下面的
###字符串
前面一节里面说过，字符串都是UTF-8类型的，字符串通过一对双引号(")或反引号（`）来定义，它的类型是string
前面一节里面说过，字符串都是UTF-8类型的。字符串通过一对双引号（""）或反引号（` `` `）来定义，它的类型是`string`。
//示例代码
var french_hello string //声明变量为字符串的一般方法
var empty_string string = "" // 申明了一个字符串变量，初始化为空值
var frenchHello string //声明变量为字符串的一般方法
var emptyString string = "" // 声明了一个字符串变量，初始化为空值
func test(){
no, yes, maybe := "no", "yes", "maybe" //忽略var和type的申明，同时申明多个变量
japanese_hello := "Ohaiou" //同上
french_hello = "Bonjour" //常规赋值
no, yes, maybe := "no", "yes", "maybe" //忽略var和type的声明，同时声明多个变量
japaneseHello := "Ohaiou" //同上
frenchHello = "Bonjour" //常规赋值
}
在Go中字符串是不可变的，例如如下的代码编译时会报错
在Go中字符串是不可变的，例如如下的代码编译时会报错：
var s string = "hello"
s[0] = 'c'
那么如果真的想要修改怎么办呢？如下的代码可以实现
那么如果真的想要修改怎么办呢？如下的代码可以实现：
s := "hello"
c := []byte(s)
c[0] = 'c'
s2 := string(c)
c := []byte(s) // 将字符串 s 转换为 []byte 类型
c[0] = 'c'
s2 := string(c) // 再转换回 string 类型
fmt.Printf("%s\n", s2)
GO中可以使用`+`来链接两个字符串
Go中可以使用`+`来链接两个字符串：
s := "hello"
m := "world"
s := "hello,"
m := " world"
a := s + m
fmt.Printf("%s\n", a)
fmt.Printf("%s\n", a)
修改字符串也可写为
s := "hello"
s = "c" + s[1:] // 字符串虽不能更改，但可进行切片操作
fmt.Println("%s\n", s)
如果要申明一个多行的字符串怎么办？可以通过`` ` ``来申明
m:=`hello
world`
如果要声明一个多行的字符串怎么办？可以通过`` ` ``来声明：
m := `hello
world`
`` ` `` 括起的字符串为Raw字符串，即字符串在代码中的形式就是打印时的形式，没有字符转义，换行也将原样输出。
###错误类型
Go内置有一个`error`类型，专门用来处理错误信息，GO的package里面还专门有一个包errors来处理错误
Go内置有一个`error`类型，专门用来处理错误信息，Go的`package`里面还专门有一个包`errors`来处理错误：
err := errors.New("emit macho dwarf: elf header corrupted")
if err != nil {
fmt.Print(err)
}
###GO数据底层的存储
###Go数据底层的存储
下面这张图来源于 Russ Cox blog中的一篇介绍GO数据结构的文章，大家可以看到这些基础类型底层都是开辟了一块内存，然后存了相应的值
下面这张图来源于 Russ Cox blog中的一篇介绍Go数据结构的文章，大家可以看到这些基础类型底层都是开辟了一块内存，然后存了相应的值。
![](images/2.2.basic.png?raw=true)
![](images/2.2.basic.png?raw=true)
##一些技巧
###分组定义
Go语言里面针对多个同时申明变量、常量或者import多个包的时候可以采用分组的方式来申明
Go语言里面针对多个同时声明变量、常量或者`import`多个包的时候可以采用分组的方式来声明
如下的代码
@@ -196,7 +194,7 @@ Go语言里面针对多个同时申明变量、常量或者import多个包的时
const i = 100
const pi = 3.1415
const prefix = "go_"
const prefix = "Go_"
var i int
var pi float32
@@ -212,89 +210,89 @@ Go语言里面针对多个同时申明变量、常量或者import多个包的时
const(
i = 100
pi = 3.1415
prefix = "go_"
prefix = "Go_"
)
var(
i int
pi float32
prefix string
)
>除非被显式设置为其他值或iota, 每个const分组的第一个常量被默认设置为它的0值,第2及后续的常量被默认设置为他前面那个常量的值，如果前面那个常量的值是iota，则它也被设置为iota
)
>除非被显式设置为其它值或`iota`，每个`const`分组的第一个常量被默认设置为它的0值,第二及后续的常量被默认设置为它前面那个常量的值，如果前面那个常量的值是`iota`，则它也被设置为`iota`
###iota枚举
GO里面有一个关键字`iota`，这个关键字用来申明enum的时候采用，它默认开始值是0，每调用一次加1
Go里面有一个关键字`iota`，这个关键字用来声明`enum`的时候采用，它默认开始值是0，每调用一次加1
const(
x = iota //x == 0
y = iota //y == 1
z = iota //z == 2
w // 常量申明省略值时，默认和之前一个值的字面相同。这里隐示的说w = iota,因此w==3, 其实上面y和z可以同样不用=iota
w // 常量声明省略值时，默认和之前一个值的字面相同。这里隐式地说w = iota,因此w == 3。其实上面y和z可以同样不用"= iota"
)
const v = iota // 每遇到一个const关键字，iota被重置，此时 v==0
###Go设计的一些规则
Go之所以会那么简洁，是因为他有一些默认的行为
- 大写字母开头的变量是导出的，也就是其他包可以读取的，类似类中的public的概念
Go之所以会那么简洁，是因为它有一些默认的行为
- 大写字母开头的变量是导出的，也就是其它包可以读取的，类似类中的public的概念
- 大写字母开头的函数也是一样，相当于public的函数，小写的就是类似private
##array、slice、map
###array
array就是数组，它的定义如下`[n]type`,n表示数组的长度，type表示存储内容的类型
`array`就是数组，它的定义方式如下。在`[n]type`中，`n`表示数组的长度，`type`表示存储内容的类型
对数组的操作和其他语言类似，都是通过`[]`来进行读取和赋值
对数组的操作和其它语言类似，都是通过`[]`来进行读取和赋值
var arr [10]int //申明了一个int类型的数组
var arr [10]int //声明了一个int类型的数组
arr[0] = 42 //数组下标是从0开始的
arr[1] = 13 //赋值操作
fmt.Printf("The first element is %d\n", arr[0]) //获取数据
由于数组的长度也是类型的一部分,比如`[3]int`与`[4]int`是不同的类型，所以数组是不能改变长度的，而且数组之间的赋值是值赋值，当把一个数组作为一个参数传入函数的时候，是这个数组的副本，而不是该数组的指针，如果要使用指针，那么就需要用到下面介绍的`slice`。
由于数组的长度也是类型的一部分,比如`[3]int`与`[4]int`是不同的类型，所以数组是不能改变长度的，而且数组之间的赋值是值赋值，即当把一个数组作为一个参数传入函数的时候，是这个数组的副本，而不是该数组的指针。如果要使用指针，那么就需要用到下面介绍的`slice`。
数组申明可以使用另一种`:=`来申明
数组声明可以使用另一种`:=`来声明
a := [3]int{1,2,3} //申明一个长度为3的数组
a := [3]int{1,2,3} //声明一个长度为3的数组
b := [10]int{1,2,3} //申明了一个长度为10的数组，其中前面三个元素初始化为1、2、3，其他默认为0
b := [10]int{1,2,3} //声明了一个长度为10的数组，其中前面三个元素初始化为1、2、3，其它默认为0
c := […]int{4,5,6} //可以省略长度，采用…，go会自动计算长度
也许你会说，我想数组里面还是数组，能实现吗？当然咯，GO支持嵌套数组，即多维数组，如下代码申明了一个二维数组
c := [...]int{4,5,6} //可以省略长度，采用“...”，Go会自动计算长度
//申明了一个二维数组，该数组是一个两个元素的数组，然后每个元素里面是4个int的元素
double_array := [2][4]int {[4]int{1,2,3,4}, [4]int{5,6,7,8}}
//如果内部的元素和外部的一样，那么上面的申明可以简化，直接忽略内部的类型
easy_array :=[2][4]int{{1,2,3,4},{5,6,7,8}}
也许你会说，我想数组里面还是数组，能实现吗？当然咯，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}}
数组的分配如下所示：
![](images/2.2.array.png?raw=true)
![](images/2.2.array.png?raw=true)
###slice
在很多的应用场景里面，数组不能满足我们的需求，因为在刚开始的时候，我们不知道到底需要多大的数组合适,所以我们需要动态数组,在go里面这种数据结构叫`slice`
在很多的应用场景里面，数组不能满足我们的需求。因为在刚开始的时候，我们不知道到底需要多大的数组合适，所以我们需要动态数组。在Go里面这种数据结构叫`slice`
`slice`并不是真正意义上面的动态数组，而是一个引用类型，`slice`总是指向底层的一个`array`。`slice`的申明也可以像`array`一样，只要省略size
`slice`并不是真正意义上的动态数组，而是一个引用类型，`slice`总是指向底层的一个`array`。`slice`的声明也可以像`array`一样，只要省略size。
//和申明array一样，只是少了长度
//和声明array一样，只是少了长度
var fslice []int
接下来我们可以申明一个slice，并初始化数据，如下所示
接下来我们可以声明一个`slice`，并初始化数据，如下所示：
slice := []byte {'a', 'b', 'c', 'd'}
slice可以从一个数组或者一个已经存在的slice里面再次申明，`slice`通过array[i:j]来获取，i是数组的开始位置，j是结束位置，但不包含array[j]，他的长度是j-i
//申明一个含有十个字符元素的数组
`slice`可以从一个数组或者一个已经存在的`slice`里面再次声明，`slice`通过`array[i:j]`来获取，`i`是数组的开始位置，`j`是结束位置，但不包含`array[j]`，它的长度是`j-i`。
//声明一个含有十个字符元素的数组
var ar = [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
//申明两个含有byte的slice
//声明两个含有byte的slice
var a,b[]byte
//a指向数组的第3个元素开始，并到第五个元素结束，
@@ -305,43 +303,43 @@ slice可以从一个数组或者一个已经存在的slice里面再次申明，`
b = ar[3:5]
// b的元素是: ar[3], ar[4]
注意slice和数组申明时的区别：申明数组时，方括号内写明了数组的长度或使用`...`自动计算长度，而申明slice时，方括号内没有任何字符
注意`slice`和数组声明时的区别：声明数组时，方括号内写明了数组的长度或使用`...`自动计算长度，而声明``slice``时，方括号内没有任何字符
他们的数据结构如下所示
它们的数据结构如下所示
![](images/2.2.slice.png?raw=true)
slice有一些简便的操作
- slice的默认开始位置是0，ar[:n]等价于ar[0:n]
- slice的第二个序列默认是数组的长度，ar[n:]等价于ar[n:len(ar)]
- slice如果从一个数组里面直接获取，可以这样ar[:]，因为默认第一个序列是0，第二个是数组的长度，即等价于ar[0,len(ar)]
- `slice`的默认开始位置是0，`ar[:n]`等价于`ar[0:n]`
- `slice`的第二个序列默认是数组的长度，`ar[n:]`等价于`ar[n:len(ar)]`
- `slice`如果从一个数组里面直接获取，可以这样`ar[:]`，因为默认第一个序列是0，第二个是数组的长度，即等价于`ar[0,len(ar)]`
下面这个例子展示更多关于slice的操作
下面这个例子展示更多关于`slice`的操作
//申明一个数组
// 声明一个数组
var array = [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
//申明两个slice
var a_slice,b_slice
//声明两个slice
var aSlice,bSlice
// 演示一些简便操作
a_slice = array[:3] // 等价于a_slice = array[0:3] a_slice包含元素: a,b,c
a_slice = array[5:] // 等价于a_slice = array[5:9] a_slice包含元素: f,g,h,i,j
a_slice = array[:] // 等价于a_slice = array[0:9] 这样a_slice包含了全部的元素
aSlice = array[:3] // 等价于aSlice = array[0:3] aSlice包含元素: a,b,c
aSlice = array[5:] // 等价于aSlice = array[5:9] aSlice包含元素: f,g,h,i,j
aSlice = array[:] // 等价于aSlice = array[0:9] 这样aSlice包含了全部的元素
//从slice获取slice
a_slice = array[3:7] // a_slice包含元素: d,e,f,g，len=4，cap=8
b_slice = a_slice[1:3] // b_slice 包含a_slice[1], a_slice[2] 也就是含有: e,f
b_slice = a_slice[:3] // b_slice 包含 a_slice[0], a_slice[1], a_slice[2] 也就是含有: d,e,f
b_slice = a_slice[0:5] // 对slice的slice可以在cap范围内扩展，此时b_slice包含：c,d,e,f,g
b_slice : a_slice[:] // b_slice包含所有a_slice的元素: d,e,f,g
// 从slice获取slice
aSlice = array[3:7] // aSlice包含元素: d,e,f,g，len=4，cap=8
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包含：c,d,e,f,g
bSlice : aSlice[:] // bSlice包含所有aSlice的元素: d,e,f,g
slice是引用类型，所以当引用改变其中项目的值的时候，那么其他的所有引用都会改变该值，例如上面的a_slice和b_slice，如果修改了a_slice中项目的值，那么b_slice相对应的值也会改变。
`slice`是引用类型，所以当引用改变其中项目的值的时候，那么其它的所有引用都会改变该值，例如上面的`aSlice`和`bSlice`，如果修改了`aSlice`中项目的值，那么`bSlice`相对应的值也会改变。
从概念上面来说slice像一个结构体，这个结构体包含了三个元素：
- 一个指针，指向数组中slice指定的开始位置
- 长度，slice的长度
- 最大长度，也就是slice开始位置到数组的最后位置的长度
从概念上面来说`slice`像一个结构体，这个结构体包含了三个元素：
- 一个指针，指向数组中`slice`指定的开始位置
- 长度，`slice`的长度
- 最大长度，也就是`slice`开始位置到数组的最后位置的长度
array := [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
slice := A[4:8]
@@ -350,25 +348,25 @@ slice是引用类型，所以当引用改变其中项目的值的时候，那么
![](images/2.2.slice2.png?raw=true)
slice下面有几个有用的内置函数
`slice`下面有几个有用的内置函数
- len 获取slice的长度
- cap 获取slice的最大容量
- append 向slice里面追加一个或者多个元素，然后返回一个和slice一样类型的slice
- copy 函数copy 从源slice src 复制元素到目标dst，并且返回复制的元素的个数
- `len` 获取`slice`的长度
- `cap` 获取`slice`的最大容量
- `append` 向`slice`里面追加一个或者多个元素，然后返回一个和`slice`一样类型的`slice`
- ``copy` 函数`copy`从源`slice`的`src`中复制元素到目标`dst`，并且返回复制的元素的个数
注：append函数会改变slice所引用的数组的内容，从而影响到引用同一数组的其它slice。
但当slice中没有剩余空间（(cap-len) == 0)时，此时将动态分配新的数组空间，返回的slice的数组指针将指向这个空间，而原数组的内容将保持不变，其它引用此数组的slice不受影响。
注：`append`函数会改变`slice`所引用的数组的内容，从而影响到引用同一数组的其它`slice`。
但当`slice`中没有剩余空间（即`(cap-len) == 0`）时，此时将动态分配新的数组空间。返回的`slice`数组指针将指向这个空间，而原数组的内容将保持不变，其它引用此数组的`slice`不受影响。
###map
map也就是python中字典的概念，它的格式`map[keyType]valueType`
`map`也就是Python中字典的概念，它的格式`map[keyType]valueType`
我们看下面的代码，map的读取和设置也类似slice一样，通过key来操作，只是slice只有int的key，而map多了很多类型，可以是int，可以是string及所有完全定义了"=="与"!="操作的类型
// 申明一个key是字符串，值为int的字典
var numbers map[string] int
//另一种map的申明方式
我们看下面的代码，`map`的读取和设置也类似`slice`一样，通过`key`来操作，只是`slice`只有`int`的`key`，而`map`多了很多类型，可以是`int`，可以是`string`及所有完全定义了`==`与`!=`操作的类型。
// 声明一个key是字符串，值为int的字典
var numbers map[string] int
//另一种map的声明方式
numbers := make(map[string]int)
numbers["one"] = 1 //赋值
numbers["ten"] = 10 //赋值
@@ -378,17 +376,17 @@ map也就是python中字典的概念，它的格式`map[keyType]valueType`
// 打印出来如下:
//第三个数字是: 3
这个map就像我们平常看到的表格一样，左边列是key，右边列是值
这个`map`就像我们平常看到的表格一样，左边列是`key`，右边列是值
使用map过程中需要注意的几点
- map是无序的，每次打印出来的map都会不一样,他不能通过index获取，而必须通过key获取
- map的长度是不固定的，也就是和slice一样，也是一种引用类型
- 内置的len函数同样试用于map，返回map拥有的key的数量
- map的值可以很方便的修改，通过`numbers["one"]=11`可以很容易的把key为`one`的字典值改为11
使用map过程中需要注意的几点：
- map是无序的，每次打印出来的`map`都会不一样，它不能通过`index`获取，而必须通过`key`获取
- map的长度是不固定的，也就是和`slice`一样，也是一种引用类型
- 内置的len函数同样适用于`map`，返回`map`拥有的`key`的数量
- map的值可以很方便的修改，通过`numbers["one"]=11`可以很容易的把key为`one`的字典值改为`11`
map的初始化可以通过key:val的方式初始化值，同时map内置有判断是否存在key的方式
`map`的初始化可以通过`key:val`的方式初始化值，同时`map`内置有判断是否存在`key`的方式
删除map的元素通过delete
通过`delete`删除`map`的元素：
//初始化一个字典
rating := map[string]float32 {"C":5, "Go":4.5, "Python":4.5, "C++":2 }
@@ -399,27 +397,27 @@ map的初始化可以通过key:val的方式初始化值，同时map内置有判
} else {
fmt.Println("We have no rating associated with C# in the map")
}
delete( rating， "C") //删除key为C的元素
上面说过了，map也是一种引用类型，如果两个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返回指针。
内建函数`new`本质上说跟其它语言中的同名函数功能一样：`new(T)`分配了零值填充的`T`类型的内存空间，并且返回其地址，即一个`*T`类型的值。用Go的术语说，它返回了一个指针，指向新分配的类型`T`的零值。有一点非常重要：`new`返回指针。
内建函数make(T, args)与new(T)有着不同的功能。它只能创建slice，map和channel，并且返回一个有初始值(非零)的T类型，而不是*T。本质来讲，导致这三个类型有所不同的原因是指向数据结构的引用在使用前必须被初始化。例如，一个slice，是一个包含指向数据（内部array）的指针，长度和容量的三项描述符；在这些项目被初始化之前，slice 为nil。对于slice，map 和channel，make 初始化了内部的数据结构，填充适当的值。make返回初始化后的（非零）值。
内建函数`make(T, args)`与`new(T)`有着不同的功能，它只能创建`slice`、`map`和`channel`，并且返回一个有初始值(非零)的`T`类型，而不是`*T`。本质来讲，导致这三个类型有所不同的原因是指向数据结构的引用在使用前必须被初始化。例如，一个`slice`，是一个包含指向数据（内部`array`）的指针、长度和容量的三项描述符；在这些项目被初始化之前，`slice`为`nil`。对于`slice`、`map`和`channel`来说，`make`初始化了内部的数据结构，填充适当的值。`make`返回初始化后的（非零）值。
下面这个图详细的解释了new和make之间的区别
下面这个图详细的解释了`new`和`make`之间的区别
![](images/2.2.makenew.png?raw=true)
@@ -430,5 +428,5 @@ map的初始化可以通过key:val的方式初始化值，同时map内置有判
* 上一章: [你好,Go](<2.1.md>)
* 下一节: [流程和函数](<2.3.md>)
## LastModified
## LastModified
* $Id$