zoukankan      html  css  js  c++  java
  • Go:变量、常量、枚举

    一、变量

    package main
    
    import "fmt"
    
    func variableZeroValue() {
    	// 变量声明
    	var a int
    	var b string
    	fmt.Println(a, b)			 // 0
    	fmt.Printf("%d %q
    ", 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为包内私有,其他符号则可被其他包访问。

  • 相关阅读:
    查看SQL语句执行时间、IO开销
    创建性能监视器(logman)
    IIS连接数
    SQL Server重建索引计划
    删除不存在的网卡
    授予普通域用户远程桌面连接DC/客户端权限
    AD新建用户、组、OU
    常用短语
    Android之APP模块编译
    Web&网络协议
  • 原文地址:https://www.cnblogs.com/believepd/p/10810694.html
Copyright © 2011-2022 走看看