go基础
GO的环境变量与工作目录
GOPATH下需要建立3个目录
bin(存放编译后生成的可执行文件)
pkg(存放编译后生成的包文件)
src(存放项目源码)
GO的命令
go run: 直接运行程序
go build: 测试编译, 检查是否有编译错误
go fmt: 格式化源码
go install: 编译包文件并编译整个程序
go test: 运行测试文件
go doc: 查看文档(godoc -http=:8080)
Go是一门类似于C的编译型语言,但是它的编译速度非常快,这门语言的关键总共25个.
break default func interface select case defer go map struct chan else goto package switch const fallthrough if range type continue for import return var
1,你好,Go
注意:导入的包如果没有用到,go里是不允许的.
package main import "fmt" func main() { fmt.Printf("hello, world") }
详解
Go程序是通过package来组织的
package <pkgName> 这一行告诉我们当前文件属于那个包,而包名main则告诉我们他是一个可独立运行的包,他在编译后会产生可执行文件,除了main包之外,其他的包最后都会生成*.a文件(也就包文件)并放置在$GOPATH/pkg/$GOOS_$GOARCH中(以mac为例就是$GOPATH/pkg/darwin_amd64).
每一个可独立运行的Go程序,必定包含一个package main,在这个main包中必定包含
一个入口函数main,而这个函数既没有参数,也没有返回值
为了打印hello,woeld,我们调用了一个函数Printf,这个函数来自于fmt包,所以我们在第三行中导入fmt包:import "fmt"
2,定义变量
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
以上的定义有点繁琐,有相应的简单写法
var vname1, vname2, vname3 = v1, v2, 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 } //i declared and not used
常量
所谓常量,也就是在程序编译阶段就确定下来的值,而程序在运行时无法修改该值,在go中,变量可定义为数值,布尔值或字符串等类型
const constantName = value //如果需要,也可以明确指定常量的类型 const Pi float 32 = 3.1315926
下面是一些常量声明的例子
const Pi = 3.1415926 sonst i = 1000 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, int16, int32, int64, 和byte, uint8,uint16,uint32,uint64.其中rune时int32的别称,byte时unit8的别称
需要注意的一点时,这些类型的变量之间不允许互相赋值或操作,不然会在编译时引起编译器报错. 如下代码会产生错误:invalid operation: a+b(mismatched types int8 and int32) var a int8 var b int32 c := a + b 另外,尽管int的长度是32bit,但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)
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数据底层的存储
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 float 32 prefix string )
iota枚举
Go里面有一个关键字iota,这个关键字用来声明enum的时候采用,它默认开始值时0,const中每增加一行加1:
package main import "fmt" 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 ( h, i, j = iota, iota, 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 = iota // g =4 ) func main() { fmt.Println(a, b, c, d, e, f, g, h, i, j, x, y, z, w, v)
除非被显示设置为其他值或iota,每个const分组的第一个常量被默认值设置为它的0值,第二个及后续的常量被默认设置为它前面那个常量的值,如果前面那个常量的值是iota,则它也被设置为iota.
Go程序设计的一些规则
Go之所以那么简介,是因为他有一些默认的行为
大写字母开头的变量是可导出的,也就是其他包可以读取的,是公有变量,小写字母开头的就是不可导出的,是私有变量
大写字母开头的函数也是一样的,相当于class中带public关键词的共有函数;小写字母开头的就是有private关键词的私有函数
array, slice, map
array
array 就是数组,他的定义方式如下:
var arr [n]type
在[n]type中, n 表示数组的长度,type表示存储元素的类型.对数组的操作和其他语言类似,都是通过[]来进行读取或赋值:
package main import "fmt" func main() { var arr [10]int // 声明一个int类型的数组 arr[0] = 42 // 数组下标从零开始 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}}
数组的分配
多维数组的映射关系
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时,方括号内没有任何字符
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 aSlicem, bSlice []byte //演示一些简单操作 aSlice = array[3:7] //aSlice包含元素,d,e,f,g, len=4,cap=7 bSlice = aSlice[1:3] // bSlice包含aSlice[2]也就是含有:e,f bSlice = aSlice[:3] bSlice = aSlice[0:5] bSlice = aSlice[:]
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]
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
map
map也就是python中字典的概念,他的格式为map[keyType]valueType
我们看下面的代码,map的读取和设置类似slice一样,通过key来操作,只是slice的index只能是'int'类型,而map多了很多类型,可以是int,可以是string及所有完全定义了==与!=操作的类型.
//声明了一个key是字符串,值为int的字典,这种方式的声明需要在使用之前使用make的初始化 var numbrers 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["name"]=11可以很容易的把key为one的字典值改为11
map和其他基本数据类型不同,他不是thread - safe,在多个go - routine存取时,必须使用mutex lock机制
map的初始化可以通过key : val的方式初始化值,同时map内置有判断是否存在key的方式
通过delete删除map的元素:
package main import "fmt" func main() { //初始化一个字典 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") fmt.Println("这个字典还有", rating) }
上面说过了,map也是一种引用类型,如果两个map同时指向一个底层,那么一个该百年,另一个也相应改变:
m := make(map[string]string) m['hello'] = 'Bonjour' m1 := m m1["Hello"] = "salut" //现在m["hello"]的值已经时sault了
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之间的区别
零值
关于"零值",所指并非时空间,而是一种"变量未值填充前"的默认值,通常为0,此处罗列部分类型的零值
int 0 int8 0 int32 0 int64 0 uint 0*0 rune 0 //rune的实际类型时int32 byte 0*0 //byte的实际类型时 uint8 float32 0 // 长度为4byte float64 0 // 长度为8byte bool false string ""
浙公网安备 33010602011771号