爱上开源之golang入门至实战-第二章语言基础-变量

 

变量和常量都是数据类型的载体，从名称上就可以看出常量和变量的不同，常量表示不能改变的数值，而变量表示能够改变的数值。这里先来看一个示例代码。

func printSize() {
    const PI float64 = 3.14 // 定义一个名为PI的常量
    var r, v float64        // 定义名为r, v的变量， 变量定义，r，v值均为0
    fmt.Printf("r的值为%f,v的值为%f\n", r, v)
    r = 4          // 为r赋值为4
    v = PI * r * r // 为v赋值为PI*r*r
    fmt.Printf("面积为%f\n", v)
} 

运行结果

r的值为0.000000,v的值为0.000000
面积为50.240000       

 

代码实现的是，计算圆面积并打印出计算的结果，计算需要两个预先的值，分别是PI和半径。PI是一个固定的值，在程序里通过const关键字使用常量来表示。圆的半径是各不相同的，在程序里通过var关键字使用一个变量来表示。在上面代码中在定义常量和变量的后面都出现了个float64，它们是下一节将要讲到的数据类型。

2.5.1 变量

2.5.1.1 声明

使用var关键字进行变量的声明，其一般形式是：var identifier type； 并且同一作用域内不支持重复声明，即变了只能声明一次；且声明的变量必须在其作用域内至少使用一次；否则编译报错

var name string 
var age int 
var yet bool

需要注意：Go 和许多编程语言不同

1. 它在声明变量时将变量的类型放在变量的名称之后。

1. 声明的变量必须在其作用域内至少使用一次

Golang语言可以通过var ()的形式， 对多个变量进行声明； 格式如下

var ( 
    str string 
    i int32 
    b bool 
    f float32
    s struct{ Name string }
)

2.5.1.2 初始化

Golang语言在变量声明的时候，会按照变量对应的数据类型分配内存区域，并进行初始化操作。各种数据类型的变量会被按照其数据类型初始化成其类型对应的默认值。

默认产生规则如下：

整型和浮点型变量的默认值为0。

字符串变量的默认值为空字符串。

布尔型变量 默认为 false 。

映射，切片产生没有任何元素的空对象。

数组产生默认初始化所有数组元素的数组。

通道，函数、指针变量的默认为 nil 。

自定义结构体为默认值的结构体。

看看下面的示例代码

​
func printVar() {
​
    var (
        str string
        i   int
        b   bool
        f   float32
        s   struct {
            Name string
            Age  int
        }
        sli []int
        a   [3]int
        m   map[string]bool
​
        c   chan int
        ptr *int
        fn  func(int)
    )
​
    fmt.Printf("string的值为%q\n", str)
    fmt.Printf("int的值为%d\n", i)
    fmt.Printf("bool的值为%v\n", b)
    fmt.Printf("float的值为%f\n", f)
    fmt.Printf("结构体类型的值为%+v\n", s)
    fmt.Printf("切片的值为%v\n", sli)
    fmt.Printf("数组的值为%v\n", a)
    fmt.Printf("映射的值为%v\n", m)
    fmt.Printf("通道类型的值为%v\n", c)
    fmt.Printf("指针的值为%v\n", ptr)
    fmt.Printf("函数类型的值为%v\n", fn)
​
}

运行结果

string的值为""                 
int的值为0                     
bool的值为false                
float的值为0.000000            
结构体类型的值为{Name: Age:0}  
切片的值为[]                   
数组的值为[0 0 0]              
映射的值为map[]                
通道类型的值为<nil>            
指针的值为<nil>                
函数类型的值为<nil>                     
​

 

程序代码声各种具有代表性的数据类型的变量，并通过程序打印出各种数据类型的变量的初始化的值

Tips

小技巧:

通过fmt.Printf和fmt.Sprintf函数；可以进行各种格式化的文本打印或者输出； 其中可以通过如上代码中的%s,%f,%d这样的格式化标签进行转换输出

[通用数据]

%v 相应值的默认格式。在打印结构体时，“加号”标记（%+v）会添加字段名

%#v 相应值的 Go 语法表示

%T 相应值的类型的 Go 语法表示

%% 字面上的百分号，并非值的占位符

[布尔]

%t 单词 true 或 false。

[整数]

%b 二进制表示

%c 相应 Unicode 码点所表示的字符

%d 十进制表示

%o 八进制表示

%q 单引号围绕的字符字面值，由 Go 语法安全地转义

%x 十六进制表示，字母形式为小写 a-f

%X 十六进制表示，字母形式为大写 A-F

%U Unicode 格式：U+1234，等同于 “U+%04X”

[浮点数及其复合构成]

%b 无小数部分的，指数为二的幂的科学计数法，与 strconv.FormatFloat 的 ‘b’ 转换格式一致。例如 -123456p-78

%e 科学计数法，例如 -1234.456e+78

%E 科学计数法，例如 -1234.456E+78

%f 有小数点而无指数，例如 123.456

%g 根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的 0）输出

%G 根据情况选择 %E 或 %f 以产生更紧凑的（无末尾的 0）输出

[字符串与字节切片]

%s 字符串或切片的无解译字节

%q 双引号围绕的字符串，由 Go 语法安全地转义

%x 十六进制，小写字母，每字节两个字符

%X 十六进制，大写字母，每字节两个字符

[指针]

%p 十六进制表示，前缀 0x

2.5.1.3 赋值

变量可以作用域范围内进行赋值，赋值给变量使用运算符等号 = ； 比如

i = 15
f = 1.0

可用用同数据类型的变量进行变量的赋值； 比如

var i, j int
i = 10
j = i

声明与赋值组合；语法格式为： var identifier [type] = value ; 这里的type可以忽略，golang会根据后面的数据值，推导出变量的数据类型； 比如

var i = 15
var j int = 10

更加简洁的写法，可以把var关键字也省略掉； 比如

i := 15
str := "string"
sli := make([]byte, 0)
ch := make(chan int)
fn1 := func() {}
map1 := make(map[string]bool)

变量的赋值也可以使用=进行批量对多个变量赋值； 比如

var i, j int   // 声明变量i,j 
i,j = 10,15    // 多个赋值， i赋值为10， j赋值为15

i,j := 10,15    // 批量声明和赋值一起组合， i赋值为10， j赋值为15

提示

Golang定义的函数和其他语言的函数不同， golang可以定义返回多个值的函数， 对于返回多个值的函数，我们在获取返回值的时候，就非常方便的能够使用到这个功能，比如 获取隐射中的对象

obj, ok := map1["test"]

if ok {

}else{

}

2.5.1.4 匿名变量

在使用多变量赋值时，如果想要忽略某个值，可以使用 匿名变量（anonymous variable） 。 匿名变量可以使用一个下划线_表示，这个和我们前面讲到的包引入时的匿名引入，是同样的方式，例如：

看看下面的示例代码

func anonymousVariable() {
    divFn := func(x, y int) (int, bool) {
        if y == 0 { // 除数不能为0
            return 0, false
        }
​
        return x / y, true
    }
​
    p1, ok1 := divFn(3, 3)
    fmt.Printf("%q 运算结果 %d %v \n", "divFn(3,3)", p1, ok1)
​
    p2, ok2 := divFn(3, 0)
    fmt.Printf("%q 运算结果 %d %v \n", "divFn(3,0)", p2, ok2)
}

运行结果

"divFn(3,3)" 运算结果 1 true 
"divFn(3,0)" 运算结果 0 false 

 

代码解析

程序代码首先定义了一个名称为divFn的内部函数， 函数进行整除计算，返回整除结果和是否能进行整除计算两个返回值，当除数为0时，不能进行整除计算， 第二个返回值返回false；

然后程序分别使用3，3以及3，0进行divfn调用，并打印出返回结果