基础语法

  1. import 原理
    • main 包中导入的包会被顺序导入
    • 导入的包中依赖其他包，会首先导入依赖包，并初始化依赖包中的常量与变量，如果依赖包中有 init()，会自动执行 init()
    • 所有包导入完成后会对 main 包中的变量与常量进行初始化，然后执行 init()，最后执行 main()
    • 一个包被导入多次则该包只会被导入一次
  2. import 别名用法
    • 别名 "package"
    • . "package" 调用该包中函数时可以省略前缀
    • _ "package" 只执行包中 init() 函数，无法调用包中其他函数

数据类型

  1. 整型
  2. 浮点型
  3. 字符串型：string 统一编码为 UTF-8
  4. 布尔型：true 或 false
  5. 派生类型

值类型默认为0，布尔类型默认为 false ，字符串类型默认为空字符串

整型：

序号 类型
1 uint8 无符号 8 位整型 (0 到 255)
2 uint16 无符号 16 位整型 (0 到 65535)
3 uint32 无符号 32 位整型 (0 到 4294967295)
4 uint64 无符号 64 位整型 (0 到 18446744073709551615)
5 int8 有符号 8 位整型 (-128 到 127)
6 int16 有符号 16 位整型 (-32768 到 32767)
7 int32 有符号 32 位整型 (-2147483648 到 2147483647)
8 int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)

浮点型：

序号 类型
1 float32 IEEE-754 32 位浮点型数
2 float64 IEEE-754 64 位浮点型数
3 complex64 32 位实数和虚数
4 complex128 64 位实数和虚数

其他数字类型：

序号 类型
1 byte 类似 uint8
2 rune 类似 int32
3 uint 32 或 64 位
4 int 与 uint 一样大小

派生类型：

序号 类型
1 指针类型（Pointer）
2 数组类型
3 结构化类型（struct）
4 Channel 类型（chan）
5 函数类型（func）
6 切片类型（slice）
7 接口类型（interface）
8 Map 类型（map）

变量与常量

变量

  1. 单个变量的声明和赋值
    • 声明：var i int 「var 变量名称 变量类型」
    • 赋值：i = 1 「变量名称 : 值、表达式、函数等」
    • 声明和赋值同时进行：var i int = 1「var 变量名称 变量类型 = 值、表达式、函数等」
    • 分组声明格式： 
      1
      2
      3
      4
      5
      var (
          i int
          j float32
          k string
      )
  2. 同时声明多个变量和赋值：var a,b,c int = 1,2,3 或 a,b,c := 1,2,3
  3. 全局变量的声明必须使用 var 关键词，局部变量可省略
  4. 变量的类型转换只能发生在兼容类型之间、必须是显式的
  5. 变量的可见性规则
    • 大写字母开头的变量可以再其他包中读取，是公用变量
    • 小写字母开头的变量其他包中不可读取，是私有变量

常量

  1. 常量定义形式，常量类型范围

    • 显式：const identifier [type] = value
    • 隐式：const identifier = value (通常叫无类型常量)

    可使用分组声明、单行声明格式

  2. 常量可以使用内置表达式定义，例如 len() unsafe.Sizeof() 等

  3. 常量范围目前只支持布尔型、数字型（整数型、浮点型和复数）和字符串型

特殊常量 iota 的使用

  1. iota 只能在常量定义中使用
  2. iota 在 const 关键字出现的时候会被重置为 0
  3. const 中每新增一行常量声明将使 iota 计数一次
  4. iota 常见使用法
    • 跳值使用法 使用 _ 声明常量来达到跳值的目的 
      1
      2
      3
      4
      5
      6
      7
      const (
          a = iota
          b = iota
          _
          _
          c = iota    // c = 4
      )
    • 插队使用法 
      1
      2
      3
      4
      5
      const (
          a = iota
          b = 3.14
          c = iota    // c = 2
      )
    • 表达式隐式使用法 
      1
      2
      3
      4
      5
      6
      const (
          a = iota * 2    // a = 0
          b = iota * 3    // b = 3
          c               // c = 6
          d               // d = 9
      )
    • 单行使用法 
      1
      2
      3
      4
      5
      6
      const (
          a, b = iota + 1, iota + 3 
          c, d
          e = iota
      )
      // a = 1, b = 3, c = 2, d = 4, e = 2