3.1Go变量

3.1 Go变量

变量是对内存中数据存储空间的表示，如同门牌号对应着房间，同样的，变量名字对应变量的值。

变量：本质就是一块内存空间。用于存储某个数值。该数值在运行时可以改变。

变量使用步骤

1.声明变量，定义变量
2.给与变量赋值
3.使用变量

实际案例

package main

import "fmt"

func main() {
    var name string               //声明变量名 name
    name = "超哥"                   //给与变量赋值
    fmt.Println("name的值是：", name) //使用变量
}

结果

name的值是： 超哥

变量使用过程

代码读取
变量加载到内存  name 指向 内存地址的值
1）变量含有名字，变量类型

1.1.1. 变量定义方式

变量作用域

如同天气预报，局部地区有雨，全国地区艳阳高照

局部变量：函数内部定义的变量，指的是该变量的作用范围
全局变量：函数外部，整体作用域

1）定义变量与类型，不赋值，含有默认值

语法：var 语句定义变量的列表，类型在后面，可以定义局部变量也可以，也可全局变量

var name string

var age int

声明多个变量

var num,num2 int

package main

import "fmt"

func main() {
    var age int
    fmt.Println("age的值是：", age)

    var name string
    fmt.Println("name的值是：", name)

    var salary float64
    fmt.Println("salary的值是：", salary)

}

结果

age的值是： 0
name的值是：
salary的值是： 0

2）编译器类型推导，自行判断变量类型

var num = 10.1

一次性定义多个变量

var age,age2 = 10,11

package main

import "fmt"

func main() {
    var num, num1 = 10, 11
    fmt.Println(num, num1)
}

3）短声明，省略var，只能用在函数内部

package main

import "fmt"

func main() {
    name := "超哥"
    fmt.Println("name的值是：", name)

    //上述段声明等于如下方式
    var name2 string
    name2 = "超哥"
    fmt.Println(name2)
}

4）多变量声明

golang支持一次性声明多个变量

支持平行赋值

多个局部变量

作用域只在函数体内，参数和返回值也是局部变量

package main

import "fmt"

func main() {
    //一次性声明多个变量，int默认值
    var n1, n2, n3 int
    fmt.Println(n1, n2, n3)

    //声明多个变量，且赋值
    //平行赋值
    var c1, c2, c3 = "chaoge", 18, 99.99
    fmt.Println(c1, c2, c3)

    //短声明多个变量
    a1, a2, a3 := "yu", 17, 100.0
    fmt.Println(a1, a2, a3)
}

5）一次性声明多个全局变量

package main

import "fmt"
//声明全局变量方式1
var n1 = 100
var n2 = 200
var n3 = 300
//声明全局变量方式2
var (
    d1, d2, d3 = 1, 2, 3
)
//声明全局变量方式3
var (
    c1 = 100
    c2 = 200
    c3 = 300
)

func main() {
    fmt.Println("这里是函数体内")
}

6）特殊变量，占位符 "_"

Go编译器要求变量必须被使用，"_"是一个只写的变量，不能读，等于舍弃，常用于接收函数的返回值

package main

import "fmt"

func Person(a1 int, n1 string) (int, string) {
    return a1, n1
}

func main() {
    //丢弃变量
    n1,n2,_:=1,2,3

    _, name := Person(18, "好嗨哦")
    fmt.Println(name)
}

7）常见数据类型变量默认值

默认值，某个变量没有给定具体的数值，称为默认值

package main

import "fmt"

func main() {
    // 只声明变量，不赋值，只有默认值
    var age int
    var name string
    var gender bool
    var salary float64
    fmt.Println("age默认值 :", age)
    fmt.Println("name默认值 :", name)
    fmt.Println("gender默认值 :", gender)
    fmt.Println("salary默认值 :", salary)
}

输出结果

age默认值 : 0
name默认值 :
gender默认值 : false
salary默认值 : 0

2. Go常量

常量使用关键字 const 定义，用于存储不会改变的数据。常量不能被重新赋予任何值。 存储在常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。 常量的定义格式：const identifier [type] = value

常量代表只读的，不可修改的值，用const关键字定义。

如同用常量定义 "π"之类的常数。

常量如同变量一样，可以批量声明，或者一组相关的常量。

常量的计算都在编译期间完成，并非运行期间！减少运行时的工作。

未使用的常量不会引发编译错误。(这点和变量不一样哦~)

常量习惯用法，所有的字母全大写，代表变量可导出，私有则常量以小写开头即可

package main

import (
    "fmt"
    "unsafe"
)

//常量定义且赋值
const World string = "世界"

//多常量初始化
const x, y int = 1, 2

//常量类型推断，字符串类型
const s1 = "Hello golang"

//常量组
const (
    e       = 2.71828182845904523536028747135266249775724709369995957496696763
    pi      = 3.14159265358979323846264338327950288419716939937510582097494459
    b  bool = true
)

//常量组，可以除了第一个外其他的常量右边的初始化表达式可以省略
//如果省略初始化表达式，默认使用前面常量的表达式
//与上一个常量相同
const (
    c1=1
    c2
    c3
    c4="c44444"
    c5
)
/*
输出结果
1
1
1
c44444
c44444
 */

 //常量也可以定义函数的返回值
 const (
     f1="abc"  //长度为3的字符串类型
     f2=len(f1)//返回长度的函数结果
     f3=unsafe.Sizeof(f2)//返回f2所占用的内存大小
 /*
 输出结果
 abc
 3
 8
  */

func main() {
    fmt.Println(f1)
    fmt.Println(f2)
    fmt.Println(f3)
}

3. Go常量之iota常量生成器

iota用于生成一组相似规则初始化的常量，在const常量声明的语句中，第一个常量所在行，iota为0，之后每一个常量声明加一。

例如time包的例子，一周7天，每天可以定义为常量，1~6，周日为0，这种类型也称为枚举

package main

import (
    "fmt"
)

const (
    Sunday = iota
    Monday //通常省略后续行表达式
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
)

func main() {
    fmt.Println(Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday)
}

如果iota表达式被打断，需要显示恢复

package main

import (
    "fmt"
)

const (
    A = iota //初始0
    B        // +1
    C = "c"  //iota枚举被打断 ，为  c
    D        // c，与上  相同。
    E = iota // 4，显式恢复。注意计数包含了 C、D 两个，此时为4 。
    F        // 恢复iota 加一，此时为5
)

func main() {
    fmt.Println(A, B, C, D, E, F)
}

输出结果

0 1 c c 4 5