一、变量定义
所谓的变量就是一个拥有指定名称
和类型
的数据存储位置
。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
//看一个例子 package main import ( "fmt" ) func main() { var x string = "hello world" fmt.Println(x) }
变量的定义首先使用var关键字,然后指定变量的名称x,再指定变量的类型string,在本例中,还对变量x进行了赋值,然后在命令行输出该变量。Go这种变量定义的方式和其他的语言有些不同,但是在使用的过程中,你会逐渐喜欢的。当然上面的变量定义方式还可以如下,即先定义变量,再赋值。
var x string x = "hello world"
或者是直接赋值,让Go语言推断变量的类型。如下:
var x = "hello world"
当然,上面变量的定义还有一种快捷方式
。如果你知道变量的初始值,完全可以像下面这样定义变量,完全让Go来推断语言的类型
。这种定义的方式连关键字var
都省略掉了。
x := "hello world"
注意:上面这种使用:=
方式定义变量的方式只能用在函数内部
。
package main import ( "fmt" ) x:="hello world" func main() { y := 10 fmt.Println(x) fmt.Println(y) }
对于上面的变量定义x是无效的。会导致编译错误:
./test_var_quick.go:7: non-declaration statement outside function body
不过我们对上面的例子做下修改,比如这样是可以的。也就是使用var关键字定义的时候,如果给出初始值,就不需要显式指定变量类型。
package main import ( "fmt" ) var x = "hello world" func main() { y := 10 fmt.Println(x) fmt.Println(y) }
变量
之所以称为变量,就是因为它们的值在程序运行过程中可以发生变化
,但是它们的变量类型是无法改变的
。因为Go语言是静态语言
,并不支持
程序运行过程中变量类型发生变化
。比如如果你强行将一个字符串值赋值给定义为int的变量,那么会发生编译错误。即使是强制类型转换也是不可以的。强制类型转换只支持同类的变量类型
。比如数值类型之间强制转换。
下面我们看几个例子:
package main import ( "fmt" ) func main() { var x string = "hello world" fmt.Println(x) x = "i love go language" fmt.Println(x) }
本例子演示变量的值在程序运行过程中发生变化,结果输出为
hello world
i love go language
我们尝试不同类型的变量之间转换
package main import ( "fmt" ) func main() { var x string = "hello world" fmt.Println(x) x = 11 fmt.Println(x) }
在本例子中,如果试图将一个数值赋予字符串变量x,那么会发生错误:
./test_var.go:10: cannot use 11 (type int) as type string in assignment
上面的意思就是无法将整型数值11当作字符串赋予给字符串变量。
但是同类的变量之间是可以强制转换的,如浮点型和整型之间的转换。
package main import ( "fmt" ) func main() { var x float64 = 32.35 fmt.Println(x) fmt.Println(int(x)) }
输出的结果为
32.35 32
二、变量命名
上面我们看了一些变量的使用方法,那么定义一个变量名称,有哪些要求呢?
这里我们要注意,Go的变量名称必须以字母或下划线(_)开头,后面可以跟字母,数字,或者下划线(_)
。除此之外,Go语言并不关心你如何定义变量。我们通用的做法是定义一个用户友好的变量。假设你需要定义一个狗狗的年龄,那么使用dog_age作为变量名称要好于用x来定义变量。
三、变量作用域
现在我们再来讨论一下变量的作用域。所谓作用域就是可以有效访问变量的区域。比如很简单的,你不可能在一个函数func_a里面访问另一个函数func_b里面定义的局部变量x。所以变量的作用域目前分为两类,一个是全局变量
,另一个是局部变量
。下面我们看个全局变量的例子:
package main import ( "fmt" ) var x string = "hello world" func main() { fmt.Println(x) }
这里变量x定义在main函数之外,但是main函数仍然可以访问x。全局变量的作用域是该包中所有的函数。
package main import ( "fmt" ) var x string = "hello world" func change() { x = "i love go" } func main() { fmt.Println(x) change() fmt.Println(x) }
在上面的例子用,我们用了change函数改变了x的值。输出结果如下:
hello world
i love go
我们再看一下局部变量的例子。
package main import ( "fmt" ) func change() { x := "i love go" } func main() { fmt.Println(x) }
该例子中main函数试图访问change函数中定义的局部变量x,结果发生了下面的错误(未定义的变量x):
./test_var.go:11: undefined: x
三、常量
Go语言也支持常量定义。所谓常量就是在程序运行过程中保持值不变的变量定义
。常量的定义和变量类似,只是用const
关键字替换了var关键字,另外常量在定义的时候必须有初始值
。
package main import ( "fmt" ) func main() { const x string = "hello world" const y = "hello world" fmt.Println(x) fmt.Println(y) }
这里有一点需要注意,变量定义的类型推断方式:=
不能够用来定义常量。因为常量的值是在编译的时候就已经确定的,但是变量的值则是运行的时候才使用的。这样常量定义就无法使用变量类型推断的方式了。
常量的值在运行过程中是无法改变的,强制改变常量的值是无效的。
我们看一个Go包math里面定义的常量Pi,用它来求圆的面积。
package main import ( "fmt" "math" ) func main() { var radius float64 = 10 var area = math.Pow(radius, 2) * math.Pi fmt.Println(area) }
四、多变量或常量定义
Go还提供了一种同时定义多个变量或者常量
的快捷方式。
package main import ( "fmt" ) func main() { var ( a int = 10 b float64 = 32.45 c bool = true ) const ( Pi float64 = 3.14 True bool = true ) fmt.Println(a, b, c) fmt.Println(Pi, True) }
在定义常量组时,如果不提供初始值,则表示将使用上行的表达式。
package main import "fmt" const ( a = 1 b c d ) func main() { fmt.Println(a) // b、c、d没有初始化,使用上一行(即a)的值 fmt.Println(b) // 输出1 fmt.Println(c) // 输出1 fmt.Println(d) // 输出1 }
五、iota
iota,特殊常量,可以认为是一个可以被编译器修改的常量。
iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前),const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。
iota 可以被用作枚举值:
const ( a = iota b = iota c = iota )
第一个 iota 等于 0,每当 iota 在新的一行被使用时,它的值都会自动加 1;所以 a=0, b=1, c=2 可以简写为如下形式:
const ( a = iota b c )
iota 用法
实例
package main import "fmt" func main() { const ( a = iota //0 b //1 c //2 d = "ha" //独立值,iota += 1 e //"ha" iota += 1 f = 100 //iota +=1 g //100 iota +=1 h = iota //7,恢复计数 i //8 ) fmt.Println(a,b,c,d,e,f,g,h,i) }
以上实例运行结果为:
0 1 2 ha ha 100 100 7 8
再看个有趣的的 iota 实例:
package main import "fmt" const ( i=1<<iota j=3<<iota k l ) func main() { fmt.Println("i=",i) fmt.Println("j=",j) fmt.Println("k=",k) fmt.Println("l=",l) }
以上实例运行结果为:
i= 1 j= 6 k= 12 l= 24
ota 表示从 0 开始自动加 1,所以 i=1<<0, j=3<<1(<< 表示左移的意思),即:i=1, j=6,这没问题,关键在 k 和 l,从输出结果看 k=3<<2,l=3<<3。
简单表述:
i=1
- :左移 0 位,不变仍为 1;
- j=3:左移 1 位,变为二进制 110, 即 6;
- k=3:左移 2 位,变为二进制 1100, 即 12;
- l=3:左移 3 位,变为二进制 11000,即 24。