运算符

  1. 算数运算符：+ - * / % ++ --
  2. 关系运算符：== != > < >= <=
  3. 逻辑运算符：&& || !
  4. 位运算符：
    • & 按位与：都为 1 则结果为 1
    • | 按位或：有一个为 1 则结果为 1
    • ^ 按位异或：对应位不同值则结果为 1
    • << 左移：把数整体向左移
    • >> 右移：把数整体向右移
    • &^ 位清空：被运算变量 bit 位上数字为 0 ，则取运算变量对应位置上的数字，如果被运算变量 bit 位上数字为 1 ，则结果位上取 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
func main() {
        a := 60         // 0011 1100
        b := 13         // 0000 1101
        println(a & b)  // 0000 1100 = 12
        println(a | b)  // 0011 1101 = 61
        println(a ^ b)  // 0011 0001 = 49
        println(a << 2) // 1111 0000 = 240
        println(b >> 2) // 0000 0011 = 3
        println(a &^ b) // 0011 0000 = 48

        c := 50         // 0011 0010
        d := 12         // 0000 1100
        println(c &^ d) // 0011 0010 = 50
}
  1. 赋值运算符：= += -= *= /+ %= &= |= ^= >>= <<=

控制语句

  1. 条件语句：if...else，嵌套 if...else if...
  2. 选择语句：switch，select 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    func main() {
        var a interface{}
        a = 3.14
        switch a.(type) {
            case int:
                println("整型")
            case float64:
                println("浮点型")
            case bool:
                println("布尔型")
            case string:
                println("字符串型")
            default:
                println("都不是")
        }
    }
    // 浮点型
  3. 循环语句：for 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    //循环数组
    func main() {
        var array = []string{"苹果", "香蕉", "大鸭梨"}

        for k, v := range array {
            println(k)
            println(v)
        }
    }
  4. 关键字：goto，break，continue 
    1
    2
    3
    4
    5
    6
    7
    8
    func main() {
        goto One
        fmt.Println("张三")
        One:
            fmt.Println("李四")
    }

    // 李四

函数

  1. 函数定义格式

    1
    2
    3
    func function_name( [parameter list] ) [return_type] {
            // 函数体
    }

    func 函数由 func 开始声明
    function_name 函数名称
    parameter list 参数列表，指定参数类型、顺序、个数，可选
    return_type 返回值类型，可选

    函数可返回多个值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    func swap(x, y string) (string, string) {
        return y, x
    }

    func main() {
        a, b := swap("Mahesh", "Kumar")
        fmt.Println(a, b)
    }
    // Kumar Mahesh

数组

  1. 数组定义格式

    1
    var variable_name [SIZE] variable_type

    例：以下定义了长度为 10 ，类型为 float32 的数组 balance

    1
    var balance [10] float32

  2. 多维数组

    1
    var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type

    例：以下实例声明了二维的浮点型数组：

    1
    2
    3
    4
    5
      var balance = [3][4]float32{
    {3.14, 5.19, 2.34, 4.05},
    {3.14, 5.19, 2.34, 4.05},
    {3.14, 5.19, 2.34, 4.05},
      }

结构体

  1. 结构体定义格式

    1
    2
    3
    4
    5
    6
    type struct_variable_name struct {
        member_name member_type
        member_name member_type
        ...
        member_name member_type
    }

    一旦定义了结构体类型，它就能用于变量的声明，语法格式如下：

    1
    variable_name := struct_variable_name{value1, value2...value3}

    或

    1
    variable_name := struct_variable_name{ key1: value1, key2: value2, ...}

  2. 访问结构体成员

    使用 . 操作符，例：结构体名.成员名

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    type Shops struct {
        shop_id int
        name string
        title string
    }

    func main() {
        var Shop1, Shop2 Shops

        Shop1.shop_id = 1
        Shop1.name = "剃须刀"
        Shop1.title = "刮胡子的！"

        Shop2 = Shops{2, "牙膏", "刷牙的！"}
        fmt.Println(Shop1)
        fmt.Println(Shop2)
    }

切片

  1. 切片的定义格式

    通过声明个一个未指定大小的数组来定义切片：

    1
    var slice = []int

    或者通过 make() 函数来创建切片

    1
    2
    3
    var slice []int = make([]int, 10)
    //简写为
    slice := make([]int, 10)

    也可以指定容量

    1
    make([]type, len, capacity)

    一个切片在未初始化之前默认为 nil，长度为 0

  2. len() 和 cap() 函数

    切片是可索引的，并且可以由 len() 函数获取长度，cap() 函数测量切片容量

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    func main() {
        var numbers = make([]int, 3, 5)

        printSlice(numbers)
    }

    func printSlice(x []int){
        fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
    }

    // len=3 cap=5 slice=[0 0 0]

  3. 切片截取

    可以通过设置下限及上限来设置截取切片 [lower-bound:upper-bound]，实例如下：

    1
    2
    3
    4
    5
    6
    7
    var arr = []int{1, 2, 3, 4}

    var slice = arr[1:3]

    fmt.Println("slice = ", slice)

    // [2 3]
    1
    2
    3
    4
    5
    6
    7
    var arr = []int{1, 2, 3, 4}

    var slice = arr[1:]

    fmt.Println("slice = ", slice)

    // [2 3 4]
    1
    2
    3
    4
    5
    6
    7
    var arr = []int{1, 2, 3, 4}

    var slice = arr[:3]

    fmt.Println("slice = ", slice)

    // [1 2 3]

  4. append() 和 copy() 函数

    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
    func main() {
        var numbers []int
        printSlice(numbers)

        /* 允许追加空切片 */
        numbers = append(numbers, 0)
        printSlice(numbers)

        /* 向切片添加一个元素 */
        numbers = append(numbers, 1)
        printSlice(numbers)

        /* 同时添加多个元素 */
        numbers = append(numbers, 2,3,4)
        printSlice(numbers)

        /* 创建切片 numbers1 是之前切片的两倍容量*/
        numbers1 := make([]int, len(numbers), (cap(numbers))*2)

        /* 拷贝 numbers 的内容到 numbers1 */
        copy(numbers1,numbers)
        printSlice(numbers1)   
    }

    func printSlice(x []int){
        fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
    }

    以上代码输出结果为：

    1
    2
    3
    4
    5
    len=0 cap=0 slice=[]
    len=1 cap=1 slice=[0]
    len=2 cap=2 slice=[0 1]
    len=5 cap=6 slice=[0 1 2 3 4]
    len=5 cap=12 slice=[0 1 2 3 4]