参考文献

命名

  • Go语言中的函数名、变量名、常量名、类型名、语句标号和包名等所有的命名,都遵循一个简单的命名规则:一个名字必须以一个字母(Unicode字母)或下划线开头,后面可以跟任意数量的字母、数字或下划线.大写字母和小写字母是不同的:heapSort和Heapsort是两个不同的名字.

  • Go语言中类似if和switch的关键字有25个；关键字不能用于自定义名字,只能在特定语法结构中使用.

    1
    2
    3
    4
    5
    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

  • 此外,还有大约30多个预定义的名字,比如int和true等,主要对应内建的常量、类型和函数.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    内建常量: true false iota nil

    内建类型: int int8 int16 int32 int64
              uint uint8 uint16 uint32 uint64 uintptr
              float32 float64 complex128 complex64
              bool byte rune string error

    内建函数: make len cap new append copy close delete
              complex real imag
              panic recover

声明

  • Go语言主要有四种类型的声明语句:var、const、type和func,分别对应变量、常量、类型和函数实体对象的声明.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    var age int

    const boilingF = 212.0

    type people struct{
      Nanme string
      Age int
      Address string
    }

    func FunctionName(param1 int,param2 string)(int,string){
      
    }

变量

  • var声明语句可以创建一个特定类型的变量,然后给变量附加一个名字,并且设置变量的初始值.变量声明的一般语法如下:

    1
    var 变量名字 类型 = 表达式

  • 其中类型或= 表达式两个部分可以省略其中的一个.

    • 如果省略的是类型信息,那么将根据初始化表达式来推导变量的类型信息.
    • 如果初始化表达式被省略,那么将用零值初始化该变量. 数值类型变量对应的零值是0,布尔类型变量对应的零值是false,字符串类型对应的零值是空字符串,接口或引用类型(包括slice、指针、map、chan和函数)变量对应的零值是nil.数组或结构体等聚合类型对应的零值是每个元素或字段都是对应该类型的零值.

  • 零值初始化机制可以确保每个声明的变量总是有一个良好定义的值,因此在Go语言中不存在未初始化的变量.这个特性可以简化很多代码,而且可以在没有增加额外工作的前提下确保边界条件下的合理行为.例如:

    1
    2
    var s string
    fmt.Println(s) // ""

简短变量声明

  • 在函数内部,有一种称为简短变量声明语句的形式可用于声明和初始化局部变量.它以名字 := 表达式形式声明变量,变量的类型根据表达式来自动推导.

指针

  • 如果用var x int声明语句声明一个x变量,那么&x表达式(取x变量的内存地址)将产生一个指向该整数变量的指针,指针对应的数据类型是*int,指针被称之为“指向int类型的指针”.如果指针名字为p,那么可以说“p指针指向变量x”,或者说“p指针保存了x变量的内存地址”.同时*p表达式对应p指针指向的变量的值.一般*p表达式读取指针指向的变量的值,这里为int类型的值,同时因为*p对应一个变量,所以该表达式也可以出现在赋值语句的左边,表示更新指针所指向的变量的值.

    1
    2
    3
    4
    5
    x := 1
    p := &x         // p, of type *int, points to x
    fmt.Println(*p) // "1"
    *p = 2          // equivalent to x = 2
    fmt.Println(x)  // "2"

赋值

  • 使用赋值语句可以更新一个变量的值,最简单的赋值语句是将要被赋值的变量放在=的左边,新值的表达式放在=的右边.

    1
    2
    3
    4
    5
    6
    x = 1                       // 命名变量的赋值
    *p = true                   // 通过指针间接赋值
    person.name = "bob"         // 结构体字段赋值
    count[x] = count[x] * scale // 数组、slice或map的元素赋值
    count[x] *= scale

元组赋值

  • 元组赋值是另一种形式的赋值语句,它允许同时更新多个变量的值.在赋值之前,赋值语句右边的所有表达式将会先进行求值,然后再统一更新左边对应变量的值.

    1
    2
    3
    x, y = y, x

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

条件和循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
  if a == 0 {
    fmt.Println("0")
  } else if a < 0 {
    fmt.Println("a < 0")
  } else {
    fmt.Println("a > 0")
  }


  // 类似与Java的while
  a := 1
  for a <= 3 {
      fmt.Println(a)
      a++
  }

  // 类似与Java的while(true)
  for {
      fmt.Println("break")
      break
  }

  // 类似于Java的for
  for i := 0; i < 3; i++ {
      fmt.Println("hello")
  }

  for val := range []int{1, 2, 3} {
    fmt.Println(val)
  }

var number interface{} = 1
  switch number.(type) {
  case int:
    fmt.Println("int")
  case float64:
    fmt.Println("float64")
  case string:
    fmt.Println("string")
  }