go语言学习笔记一

go语言学习笔记一

2018年1月14日

14:49

1安装:

下载go1.9.2.windows-amd64.msi

默认安装c:/go,环境变量自动配置

命令行输入:go 如下提示就是成功



 
 
2 语法:

21.定义变量

var v1 int

var v2 string

 
 
var (

v1 int

v2 string

)

 
 
2.2变量初始化不需要分号；

 
 
var v1 int = 10 // 正确的使用方式1

var v2 = 10 // 正确的使用方式2，编译器可以自动推导出v2的类型

v3 := 10 // 正确的使用方式3，编译器可以自动推导出v3的类型

 
 
var i int

i := 2

使用:=必须是未使用的变量名

 
 
2.3变量赋值

i, j = j, i

交换值不需要中间变量，实现了多重赋值

 
 
2.4匿名变量

 
 
func GetName() (firstName, lastName, nickName string) {

return "May", "Chan", "Chibi Maruko"

}

firstName, lastName, nickName string 是返回值

 
 
可以定义如下格式接收

_, _, nickName := GetName()

 
 
2.5常量定义

const Pi float64 = 3.14159265358979323846

const zero = 0.0 // 无类型浮点常量

const (

size int64 = 1024

eof = -1 // 无类型整型常量

)

const u, v float32 = 0, 3 // u = 0.0, v = 3.0，常量的多重赋值

const a, b, c = 3, 4, "foo"

// a = 3, b = 4, c = "foo", 无类型整型和字符串常量

常量定义的右值也可以是一个在编译期运算的常量表达式

const mask = 1 << 3

 
 
由于常量的赋值是一个编译期行为，
所以右值不能出现任何需要运行期才能得出结果的表达

式，比如试图以如下方式定义常量就会导致编译错误：

const Home = os.GetEnv("HOME")

 
 
2.6预定义常量

Go语言预定义了这些常量： true 、 false 和 iota 。

 
 
iota 比较特殊，可以被认为是一个可被编译器修改的常量，在每一个 const 关键字出现时被

重置为0，然后在下一个 const 出现之前，每出现一次 iota ，其所代表的数字会自动增1。

 
 
const ( // iota被重设为0

c0 = iota // c0 == 0

c1 = iota // c1 == 1

c2 = iota // c2 == 2

)

const (

a = 1 << iota // a == 1 (iota在每个const开头被重设为0)

b = 1 << iota // b == 2

c = 1 << iota // c == 4

)

const (

u = iota * 42 // u == 0

v float64 = iota * 42 // v == 42.0

w = iota * 42 // w == 84

)

const x = iota // x == 0 (因为iota又被重设为0了)

const y = iota // y == 0 (同上)

 
 
如果两个 const 的赋值语句的表达式是一样的，那么可以省略后一个赋值表达式。因此，上

面的前两个 const 语句可简写为：

const ( // iota被重设为0

c0 = iota // c0 == 0

c1 // c1 == 1

c2 // c2 == 2

)

const (

a = 1 <<iota // a == 1 (iota在每个const开头被重设为0)

b // b == 2

c // c == 4

)

 
 
2.7枚举

枚举指一系列相关的常量，比如下面关于一个星期中每天的定义。通过上一节的例子，我们

看到可以用在 const 后跟一对圆括号的方式定义一组常量， 这种定义法在Go语言中通常用于定义

枚举值。Go语言并不支持 enum 关键字。

const (

Sunday = iota

Monday

Tuesday

Wednesday

Thursday

Friday

Saturday

numberOfDays // 这个常量没有导出

)

同Go语言的其他符号（symbol）一样，以大写字母开头的常量在包外可见。

以上例子中 numberOfDays 为包内私有，其他符号则可被其他包访问。

 
 
2.8 数据类型

 
 
Go语言内置以下这些基础类型：


布尔类型： bool 。


整型： int8 、 byte 、 int16 、 int 、 uint 、 uintptr 等。


浮点类型： float32 、 float64 。


复数类型： complex64 、 complex128 。


字符串： string 。


字符类型： rune 。


错误类型： error 。

以及复合类型


指针（pointer）


数组（array）


切片（slice）


字典（map）


通道（chan）


结构体（struct）


接口（interface）

 
 
float32 等价于C语言的 float 类型，

float64 等价于C语言的 double 类型。

 
 
2.9数组

常规的数组声明方法：

[32]byte // 长度为32的数组，每个元素为一个字节

[2*N] struct { x, y int32 } // 复杂类型数组

[1000]*float64 // 指针数组

[3][5]int // 二维数组

[2][2][2]float64 // 等同于[2]([2]([2]float64))

 
 
在Go语言中，数组长度在定义后就不可更改，在声明时长度可以为一个常量或者一个常量

表达式（常量表达式是指在编译期即可计算结果的表达式）
。数组的长度是该数组类型的一个内

置常量，可以用Go语言的内置函数 len() 来获取。下面是一个获取数组 arr 元素个数的写法：

arrLength := len(arr)

 
 
for i := 0; i < len(array); i++ {

fmt.Println("Element", i, "of array is", array[i])

}

 
 
关键字 range

 
 
for i, v := range array {

fmt.Println("Array element[", i, "]=", v)

}

在上面的例子里可以看到， range 具有两个返回值，第一个返回值是元素的数组下标，第二

个返回值是元素的值

 
 
2.10 值类型

在Go语言中数组是一个值类型（value type） 。所有的值类型变量在赋值和作为参数传递时都将产生一次复制动作。如果将数组作为函数的参数类型，则在函数调用时该参数将发生数据复制。因此，在函数体中无法修改传入的数组的内容，因为函数内操作的只是所传入数组的一个副本。

 
 
package main

import "fmt"

func modify(array [10]int) {

array[0] = 10 // 试图修改数组的第一个元素

fmt.Println("In modify(), array values:", array)

}

func main() {

array := [5]int{1,2,3,4,5} // 定义并初始化一个数组

modify(array) // 传递给一个函数，并试图在函数体内修改这个数组内容

fmt.Println("In main(), array values:", array)

}

 
 
In modify(), array values: [10 2 3 4 5]

In main(), array values: [1 2 3 4 5]

 
 
2.11 数组切片

创建数组切片的方法主要有两种——基于数组和直接创建

基于数组

// 先定义一个数组

var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

// 基于数组创建一个数组切片

var mySlice []int = myArray[:5]

 
 
// 先定义一个数组

var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

// 基于数组创建一个数组切片

var mySlice []int = myArray[:5]

基于从第5个元素开始的所有元素创建数组切片：

mySlice = myArray[5:]

直接创建

并非一定要事先准备一个数组才能创建数组切片。Go语言提供的内置函数 make() 可以用于

灵活地创建数组切片。

创建一个初始元素个数为5的数组切片，元素初始值为0：

mySlice1 := make([]int, 5)

创建一个初始元素个数为5的数组切片，元素初始值为0，并预留10个元素的存储空间：

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

直接创建并初始化包含5个元素的数组切片：

mySlice3 := []int{1, 2, 3, 4, 5}

事实上还会有一个匿名数组被创建出来，只是不需要我们来操心而已。

 
 
动态增减元素

切片元素个数和分配的空间可以是两个不同的值

数组切片支持Go语言内置的 cap() 函数和 len() 函数， cap() 函数返回的是数组切片分配的空间大小，而 len() 函数返回的是数组切片中当前所存储的元素个数

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

fmt.Println("len(mySlice):", len(mySlice))

fmt.Println("cap(mySlice):", cap(mySlice))

如果需要往上例中 mySlice 已包含的5个元素后面继续新增元素，可以使用 append() 函数。

下面的代码可以从尾端给 mySlice 加上3个元素，从而生成一个新的数组切片：

mySlice = append(mySlice, 1, 2, 3)

 
 
2.12 map:

变量声明

map 的声明基本上没有多余的元素，比如：

var myMap map[string] PersonInfo

 
 
可以使用Go语言内置的函数 make() 来创建一个新 map 。下面的这个例子创建了一个键

类型为 string 、值类型为 PersonInfo 的 map :

myMap = make(map[string] PersonInfo)

 
 
myMap = make(map[string] PersonInfo, 100)

 
 
myMap = map[string] PersonInfo{

"1234": PersonInfo{"1", "Jack", "Room 101,..."},

}

删除delete()

 
 
value, ok := myMap["1234"]

if ok { // 找到了

// 处理找到的value

}