语言数据类型

变量概念

变量声明，初始化与赋值

单个变量的声明与赋值
- 变量的声明格式： var <变量名称> [变量类型]
- 变量的赋值格式：<变量名称> = <值，表达式，函数等>
- 声明和赋值同时进行：var <变量名称> [变量类型] = <值，表达式，函数等>
- 分组声明格式：
  1 2 3 4 5
  var ( i int j float32 name string )
同一行声明多个变量和赋值：var a, b, c int = 1, 2, 3 或者 a, b : = 1, 2
全局变量的声明必须使用 var 关键词，局部变量则可以省略
特殊变量下划线 _ （垃圾桶）

变量的类型转换

Go中不存在隐式转换，类型必须是显示的
类型转换只能发生在两种兼容类型之间
类型转换格式：<变量名称> [:] = <目标类型>(<需要转换的变量>)

变量可见性规则

大写字母开头的变量是可导出的，也就是其他包可以读取的，是公用变量
小写字母开头的就是不可导出的，是私有变量

常量，常量声明及iota的使用

变量代码讲解

package main

import "fmt"

var a int
var b int = 12
var (
    c int
    d string = "你好色彩佳能"
)

func main() {
    fmt.Print(a)
    fmt.Print("\n")
    fmt.Print(b)
    fmt.Print("\n")
    fmt.Print(c)
    fmt.Print("\n")
    fmt.Print(d)
    fmt.Print("\n")

    // 单行声明多个变量
    var e, f, g int = 1, 2, 3
    fmt.Print(e)
    fmt.Print("\n")
    fmt.Print(f)
    fmt.Print("\n")
    fmt.Print(g)
    fmt.Print("\n")
}

// 顺序输出
// 0
// 12
// 0
// 你好色彩佳能
// 1
// 2
// 3

常量定义

常量定义形式和常量类型范围

常量定义从形式上可以分为显式和隐式；
- 显式：*** const 常量名称 [常量类型] = 常量值 ***
- 隐式： const 常量名称 = 常量值 (通常叫无类型常量)

常量可以使用内置表达式定义，例如 len()，unsafe.Sizeof() 等；

package main

import (
    "fmt"
    "reflect"
)

// 显式
const name1 string = "elasticnotes1"

// 隐式
const name2 = "elasticnotes2"

// 组合
const (
    name3 string = "elasticnotes3"
    name4        = "elasticnotes4"
)

// 单行 - 显式
const name5, name6 string = "elasticnotes5", "elasticnotes6"

// 单行 - 隐式
const name7, name8 = 7, "elasticnotes8"

// 内置函数
const name9 = len("123123123")

func main() {
    fmt.Print(name1)
    fmt.Print("\n")
    fmt.Print(name2)
    fmt.Print("\n")
    fmt.Print(name3)
    fmt.Print("\n")
    fmt.Print(name4)
    fmt.Print("\n")
    fmt.Print(name5)
    fmt.Print("\n")
    fmt.Print(name6)
    fmt.Print("\n")
    fmt.Print(name7)
    fmt.Print("\n")
    fmt.Print(reflect.TypeOf(name7))
    fmt.Print("\n")
    fmt.Print(name8)
    fmt.Print("\n")
    fmt.Print(reflect.TypeOf(name8))
    fmt.Print("\n")
    fmt.Print(name9)
    fmt.Print("\n")
}

// 输出
MacintoshdeMacBook-Pro-139:code elasticnotes$ go run test.go 
elasticnotes1
elasticnotes2
elasticnotes3
elasticnotes4
elasticnotes5
elasticnotes6
7
int
elasticnotes8
string
9

常量范围目前只支持布尔、数字（整数、浮点、复数）和字符串；

特殊常量 iota 的使用

iota在const关键字出现时将被重置为0；

package main

import "fmt"

const a = iota
const b = iota

func main() {
    fmt.Print("a的常量值为：")
    fmt.Print(a)
    fmt.Print("\n")
    fmt.Print("b的常量值为：")
    fmt.Print(b)
    fmt.Print("\n")
}

// 输出
MacintoshdeMacBook-Pro-139:code elasticnotes$ go run iota.go 
a的常量值为：0
b的常量值为：0

const中每新增一行常量声明将使iota计数一次；

package main

import "fmt"

const (
    c = iota
    d = iota
)

func main() {
    fmt.Print("c的常量值为：")
    fmt.Print(c)
    fmt.Print("\n")
    fmt.Print("d的常量值为：")
    fmt.Print(d)
    fmt.Print("\n")
}

// 输出
MacintoshdeMacBook-Pro-139:code elasticnotes$ go run iota.go 
c的常量值为：0
d的常量值为：1

iota常见用法

只能在常量中使用，不能在方法中使用

跳值使用法；

package main

import "fmt"

const (
    d = iota
    _
    e = iota // 跳值 e 为 3
)

func main() {
    fmt.Print("d的常量值为：")
    fmt.Print(d)
    fmt.Print("\n")
    fmt.Print("e的常量值为：")
    fmt.Print(e)
    fmt.Print("\n")
}


// 输出
MacintoshdeMacBook-Pro-139:code elasticnotes$ go run iota.go 
d的常量值为：0
e的常量值为：2

插队使用法；

package main

import "fmt"

const (
    f = iota
    g = 122 // 插队使用法
    h = iota
)

func main() {
    fmt.Print("f的常量值为：")
    fmt.Print(f)
    fmt.Print("\n")
    fmt.Print("g的常量值为：")
    fmt.Print(g)
    fmt.Print("\n")
    fmt.Print("h的常量值为：")
    fmt.Print(h)
    fmt.Print("\n")
}

// 输出
MacintoshdeMacBook-Pro-139:code elasticnotes$ go run iota.go 
f的常量值为：0
g的常量值为：122
h的常量值为：2

表示式隐式使用法；

package main

import "fmt"

const (
    i = iota * 2
    j = iota
    k = iota
)

func main() {
    fmt.Print("i的常量值为：")
    fmt.Print(i)
    fmt.Print("\n")
    fmt.Print("j的常量值为：")
    fmt.Print(j)
    fmt.Print("\n")
    fmt.Print("k的常量值为：")
    fmt.Print(k)
    fmt.Print("\n")
}

// 输出
MacintoshdeMacBook-Pro-139:code elasticnotes$ go run iota.go 
i的常量值为：0
j的常量值为：1
k的常量值为：2

// ============ DIFF ============ 

package main

import "fmt"

const (
    i = iota * 2
    j  // 1 * 2 = 2
    k  // 2 * 2 = 4
)

func main() {
    fmt.Print("i的常量值为：")
    fmt.Print(i)
    fmt.Print("\n")
    fmt.Print("j的常量值为：")
    fmt.Print(j)
    fmt.Print("\n")
    fmt.Print("k的常量值为：")
    fmt.Print(k)
    fmt.Print("\n")
}

// 输出
MacintoshdeMacBook-Pro-139:code elasticnotes$ go run iota.go 
i的常量值为：0
j的常量值为：2
k的常量值为：4

单行使用法；

package main

import "fmt"

const (
    l, m = iota, iota + 3
    n, o
    p = iota
)

func main() {
    fmt.Print("l的常量值为：")
    fmt.Print(l)
    fmt.Print("\n")
    fmt.Print("m的常量值为：")
    fmt.Print(m)
    fmt.Print("\n")
    fmt.Print("n的常量值为：")
    fmt.Print(n)
    fmt.Print("\n")
    fmt.Print("o的常量值为：")
    fmt.Print(o)
    fmt.Print("\n")
    fmt.Print("p的常量值为：")
    fmt.Print(p)
    fmt.Print("\n")
}

// 输出
MacintoshdeMacBook-Pro-139:code elasticnotes$ go run iota.go 
l的常量值为：0
m的常量值为：3
n的常量值为：1
o的常量值为：4
p的常量值为：2