Golang开发-常量和变量

分手后的思念是犯贱 2022-11-17 13:35 196阅读 0赞

## 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