2.1 变量

程序可以通过定义一个变量来申请一块数据存储空间，之后可以通过引用变量名来使用这块存储空间。

2.1.1 变量声明

Go语言引入了关键字var ，而类型信息放在变量名之后：

java：public String str1="ss";

C++:

Go:

var v1 int

2.1.2 变量初始化

var v1 int = 10

var v2 = 10

v3 := 10

这三种都是变量初始化，但是还是标准写法。后面两种奇葩写法看看就好了。

2.1.3 变量赋值

I,j交换变量值：i, j = j, I 等价t = i; i = j; j = t;

var v1 int

v1=10

2.1.4 匿名变量

对于多个返回值：_, _, nickName := GetName()，GetName()函数返回三个值，只要返回nickName就这样写。

2.2 常量

2.2.1 字面常量

2.2.2 常量定义

const Pi float64 = 3.14

const a int =1

const b="B"

const a,b,c=1,"2","C"

const (

a=1

b="B"

c=iota //c=3表示第三个常量

)

2.2.3 预定义常量

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

Go语言预定义了这些常量：true、false和iota。 在每一个const关键字出现时被重置为0，然后在下一个const出现之前，每出现一次iota，其所代表的数字会自动增1。

const (

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

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

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

)

fmt.Println(a, b, c)

2.3 类型

2.3.1 布尔类型

var v1 bool

v1 = true

2.3.2 整型

var value2 int32

value2 = 64

强制类型转换，把value1强制转换为int32类型：

value2 = int32(value1)

运算符：

加减乘除，取余运算：+、-、*、/和%。

^ ,!

指针：& ,&^ 。&取地址，*访问地址对应的对象

a:=1

var p *int =&a

fmt.Println(*p)

比较运算：>、<、==、>=、<=和!=。不同类型的整型不能比较大小！

位运算符：

2.3.3 浮点型

因为浮点数像整型那样直接用==来判断两个浮点数是否相等是不可行的，这可能会导致不稳定的结果。

2.3.4 复数类型

var value1 complex64 // 由2个float32构成的复数类型

value1 = 3.2 + 12i

value2 := 3.2 + 12i // value2是complex128类型

value3 := complex(3.2, 12) // value3结果同 value2

2.3.5 字符串

字符串拼接

python：

java：

c++：

2.3.6 字符类型

byte

2.3.7 数组

array（数组） struct（结构体）point（指针）

数组：

a:=[10]int{}

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

a[5:10]//取a[5],...,a[9]

a[4:]

a[:6]

// 数组切片

func f6() {

// 先定义一个数组

var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} // 基于数组创建一个数组切片

var mySlice []int = myArray[:5]

fmt.Println("Elements of myArray: ")

for _, v := range myArray {

fmt.Print(v, " ")

}

fmt.Println("\nElements of mySlice: ")

for _, v := range mySlice {

fmt.Print(v, " ")

}

fmt.Println()

}

// 切片append，copy

func f7() {

s1 := make([]int, 5)

s2 := make([]int, 3, 4)

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

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

fmt.Println("s1[", i, ",]=", s1[i])

}

fmt.Println(cap(s2))

// fmt.Println(len(s2))

// append(s2, 1, 2, 3)

// append(s2, s3)

copy(s2, s3)

}

引用

slice（切片） map（字典） chan（通道）

slice切片，类似于数组，但是是引用类型数组

type PersonInfo struct {

ID string

Name string

Age int

Address string

}

// map

func f8() {

persond := make(map[string]PersonInfo)

persond["1"] = PersonInfo{"1234", "tome2", 18, "上海市1"}

persond["2"] = PersonInfo{"123", "tom1", 18, "上海市"}

person, ok := persond["1"]

if ok {

fmt.Println("name", person.Name)

} else {

fmt.Println("没找到")

}

//删除一个map

delete(persond, "1")

fmt.Println("map长度：", len(persond))

}

var s1 [10]int

s1:=make([]int,3,10)

len()

cap()

接口：

interface

函数：func

2.3.8 数组切片

2.3.9 map

2.4 流程控制

2.4.1 条件语句

var a int = 10

if a > 100 {

fmt.Println("n大于100")

} else if a > 10 {

fmt.Println("n在100以内")

} else {

fmt.Println("n在10以内")

}

2.4.2 选择语句

switch a {

case 100:

fmt.Println("n=100")

case 10:

fmt.Println("n=10")

default:

fmt.Println("n=?")

}

switch {

case a > 100:

fmt.Println("n大于100")

case a > 10:

fmt.Println("n大于10")

default:

fmt.Println("n在10以内")

}

switch默认匹配到条件会跳出switch，不需要加break退出，不想退出加：fallthrought

2.4.3 循环语句

只有for一个关键字循环。

sum := 0

for i := 1; i <= 36; i++ {

sum = sum + i

}

fmt.Println("sum：", sum)

数组遍历：

var array [3]int

for i, v := range array {

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

}

2.4.4 跳转语句

goto ,break ,continue

for i := 1; i < 36; i++ {

sum = sum + i

if sum > 300 {

break

}

}

label1:

for {

for i := 1; i < 36; i++ {

sum = sum + i

if sum > 300 {

break label1

}

}

}

label2:

for i = 1; i < 36; i++ {

sum = sum + i

if sum > 300 {

goto label1

}

}

2.5 函数

2.5.1 函数定义

函数的基本组成为：关键字func、函数名、参数列表、返回值、函数体和返回语句。第一个括号包含参数，第二个括号包含返回值（一个参数可不括号）。
这个定义方法和java不同，可以多个返回值。

func f1() (res int) {

var a int = 0

if a < 10 {

res = 1

} else if a < 5 {

res = 2

} else {

res = 3

}

return res

}

如果只有一个返回值（矫情）：

func f1() int {

var a int = 0

var res int

if a < 10 {

res = 1

} else if a < 5 {

res = 2

} else {

res = 3

}

return res

}

2.5.2 函数调用

这个和其他语言类似，不多说：

func f2(a int, b int) (res int) {

if a < b {

return a

} else if a > b {

return b

} else {

return 0

}

}

func main() {

fmt.Println(f2(1, 2))

}

2.5.3 不定参数

…表示不定参数，必须是最后一个参数。

func f3(args ... int) {

for _, arg := range args {

fmt.Println(arg)

}

}

2.5.4 多返回值

和python类似，多返回值。

2.5.5 匿名函数与闭包

这个java/C++没有这个概念，js里面function(){}

不写函数名就是匿名函数。对应js回调函数去理解。

f := func(x, y int) int { return x + y }

return是一个匿名函数，形成一个闭包，也就是所谓的函数里面的函数，这种做法很不标准。

func main() {

var j int = 5

f1 := func() (func()) {

var i int = 10

return func() {

fmt.Printf("i, j: %d, %d\n", i, j)

}

}()

f1()

}

2.6 错误处理

2.6.1 error接口

java中try{}catch{}.go语言直接返回error错误即可。

2.6.2 defer

2.6.3 panic()和recover()