Go：变量、常量、枚举

清疚 2022-01-06 22:05 261阅读 0赞

## 一、变量 ##

package main
    
    import "fmt"
    
    func variableZeroValue() {
    	// 变量声明
    	var a int
    	var b string
    	fmt.Println(a, b)			 // 0
    	fmt.Printf("%d %q\n", a, b)	 // 0 ""
    }
    
    func variableInitialValue() {
    	// 变量初始化
    	var a, b = 1, 2     // 编译器可以自动推导出变量的类型
    	c, d := 1, "pd"     // 使用:=定义变量（只能在函数内使用）
    	a = 10              // 赋值不能使用 a := 10
    	a, b = b, a			// 变量交换
    	fmt.Println(a, b, c, d)
    }
    
    //在函数外定义变量，不能使用 :=
    var a = 10
    var b = 20
    // 上面方式可以这样
    var (
    	c = 30
    	d = 40
    )
    
    func main() {
    	variableZeroValue()
    	variableInitialValue()
    	fmt.Println(a, b, c, d)
    }

*  **变量类型写在变量名之后；**
 *  **编译器可以推测变量所属类型；**
 *  **没有char，只有rune；**
 *  **原生支持复数类型。**

## **二、常量** ##

在Go语言中，常量是指编译期间就已知且不可改变的值。常量可以是数值类型（包括整型、浮点型和复数类型）、布尔类型、字符串类型等。

一个常量的声明语句定义了常量的名字，和变量的声明语法类似，常量的值不可修改，这样可以防止在运行期被意外或恶意的修改。

### 2.1 字面常量 ###

所谓字面常量（literal），是指程序中硬编码的常量，如：

-12 
    3.1415926  // 浮点类型的常量
    3.2+12i    // 复数类型的常量
    true       // 布尔类型的常量
    "foo"      // 字符串常量

### 2.2 常量定义 ###

通过const关键字，可以给字面常量指定一个名字：

func constDefine() {
    	// 定义常量
    	/*
    	常量定义可以限定常量类型，但不是必需的。
    	如果定义常量时没有指定类型，那么它与字面常量一样，是无类型常量。
    	 */
    	const pi =  3.1415926
    	const zero = 0.0	   // 无类型浮点常量
    	const (
    		size int64 = 1024
    		xx = -1			   // 无类型整型常量
    	)
    	const a, b float32 = 1, 2  // 常量的多重赋值
    	const c, d, e = 3, 4, "foo"
    	fmt.Println(pi, zero, size, xx, a, b, c, d, e)
    }

### 2.3 预定义常量 ###

Go语言预定义了这些常量：true、false和iota。

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

func func1() {
    	const ( 		// iota被重设为0
    		c0 = iota 	// c0 == 0
    		c1 = iota 	// c1 == 1
    		c2 = iota 	// c2 == 2
    	)
    	fmt.Println(c0, c1, c2)  // 0 1 2
    
    	const (
    		a11 = 1 << iota 	// a11 == 1 (iota在每个const开头被重设为0)
    		b11 = 1 << iota 	// b11 == 2
    		c11 = 1 << iota 	// c11 == 4
    	)
    	fmt.Println(a11, b11, c11)  // 1 2 4
    	/*
    	如果两个const的赋值语句的表达式是一样的，那么可以省略后一个赋值表达式；
    	因此，上面的前两个const语句可简写为：
    	 */
    	const (
    		c00 = iota
    		c01
    		c02
    	)
    	const (
    		a22 = 1 << iota
    		b22 = 1 << iota
    		c22 = 1 << iota
    	)
    
    	const (
    		b = 1 << (10 * iota)
    		kb
    		mb
    		gb
    	)
    	fmt.Println(b, kb, mb, gb)  // 1 1024 1048576 1073741824
    }

## 三、枚举 ##

枚举指一系列相关的常量，比如下面关于一个星期中每天的定义。通过上一节的例子，我们看到可以用在const后跟一对圆括号的方式定义一组常量，这种定义法在Go语言中通常用于定义枚举值。Go语言并不支持众多其他语言明确支持的enum关键字。

下面是一个常规的枚举表示法，其中定义了一系列整型常量：

func enum() {
    	const (
    		Sunday = iota
    		Monday
    		Tuesday
    		Wednesday
    		Thursday
    		Friday
    		Saturday
    		numberOfDays  // 这个常量没有导出
    	)
    	fmt.Println(Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday)  // 0 1 2 3 4 5 6
    }

同Go语言的其他符号（symbol）一样，以大写字母开头的常量在包外可见。

以上例子中numberOfDays为包内私有，其他符号则可被其他包访问。

转载于:https://www.cnblogs.com/believepd/p/10810694.html