Skip to main content

Identifier

标识符​

程序员自己可以决定命名的内容全部称为标识符，如变量、常量、函数、结构体、接口等。

命名方式​

  1. 驼峰命名法：camel case，如getCurrentTime。
  2. 帕斯卡命名法：pascal case，如GetCurrentTime。
  3. 蛇形命名法：snake came，如get_current_time。
  4. 中横线命名法：Kebab case，如get-current-time。
  5. 空格命名法：space case，如get current time。

标识符元素​

Go语言在标识符命名时，除以下四种以外的所有字符都不被允许：

  1. 大写字母。
  2. 小写字母。
  3. 数字。
  4. 下划线。

也就是说，标识符中不能带有$、@、&等字符。

命名规则​

  1. 不能以数字开头，且不运行有空格。
  2. 严格区分大小写。
  3. 语义尽可能的清晰明了、简洁。
  4. 关键字与预定义标识符不能作为标识符。
package main

func main() {
  var 1abc int = 123
  var $abx int = 123
  var my title string = 'hello'
  var import string = "hello"

  var mytitle string = "abc"
  var myTitle string = "cba"
}

关键字​

Go语言中共有25个关键字：

breakdefaultfuncinterfaceselect
casedefergomapstruct
chanelsegotopackageswitch
constfallthroughifrangetype
continueforimportreturnvar

预定义标识符​

appendboolbytecapclosecomplex
complex64complex128uint16copyfalsefloat32
float64imagintint8int16uint32
int32int64iotalenmakenew
nilpanicuint64printprintlnreal
recoverstringtrueuintuint8uintptr

命名规范​

项目名​
  1. 中横线隔开。
  2. 全部小写字母。
包名​
  1. 包名与目录名保持一致。
  2. 全部小写。
  3. 不能使用下划线。
  4. 不能使用标准库的名称。
模块名​
  1. 全部小写。
  2. 单词使用下划线隔开。
常量​
  1. 全部大写。
  2. 单词使用下划线隔开。
结构体​

遵循命名规则。

接口名​

遵循命名规则。

函数与变量​
  1. 遵循命名规则。
  2. 任何需要在包外暴露被使用的标识符都必须以大写字母开头。
  3. 任何不需要在包外暴露被使用的标识符都必须以小写字母开头。

变量​

数学工具​

  1. 当在计算中，不确定值是什么的时候，用变量进行暂时的替代(抽象)以完成运算，且变量是可变的不确定量。
  2. 在不同的运算中，变量所表示的最终值不同，所以变量是可变的量。

基本概念​

  1. 表示值的抽象工具。
  2. 存储计算结果的工具。

变量就是在计算机语言编程时，方便从内存中取值和向内存中存值的工具。

变量声明​

Go语言中使用var关键字声明变量，完整的声明格式为：

// 关键字  标识符  变量类型  赋值符号  值
    var     x     int       =      1
  1. 变量声明可以不初始化。
  2. 变量初始化可以在变量声明之后进行。
  3. 变量赋值或初始化不是使用变量。
package main

import "fmt"

func main() {
  // 声明变量
  var x int
  // 初始化变量
  x = 1
  // 使用变量
  fmt.Println(x)
}
  1. 值必须与声明变量时的类型保持一致。
package main

import "fmt"

func main() {
  var x int

  // cannot use "abc" (untyped string constant) as int value in assignment
  x = "abc"
}
  1. 变量必须先声明后使用。
package main

import "fmt"

func main() {
  // undefined a
  fmt.Println(a)
}
  1. 变量声明后必须使用。
package main

import "fmt"

func main() {
  // x declared and not used
  var x int
  x = 1
}
  1. 同一作用域下不能重复声明同名变量。
package main

func main() {
  // int redeclared in this block
  var int x
  var int x
}

单一声明法​

同类型的多个变量可使用单一声明法。

package main

func main() {
  var x int = 1
  var y int = 2
  var z int = 3

  // 单一声明
  var a, b, c int
  a = 1
  b = 2
  c = 3
  
  // 单一声明与类型推断
  var m, n, h = 1, "abc", false
}

批量声明​

多个变量可以批量声明。

package main

func main() {
  var (
    x int    = 1
    y string = "abc"
    z bool   = false
  )
}

类型推断​

Go语言可以根据变量初始值的类型推断其类型。

package main

func main() {
  // var x int
  var x = 1

  // var y string
  var y = "abc"

  // var z bool
  var z = false
}

显式类型声明和类型推断都有各自的使用场景，在保证代码可读性及可维护性的同时按需选择。

短变量语法​

在类型推断的基础上省略了声明关键字var。

package main

// 声明语句
var a = 123 

func main() {
  /*
    解析为:
    var x int // 声明语句
    x = 1     // 赋值语句
  */
  x := 1
}

Go语言的函数外部不能使用赋值语句，只能出现声明语句，因此短语法变量不能在函数外部使用。

短变量也可进行批量声明赋值：

package main

func main() {
  x, y, z := 1, "abc", false
}

匿名变量​

  1. 匿名变量表示不使用的变量，用_表示，解析时会被忽略。
  2. 匿名变量无法访问且一个作用域内可以有多个。
package main

import "fmt"

func main() {
  // _ 表示匿名变量
  x, _, z := getXYZ()
  fmt.Println(x, z)
}

func getXYZ() (int, string, bool) {
  return 1, "abc", false
}

常量​

数学中的常量​

  1. 恒定不变的自然数或者定义数，如π、i、∞等。
  2. 用符号代替比较复杂的数值来表示参与运算的过程。
  3. 数学中的常量表示的是实用性的值，而不是操作性的值。

编程中的常量​

  1. 沿用了数学中常数的基本特性。
  2. 常量是被开发者定义的量。
  3. 常量在初始化后，不可以被修改。
  4. 常量不可以在同一作用域下重复声明。

总的来说，常量代替值的重复使用，且限制其值的改变。常量在编译时确定其值，运行时不可变其值。

常量定义​

Go语言中常量使用const关键声明：

// 关键字  标识符  变量类型  赋值符号  值
   const    PI   float32    =    3.14
  1. 常量在声明时必须初始化值。
  2. 常量没有严格要求必须使用，会警告，但不影响编译。
  3. 常量值不可修改。
package main

func main() {
  const PI float32 = 3.1415926
  // cannot assign to PI
  PI = 3.14
}

类型推断​

常量也可根据值的类型进行类型推断。

package main

func main() {
  const PI = 3.1415926
}

批量声明​

常量也可进行批量声明。

package main

func main() {
  const (
      NAME = "Tom"
      AGE  = 12
  )
}

单一声明​

常量也可进行单一声明。

package main

func main() {
  const NAME, AGE = "Tom", 12
}

iota​

批量声明常量的时候，第一常量必须要初始化，后续的常量可以不进行初始化，后续没有初始化值的常量，在编译时会赋值为最后一个赋值的常量值。

package main

func main() {
  const (
      a = 0
      b // 0
      c // 0
      d // 0
      e // 0
  )
}

iota在Go程序编译时可以修改常量值，默认起始值为0，常量每声明一次, iota迭代一次，与其所在的位置无关。

使用iota相当于使用常量迭代器：

package main

func main() {
  const a, b, c, d, e = 1, 2, 3, 4, 5
}

要想达到以上相同的声明效果，可使用iota：

package main

func main() {
  const (
      a = iota  // 0
      b         // 1
      c         // 2
      d         // 3
      e         // 4
  )

  const (
      x = 100  // 100
      y        // 100
      z = iota // 2
      m        // 3
      n        // 4
  )
}
Last updated on