go语言变量与常量

变量是一个抽象概念，它有内存地址，数据类型和值组成：

• 内存地址：给出了变量在内存中存储的其实地址，一般占用4或8字节（32位、64位机器）。
• 数据类型：定义了变量占用内存的大小。
• 值：表示内存地址中存放的内容。

基本类型

go语言内置了如下这些基本数据类型

整型

• 无符号：uint, uint8, uint16, uint32, uint64, uintptr ,byte，值范围为0 ~ 2^n-1 ，uintptr初始值为nil，其他初始值为0，uint和uintptr长度跟随硬件平台而变，uintptr能够容纳当前硬件平台的一个指针，byte与uint8等价，表示一个字节。
• 有符号：int , int8, int16, int32, int64,rune，值范围为-2^(n-1) ~ 2^(n-1)-1，初始值为0，其中int类型的长度跟随硬件平台而变，rune用来表示一个unicode字符，与int32等价，可以互换使用。

整型中byte和rune也叫字符型，byte是uint8的别称，用来表示一个ASCII字符。
rune是int32的别称，用来表示一个Unicode字符，Unicode字符长度不一，一般用十六进制表示

var ch1 byte = 'A'    //字符
var ch2 byte = 65     //十进制
var ch3 byte = '\x41' //十六进制，以 ‘ \x ’开头
var ch4 byte = '\101' //八进制，以 ‘ \ ’开头
//Unicode字符A的定义方式
var ch5 rune = '\u0041'      //用小u表示4字节字符
var ch6 int64 = '\U00000041' //大U表示8字节
fmt.Printf("ASCII 字符: %c,%c,%c,%c \n", ch1, ch2, ch3, ch4)
fmt.Printf("Unicode 字符: %c,%c, 对应整数: %v,%d, 对应十六进制表示:%U", ch5, ch6, ch5, ch5, ch5)

// 输出
// ASCII 字符: A,A,A,A 
// Unicode 字符: A,A, 对应整数: 65,65, 对应十六进制表示:U+0041%  

Unicode，ASCII都是字符集，Unicode是ASCII的超集。
UTF-8是可变长编码规则，可编码长度从1~4字节不等，优势是不存在字节序问题，所以很适合在网络上传输。

浮点型

• float32, float64:浮点型都是有符号的，应该优先使用float64，因为float32能精确表示的浮点数并不多，误差容易扩散。浮点型定义时可以只写整数或小数部分，但是小数点不能省。可以使用科学计数法来书写，e或E指定指数部分。

var f1 float64 = 1.
var f2 = .000002
f3, f4 := 1.2e12, 3.5E-12

复数类型

• complex64, complex128：复数

布尔型

• bool: 取值为true和false，不能参与运算，逻辑运算会产生bool值，go语言中只有相同数据类型才能进行比较，如果是类对象，需要实现相同的接口才能比较。但是可以转换成相同类型后进行比较。
  go语言逻辑运算也会截断，如(a>b && a<c)，如果a>b为false，则直接返回false而不会比较a和c。

变量定义方式

• 1、标准格式
  go语言变量类型是后置的

var 变量名 类型
var a int

• 2、缺省类型方式
  go语言根据初始化值自动推导类型，这种方式必须显式初始化。

var b = 1

• 3、批量定义

var(
    c int = 10
    d float32
    e []byte
)

• 4、简短格式
  这种方式只能用在函数内部，必须显式初始化，在局部变量定义中比较常用。

f := 1.0
f1,f2,f3 := 1, 1.0, "aaa"

需要注意，同一作用域内不能重复定义变量

var g int = 10
g := 12  //这一行将会报错，g重复定义

不同作用域可以重复定义，go会使用相同作用域内的变量，不会覆盖

var h int = 10
{
	h := 12.0
	fmt.Printf("h = %f", h)
}
fmt.Printf("h = %d", h)
 //输出： h = 12.000000, h = 100

在简短定义多个变量时，只要左边有一个新定义的变量，其他变量就可以重复赋值（注意不是重复定义，因为赋值类型必须和之前定义的一致）

//这个例子中，i重复复制1.0，但是类型任然是int，但是会把2.0强转为int。
i := 1
i, i1 := 2.0, "xxx"
fmt.Printf("type of i is :  %T, i = %d, i1 = %s", i, i, i1)
//输出：type of i is :  int, i = 2, i1 = xxx

匿名变量

go语言中定义的变量如果没有使用就会报错，从根源上杜绝了变量的泛滥。
然而有些函数的多个返回值有时候我们并不全都需要，但是全都定义又必须要使用，这时候就需要用到匿名变量。

匿名变量用一个下划线"_"表示，不分配内存，可以重复定义，任何类型变量都可以赋值给它，但是不能使用它，也不能将它赋值给其他变量和参与运算（即只能作为左值）。

//正常情况下定义两个返回值
conn, err := net.Dial("tcp", "127.0.0.1")
fmt.Printf("conn  = %v, err = %v \n", conn, err)
//不关系err这个返回值时
conn1, _ := net.Dial("tcp", "127.0.0.1")
//当所有返回值都不关心时，直接不定义返回值就可以，不能所有返回值都用匿名变量
// _, _ := net.Dial("tcp", "127.0.0.1")

类型转换

• go语言没有隐式类型转换，所有需要转换的类型都必须显式申明：

var a TypeA
var b TypeB = TypeB(a)  //将a的值强制转换为TypeB类型并赋值给b，a不变
c := 1.0
var b int = int(c)

• 只有底层类型相同（如int16和int32互转）的变量才能相互转化，不同底层类型（如bool和int）互转将会编译错误。
• 短类型转为长类型没有风险，长类型转为短类型有精度丢失风险。

作用域

作用域表示可访问某变量的范围，go语言有两种作用域

• 1、局部作用域
  定义在局部作用域中的变量称为局部变量，局部变量出了作用域就会被销毁，像函数参数、返回值、函数内部定义的变量都是局部变量，函数调用一旦完成就这些变量都会被销毁。
  在函数内部也可以用大括号{ }来定义一个更小的局部作用域。

func foo(a, b int) (c, d int) {
	//通过{}定义局部作用域，i出了{}就没了，所以只能在{}内使用
	{
		i := 100
		fmt.Printf("自定义局部作用域: i = %d \n", i)
	}
	c, d = b, a
	fmt.Printf("函数参数和返回值都是局部变量: a = %d,b = %d,c = %d, d = %d \n", a, b, c, d)
	return
}

• 2、全局作用域
  函数外部定义的变量就是全局变量，这些变量的生命周期与进程相同，在进程结束时才会销毁。

• 全局变量必须使用var关键字进行定义
• 全局变量可以被本文件中的所有函数访问，如果需要在其他源文件中访问变量，需要将变量首字母大写（即通过变量名大小写控制访问权限），并在需要访问的文件中通过import导入当前源文件。

var AAA int = 10 //外部文件可以访问
var bbb = 123    //外部文件无法访问

func main() {
...
}

常量

• 常量是与变量相对于的一个概念，他们都是对应一块内存，只是变量可以被修改，常量一旦定义就不能被修改。
• 常量在编译时就创建，只能定义bool，字符串和数字型（包括整型，字符，浮点型，复数）
• 常量的算数、逻辑、比较运算的结果也是常量
• len、cap、real、image、complex、unsafe.Sizeof的调用返回是常量。

定义方式和变量类似

//定义变量
var a int = 1
//定义常量
const b int = 2 
//同时声明多个常量
const(  
    c = 1.0
    d = "str"
)
//同时申明多个常量时，未赋值的常量会复用前一个常量的值
const(
    e = 1
    f
    g = 2
    h
)
fmt.Println(e,f,g,h) //输出：1 1 2 2
//使用iota常量生成器
const(
    i = iota
    j
    k
    l
)
fmt.Println(i,j,k,l) //输出：0 1 2 3

总结

• go语言行尾不用加分号，go语言没有分号。
• go语言变量类型是后置的，所有变量定义即自动初始化为初始值，不存在c语言的声明和定义的区别。
• 简短定义变量只能使用在函数内部。
• 同一作用域不能重复定义变量，不同作用域可以重复定义，简短定义左边至少有一个新变量。
• 首字母大写的变量或函数可以被import该文件的外部文件访问。

---

---

完整示例代码

/*
 * 这个文件主要介绍变量的相关内容
 */

package main

import (
	"fmt"
	"net"
)

func foo(a, b int) (c, d int) {
	//通过{}定义局部作用域，i出了{}就没了，所以只能在{}内使用
	{
		i := 100
		fmt.Printf("自定义局部作用域: i = %d \n", i)
	}
	c, d = b, a
	fmt.Printf("函数参数和返回值都是局部变量: a = %d,b = %d,c = %d, d = %d \n", a, b, c, d)
	return
}

var AAA int = 10 //外部文件可以访问
var bbb = 123    //外部文件无法访问

func main() {
	//变量标准定义方式，自动初始化
	var a int
	fmt.Printf("变量标准定义模式,自动初始化为: a = %d \n", a)

	//缺省类型的定义方式，自动推到类型，明确初始化
	var b = 1
	fmt.Printf("缺省类型的定义方式,自动推到类型: type fo b is %T \n", b)

	//批量定义变量
	var (
		c int = 12
		d float32
		e []byte
	)
	fmt.Printf("批量定义变量: c = %d,d = %f,e = %s \n", c, d, e)

	//简短格式，缺省var和类型，可同时定义多个变量
	f := 1.2
	f1, f2, f3 := 1, 1.2, "xxxx"
	fmt.Printf("简短格式定义变量,type of f is : %T, f = %f ,f1 = %d,f2 = %f,f3 = %s\n", f, f, f1, f2, f3)

	//同一作用域不能重复定义变量
	var g int = 10
	//g := 12   //这一行将会报错，重复定义
	fmt.Printf("相同作用域内重复定义会出错: g = %d\n", g)

	//不同作用域可以重复申明，go会使用相同作用域内的变量
	var h = 100
	{
		h := 12.0 //较小作用域内定义
		fmt.Printf("较小作用域内重复定义: h = %f, ", h)
	}
	fmt.Printf("较大作用域内定义的变量没有被覆盖: h = %d \n", h)

	//例外情况，简短定义只要左边有一个新变量，其他变量可以重复之前定义过的变量
	i := 1
	i, i1 := 2.0, "xxx"
	fmt.Printf("简短定义只要左边有一个新变量，其他变量可以重复之前定义过的变量: type of i is :  %T,i = %d, i1 = %s \n", i, i, i1)

	//变量交换
	j, k := 1, 2
	fmt.Printf("变量交换: j=%d,k=%d , ", j, k)
	j, k = k, j
	fmt.Printf(" 交换后: j=%d,k=%d \n", j, k)

	// 匿名变量
	//正常情况下定义两个返回值
	conn, err := net.Dial("tcp", "127.0.0.1")
	fmt.Printf("conn  = %v, err = %v , ", conn, err)
	//不关系err这个返回值时
	conn1, _ := net.Dial("tcp", "127.0.0.1")
	fmt.Printf("conn1 = %v \n", conn1)
	//当所有返回值都不关心时，直接不定义返回值就可以，不能所有返回值都用匿名变量
	// _, _ := net.Dial("tcp", "127.0.0.1")

	foo(1, 2)
	fmt.Printf("全局变量:AAA = %d,bbb = %d \n", AAA, bbb)

	//byte和rune使用
	var ch1 byte = 'A'    //字符
	var ch2 byte = 65     //十进制
	var ch3 byte = '\x41' //十六进制，以 ‘ \x ’开头
	var ch4 byte = '\101' //八进制，以 ‘ \ ’开头
	//Unicode字符A的定义方式
	var ch5 rune = '\u0041'      //用小u表示4字节字符
	var ch6 int64 = '\U00000041' //大U表示8字节

	fmt.Printf("ASCII 字符: %c,%c,%c,%c \n", ch1, ch2, ch3, ch4)
	fmt.Printf("Unicode 字符: %c,%c, 对应整数: %v,%d, 对应十六进制表示:%U", ch5, ch6, ch5, ch5, ch5)
}

输出

变量标准定义模式,自动初始化为: a = 0 
缺省类型的定义方式,自动推到类型: type fo b is int 
批量定义变量: c = 12,d = 0.000000,e =  
简短格式定义变量,type of f is : float64, f = 1.200000 ,f1 = 1,f2 = 1.200000,f3 = xxxx
相同作用域内重复定义会出错: g = 10
较小作用域内重复定义: h = 12.000000, 较大作用域内定义的变量没有被覆盖: h = 100 
简短定义只要左边有一个新变量，其他变量可以重复之前定义过的变量: type of i is :  int,i = 2, i1 = xxx 
变量交换: j=1,k=2 ,  交换后: j=2,k=1 
conn  = <nil>, err = dial tcp: address 127.0.0.1: missing port in address , conn1 = <nil> 
自定义局部作用域: i = 100 
函数参数和返回值都是局部变量: a = 1,b = 2,c = 2, d = 1 
全局变量:AAA = 10,bbb = 123 
ASCII 字符: A,A,A,A 
Unicode 字符: A,A, 对应整数: 65,65, 对应十六进制表示:U+0041%