Golang开发-常量和变量

Golang变量

1.声明变量

使用关键字var

一般形式：

var x xtype

一次声明多个变量：

var x1,x2 xtype

示例代码：

package main
import "fmt"
func main() {
    var a string = "test"
    fmt.Println(a)
    var b, c int = 1, 2
    fmt.Println(b, c)
}

执行代码运行结果为：

test
1 2

2.声明变量的方式
1）指定变量类型，如果没有初始化，则变量默认为“零值”(变量没有做初始化时系统默认设置的值)

var x xtype
x=xvalue

package main
import "fmt"
func main() {
	var a string
	fmt.Println(a)
	var b int
	fmt.Println(b)
	var c bool
	fmt.Println(c)
}

输出为：

“”
0
false

2)不指定变量类型，根据值自行判断

var x = xvalue

package main
import "fmt"
func main() {
	var a ="test"
	fmt.Println(a)
	var b =10
	fmt.Println(b)
	var c =true
	fmt.Println(c)
}

输出为：

test
10
true

注意：

字符串要用双引号，用单引号会报错：
more than one character in rune literal
字符用单引号，而且输出为该字符的ascii值

例如：

var a =‘a’
fmt.Println(a)
输出为：97

3）省略var,用 :=代替,但是如果该变量已经被声明过，则会报错

x:=xvalue

例如：

var intVal int 
intVal :=1 

这时候会报错，因为 intVal 已经声明，不需要重新声明，直接用下面那条语句即可,下面这三条语句是等价的

var x int =10
//
var x =10
//
x:=10

package main
import "fmt"
var x, y int
var ( 
    a int=10
    b bool=true
)

var c, d int = 1, 2
var e, f = 123, "hello"

//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"

func main(){
    g, h := 123, "hello"
    fmt.Println(x, y, a, b, c, d, e, f, g, h)
}

输出为：

0 0 10 true 1 2 123 hello 123 hello

Golang常量

常量即在程序运行时不会修改的量。
常量中的数据类型只能是：布尔型，数字型（整型，浮点型，复数）和字符串型。

定义格式为：

const x [xtype] = xvalue

显式类型定义：const a int =10
隐式类型定义：const a=10

多个常量的声明：

const x1,x2=xvalue1,xvalue2

示例代码：

package main
import "fmt"
func main(){
const x=10
const y=30
const a,b,c,d = 1,'t',true,"hello"
fmt.Printf("%d*%d=%d",x,y,x*y)
println()
println("a=",a)
println("b=",b)
println("c=",c)
println("d=",d)
}

运行结果为：

10*30=300
a= 1
b= 116
c= true
d= hello

常量也可以用于枚举，而且可以用函数计算表达式的值，但是函数必须为内置函数。

package main
import "unsafe"
const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(a)
)
func main(){
    println(a, b, c)
}

输出为：

abc 3 16

字符串类型在 go 里是个结构, 包含指向底层数组的指针和长度,这两部分每部分都是 8 个字节，所以字符串类型大小为 16 个字节。

特殊常量：iota
iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

package main
const (
    a = iota
    b 
    c 
)
func main(){
    println(a, b, c)
}
//0 1 2

在定义常量组时，如果不提供初始值，则表示将使用上行的表达式

package main
const (
    a = 1
    b 
    c 
)
func main(){
    println(a, b, c)
}
//1 1 1

iota 只是在同一个 const 常量组内递增，每当有新的 const 关键字时，iota 计数会重新开始

package main
const (
    a = iota
    b 
    c 
	d="hello"
	e
	f=true
	g
	h
	i=iota
	j
	k
)
const x=iota
const y=iota
func main(){
    println(a, b, c,d,e,f,g,h,i,j,k,x,y)
}

输出为：

0 1 2 hello hello true true true 8 9 10 0 0