编译型语言#

先把整个源代码翻译成机器码，生成一个可执行文件，然后再运行。翻译这个动作叫编译，做这件事的工具叫编译器

Go 是编译型语言。你写好代码，go build 一下，生成一个二进制文件，直接运行，不需要任何额外环境

源代码 → 编译器 → 可执行文件 → 运行

优点是运行快，因为机器码直接在 CPU 上跑。缺点是每次改完代码都要重新编译

解释型语言

不提前翻译，运行的时候边读代码边执行。做这件事的工具叫解释器

Python 是解释型语言。你写好代码，python hello.py，解释器一行一行读，一行一行执行

源代码 → 解释器 → 运行（边翻译边执行）

优点是改完代码立刻能跑，开发方便。缺点是运行速度比编译型慢，因为翻译是实时发生的

Go 是编译型，但提供了 go run 让你感觉像解释型：它在后台帮你编译，编译完立刻运行，临时文件放在系统缓存目录里，你不用关心中间过程

学习阶段用 go run，部署的时候用 go build，这个习惯记住就行

package#

每个文件都属于一个包

Go 的代码是用包（package） 来组织的。每个 .go 文件的第一行，必须声明自己属于哪个包

main 是一个特殊的包名，意思是”这是程序的入口”。Go 运行的时候，会找 package main 里的 main 函数，从那里开始执行

如果你把 package main 改成 package hello，这个文件就变成了一个库，不能直接运行。包的组织方式后面会专门讲，现在只需要记住：能直接运行的程序，包名一定是 main

import#

引入别人写好的代码

import 的意思是”引入这个包，我要用”。fmt 是 Go 标准库里的一个包，提供格式化输入输出的功能

引入多个包时用括号括起来：

import (
    "fmt"
    "time"
)

Go 有一个强规定：引入了包必须用，不然报错

import (
    "fmt"
    "time"
)
func main() {
    fmt.Println("hello")
    // time 没用
}
// 报错：time imported and not used

这个设计和变量必须被使用一样，目的是保持代码干净，不留垃圾

如果有时候你确实需要引入一个包但不直接调用它（比如只需要它的初始化副作用），这时候用 _ 匿名引入：

import _ "some/package"

还可以给包起别名，在包名太长或者有冲突的时候用：

import (
    f "fmt"
)
func main() {
    f.Println("hello") // 用别名 f 代替 fmt
}

func main()#

程序从这里开始

func main() {
    // 代码写在这里
}

func 是定义函数的关键字，main 是函数名，() 是参数列表，现在是空的，{} 里面是函数体

Go 程序启动时，自动从 func main() 的第一行开始，从上到下依次执行，执行完程序就结束了

遇到函数调用时，会跳进那个函数执行完，再回到原来的位置继续往下走：

func main() {
    fmt.Println("第一行")   // 1. 先执行这里
    fmt.Println("第二行")   // 2. 再执行这里
    fmt.Println("第三行")   // 3. 最后这里
}

输出永远是按顺序的：

第一行
第二行
第三行

这个顺序执行的概念听起来理所当然，但你要真正记住它，因为后面学并发的时候，这个顺序会被打破

fmt.Println#

fmt.Println("Hello, Go!")

fmt 是包名，Println 是这个包里的一个函数，. 是”属于”的意思

注意 Println 的首字母是大写的。在 Go 里，大小写决定了一个东西能不能被外部访问

• 大写字母开头：公开的，其他包可以用
• 小写字母开头：私有的，只有同一个包内部能用

fmt.Println 之所以能被我们调用，就是因为它首字母大写，是公开的。如果 Go 官方把它写成 fmt.println，你就调用不了

这个规则贯穿整个 Go，函数、变量、结构体，都遵守这个规定，后面会反复遇到