第2章 顺序编程

2.1 变量

变量声明

变量声明的类型信息放在变量之后，放在数组的中括号之后，作返回值类型放在方法名之后。

不需要使用分号作为结束符。

//字串和哈希表都是内置类型，都小写

varv1int

varv2string

varv3[10]int

varv4[]int//数组切片

v4=make([]string,10)

varv5stuct{

fint

}

varv6*int

varv7map[string]int//map,key为string类型,value为int类型

varv8func(aint)int

Go语言是个静态类型语言，但以上写法看上去却像动态语言。

var只用来声明，直接不值不用写var。

varv1=1//编译器报错

go语言变量赋值不使用也报错。

变量初始化

注意类型推演符左侧的就是不应该是已被声明过的。

varv1int=10

varv2=10//不指明类型也可以变量推演

varv3:=10//使用类型推演符:=

==总结==：没声明的必须类型推演，只声明没指定类型的可以类型推演，已声明类型的不能类型推演。

不用类型推演:=，用变量必须声明var，可以不写类型。

交换2个变量的值直接用多重赋值

i,j=j,i

匿名变量

可以使用多重返回和匿名变量的写法，使代码更优雅。

funcmain() {

    _,_,nickName:=GetName()

​

}

//多个同样类型的变量只声明一次就可以

funcGetName() (firstName,lastName,nickNamestring)  {

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

}

字面常量

Go语言的字面常量是无类型的，只要值在某类型的值域范围内，就可以赋值（不用再写类型转换了，简化代码）。如-12可以赋给int、unit、int32、float64等。

-12

3.14159//浮点型常量

3.2+12i//复数常量

true//布尔型常量

"foo"//字串常量

常量定义

常量也可以限定类型，但不是必须的。

constzerofloat64=3.14159

constzero=3.14159// 无类型常量

const{

zeroint64=0

zero=0//无类型常量

}

==常量赋值是编译期行为==，常量定义的右侧值也可以是一个编译期运行的常量表达式。

constmask=1<<3

//os.GetEnv("HOME")是运行期返回结果，所以下行代码编译错误

constHome=os.GetEnv("HOME")

预定义常量

go语言有3个预定义常量：true、false、iota。

每const关键字出现时，iota被重置为0，每出现一次iota其值增1。

const{

c0=iota

c1=iota

c2=iota

}

两个const赋值表达式是一样的，则可以省略后一个（==方便之处在于枚举型赋值，但可能带来意外赋值==）。这种写法多用于枚举型。

const{

a=1<

b//b == 2

c//c == 4

}

枚举

go语言并不支持enum关键字。枚举使用const后跟一对==圆括号==定义一组常量。

const(

Sunday=iota

Monay

TuesDay

numberOfDays//这个常量没有导出

)

go语言中大写字母的常量在包外可见，相当于访问限制符。

2.3 类型

go语言内置以下基础类型（7个）

bool

byte int unit int8 int16 uint uintptr等。(整形一般用int unit就可以了，以免移植困难)

float32 float64

complex64 complex128

string

字符类型rune

错误类型error

go语言的复合类型（7个）

指针pointer

数组array

切片slice

字典map

通道chan

结构体struct

接口interface

布尔型

varv1bool=true

布尔型不接受其它类型的赋值，也不支持强制类型转换。

整形

int和int32是两种不同的类型，编译器不会自动转换。

value1:=64//自动推导为

varvalue2int32

value2=value1//编译器报错

go语言不会隐式的类型转换，不同类型的整型不能比较和赋值，如int8和int。但可以直接与字面值常量比较（无类型）。（没有隐式类型转换的烦恼）

不同类型赋值要强制类型转换

value2=int32(value1)//强制转换用静态方法

variint32

varjint64

i,j=1,2

ifi==j{}//编译器报错

ifi==1||j==2{}//编译通过

==取反运算符是^x==，这与C语言不同。

浮点型

varfvalue1

fvalue1:=12.0//加小数点，推导为浮点型。

float32等价于C语言中的float型，float64等价于C语言中的double型（浮点型自动推演的的类型）。

用==比较浮点型不稳定，使用以下方案：

import"math"

funcIsEqual(f1,f2,pfloat64){

returnmath.Fdim(f1,f2)

}

复数

复数表示

varvaluecomplex64

value1=3.2+12i

value2:=complex(3.2,12)

real(value1)//取实部

imag(value1)//取虚部

字串

varstrstring

str="hello"

ch:=str[0]

fmt.Printf("the length of "%s" is %d n",str,len(str))

fmt.Printf("the first character of "%s" is %c"str,ch)

字串不能在初始化后修改

str:="hello"

str[0]"X"//编译错误

字串编码转换go只支持utf-8和unicode。其它可用iconv库转换。

字串操作：

x+y//字串连接

len(s)//取字串长度

s[i]//取字符

​

//两种字串遍历方式

str:="hello"

n:=len(str)

fori,ch:=rangestr{

fmt.Println(i,ch)

}

fori:=0;i

ch:=str[i]

fmt.Println(i,ch)//可以直接打印两个字符

}

字符

两种字符类型，byte表示UTF-8字串的单个字节值，rune代表单个Unicode字符。

数组

数组声明方法：

[32]byte

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

[1000]*float指针类型数组

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

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

​

varfVar[2][2]float64=[2][2]float64{{1,2},{1,2}}

数组可以是多维的，一旦定义长度后就不能修改。

go语言是值类型，在赋值和参数传递时会进行一次复制动作。因而在函数体中无法修改数组的内容，函数内操作的只是所传入数组的一个副本。

数组切片

数组在长度定义后无法修改，数组是值类型，这些无法满足开发者需求。

数组切片的数据结构可以抽象为以下3个变量：（类似于ArrayList）

指向原生数组的指针

数组切片的元素个数

数组切片已分配的存储空间

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

varslice1[]int=array1[:5]//使用数组的片段创建切片

slice2=make([]int,5)//创建元素个数为5的数组切片

slice3=make([]int,10)//创建元素个数5的数组切片，预留10个存储空间

slice4:=[]int{1,2,3,4,5}//直接创建5个元素的数组切片

​

len(slice1)

cap(slice1)//返回容量大小

这里书中有误：==make方法返回值==赋变量 ，无需类型推演。

==让编译器自行统计元素个数==：

b := [...]string{"Penn", "Teller"}

切片能够区分元素个数和容量。为避免扩容开销，容量由开发人员指定。

slice1:=append(slice1,8,9,10)//向切片末尾添加元素

slice1:=append(slice1,slice2)//添加切片

使用切片创建切片：

newSlice:=oldSlice[:3]//选择范围超过原切片，则补上0

切片复制：

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

slice2:=[]int(5,4,3)

copy(slice2,slice1)//只复制slice1的前3个元素到slice2中

copy(slice1,slice2)//复制slice2的元素到slice1的前3个位置

切片复制的原则是==不改变原切片长度==。

map

varmap1map[int]string

map1=make(map[int]string)

map1[1]="jack"

map1[2]="bill"

str,ok=map1[1]//查找键为1的数据

map的多返回值判断是否查找成功，使代码更简洁。

map初始化时可以设置容量：

map1=make(map[int]string,100)

添加元素如同元素赋值。

删除元素：

delete(map1,1)

struct(引自博客)

//结构体初始化

b := person{

       name: "wyff",

       age:  300,

   }

2.4 流程控制

选择语句支持switch、case和select。循环语句支持for和rage。跳转语句支持goto。

if语句要求

不需要括号()包条件

无论几条语句，{}是必须的

左花括号必须与if/else在同一行

有返回值函数中，不允许将"最终"return放在if...else中。

if语句也可以在条件表达式前加赋值语句。

switch选择语句

    switchi{

    case0:

        fmt.Print("0")

    case1:

        fmt.Print("1")

    case2:

        fmt.Print("2")

    default:

        fmt.Print("default")

    }

switch后无表达式的写法：

    varNum

    switch{

    case0

        fmt.Print("0-3")

    case4

        fmt.Print("4-6")

    }

//case不再是匹配项，而是表达式。

要求：

左花括号必须与switch处于同一行

条件表达式==不限制不整形或常量==，也可以不写

单个case可以出现多结果选项？？

==不需要break来明确退出一个case==，只有加fallthrough关键字才继续执行下一个case。

switch后无表达式，与if...else逻辑等同。

循环语句

无限循还直接写，而不需要for(;;)和do{}while(1)

for{

}

条件表达式支持多重赋值：

foti,j=0,len(arr);i

a[i],a[j]=a[j],a[i]

}

支持continue break循环控制，还可以决定跳出哪个循还。

forj:=0;j<5;j++{

fori:=0;i<5;i++{

ifi>3{

breakJLoop

   }

fmt.

  }

}

JLoop://循环标签

==注意循还标签有冒号==。Java使用bool标志来实现。

跳转语句

HERE:

ifi<10{

gotoHERE

}

2.5 函数

相邻的类型相同的参数，可以只写一个类型声明

函数的返回值的变量需要命名，只有一个可以不命名

funcAdd(a,bint)(resint,errerror){

err=errors.New("have errors")

return

}

forAdd(a,bint)int{}//单个返回值

func(a*Integer)Add(i,jint)int{returnx+y}//类方法的写法，是否加*后面讲

函数和变量的小写仅在包内可见，大写才能被其它包使用。相当于访问限制符。

多返回值

匿名函数和闭包

匿名函数可以直接赋值给一个变量或直接执行。

f:=func(x,yint)int{

returnx+y

}

f:=func(x,yint)int{

returnx+y

}(1,2)//后面带参数表示直接执行

匿名函数是一个闭包。

闭包定义：包含自由变量（未绑定到对象）的代码块。要执行的代码块为自由变量提供绑定的计算环境（作用域）。

闭包的价值：用作函数对象或匿名函数，==支持闭包的语言将函数存储到变量作为参数传递给其它函数==。

闭包是函数式编程中很重要的概念。

funcmain() {

    varjint=5

    a:=func() (func()){

        variint=10

        returnfunc() {fmt.Printf("i,j:%d,%d",i,j)}

    }()

    a()

    j*=2

    a()

}

//闭包内的i值被隔离，不会被修改。

//fmt.Print()用法如java，fmt.Printf()用法如C。

错误处理

typeerrorinterface{

Error()string

}

将error作为多返回值的最后一个，用于函数的返回错误。

错误处理：

iferr!=nil{}

defer关键字

提前写关闭文件、连接的语句。java用finally，C++用包一个类在析构函数中关闭。

funcCopyFile(dst,srcstring) (wint64,errerror) {

    srcFile,err:=os.Open(src)

    iferr!=nil{

        return

    }

    defersrcFile.Close()

    dstFile,err:=os.Create(dst)

    iferr!=nil{

        return

    }

    deferdstFile.Close()

    returnio.Copy(dstFile,srcFile)

}

panic()和recover()方法

错误处理流程：

当一个函数调用panic()函数时，正常的函数执行流程立即终止。

但使用defer关键字推迟执行语句正常展开执行。

函数返回到调用函数，逐层执行panic流程，直至所属的goroutine中所有执行的函数被终止。

报告错误信息，包括panic()函数传入的参数。

panic()的形参接收任意类型的数据。

recover()函数终止错误处理流程：如果没有在没有发生异常的goroutine中明确地调用恢复过程（使用recover()），则goroutine所属的进程==打印异常信息==后直接退出。