这是我参与「第五届青训营 」伴学笔记创造活动的第 1 天

前言

记载参加青训营的每一天的日笔记

本文一共分为：介绍、关键字、数据类型的界说、内置基础类型、array/slice/map、零值

Go介绍

Go 是在设计时考虑了系统编程的通用型编程言语。它是强类型，有废物回收机制并原生支持并发编程。Go 程序由一个或多个 package 组成，这样能够高效的办理依靠。

Go 的语法简练且有规则，这让主动化工具能够很容易的分析代码，例如：集成开发环境。

Go一些规则

Go之所以会那么简练，是由于它有一些默许的行为：

  • 大写字母最初的变量是可导出的，也便是其它包能够读取的，是公有变量；小写字母最初的便是不可导出的，是私有变量。
  • 大写字母最初的函数也是相同，相当于class中的带public关键词的公有函数；小写字母最初的便是有private关键词的私有函数。

关键字

  • var和const 是 Go言语基础里边的变量和常量声明
  • package和import 用于分包和导入
  • func 用于界说函数和办法
  • return 用于从函数回来
  • defer 用于相似析构函数
  • go 用于并发
  • select 用于挑选不同类型的通讯
  • interface 用于界说接口
  • struct 用于界说抽象数据类型
  • break、case、continue、for、fallthrough、else、if、switch、goto、default 用于流程控制
  • chan用于channel通讯
  • type用于声明自界说类型
  • map用于声明map类型数据
  • range用于读取slice、map、channel数据

数据类型的界说

变量

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
​
/*
  界说三个变量，它们别离初始化为相应的值
  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办法来界说全局变量。
    _（下划线）是个特殊的变量名，任何赋予它的值都会被丢掉
*/
_, b := 34, 35

常量

Go 常量和一般程序言语不同的是，能够指定相当多的小数位数(例如200位)，若指定给float32主动缩短为32bit，指定给float64主动缩短为64bit

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

const constantName = value
//假如需求，也能够清晰指定常量的类型：
const Pi float32 = 3.1415926
//下面是一些常量声明的例子
const Pi = 3.1415926
const i = 10000
const MaxThread = 10
const prefix = "astaxie_"

内置基础类型

布尔类型

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

数值类型

整数类型有无符号和带符号两种。Go同时支持int和uint，这两种类型的长度相同，但具体长度取决于不同编译器的实现。

Go里边也有直接界说好位数的类型：rune, int8, int16, int32, int64和byte, uint8, uint16, uint32, uint64。其间rune是int32的别称，byte是uint8的别称。

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

另外，虽然int的长度是32 bit, 但int 与 int32并不能够互用。

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

字符串

Go中的字符串都是选用UTF-8字符集编码。字符串是用一对双引号（""）或反引号（“）括起来界说，它的类型是string。

//示例代码
var frenchHello string // 声明变量为字符串的一般办法
var emptyString string = "" // 声明晰一个字符串变量，初始化为空字符串
func test() {
  no, yes, maybe := "no", "yes", "maybe" // 简短声明，同时声明多个变量
  japaneseHello := "Konichiwa" // 同上
  frenchHello = "Bonjour" // 惯例赋值
}

在Go中字符串是不可变的，但能够经过切片方法进行修正

s := "hello"
c := []byte(s) // 将字符串 s 转换为 []byte 类型
c[0] = 'c'
s2 := string(c) // 再转换回 string 类型
fmt.Printf("%s\n", s2)

错误类型

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

err := errors.New("emit macho dwarf: elf header corrupted")
if err != nil {
  fmt.Print(err)
}

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 //h=0,i=0,j=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    = iota       //g = 4
)
func main() {
  fmt.Println(a, b, c, d, e, f, g, h, i, j, x, y, z, w, v)
}

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是不同的类型，数组也就不能改动长度。数组之间的赋值是值的赋值，即当把一个数组作为参数传入函数的时分，传入的其实是该数组的副本，而不是它的指针。

数组能够运用另一种:=来声明

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的一些简洁操作

  • slice的默许开端方位是0，ar[:n]等价于ar[0:n]
  • slice的第二个序列默许是数组的长度，ar[n:]等价于ar[n:len(ar)]
  • 假如从一个数组里边直接获取slice，能够这样ar[:]，由于默许第一个序列是0，第二个是数组的长度，即等价于ar[0:len(ar)] 
// 声明一个数组
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开端方位到数组的最终方位的长度

slice有几个有用的内置函数

  • len 获取slice的长度
  • cap 获取slice的最大容量
  • append 向slice里边追加一个或许多个元素，然后回来一个和slice相同类型的slice
  • copy 函数copy从源slice的src中仿制元素到方针dst，而且回来仿制的元素的个数

append函数会改动slice所引证的数组的内容，从而影响到引证同一数组的其它slice。

但当slice中没有剩余空间（即(cap-len) == 0）时，此刻将动态分配新的数组空间。回来的slice数组指针将指向这个空间，而原数组的内容将保持不变；其它引证此数组的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回来初始化后的（非零）值。

零值

关于“零值”，所指并非是空值，而是一种“变量未填充前”的默许值，一般为0。