go语言的变量和常量-var&const

go语言的变量和常量-var&const

• go语言的变量和常量var&const
  • 1.go语言的变量-Variable
    • 1.1.什么是变量
    • 1.2.变量的数据类型
    • 1.3.变量声明
      • 1.3.1.变量的标准声明
      • 1.3.2.变量的批量声明
    • 1.4.变量的初始化-赋值
    • 1.5.变量的类型推导
    • 1.6.短变量声明
    • 1.7.匿名变量
  • 2.go语言的常量-const
    • 2.1.常量的声明
    • 2.2.常量计数器-iota
      • 2.2.1.iota-特点
      • 2.2.2.实例演示-iota
  • 10.参考地址

1.go语言的变量-Variable

• 变量的功能是存储数据(数据的内存地址)

1.1.什么是变量

• 为什么要用到变量？

程序运行过程中的数据都是保存在内存中，然后返回给我们内存地址，
我们想要在代码中操作某个数据时就需要去内存上找到这个内存地址
但是如果我们直接在代码中通过内存地址去操作数据的话，代码的可读性会非常差而且还容易出错
所以我们就利用变量将这个数据的内存地址保存起来，以后直接通过这个变量就能找到内存上对应的数据了

1.2.变量的数据类型

• 常见变量的数据类型有：整型、浮点型、布尔型等

1.Go语言中的每一个变量都有自己的类型
2.不同的变量保存的数据类型可能会不一样

1.3.变量声明

• 1.Go语言中的变量必须经过声明才能开始使用，且函数内部的变量声明后必须使用
• 2.声明变量时如果没有赋值，go 编译器会使用推导出的变量类型默认值进行初始化，占据内存空间
• 3.同一作用域内，同一变量不支持重复声明，可以重复赋值

1.3.1.变量的标准声明

• 变量声明以关键字 var 开头，后面接变量名称与变量类型，行尾无需分号

# 格式
var 变量名 变量类型

# 实例演示
var name string
var age int
var isOk bool

1.3.2.变量的批量声明

• 每声明一个变量就需要写var关键字会比较繁琐，go 语言中还支持批量变量声明

var (
    a string
    b int
    c bool
    d float32
)

1.4.变量的初始化-赋值

• Go 语言在声明变量的时候，会自动对变量对应的内存区域进行初始化赋值操作，每个变量会被初始化成其相应类型的默认值

• 函数外的每个语句都必须以关键字开始（var、const、func等），所以变量赋值只能在函数内部执行

• 实例演示：

# 单个变量声明加初始化
var name string = "zhangsan"
var age int = 18

# 多个变量同时初始化
var name, age = "zhangsan", 18

• 变量初始化时的默认值

整形: int8、byte、int16、uint、uintprt 等，默认值为 0
浮点类型: float32、float64，默认值为 0
布尔类型: 默认值为 false
复数类型: complex64、complex128，默认值为 0+0i
字符串: 默认值为空字符串 ""
数组的默认值要根据其数据类型来确定，例如：var a [4]int，其默认值为 [0 0 0 0]
错误类型: 的默认值为 nil
复合类型: 如指针、切片、字典、通道、接口，默认值为 nil

1.5.变量的类型推导

• GO 语言中声明变量时可以将变量的类型省略，编译器会根据等号右边的值来推导变量的类型完成初始化

var name = "zhangsan"
var age = 18

1.6.短变量声明

• 在函数内部，可以使用更简略的 := 方式声明并初始化变量
• := 不能使用在函数外

package main

import (
  "fmt"
)
// 全局变量m
var m = 100

func main() {
  m := 200 // 此处声明局部变量m
  n := 10
  fmt.Println(m, n)
}

1.7.匿名变量

• 在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量 anonymous variable

匿名变量用一个下划线 _ 表示,多用于占位，表示忽略值，类似 shell 的 null 黑洞
匿名变量不占用命名空间，不会分配内存，所以匿名变量可以重复声明
在Lua等编程语言里，匿名变量也被叫做哑元变量

• 实例演示：

func foo() (int, string) {
  return 10, "Q1mi"
}
func main() {
  x, _ := foo()
  _, y := foo()
  fmt.Println("x=", x)
  fmt.Println("y=", y)
}

2.go语言的常量-const

• 常量是相对于变量恒定不变的值,在定义的时候必须赋值，多用于定义程序运行期间不会改变的那些值

2.1.常量的声明

• 作用域：可以是全局或者局部

# 标准声明
const pi = 3.1415
const e = 2.7182

# 批量声明
const (
    pi = 3.1415
    e = 2.7182
)

• const 同时声明多个常量时，如果省略了值则表示和上面一行的值相同

const (
    n1 = 100    // n1 = 100
    n2          // n2 = 100
    n3          // n3 = 100
)

2.2.常量计数器-iota

2.2.1.iota-特点

• iota 是 go 语言的常量计数器，只能在常量的表达式中使用

1.const 关键字出现时 iota 将被重置为 0
2.const 中常量声明每增加一行将使 iota 计数增加一次，所以 iota 可理解为 const 语句块中的行索引
3.使用 iota 能简化定义，在定义枚举时很有用

2.2.2.实例演示-iota

• 一般实例

const (
    n1 = iota //0
    n2        //1
    n3        //2
    n4        //3
  )

• 使用下划线 _ 跳过某些值

const (
    n1 = iota //0
    n2        //1
    _
    n4        //3
  )

• iota 声明中间插队计数

const (
    n1 = iota //0
    n2 = 100  //100
    n3 = iota //2
    n4        //3
  )
const n5 = iota //0

• 定义数量级

# 这里的 << 是 go 语言中的位移运算，表示左移操作
# 1<<10 表示将 1 的二进制表示 1 向左移 10 位，也就是由二进制的 1 变成了二进制的 10000000000 ，也就是十进制的 1024 
# 同理 2<<2 表示将 2 的二进制表示 10 向左移 2 位，也就是由二进制的 10 变成了二进制的 1000，也就是十进制的 8
const (
    _  = iota
    KB = 1 << (10 * iota)
    MB = 1 << (10 * iota)
    GB = 1 << (10 * iota)
    TB = 1 << (10 * iota)
    PB = 1 << (10 * iota)
  )

• 多个 iota 定义在一行

const (
    a, b = iota + 1, iota + 2 //1,2
    c, d                      //2,3
    e, f                      //3,4
  )

10.参考地址

https://www.liwenzhou.com/posts/Go/01_var_and_const/