上首诗如是说了自然环境构筑，并顺利完成了自学 Go 的第二个流程 Hello World。这首诗竭尽全力自学 Go 的基本知识，来看一看表达式，自变量的新闻稿与表达式。

责任编辑大部份标识符如前所述 go1.16.6 撰写。

表达式

Go 程式设计的重新命名艺术风格更生活习惯采用「短中文名称」和「之字形式」的中文名称，所以UTF脆弱。

结尾要是拉丁字母或是换行，所以第二个拉丁字母是小写却是小写也是有特定涵义的。小写拉丁字母结尾能塞雷县外提及，小写拉丁字母结尾根本无法在包中采用，那个会在之后的该文中竭尽全力撷取。

新闻稿

第二种采用URL var 新闻稿表达式：

var name type = expression

和 C 词汇刚好恰好相反，类别是跟在表达式名前面的。虽说，刚开始写 Go 标识符的这时候还真很多不生活习惯。

类别和表达式能略去两个，但无法都略去。假如类别略去，则类别由调用表达式下定决心；假如表达式略去，则调用值相关联类别的常量。

对位数是 0，常量是 false，字符串是 “”，USB和提及（slice，指针，map，地下通道，表达式）是nil，对字符串或内部结构体这种的A43EI235E类别，常量是其大部份原素或核心成员的常量。

// 没常量，会赋预设常量 var v1 int var v2 string var v3 bool var v4 [10]int // 字符串 var v5 []int // 字符串切片 var v6 struct { e int } var v7 *int // 操作符 var v8 map[string]int // map，key 为 string 类别，value 为 int 类别 var v9 func(e int) int fmt.Println(v1, v2, v3, v4, v5, v6, v7, v8, v9) // 输出 // 0 false [0 0 0 0 0 0 0 0 0 0] [] {0} <nil> map[] <nil>

所以在 Go 中是不存在未调用的表达式的。

新闻稿单个表达式：

// 新闻稿单个表达式 var a = “initial”fmt.Println(a)// 新闻稿常量表达式 var d = true fmt.Println(d)

一次新闻稿多个表达式：

// 新闻稿多个表达式 var b, c int = 1, 2 fmt.Println(b, c)

建议以组方式一次新闻稿多个表达式：

// 以组的方式新闻稿多个表达式 var ( b1, c1 int b2, c2 = 3, 4 ) fmt.Println(b1, c1) fmt.Println(b2, c2)

第二种方式是短表达式新闻稿：

name := expression

采用 := 来新闻稿，Go 编译器会自动推断表达式类别。注意 := 和 = 的区别，前者是新闻稿并表达式，后者是表达式。

这种调用方式非常方便，在局部表达式的新闻稿和初始化时经常采用。

举个例子：

// 短表达式新闻稿方式 f := “short” fmt.Println(f)

多个表达式：

// 新闻稿表达式多个表达式 g, h := 5, “alwaysbeta”fmt.Println(g, h)

有一点需要注意，多个表达式新闻稿时，最少有两个新表达式，否则会报错。

var i int // i := 100 // 报错 no new variables on left side of := i, j := 100, 101 // 有新值 j，不报错 fmt.Println(i, j)

第三种采用内置 new 表达式：

p := new(T)

调用为类别 T 的常量，并返回其地址。

址符& 即可。

新闻稿两个整型的表达式，然后对其取地址：

// 操作符 k := 6 l := &k // l 为整型操作符，指向 k fmt.Println(*l) // 输出 6 *l = 7 fmt.Println(k) // 输出 7

采用 new 表达式新闻稿表达式：

// 采用内置表达式 new 新闻稿 var p = new(int) fmt.Println(*p) // 输出整型预设值 0 *p = 8 fmt.Println(*p) // 输出 8

再来看两个例子，下面两个表达式是等价的，唯一的区别就是采用 new 少新闻稿了两个中间表达式。

func newInt() *int { return new(int) } func newInt1() *int { var p int return &p }

表达式

采用 = 来表达式：

举例：

// 表达式表达式 var m, n int m = 9 n = 10 fmt.Println(m, n)

多重表达式：

// 表达式表达式 var m, n int m = 9 n = 10 m, n = n, m fmt.Println(m, n)

那个特性真是很爽，想想在 C 词汇中是无法这么做的，要实现相同的效果，要要借助两个中间表达式才行。

假如有不需要的表达式，采用空标识符_ 来忽略，在 Go 词汇中，假如新闻稿了表达式而不采用，流程是会报错的。

// 空标识符 r := [5]int{1, 2, 3, 4, 5} for _, v := range r { // fmt.Println(i, v) // fmt.Println(v) // 定义 i 但不用会报错 i declared but not used fmt.Println(v) // 忽略索引 }

作用域

表达式分为全局表达式和局部表达式，局部表达式会覆盖全局表达式：

// 全局表达式 var gg = “global” func main() { // 作用域 fmt.Println(gg) // 输出 global gg = “local”fmt.Println(gg)// 输出 local }

采用流程控制语句时，需要特定注意表达式的作用域：

// 条件分支下的作用域 if f, err := os.Open(“./00_hello.go”); err != nil { fmt.Println(err) } f.Close() // 报错 f.Close undefined (type string has no field or method Close)

正确的写法：

// 正确写法 file, err := os.Open(“00_hello.go”) if err != nil{ fmt.Println(err) } file.Close()

自变量

自变量表示在流程运行过程中恒定不变的值。

新闻稿

采用URL const 来新闻稿，语法和表达式类似。

一般在给自变量起名的这时候，会起两个有明确涵义的名字。

const Pi float64 = 3.14159265358979323846

新闻稿单个自变量：

// 无类别整型自变量 const n = 500000000 // 用编译阶段即可计算出值的表达式来表达式 const d = 3e20/ n fmt.Println(d)// 无类别浮点自变量 const zero = 0.0

新闻稿多个自变量

// 无类别整型和字符串自变量 const a, b, c = 3, 4, “foo” fmt.Println(a, b, c) // 多个自变量 const ( size int64 = 1024 eof = -1 // 无类别整型自变量 ) fmt.Println(size, eof)

iota

自变量新闻稿还有能采用自变量生成器 iota，它不会显示写出自变量的值，而是从 0 开始，逐项加 1。

// 从 0 值开始，逐项加 1 const ( a0 = iota // 0 a1 = iota // 1 a2 = iota // 2) fmt.Println(a0, a1, a2)// 简写，表达式相同，能略去前面的 const ( b0 = iota // 0 b1 // 1 b2 // 2) fmt.Println(b0, b1, b2)const ( b = iota // 0 c float32 = iota * 10 // 10 d = iota // 2 ) fmt.Println(b, c, d)

iota 在每个 const结尾被重置为 0。

// iota 在每个 const 结尾被重置为 0 const x = iota // 0 fmt.Println(x) // 同上 const y = iota // 0 fmt.Println(y)

还能用来作为枚举类别，比如一周 7 天，每天用两个位数表示，那么能这么新闻稿：

// 枚举 const ( Sunday = iota // 0 Monday // 1 Tuesday // 2 Wednesday // 3Thursday// 4 Friday // 5 Saturday // 6) fmt.Println(Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday)