Synopsis: Go 语言将数据类型分为四类：基本类型、复合类型、引用类型和接口类型，本文仅简单介绍下布尔型、字符串、整型、浮点型、复数等基本类型，各类型的详细说明可以参考《The Go Programming Language》，然后学习如何声明变量和常量

1. 基本类型

Go 的基本类型有三类：

布尔型 bool：只有 true 和 false 两种值，支持以下逻辑运算符
- 与 &&
- 或 ||
- 非 !
字符串 string：是一个不可改变的字节序列，文本字符串通常被解释为采用 UTF8 编码的 Unicode code point（rune）序列。注意：内置的 len() 函数返回一个字符串中的字节数目（不是 rune 字符数目）
数值型
- 整数 int/int8/int16/int32/int64/uint/uint8/uint16/uint32/uint64/uintptr/byte/rune
- 浮点数 float32/float64
- 复数 complex64/complex128

其中 byte 是 uint8 的别名。rune 是 int32 的别名，表示一个 Unicode code point（比如字符 𪸿 的 Unicode 码点为 U+2AE3F，十六进制转换为十进制后的整数为 175679）:

// byte is an alias for uint8 and is equivalent to uint8 in all ways. It is
// used, by convention, to distinguish byte values from 8-bit unsigned
// integer values.
type byte = uint8  // Go 1.9 开始用户也可以声明自定义的类型别名(type alias)

// rune is an alias for int32 and is equivalent to int32 in all ways. It is
// used, by convention, to distinguish character values from integer values.
type rune = int32

注意：字符串必须用双引号，比如 "hello"。单引号表示一个 rune 字符，比如 '𪸿'

2. 变量

使用 var 关键字来声明一个或多个变量，注意类型在变量名之后

package main

import "fmt"

// 包级别声明的变量会在 main 入口函数执行前完成初始化
var a int = 10

func main() {
  fmt.Printf("%T %v\n", a, a)

  // 局部变量将在声明语句被执行到的时候完成初始化
  var b int = 20
  fmt.Printf("%T %v\n", b, b)

  // 可以在一个声明语句中同时声明一组变量：变量类型相同时，保留最后的类型即可
  var c, d bool = true, false
  fmt.Printf("%T %v\n", c, c)
  fmt.Printf("%T %v\n", d, d)

  // 可以在一个声明语句中同时声明一组变量：变量类型不同时，不能分别写类型，由 Go 自动进行类型推导
  var e, f = "hello", 3.14
  fmt.Printf("%T %v\n", e, e)
  fmt.Printf("%T %v\n", f, f)
}

/* Output:
int 10
int 20
bool true
bool false
string hello
float32 3.14
*/

使用小括号 分组 形式声明多个变量：

var (
  b bool    = true
  s string  = "hello"
  i int     = 10
  f float64 = 3.14
)

一组变量也可以通过调用一个函数，由函数返回的多个返回值初始化：

var f, err = os.Open(name)  // os.Open returns a file and an error  表达式在运行时(runtime)被计算

2.1 零值

声明变量时，这个变量对应的值总是会被初始化。要么用指定的值初始化，要么用变量类型的默认值 零值(zero value) 做初始化

布尔型: false
字符串: ""(空字符串)
数值型: 0

package main

import "fmt"

func main() {
  var b bool
  var s string
  var i int
  var f float64
  fmt.Printf("%v %q %v %v\n", b, s, i, f)
}

/* Output:
false "" 0 0
*/

其它零值：

引用类型（function、slice、map、channel、pointer 和 interface）对应的零值是 nil
array 或 struct 等聚合类型对应的零值是每个元素或字段所对应的类型的零值

零值初始化机制可以确保每个声明的变量总是有一个良好定义的值，因此在 Go 语言中不存在未初始化的变量。这个特性可以简化很多代码，而且可以在没有增加额外工作的前提下确保边界条件下的合理行为

2.2 类型推导

在声明一个变量而不指定其类型时，变量的类型由右值推导得出

package main

import "fmt"

func main() {
  var b, s, i, f = false, "hello", 10, 3.14
  fmt.Printf("%T %v\n", b, b)
  fmt.Printf("%T %v\n", s, s)
  fmt.Printf("%T %v\n", i, i)
  fmt.Printf("%T %v\n", f, f)
}

/* Output:
bool false
string hello
int 10
float64 3.14
*/

当右值声明了类型时，新变量的类型与其相同：

var i int
j := i  // j 也是一个 int

2.3 短变量声明

在函数（比如 func main() {...}）中，如果右值的类型明确，可以用 := 代替 var 声明变量。短变量声明 := 在一次操作中完成两件事情：声明一个变量、并初始化

函数外的每个语句都必须以关键字开始（比如 import、var 等），因此 := 只能在函数内使用

package main

import "fmt"

// var 声明变量可以出现在函数外
var b bool = false

// b := false  // 报错： syntax error: non-declaration statement outside function body

func main() {
  // var 声明变量也可以出现在函数内
  var s = "hello"

  // 短变量声明 := 只能出现在函数内
  i, f := 10, 3.14
  fmt.Printf("%T %v\n", b, b)
  fmt.Printf("%T %v\n", s, s)
  fmt.Printf("%T %v\n", i, i)
  fmt.Printf("%T %v\n", f, f)
}

/* Output:
bool false
string hello
int 10
float64 3.14
*/

注意： := 是一个变量声明语句，而 = 是一个变量赋值操作

和普通 var 形式的变量声明语句一样，短变量声明语句也可以用函数的返回值来声明和初始化变量：

// 注意: f 和 err 至少有一个变量之前未被声明过，或者会报错 compile error: no new variables，此时只能使用 = 赋值操作
f, err := os.Open(name)
defer f.Close()

if err != nil {
  return err
}

要特别注意短变量声明语句的作用域范围：

package main

import (
  "fmt"
  "log"
  "os"
)

var cwd string

func init() {
  cwd, err := os.Getwd() // 不同代码块中的重名变量 cwd
  if err != nil {
    log.Fatalf("os.Getwd failed: %v", err)
  }
  // 如果注释掉下面的语句编译不通过，因为内部重声明的 cwd 变量未使用
  // compile error: cwd declared and not used
  fmt.Printf("Working directory = %s \n", cwd)
}

func main() {
  fmt.Printf("%T %q\n", cwd, cwd)
}

/* Output:
Working directory = D:\MyCode\go-in-action
string ""
*/

虽然 cwd 在外部已经声明过，但是 := 语句声明的 cwd 和 err 是新的局部变量，与外部的 cwd 属于不同的代码块，所以可以重名（不同代码块中的重名变量）。而 变量重声明 是在同一个代码块内，且只用于 := 语句中，比如：

func foo() {
  var err error
  n, err := io.WriteString(os.Stdout, "Hello, everyone!\n") // err 为变量重声明
  ...
}

因为内部声明的 cwd 将 屏蔽 外部的声明，所以上面的代码并不会正确更新包级声明的 cwd 变量值。为了避免出现类似潜在的问题，最直接的方法是通过单独声明 err 变量，来避免使用 := 简短声明方式：

package main

import (
  "fmt"
  "log"
  "os"
)

var cwd string

func init() {
  var err error
  cwd, err = os.Getwd()  // 不使用 :=
  if err != nil {
    log.Fatalf("os.Getwd failed: %v", err)
  }
  // 即使注释掉下面的语句也不会报错了
  fmt.Printf("Working directory = %s \n", cwd)
}

func main() {
  fmt.Printf("%T %q\n", cwd, cwd)
}

/* Output:
Working directory = D:\MyCode\go-in-action
string "D:\\MyCode\\go-in-action"
*/

2.4 类型转换

表达式 T(v) 的意思是，将值 v 的类型转换为 T 类型，如果两个类型之间无法转换时，将报错：cannot convert v (type a) to type b

package main

import "fmt"

func main() {
  // 等价于 var i int = 42
  i := 42
  fmt.Printf("%T %v\n", i, i)

  // 等价于 var f float64 = float64(i)
  f := float64(i)
  fmt.Printf("%T %v\n", f, f)
}

/* Output:
int 42
float64 42
*/

3. 常量

常量的声明与变量类似，只不过是使用 const 关键字，常量可以被赋值为布尔值、字符/字符串、数值

使用小括号 分组 形式声明多个常量：

const (
  b bool    = true
  s string  = "hello"
  i int     = 10
  f float64 = 3.14
)

注意：不能使用 := 语法声明常量

package main

import "fmt"

// const 声明常量可以出现在函数外
const b bool = false

func main() {
  // const 声明常量也可以出现在函数内
  const s = "hello"

  // const i  // 报错： missing value in const declaration，常量必须被明确赋值，没有零值的概念
  // const i, f := 10, 3.14  // 报错： syntax error: unexpected :=, expecting =

  // 类型推导
  const i, f = 10, 3.14

  fmt.Printf("%T %v\n", b, b)
  fmt.Printf("%T %v\n", s, s)
  fmt.Printf("%T %v\n", i, i)
  fmt.Printf("%T %v\n", f, f)

  // i = 20  // 报错： cannot assign to i，常量不可变
}

/* Output:
bool false
string hello
int 10
float64 3.14
*/