顺便蹭下活动，反正也是日更。这个鸡年我在简书写Golang，笑哭。
这个系列受 Python 界那本著名的《笨办法学 Python》（Learn Python the Hard Way）启发，尝试从练习和例子入手学习 Go 语言。
本文为系列第一篇，主要介绍 Go 语言的最基础的语法（部分例题来自 Go by Example）。Go 语言环境安装就不说了。
1. Hello World
这是我们的第一个 Go 语言程序。
下面是一个 Hello World 程序的全部代码。
package main
// 软件包 fmt 实现 I/O 格式化，功能类似于 C 的 printf 和 scanf。
import "fmt"
// main 函数，程序入口。
func main() {
fmt.Println("hello world")
}
点击运行，如果打不开请翻墙。
我们可以直接使用 go run 命令运行这个文件：
$ go run hello-world.go
hello world
或者使用 go build 命令把源文件
$ go build hello-world.go
$ ls
hello-world hello-world.go
编译成二进制执行文件，然后就可以直接执行了。这样，下次就不需要使用 Go 语言的环境来执行源程序，而是可以脱离 Go 语言开发环境成为一个独立的程序。例如下面，你可以把 hello-world 文件移动到其他主流 Linux 发行版运行，即便那系统没有 Go 语言环境也可以运行。
$ ./hello-world
hello world
练习
- 下面哪个可以输出“hello world”？
A.
package main
import "fmt"
func main() {
fmt.Print("hello")
fmt.Print(" world")
}
B.
package main
import "fmt"
func main()
{
fmt.Print("hello")
fmt.Print(" world")
}
C.
package main
import "fmt"
func main()
{
fmt.Println("hello")
fmt.Print(" world")
}
D.
package hello
import "fmt"
func hello() {
fmt.Print("hello")
fmt.Print(" world")
}
2. Values
Go 有各种值类型，包括 strings, integers, floats, booleans 等等。
下面是一些很基础的例子。
package main
import "fmt"
func main() {
// 字符串，可以使用“+”符号把两个值连到一起。
fmt.Println("go" + "lang")
// 整数和浮点数。
fmt.Println("1+1 =", 1+1)
fmt.Println("7.0/3.0 =", 7.0/3.0)
// 布尔值，支持常见的布尔运算符。
fmt.Println(true && false)
fmt.Println(true || false)
fmt.Println(!true)
}
点击运行，如果打不开请翻墙。
直接在本地运行：
$ go run values.go
golang
1+1 = 2
7.0/3.0 = 2.3333333333333335
false
true
false
练习
- 下列哪行代码不可以通过编译？
package main
import "fmt"
func main() {
// A
fmt.Println("go" + "lang")
// B
fmt.Println("相加：", 1 + 1)
// C
fmt.Println("相除", 7.0000000000000001 / 3)
// D
fmt.Println("真假：", 0 || 1)
}
3. Variables
Go语言里面定义变量有多种方式。
//定义一个名称为“varName”，类型为"type"的变量,变量类型放在变量名后面
var varName type
//定义三个类型都是“type”的变量
var vname1, vname2, vname3 type
//初始化“varName”的变量为“value”值，类型是“type”
var varName type = value
/*
定义三个类型都是"type"的变量,并且分别初始化为相应的值
vname1为v1，vname2为v2，vname3为v3
*/
// 这是第一种写法
var vname1, vname2, vname3 type = v1, v2, v3
// 直接忽略类型声明，Go会根据其相应值的类型来帮你初始化它们
var vname1, vname2, vname3 = v1, v2, v3
// 再简单点，直接把var都去掉
vname1, vname2, vname3 := v1, v2, v3
/*
:=这个符号直接取代了var和type,这种形式叫做简短声明。
不过它有一个限制，那就是它只能用在函数内部；
在函数外部使用则会无法编译通过，所以一般用var方式来定义全局变量。
*/
// 还可以这样
var (
v1 = 1
v2 = 2
v3 = 3
)
注意：
- _（下划线）是个特殊的变量名，任何赋予它的值都会被丢弃。
- Go对于已声明但未使用的变量会在编译阶段报错
- 变量除了可以在全局声明中初始化，也可以在 init 函数中初始化。这是一类非常特殊的函数，它不能够被人为调用，而是在每个包完成初始化后自动执行，并且执行优先级比 main 函数高。每一个源文件都可以包含且只包含一个 init 函数。初始化总是以单线程执行，并且按照包的依赖关系顺序执行。
类型转换：
var n int16 = 34
var m int32
m = int32(n)
Example
package main
import "fmt"
func main() {
// var 定义一个或者多个变量。
var a string = "initial"
fmt.Println(a)
// 你可以在一行定义多个变量。
var b, c int = 1, 2
fmt.Println(b, c)
// Go语言会自动推断变量类型。
var d = true
fmt.Println(d)
// 没有初始化声明的变量默认值是0。例如，一个没有初始化的int类型的值为0。
var e int
fmt.Println(e)
// 为了省事，Go语言提供了 := 这样的语法，它包含了定义和初始化。下面就是一个例子，下面语句中等同为：var f string = "short"
f := "short"
fmt.Println(f)
}
4. Constants
const Pi = 3.1415926
//如果需要，也可以明确指定常量的类型：
const Pi float32 = 3.1415926
//甚至还可以这样
const (
数字, 字符串, 布尔值 = 1, "你好世界", true
)
使用某个类型作为枚举常量的类型：
type Color int
const (
RED Color = iota // 0
ORANGE // 1
YELLOW // 2
GREEN // 3
BLUE // 4
INDIGO // 5
VIOLET // 6
)
需要注意的一点是，这些类型的变量之间不允许互相赋值或操作，不然会在编译时引起编译器报错。
如下的代码会产生错误：
var a int8
var b int32
c:=a + b
// 编译报错：invalid operation: a + b (mismatched types int8 and int32)
另外，尽管int的长度是32 bit, 但int 与 int32并不可以互用。
Example
package main
import "fmt"
import "math"
const declares a constant value.
const s string = "constant"
func main() {
fmt.Println(s)
// 常量可以在任意地方定义，但是初始化后便不能修改。
const n = 500000000
// 常量的值可以是一个不含变量的表达式
const d = 3e20 / n
fmt.Println(d)
// 常量同样可以隐式声明类型，即交由Go编译器判断类型，你可以使用下面的方式强制类型转换一个常量。
fmt.Println(int64(d))
// Go允许不同类型的数字常量运算，结果按照最后一个运算法则变化例如原本n是整型，经过Sin()函数转变，运算结果会变成一个浮点型。
fmt.Println(math.Sin(n))
}
