变量

1. init函数在main函数之前执行

   func init() {fmt.Println("This is init function")
   }func main() {fmt.Println("This is main function")
   }// 输出内容
   // This is init function
   // This is main function
   

2. 标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，那使用这种标识符的对象就可以被外部包的代码所使用（客户端需导入），这被称为导出
   （类似于面向对象中的public）;

3. 标识符如果以小写字母开头，则对包外不可见，但在整个包的内部是不可见且可用的
   （类似于面向对象中的private）

4. 一行代表一个语句结束（不需要以分号;结束，由编译器自动完成）
   如果打算将多个语句写在同一行，则必须使用;进行区分（不建议使用）

5. 数字类型

   类型	描述
   int8/int16/int32/int64	有符号整数
   uint8/uint16/uint32/uint64	无符号整数
   float32/float64	IEEE-754 32/64位浮点型数
   complex64/complex128	32/64位实数和虚数
   byte	类似uint8
   rune	类似 int32
   uint	32或64位
   int	与 uint 一样大小
   unitptr	无符号整型，用于存放一个指针

6. 变量

   全局变量与局部变量可以同名，参考全局变量

   // 变量声明
   var identifier type
   // 1、指定变量类型（不赋值则使用类型默认值）
   var v_name v_type
   var v_name v_type = value
   // 2、类型推导
   var v_name = value
   // 3、省略 var，使用 := 进行声明；只能用于声明局部变量
   v_name := value// 下面使用 := 的定义是正确的
   var outer = true
   func main() {// a、打印方法外定义的变量定义fmt.Println(outer)// b、如果是全局变量，可以进行重新定义（包括类型可以不一样）（fixme 应该不是同一个变量了）outer := "使用 := 重新定义变量"fmt.Println(outer)// c、如下定义不能编译通过// var inner [string] = "局部变量"// fmt.Println(inner)// inner := "使用 := 重新定义局部变量无法编译通过"// fmt.Println(inner)
   }// 局部变量：同类型多个变量
   // 1、指定类型（三个变量类型一致；可以是全局变量）
   var vname1,vname2,vname3 type
   vname1,vname2,vname3 = v1, v2, v3
   // 2、类型推导（可以是不同的类型；可以是全局变量；并行|同时赋值）
   var vname1,vname2,vname3 = v1, v2, v3
   // 3、初始化声明（可以是不同的类型；变量必须不能是已经在方法内部声明过的；并行|同时赋值）
   vname1,vname2,vname3 := v1, v2, v3
   // 全局变量：类型不同的多个变量声明（只能是全局变量）
   var (v_name_1 type1v_name_2 type2
   )
   

7. 值类型与引用类型

   1. 值类型
      1. 所有像int、float、bool和string这些基本类型都属于值类型，使用这些类型的变量直接指向存在内存中的值
      2. 当使用等号=将一个变量的值赋值给另一个变量时，如：j = i，实际上是在内存中将 i 的值进行了拷贝
      3. 可以通过&i来获取变量 i 的内存地址
      4. 值类型的变量的值存储在栈中
   2. 引用类型
      1. 更复杂的数据通常会需要使用多个值，这些数据一般使用引用类型保存
      2. 一个引用类型的变量 r1 存储的是 r1 的值所在的内存地址（数字），或内存地址中第一个值所在的位置（这个内存地址也称指针）
      3. 同一个引用类型的指针指向的多个值在内存中可以是连续的，也可以是分散的

8. 局部变量禁止只声明不使用；全局变量允许只声明不使用

   var outer string = "全局变量允许只声明不使用"
   func main() {// Unused variable 'inner'var inner = "局部变量禁止只声明不使用"
   }
   

9. 如果想要简单的交换两个变量的值，可以使用a, b=b, a

10. 空白标识符_也被用于抛弃值，如值 5 在_, b := 5, 7中被抛弃
    _ 实际上只是一个可写变量，不能获取其值
    （Go 语言中你必须使用所有被声明的变量，但有时你并不需要使用从一个函数得到的所有返回值）

11. 并行赋值也被用于当一个函数返回多个返回值

    val, err = Func1(var1)
    

常量

1. 常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型

2. 定义格式

   // 类型说明符可省略
   const identifier [type] = value
   // 支持同时定义多个同类型变量
   const c_name_1, c_name_2 = value1, value2// 可以定义同名的局部和全局常量
   const a1, a2, a3 = "a1", 23, true
   func method() {// 这么定义不会报错const a1, a2 = "aa1", "aa2"// 优先输出局部变量定义，没有则输出全局变量值fmt.Println(a1, a2, a3)
   }
   

3. 常量还可以用作枚举

   const (Unknown = 0Female  = 1Male    = 2
   )
   

4. 常量定义中可以使用len()、cap()、unsafe.Sizeof()计算表达式的值（必需是内置函数）

   const (a = "abc"b = len(a)c = unsafe.Sizeof(a)
   )
   

5. iota，特殊常量，可以认为是一个可以被编译器修改的常量
   在每一个const关键字出现时，被重置为0，然后再下一个const出现之前，每出现一次iota，其所代表的数字就会自动增加1

   // 定义一
   const (a = iotab = iotac = iota
   )
   // 接上定义二
   // const出现，值被重置
   const (d = iotae = iotaf = iota
   )
   // a=0,b=1,c=2
   // d=0,e=1,f=2
   // 简写为
   const (a = iotabc
   )
   

6. 复杂一些的用法

   // 示例一
   const (a = iota // a=0b        // b=1c        // c=2d = "ha" // d="ha",iota+=1=3e        // e="ha",iota+=1=4f = 100  // f=100,,iota+=1=5g        // g=100,,iota+=1=6h = iota // 恢复计数 h=7i        // i=8
   )
   // 示例二 
   const (i = 1 << iota // i=1<<0=1j = 3 << iota // j=3<<1=6k             // k=3<<2=12l             // l=3<<3=24
   )
   

运算符

• 算术运算符

  含+、-、*、/、%、++、--

  func method() {a := 10b := 20var c intc = a + bc = a - bc = a * bc = a / bc = a % b// 等效于：a=a+1a++// 等效于：a=a-1a--// 没有 ++a 或 --a 的操作
  }
  

• 关系运算符

  含==、!=、>、<、>=、<=

• 逻辑运算符

  含&&、||、!

  1. 没有单与、单或
  2. go的风格是不必将逻辑运算符计算使用括号包裹

  func method() {a := trueb := true// go 的风格是不必将逻辑运算使用括号包裹if a || b {fmt.Println("a||b is true")}// 逻辑运算符中没有单与、单或// if a | b{}
  }
  

• 位运算符

  可以对整数在内存中的二进制位进行操作

  含&、|、^

  运算符	说明
  &	与运算，全真为真
  |	或运算，全假才假
  ^	异或运算，相同为假，不同为真
  <<	左移运算符，左移n位就是乘以2的n次方（高位丢弃，低位补0）
  >>	右移运算符，右移n位就是除以2的n次方

• 赋值运算符

  运算符	说明	实例
  =	将一个表达式的值赋给一个左值	C = A + B
  +=	相加后再赋值	C += A 等于 C = C + A
  -=	相减后再赋值	C -= A 等于 C = C - A
  *=	相乘后再赋值	C *= A 等于 C = C * A
  /=	相除后再赋值	C /= A 等于 C = C / A
  %=	求余后再赋值	C %= A 等于 C = C % A
  <<=	左移后赋值	C <<= 2 等于 C = C << 2
  >>=	右移后赋值	C >>= 2 等于 C = C >> 2
  &=	按位与后赋值	C &= 2 等于 C = C & 2
  ^=	按位异或后赋值	C ^= 2 等于 C = C ^ 2
  |=	按位或后赋值	C |= 2 等于 C = C | 2

• 其他运算符

  运算符	说明	实例
  &	变量内存地址	&var_name返回变量的实际地址
  *（fixme）	指针变量	*var_name是一个指针变量

• 运算符优先级（由高到低）

  优先级	运算符
  7	^ !
  6	* / % <> & &^
  5	+ - | ^
  4	== != < = >
  3	<-
  2	&&
  1	||

条件语句

语句	描述
if 语句	if 语句 由一个布尔表达式后紧跟一个或多个语句组成。
if…else 语句	if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。
if 嵌套语句	你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。
switch 语句	switch 语句用于基于不同条件执行不同动作。
select 语句	select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。

Switch

• switch语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加break

• 可以在一个case中同时测试多个可能符合条件的值，使用逗号 ,分隔

• 所有case候选值必需同switch变量（表达式）相同类型（否则编译错误）

• 有两种写法

  //变量 var_name 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值
  switch var_name {case val1:// 匹配项中不需要添加 break...case val2:// case 中可以存在多个 value...default:...
  }
  

  示例：

  func method() {grade := "B"marks := 90// 写法一switch marks {case 90:grade = "A"// case 中可以同时有多个可能符合条件的值case 80:grade = "B"// case 中不需要 breakdefault:grade = "C"}// 写法二switch {case grade == "A":fmt.Println("优秀")// case 中可以同时有多个可能符合条件的值case grade == "B", grade == "C":fmt.Println("良好")// case 中不需要 breakdefault:fmt.Println("差")}fmt.Println("等级是: ", grade)
  }
  

Type Switch（fixme）

switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际存储的变量类型

switch x.(type){case type:statement(s)     case type:statement(s)/* 你可以定义任意个数的case */default: /* 可选 */statement(s)
}

示例：

func method() {// 定义接口var x interface{}switch i := x.(type) {case nil:fmt.Printf(" x 的类型 :%T", i)case int:fmt.Printf("x 是 int 型")case float64:fmt.Printf("x 是 float64 型")// case 项也可以是 funccase func(int) float64:fmt.Printf("x 是 func(int) 型")// 可以测试多个可能符合条件的值case bool, string:fmt.Printf("x 是 bool 或 string 型")default:fmt.Printf("未知型")}
}

Select（fixme）

1. 与操作系统中的 select 比较相似
2. 与 switch 有相似的控制结构，但这些 case 中的表达式必须都是Channel的收发操作

1. 是一个控制结构；
2. select 随机执行一个可运行的 case；
3. 如果没有 case 可运行，select 将阻塞，直到有 case 可运行；
4. 默认的 default （如果存在）必需可以正常执行

select {case communication clause  :statement(s)      case communication clause  :statement(s)/* 你可以定义任意数量的 case */default : /* 可选 */statement(s)
}

1. 每个 case 都必须是一个Channel
2. 所有Channel表达式都会被求值
3. 所有被发送的表达式都会被求值
4. 如果任意某个Channel可以执行，它就执行；其他被忽略
5. 如果有多个 case 可以运行，select 会随机公平的选出一个执行；其他被忽略
6. 如果没有 case 可以运行：
   1. 存在 default ，执行 default
   2. 没有 default，阻塞直到某个Channel可以进行（Go 不会对 channel 或值进行求值）

select的知识点小结如下：

1. select 语句只能用于信道的读写操作
2. select 中的 case 条件(非阻塞)是并发执行的，select 会选择先操作成功的那个 case 条件去执行，如果多个同时返回，则随机选择一个执行，此时将无法保证执行顺序。对于阻塞的 case 语句会直到其中有信道可以操作，如果有多个信道可操作，会随机选择其中一个 case 执行
3. 对于 case 条件语句中，如果存在信道值为 nil 的读写操作，则该分支将被忽略，可以理解为从 select 语句中删除了这个 case 语句
4. 如果有超时条件语句，判断逻辑为如果在这个时间段内一直没有满足条件的 case ，则执行这个超时 case 。如果此段时间内出现了可操作的 case ，则直接执行这个 case 。一般用超时语句代替 default 语句
5. 对于空的 select{} ，会引起死锁
6. 对于 for 中的 select{} ，也有可能会引起 cpu 占用过高的问题

循环语句

循环类型	描述
for 循环	重复执行语句块
循环嵌套	在 for 循环中嵌套一个或多个 for 循环

循环类型

for 循环

// 三种形式，只有一种使用分号
// 1、与 C 的 for 同（同 Java ，没有括号）
for init; condition; post { }
// 2、与 C 的 while 同
for condition { }
// 3、与 C 的 for(;;) 同
for { }

for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环

for key, value := range oldMap {newMap[key] = value
}

示例：

func method() {numbers := [6]int{1, 2, 3, 5}for i, x := range numbers {fmt.Printf("第 %d 位 x 的值 = %d\n", i, x)}
}

嵌套循环

// 同 Java ，没有括号
for [condition |  ( init; condition; increment ) | Range]
{for [condition |  ( init; condition; increment ) | Range]{statement(s)}statement(s)
}

循环控制语句

控制语句	描述
break 语句	经常用于中断当前 for 循环或跳出 switch 语句
continue 语句	跳过当前循环的剩余语句，然后继续进行下一轮循环。
goto语句	将控制转移到被标记的语句。

goto（不建议使用）

可以无条件的转移到过程中指定的行

通常与条件语句配合使用，实现条件转移，构成循环、跳出循环的等功能

一般不建议使用goto，以免造成程序流程混乱，使程序难以理解或调试困难

goto label
..
.
label: statement

示例：

// 1、终止嵌套循环
func method1() {for x := 0; x < 10; x++ {for y := 0; y < 10; y++ {if y == 2 {// 跳转到标签（同时也会终止所有循环，有点类似 Java 中的 label 使用）goto breakHere// 直接使用只会退出当前循环// break}}}// 手动返回, 避免执行进入标签return// 标签
breakHere:fmt.Println("done")
}// 2、代码复用
func method2() {err := firstCheckError()if err != nil {goto onExit}err = secondCheckError()if err != nil {goto onExit}fmt.Println("done")return
onExit:fmt.Println(err)exitProcess()
}

函数

1. 最基本的代码块，用于执行一个任务
2. 最少有一个 main 函数
3. 逻辑上每个函数执行的是指定的任务
4. 函数名称，参数列表和返回值(类型，个数，顺序)一起构成了函数签名
5. 标准库提供了多种可动用的内置的函数（存在于builtin和unsafe标准库）

定义：

// 1、可以返回多个值
// 2、如果没有返回值，return_types 可缺省  
// 3、入参类型相同可使用简单定义
func function_name( [parameter list] ) [return_types] {// function body
}
func function_name( [parameter list] ) (type1,type2,...,typeN) {// function body
}func max(a, b int) int {// 方法体省略return ret
}
func swap(x, y string) (string, string) {return y, x
}

函数参数

传递类型	描述
值传递	值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
引用传递	引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数

引用传递的一个例子（具体用法待研究）：

// 引用传递入参及方法体有所不同
func swap(x *int, y *int) {var tmp inttmp = *x*x = *y*y = tmp
}

函数用法

函数用法	描述
函数作为值	函数定义后可作为值来使用
闭包	闭包是匿名函数，可在动态编程中使用
方法	方法就是一个包含了接受者的函数

/* 声明函数变量 */
getSquareRoot := func(x float64) float64 {return math.Sqrt(x)
}
/* 闭包 */
func getSequence() func() int {i := 0return func() int {i += 1return i}
}
/* 函数方法 */
func (variable_name variable_data_type) function_name([var_name type]) [return_type]{/* 函数体*/
}

函数方法：相当于Java中的一个类拥有的自定义方法

/* 定义函数 fixme */
type Circle struct {radius float64
}// 该方法属于 Circle 类型对象中的方法
func (c Circle) getArea() float64 {//c.radius 即为 Circle 类型对象中的属性return 3.14 * c.radius * c.radius
}
// 方法定义没错，但不属于 Circle 类型对象的方法
func getArea2(c Circle) float64 {return math.Pi * c.radius * c.radius
}
// 方法可以接收入参
func (c Circle) getPerimeter(x, y int) float64 {fmt.Println("x=", x, ",y=", y)return math.Pi * c.radius * 2
}func main() {var c1 Circlec1.radius = 10.00// 方法调用fmt.Println("Area of Circle(c1) = ", c1.getArea())// getArea2 不是 Circle 类对象的方法// fmt.Println("Area of Circle(c1) = ", c1.getArea2())area := getArea2(c1)fmt.Println("area = ", area)fmt.Println("Perimeter of Circle(c1) = ", c1.getPerimeter(10, 15))
}

变量作用域

变量可以在三个地方声明：

• 函数内定义的变量称为局部变量
• 函数外定义的变量称为全局变量
• 函数定义中的变量称为形式参数

局部变量

1. 在函数体内声明
2. 作用域只在函数体内
3. 参数和返回值变量也是局部变量

全局变量

1. 在函数体外声明
2. 可以在整个包甚至外部包（被导出后）使用

全局变量与局部变量名称可以相同，但是函数内的局部变量会被优先考虑

形式参数（形参）

出现在函数/方法形参表中的变量（当作局部变量使用）

初始化局部和全局变量

数据类型	初始化默认值
int	0
float32	0
pointer（fixme）	nil

参考资料：

• Go 教程