Go 语言快速入门

一、简介和准备

什么是 Go？

• Go 语言是一门编译语言。
  • 在你运行程序之前，Go首先使用编译器把你的代码转换成机器能够读懂的 1 和 0。
  • 它会把你所有的代码编译成一个可执行文件，在编译的过程中，Go编译器能够捕获一些错误。
• 不是所有的编程语言都使用这种方式。
  • Python、Ruby 等很多语言都是使用解释器，随着程序的运行，一个语句一个语句的进行翻译。但这也意味着 bug 可能就潜伏在你还没有测试过的路径上。
  • 这些就是解释型语言。

Go 的由来和评价

“我们想要一个安全的、静态编译的、高性能的、类似 C++ 和 Java 这样的语言，但是得更轻量级并且要像Python这种动态解释型语言这样有趣。” –– Rob Pike

Go语言是通过对软件开发体验这方面经过大量深思熟虑之后而设计的。大量的程序只需一个命令便在几秒钟内就能完成编译。该语言省略了能导致歧义的特性，鼓励了可预测且易于理解的代码。Go为Java等经典语言所强加的刚性结构，提供了替代品。

Go是一个开源的编程语言，能够构建大规模简单、高效、可靠的软件。

Go Playground

安装 Go 和开发工具

官网：https://go.dev/dl/

Go语言中文网：https://studygolang.com/

• Go安装包 https://studygolang.com/dl
• Visual Studio Code
  • Go 插件 (>go Go: install/update tools)
• Go 代理
• go env -w GO111MODULE=on
• go env -w GOPROXY=https://goproxy.cn,direct

包和函数 package & function

package main

import (
  "fmt"
)

func main() {
  fmt.Println("Hello, playground")
}

作业题

• Go 编译器有哪些优点？
• Go 的程序从哪里开始运行？
• fmt 这个 package 提供了哪些功能？
• 左花括号 { 放在哪不会引起语法错误？
• 编写一个程序：
  • 第一行输出 Hello，World
  • 第二行输出 Hello。

package main

import "fmt"

// The function declares and initializes variables of different data types in Go.
func main() {
 fmt.Println("Hello World!")
 fmt.Println("Hello")
}

二、做个计算器

算术运算符

• Go 语言提供了 +、-、*、/、% 来做加减乘除和取余的算术运算

// My weight loss program.
package main

import "fmt"

// main is the function where it all begins.
func main() {
 fmt.Print("My weight on the surface of Mars is")
 fmt.Print(149.0 * 0.3783)
 fmt.Print(" libs, and I would be ")
 fmt.Print(41 * 365 / 687)
 fmt.Print(" years old.")

 fmt.Println("My weight on the surface of Mars is", 149.0*0.3783, "libs, and I would be", 41*365.2425/687, "years old.")
}

运行

Code/go/hello via 🐹 v1.20.3 
➜ go run main.go
My weight on the surface of Mars is56.3667 libs, and I would be 21 years old.My weight on the surface of Mars is 56.3667 libs, and I would be 21.79758733624454 years old.

Code/go/hello via 🐹 v1.20.3 
➜ 

fmt.Print和fmt.Println

• 上述例子里使用了Print，Println函数。
  • 可以传递若干个参数，之间用逗号分开。
  • 参数可以是字符串、数字、数学表达式等等。

格式化打印

• 可以使用Printf来控制打印的输出结果。
• 与Print和Println不同，Printf的第一个参数必须是字符串。
  • 这个字符串里包含了像%v这样的格式化动词，它的值由第二个参数的值所代替。
  • 如果指定了多个格式化动词，那么它们的值由后边的参数值按其顺序进行替换。

// My weight loss program.
package main

import "fmt"

// main is the function where it all begins.
func main() {
 fmt.Printf("My weight on the surface of Mars is %v libs,", 149.0*0.3783)
 fmt.Printf(" and I would be %v years old.\n", 41*365/687)

 fmt.Printf("My weight on the surface of %v is %v lbs.\n", "Earth", 149.0)
}

运行

Code/go/hello via 🐹 v1.20.3 
➜ go run main.go
My weight on the surface of Mars is 56.3667 libs, and I would be 21 years old.
My weight on the surface of Earth is 149 lbs.

Code/go/hello via 🐹 v1.20.3 
➜ 

使用Printf对齐文本

• 在格式化动词里指定宽度，就可以对齐文本。
• 例如，%4v，就是向左填充到足够4个宽度
• 正数，向左填充空格
• 负数，向右填充空格

// My weight loss program.
package main

import "fmt"

// main is the function where it all begins.
func main() {
 fmt.Printf("%-15v $%4v\n", "SpaceX", 94)
 fmt.Printf("%-15v $%4v\n", "Virgin Galactic", 100)
}

运行

Code/go/hello via 🐹 v1.20.3 
➜ go run main.go
SpaceX          $  94
Virgin Galactic $ 100

Code/go/hello via 🐹 v1.20.3 
➜ 

常量 和 变量

• const，用来声明常量
  • 常量的值不可以改变
• var，用来声明变量
  • 想要使用变量首先需要进行声明

// My weight loss program.
package main

import "fmt"

// main is the function where it all begins.
func main() {
 const lightSpeed = 200792 // km/s
 var distance = 56000000   // km

 fmt.Println(distance/lightSpeed, "seconds")

 distance = 401000000
 fmt.Println(distance/lightSpeed, "seconds")
}

运行

Code/go/hello via 🐹 v1.20.3 
➜ go run main.go
278 seconds
1997 seconds

Code/go/hello via 🐹 v1.20.3 
➜ 

同时声明多个变量

// My weight loss program.
package main

import "fmt"

// main is the function where it all begins.
func main() {
 var distance = 56000000
 var speed = 100800

 var (
  distance = 56000000
  speed    = 100800
 )

 var distance, speed = 56000000, 100800

 const hoursPerDay, minutesPerHour = 24, 60
}

赋值运算符

// My weight loss program.
package main

// main is the function where it all begins.
func main() {
 var weight = 149.0
 weight = weight * 0.3783
 weight *= 0.3783
}

自增运算符

• 但是Go里面没有类似C#的++count这种操作。

// My weight loss program.
package main

// main is the function where it all begins.
func main() {
 var age = 41
 age = age + 1
 age += 1
 age++
}

猜数

• 使用rand包，可以生成伪随机数
  • 例如，Intn可以返回一个指定范围的随机整数
  • import的路径是 “math/rand”

// My weight loss program.
package main

import (
 "fmt"
 "math/rand"
)

// main is the function where it all begins.
func main() {
 var num = rand.Intn(10) + 1
 fmt.Println("num = ", num)

 num = rand.Intn(10) + 1
 fmt.Println("num = ", num)
}

运行

Code/go/hello via 🐹 v1.20.3 
➜ go run main.go
num =  10
num =  3

Code/go/hello via 🐹 v1.20.3 

作业题

• Malacandra是C.S. Lewis在《太空三部曲》中给火星起的另一个名字。编写程序来确定飞船要在28天内到达Malacandra的行进速度（公里/小时）。假设距离为56,000,000公里。

// My weight loss program.
package main

import (
 "fmt"
)

// main is the function where it all begins.
func main() {
 var kilometer = 56000000
 var day = 28
 var speed = kilometer / (day * 24)

 fmt.Println("speed = ", speed)
}

三、循环和分支

Boolean类型

• 你可能经常会遇到这样的问题：
  • 如果你走出了洞穴，那么请翻到21页
• 那么你是否走出了洞穴？
  • 这个问题的答案只有true和false两种情况。
  • true和false就是两个已声明好的常量。
• 某些语言（例如js）会把“”这种字符串当作false，其他的字符串当作true。
• 而Go语言则不行，只有true是真的，只有false是假的。

strings.Contains

• 来自strings包的Contains函数可以判断某个字符串是否包含另外一个字符串

package main

import (
 "fmt"
 "strings"
)

// main is the function where it all begins.
func main() {
 fmt.Println("You find yourself in a dimly lit cavern.")

 var command = "walk outside"
 var exit = strings.Contains(command, "outside")

 fmt.Println("You leave the cave:", exit)
}

比较

• 如果我们比较两个值，得到的结果也是true或false
• 比较运算符：
  • ==
  • <=
  • <
  • !=
  • =>
  • >

package main

import (
 "fmt"
)

// main is the function where it all begins.
func main() {
 fmt.Println("There is a sign near the entrance that reads 'No Minors'.")

 var age = 41
 var minor = age < 18

 fmt.Printf("At age %v, am I a minor? %v\n", age, minor)
}

使用if来做分支

package main

import (
 "fmt"
)

// main is the function where it all begins.
func main() {
 var command = "go east"

 if command == "go east" {
  fmt.Println("You head further up the mountain.")
 } else if command == "go inside" {
  fmt.Println("You enter the cave where you live out the rest of your life.")
 } else {
  fmt.Println("Didn't quite get that.")
 }
}

• 在这里else和else if都是可选的
• 而且else if可以重复多个

逻辑运算符

• ||表示或，&&表示与。它们通常用来同时检查多个条件

package main

import (
 "fmt"
)

// main is the function where it all begins.
func main() {
 fmt.Println("The year is 2100, should you leap?")

 var year = 2100
 var leap = year%400 == 0 || (year%4 == 0 && year%100 != 0)

 if leap {
  fmt.Println("Look before you leap!")
 } else {
  fmt.Println("Keep your feet on the ground.")
 }
}

• 这里使用了短路逻辑

取反逻辑运算符

• ！，可以把true变为false，反之亦然

package main

import (
 "fmt"
)

// main is the function where it all begins.
func main() {
 var haveTorch = true
 var litTorch = false

 if !haveTorch || !litTorch {
  fmt.Println("Nothing to see here.")
 }
}

使用switch做分支

package main

import (
 "fmt"
)

// main is the function where it all begins.
func main() {
 fmt.Println("There is cavern entrance here and a path to the east.")
 var command = "go inside"

 switch command {
 case "go east":
  fmt.Println("You head further up the mountain.")
 case "enter cave", "go inside":
  fmt.Println("You find yourself in a dimly lit cavern.")
 case "read sign":
  fmt.Println("The sign reads 'No Minors'.")
 default:
  fmt.Println("Didn't quite get that.")
 }
}

• switch语句也可以对数字进行匹配
• 还有一个fallthrough关键字，它用来执行下一个case的body部分。这一点与C#、Java等语言不一样。

package main

import (
 "fmt"
)

// main is the function where it all begins.
func main() {
 var room = "lake"

 switch {
 case room == "cave":
  fmt.Println("You find yourself in a dimly lit cavern.")
 case room == "lake":
  fmt.Println("The ice seems solid enough.")
  fallthrough
 case room == "underwater":
  fmt.Println("The water is freezing cold.")
 }
}

使用循环做重复

• for关键字可以让你的代码重复执行
• for后边没有跟条件，那就是无限循环。
  • 可以使用break跳出循环

package main

import (
 "fmt"
 "time"
)

// main is the function where it all begins.
func main() {
 var count = 10

 for count > 0 {
  fmt.Println(count)
  time.Sleep(time.Second)
  count--
 }
  
  // var count = 5
  
  // for {
  // if count < 0 {
  //   break
  //  }
  //  fmt.Println(count)
 //  time.Sleep(time.Second)
 // count--
  // }
 fmt.Println("Liftoff!")
}

作业题

• 实现一个猜数游戏，首先定义一个1-100的整数。然后让计算机生成一个1-100随机数，并显示计算机猜测的结果是太大了还是太小了，没猜对的话就继续猜，直至猜对。

package main

import (
 "fmt"
 "math/rand"
)

// main is the function where it all begins.
func main() {
 var num int
 rand_num := random(1, 100)
 for {
  fmt.Print("请输入一个1-100的整数:")
  fmt.Scanln(&num)
  // fmt.Printf("扫描结果 num:%d \n", num)
  if num > rand_num {
   fmt.Println("您猜大了！")
   continue
  } else if num < rand_num {
   fmt.Println("您猜小了!")
   continue
  } else {
   fmt.Println("您猜对了!")
   break
  }
 }
}

func random(min, max int) int {
 return rand.Intn(max-min) + min
}

Vscode font：Fira code

四、变量及作用域

变量的作用域

• 当变量被声明以后，它就进入了作用域（变量就变得可见了）。
  • 只要变量在作用域内，你就可以访问它
  • 否则，访问它会报错的
• 变量声明的位置，决定了它的作用域。
• 作用域的好处？
  • 可以在不同的作用域内使用相同的变量名
• 在Go里面，作用域的范围就是{ }之间的部分

package main

import (
 "fmt"
 "math/rand"
)

// main is the function where it all begins.
func main() {
 var count = 0

 for count < 10 {
  var num = rand.Intn(10) + 1
  fmt.Println(num)

  count++
 }
}

// count 变量就是在function作用域内
// num的作用域就是for的循环体

短声明

• 在Go里，可以使用var来声明变量：
  • var count = 10
• 但是也可以使用短声明：
  • count := 10
• 这两种方式的效果是一样的
• 不仅声明语句更短，而且可以在无法使用var的地方使用

使用var声明变量

var count = 0

for count = 10; count > 0; count-- {
  fmt.Println(count)
}

fmt.Println(count)

使用短声明

for count := 10; count > 0; count-- {
  fmt.Println(count)
}

例子：在if语句里使用短声明来声明变量

if num := rand.Intn(3); num == 0 {
  fmt.Println("Space Adventures")
} else if num == 1 {
  fmt.Println("SpaceX")
} else {
  fmt.Println("Virgin Galactic")
}

例子：在switch语句里使用短声明来声明变量

switch num := rand.Intn(10); num {
  case 0:
  fmt.Println("Space Adventures")
 case 1:
  fmt.Println("SpaceX")
 case 2:
  fmt.Println("Virgin Galactic")
 default:
  fmt.Println("Random spaceline #", num)
}

package作用域

• era 变量是在main函数外声明的
  • 它拥有package作用域
  • 如果main package有多个函数，那么era对它们都可见
• 短声明不可用来声明package作用域的变量

package main

import (
 "fmt"
 "math/rand"
)

var era = "AD"

// main is the function where it all begins.
func main() {
 year := 2018

 switch month := rand.Intn(12) + 1; month {
 case 2:
  day := rand.Intn(28) + 1
  fmt.Println(era, year, month, day)
 case 4, 6, 9, 11:
  day := rand.Intn(30) + 1
  fmt.Println(era, year, month, day)
 default:
  day := rand.Intn(31) + 1
  fmt.Println(era, year, month, day)
 }

}

作业：展示随机日期

package main

import (
 "fmt"
 "math/rand"
)

var era = "AD"

// main is the function where it all begins.
func main() {
 year := 2018
 month := rand.Intn(12) + 1
 daysInMonth := 31

 switch month {
 case 2:
  daysInMonth = 28
 case 4, 6, 9, 11:
  daysInMonth = 30
 }

 day := rand.Intn(daysInMonth) + 1
 fmt.Println(era, year, month, day)

}

• 修改这个程序，让其能处理闰年的情况
  • 生成随机年份，而不是写死2018
  • 二月份：闰年为29天，非闰年为28天
  • 使用for循环生成和展示10个日期

package main

import (
 "fmt"
 "math/rand"
 "time"
)

var era = "AD"

// main is the function where it all begins.
func main() {
 rand.Seed(time.Now().UnixNano())    // 修改随机数种子
 year := rand.Intn(2025-1900) + 1900 // 生成1900年到2025年的随机年份
 month := rand.Intn(12) + 1
 daysInMonth := 31
 if year%4 == 0 {
  switch month {
  case 2:
   daysInMonth = 29
  case 4, 6, 9, 11:
   daysInMonth = 30
  }

 } else {
  switch month {
  case 2:
   daysInMonth = 29
  case 4, 6, 9, 11:
   daysInMonth = 30
  }
 }
 for i := 0; i < 10; i++ {
  day := rand.Intn(daysInMonth) + 1
  fmt.Println(era, year, month, day)
 }
}

优化代码：

package main

import (
 "fmt"
 "math/rand"
 "time"
)

const (
 era = "AD"
 startYear = 1900
 endYear = 2025
)

func main() {
 rand.Seed(time.Now().UnixNano())
 for i := 0; i < 10; i++ {
  year := rand.Intn(endYear - startYear) + startYear
  month := rand.Intn(12) + 1
  daysInMonth := daysInMonth(year, month)
  day := rand.Intn(daysInMonth) + 1
  fmt.Println(era, year, month, day)
 }
}

func daysInMonth(year, month int) int {
 switch month {
 case 2:
  if isLeapYear(year) {
   return 29
  } else {
   return 28
  }
 case 4, 6, 9, 11:
  return 30
 default:
  return 31
 }
}

func isLeapYear(year int) bool {
 if year%4 != 0 {
  return false
 } else if year%100 != 0 {
  return true
 } else if year%400 != 0 {
  return false
 } else {
  return true
 }
}

五、第一阶段测试题

测试题要求

• 假设我们要去火星，但是有多条航线，每条航线的时间、票的类型（单程、往返）、价格都不同：
  • 使用变量、常量、switch、if、for、fmt、math/rand等编写这个程序。
  • 一共四列
  • Spaceline就是航空公司：
    • Space Adventures, SpaceX, or Virgin Galactic
  • Days是指到火星单程所需的天数
    • 使用2020年7月28日作为出发日期。距离火星的距离为62,100,000公里。速度随机生成16-30 km/s
  • Trip Type就是指单程还是往返
  • Price的单位是百万美元
    • 票价随机生成：3600万-5000万之间（单程）

六、实数

声明浮点型变量

• 下面这三个语句的效果是一样的：
  • days := 365.2425
  • var days = 365.2425
  • var days float64 = 365.2425
• 只要数字含有小数部分，那么它的类型就是float64

声明浮点型变量

• 如果你使用一个整数来初始化某个变量，那么你必须指定它的类型为float64，否则它就是一个整数类型：
  • var answer float64 = 42

测试

• answer是什么类型？
  • answer := 42.0

单精度浮点数类型

• Go语言里有两种浮点数类型：
• 默认是float64
  • 64位的浮点类型
  • 占用8字节内存
  • 某些编程语言把这种类型叫做double（双精度）
• float32
  • 占用4字节内存
  • 精度比float64低
  • 有时叫做单精度类型

单精度浮点类型

• 想要使用单精度类型，你必须在声明变量的时候指定该类型

var pi64 = math.Pi
var pi32 float32 = math.Pi
fmt.Println("pi64: ", pi64)
fmt.Println("pi32: ", pi32)

单双精度的使用场景

• 当处理大量数据时，例如3D游戏中的数千个顶点，使用float32牺牲精度来节省内存是很有意义的。
• math包里面的函数操作的都是float64类型，所以应该首选使用float64，除非你有足够的理由不去使用它。

零值

• Go里面每个类型都有一个默认值，它称作零值。
• 当你声明变量却不对它进行初始化的时候，它的值就是零值。

var price float64
fmt.Println("price: ", price)

price1 := 0.0
fmt.Println("price: ", price1)

显示浮点类型

• 使用Print或Println打印浮点类型的时候，默认的行为是尽可能的多显示几位小数
• 如果你不想这样，那么你应该使用Printf函数，结合%f格式化动词来指定显示小数的位数：

third := 1.0 / 3
fmt.Println(third)
fmt.Printf("%v\n", third)
fmt.Printf("%f\n", third)
fmt.Printf("%.3f\n", third)
fmt.Printf("%4.2f\n", third)

运行

Code/go/hello via 🐹 v1.20.3 
➜ go run main.go 
0.3333333333333333
0.3333333333333333
0.333333
0.333
0.33

Code/go/hello via 🐹 v1.20.3 
➜ 

%f 格式化动词

• 它由两部分组成：
• 宽度：会显示出的最少字符个数（包含小数点和小数）
  • 如果宽度大于数字的个数，那么左边会填充空格
  • 如果没指定宽度，那么就按实际的位数进行显示
• 精度：小数点后边显示的位数
• 如果想使用0代替空格作为填充：
  • fmt.Printf("%05.2f\n", third)

浮点类型的精度

third := 1.0 / 3.0
fmt.Println(third + third + third)

piggyBank := 0.1
piggyBank += 0.2
fmt.Println(piggyBank)

可以看到，浮点类型不适合用于金融类计算为了尽量最小化舍入错误，建议先做乘法，再做除法

• 可以看到，浮点类型不适合用于金融类计算
• 为了尽量最小化舍入错误，建议先做乘法，再做除法

celsius := 21.0
fmt.Print((celsius/5.0*9.0)+32, "° F\n")
fmt.Print((9.0/5.0*celsius)+32, "° F\n")

celsius := 21.0
fahrenheit := (celsius * 9.0 / 5.0) + 32.0
fmt.Print(fahrenheit, "° F")

问题

• 如何避免上述的舍入错误？

如何比较浮点类型

piggyBank := 0.1
piggyBank += 0.2
fmt.Println(piggyBank == 0.3)

fmt.Println(math.Abs(piggyBank-0.3) < 0.0001)

作业题

• 编写一个程序：
  • 随机地将五分镍币（0.05美元）、一角硬币（0.10美元）和25美分硬币（0.25美元）放入一个空的储蓄罐，直到里面至少有20美元。
  • 每次存款后显示存钱罐的余额
  • 并以适当的宽度和精度格式化。

七、整数类型

Go语言里的整数类型

• Go提供了10种整数类型：
  • 不可以存小数部分
  • 范围有限
  • 通常根据数值范围来选取整数类型
• 5种整数类型是有符号的
  • 能表示正数、0、负数
• 5种整数类型是无符号的
  • 能表示正数、0

例子

• 最常用的整数类型是int：var year int = 2018
• 无符号整数类型是uint：var month uint = 2

例子 – 使用类型推断

• 下面三个语句是等价的：

year := 2018
var year = 2018
var year int = 2018

8种整数类型

• 整数类型，包括有符号和无符号的，实际上一共是8种类型:
  • 他们的取值范围各不相同。
  • 与架构无关
  • int8 uint8 int16 uint16 int32 uint32 int64 uint64

int和uint

• 而int和uint是针对目标设备优化的类型：

  • 在树莓派2、比较老的移动设备上，int和uint都是32位的。
  • 在比较新的计算机上，int和uint都是64位的。

• Tip：

  • 如果你在较老的32位设备上，使用了超过20亿的整数，并且代码还能运行，那么最好使用int64和uint64来代替int和uint

• 虽然在某些设备上int可以看作是int32，在某些设备上int可以看作是int64，但它们其实是3种不同的类型。

• int并不是其它类型的别名

小测试

• 哪些整数类型能够包含 –20151021？

打印数据类型

• 在Printf里使用%T就可以打印出数据的类型。

package main

import (
 "fmt"
)

// main is the function where it all begins.
func main() {
 year := 2018
 fmt.Printf("Type %T for %v\n", year, year)

 a := "text"
 fmt.Printf("Type %T for %[1]v\n", a)

 b := 42
 fmt.Printf("Type %T for %[1]v\n", b)

 c := 3.14
 fmt.Printf("Type %T for %[1]v\n", c)

 d := true
 fmt.Printf("Type %T for %[1]v\n", d)
}

运行

Code/go/hello via 🐹 v1.20.3 
➜ go run main.go 
Type int for 2018
Type string for text
Type int for 42
Type float64 for 3.14
Type bool for true

Code/go/hello via 🐹 v1.20.3 
➜ 

uint8

• uint8可以用来表示8位的颜色（红绿蓝：0-255）。
  • var red, green, blue uint8 = 0, 141, 213
• 为什么不使用int？
  • uint8的取值范围正好合适，而int则多出来几十亿不合理的数。
  • 如果很多颜色数据连续存储，例如未被压缩的图片，那么使用uint8可以节省很多内存。

十六进制表示法

• Go语言里，在数前面加上0x前缀，就可以用十六进制的形式来表示数值。

var red, green, blue uint8 = 0, 141, 213
var red, green, blue uint8 == 0x00, 0x8d, 0xd5

打印十六进制

• 打印十六进制的数，使用%x格式化动词

fmt.Printf("%x %x %x", red, green, blue)

• 也可以指定最小宽度和填充：

var red, green, blue uint8 = 0, 141, 213
fmt.Printf("clolr: #%02x%02x%02x;", red, green, blue)

问题

• 存储一个uint8的变量需要多大内存？

整数环绕

• 所有的整数类型都有一个取值范围，超出这个范围，就会发生“环绕”

var red uint8 = 255
red++
fmt.Println(red)  // 0

var number int8 = 127
number++
fmt.Println(number)  // -128

打印每个bit

• 使用%b格式化动词

var green uint8 = 3
fmt.Printf("%08b\n", green)  // 00000011
green++
fmt.Printf("%08b\n", green)  // 00000100

为什么会发生整数环绕？

整数类型的最大、最小值

• math包里，为与架构无关的整数类型，定义了最大、最小值常量：
  • math.MaxInt16
  • math.MinInt64
• 而int和uint，可能是32或64位的。

如何避免时间发生环绕

• Unix系统里，时间是以1970年1月1日至今的秒数来表示的。
• 但是在2038年，这个数就会超过20多亿，也就是超过了int32的范围。
• 应使用：int64或uint64

package main

import (
 "fmt"
 "time"
)

// main is the function where it all begins.
func main() {
 future := time.Unix(12622780800, 0)
 fmt.Println(future)
}

作业题

• 编写一个新的存钱罐程序，它使用整数来跟踪美分而不是美元的数量。：
  • 随机将五分镍币（5美分）、一角硬币（10美分）和25美分硬币（25美分）放入一个空的储蓄罐，直到里面至少有20美元。
  • 以美元显示每次存款后存钱罐的余额（例如$1.05）。

八、比较大的数

数太大了怎办？

• 浮点类型可以存储非常大的数值，但是精度不高
• 整型很精确，但是取值范围有限。
• 如果你需要很大的数，而且要求很精确，那么怎么办
  • int64可以容纳很大的数，如果还不行，那么：
  • uint64可以容纳更大的正数，如果还不行，那么：
  • 也可以凑合用浮点类型，但是还有另外一种方法：
• 使用big包。

例子一

package main

import "fmt"

func main() {
 const lightSpeed = 299792 // km/s
 const secondsPerDay = 86400

 var distance int64 = 41.3e12
 fmt.Println("Alpha Centauri is", distance, "km away.")

 days := distance / lightSpeed / secondsPerDay
 fmt.Println("That is", days, "days of travel at light speed.")
}

例子二

package main

import "fmt"

func main() {
  var distance uint64 = 24e18 // 报错 cannot use 24e18 (untyped float constant 2.4e+19) as uint64 value in variable declaration (truncated)
  
  var distance float64 = 24e18
  fmt.Println(distance)
}

提示

• 如果没有为指数形式的数值指定类型的话，那么Go将会将它视作float64类型

big包

• 对于较大的整数（超过1018）：big.Int
• 对于任意精度的浮点类型，big.Float
• 对于分数，big.Rat

big.Int

例子一

package main

import (
 "fmt"
 "math/big"
)

func main() {
 lightSpeed := big.NewInt(299792)
 secondsPerDay := big.NewInt(86400)
 fmt.Println("lightSpeed is", lightSpeed, "seconds per day", secondsPerDay)
}

例子二

package main

import (
 "fmt"
 "math/big"
)

func main() {
 distance := new(big.Int)
 distance.SetString("2400000000000000000000000", 10)
 fmt.Println("distance.", distance)
}

例子三

package main

import (
 "fmt"
 "math/big"
)

func main() {
 lightSpeed := big.NewInt(299792)
 secondsPerDay := big.NewInt(86400)

 distance := new(big.Int)
 distance.SetString("240000000000000000000", 10)
 fmt.Println("Andromeda Galaxy is", distance, "km away.")

 seconds := new(big.Int)
 seconds.Div(distance, lightSpeed) // 除法

 days := new(big.Int)
 days.Div(seconds, secondsPerDay)

 fmt.Println("That is", days, "days of travel at light speed.")
}

• 一旦使用了big.Int，那么等式里其它的部分也必须使用big.Int
• NewInt()函数可以把int64转化为big.Int类型
• 如何把24 x 10的18次方转化为big.Int类型？
  • 首先new一个big.Int
  • 再通过SetString函数把数值的字符串形式，和几进制传递进行即可。
• 缺点：用起来繁琐，且速度慢

测试题

• 用两种方式把86400转化为big.Int类型。

较大数值的常量

• 在Go里面，可以为常量指明类型（这句话会报错）：const distance uint64 = 24000000000000000
• 也可以不指明常量的类型。。。
• 对于变量，Go会使用类型推断；
• 而在Go里面，常量是可以无类型的（untyped），这句话就不会报错：
  • const distance = 24000000000000000

较大数值的常量

• 常量使用const关键字来声明，程序里的每个字面值都是常量。
• 这意味着：比较大的数值可以直接使用（作为字面值）
• 针对字面值和常量的计算是在编译阶段完成的。
• Go的编译器是用Go编写的，这种无类型的数值字面值就是由big包所支持的。这使你可以操作很大的数（超过18的10¹⁸）
• 只要能够容纳得下，那么常量就可以赋值给变量。

package main

import "fmt"

func main() {
  fmt.Println("Andromeda Galaxy is", 2400000000000000/299792/86400, "light days away.")
}

较大数值的常量

• 尽管Go编译器使用big包来处理无类型的数值常量，但是常量和big.Int的值是不能互换的。

小测试

• 常量和字面值的计算是在哪个阶段发生的？
• 函数可以使用无类型的常量作为函数的实际传入的参数吗？

作业题

• 大矮星是已知的距离地球最近的星系，距离我们的太阳236000000000000000公里（尽管有人质疑它是一个星系）。使用常量将此距离转换为光年。

九、多语言文本

声明字符串

• 声明字符串：

peace := "peace"
var peace = "peace"
var peace string = "peace"

• 字符串的零值：var blank string

字符串字面值/原始字符串字面值

• 字符串字面值可以包含转义字符，例如\n
• 但如果你确实想得到\n而不是换行的话，可以使用`来代替“，这叫做原始字符串字面值。

fmt.Println("peace be upon you\nupon you be peace")
fmt.Println(`strings can span multiple lines with the \n escape sequence`)

fmt.Println(`
peace be upon you
upon you be peace`)

小测试

• 如果你想输出C:\go，那么应该使用字符串字面值还是原始字符串字面值。
• 字符串字面值：string literal
• 原始字符串字面值：raw string literal

字符，code points，runes，bytes

• Unicode联盟为超过100万个字符分配了相应的数值，这个数叫做code point。
  • 例如：65代表A，128515 代表 一个表情字符
• 为了表示这样的unicode code point，Go语言提供了rune这个类型，它是int32的一个类型别名。
• 而byte是uint8类型的别名，目的是用于二进制数据。
  • byte倒是可以表示由ASCII定义的英语字符，它是Unicode的一个子集（共128个字符）

类型别名

• 类型别名就是同一个类型的另一个名字。
  • 所以，rune和int32可以互换使用。
• 也可以自定义类型别名，语法如下：

type byte = uint8
type rune = int32

打印

• 如果想打印字符而不是数值，使用%c格式化动词
• 任何整数类型都可以使用%c打印，但是rune意味着该数值表示了一个字符

package main

import (
 "fmt"
)

func main() {
 fmt.Println("peace be upon you\nupon you be peace")
 fmt.Println(`strings can span multiple lines with the \n escape sequence`)

 fmt.Println(`
 peace be upon you
 upon you be peace`)

 var pi rune = 960
 var alpha rune = 940
 var omega rune = 969
 var bang byte = 33

 fmt.Printf("%v %v %v %v\n", pi, alpha, omega, bang)
 // 将会打印出 code point 的值

 fmt.Printf("%c%c%c%c\n", pi, alpha, omega, bang)
 // 将会打印出 字符
}

运行

Code/go/started via 🐹 v1.20.3 via 🅒 base 
➜ go run main.go
peace be upon you
upon you be peace
strings can span multiple lines with the \n escape sequence

        peace be upon you
        upon you be peace
960 940 969 33
πάω!

Code/go/started via 🐹 v1.20.3 via 🅒 base 
➜ 

字符

• 字符字面值使用‘’括起来。例如：’A’
• 如果没指定字符类型的话，那么Go会推断它的类型为rune
• 这里的grade仍然包含一个数值，本例中就是65，它是A的code point。
• 字符字面值也可以用byte类型：var star byte = '*'

var grade rune
grade := 'A'
var grade1 = 'A'
var grade2 rune = 'A'

小测试

• ASCII编码里包含多少个字符？
• byte和rune分别是哪个类型的别名？
• *，é，的code point分别是多少？

string

• 可一个给某个变量赋予不同的string值，但是string本身是不可变的

peace := "shalom"
peace = "salam"

例子二

package main

import (
 "fmt"
)

func main() {
 message := "shalom"
 c := message[5]
 fmt.Printf("%c\n", c) // m

 message[5] = 'd' // 报错 cannot assign to message[5]
}

小测试

• 写个程序，打印出shalom的每个字符，每个字符独占一行。

Caesar cipher凯撒加密法

• 对于加密信息，一种简单有效的办法就是把每个字母都移动固定长度的位置。
  • 例如：a -> d，b -> e

package main

import (
 "fmt"
)

func main() {
 c := 'a'
 c = c + 3
 fmt.Printf("%c\n", c)

 if c > 'z' {
  c = c - 26
 }
 fmt.Printf("%c\n", c)
}

小测试

• 这个语句的作用是什么？c = c - ‘a’ + ‘A’
• 如果 c 是 ‘g’，那么c最后的结果是什么？

ROT13

• ROT13（旋转13）是凯撒密码在20世纪的变体。
  • 它会把字母替换成+13后的对应的字母。

Go的内置函数

• len是 Go 语言的一个内置函数。

message := "uv vagreangvbany fcnpr fgngvba"
fmt.Println(len(message))

• 本例中len返回message所占的byte数。
• Go有很多内置函数，它们不需要import

UTF-8

• Go中的字符串是用UTF-8编码的，UTF-8是Unicode CodePoint的几种编码之一。
• UTF-8是一种有效率的可变长度的编码，每个code point可以是8位、16位或32位的。
• 通过使用可变长度编码，UTF-8使得从ASCII的转换变得简单明了，因为ASCII字符与其UTF-8编码的对应字符是相同的。
• UTF-8是万维网的主要字符编码。它是由Ken Thompson于1992年发明的，他是Go语言的设计者之一。

ROT13

package main

import (
 "fmt"
)

func main() {
 message := "uv vagreangvbany fcnpr fgngvba"

 for i := 0; i < len(message); i++ {
  c := message[i]
  if c >= 'a' && c <= 'z' {
   c = c + 13
   if c > 'z' {
    c = c - 26
   }
  }
  fmt.Printf("%c", c)
 }
}

• 本例中，程序访问的是message这个字符串的每个字节（8位），没有考虑多字节的情况（16、32位）。
• 如何支持西班牙语、俄语、汉语等？
  • 把字符解码成rune类型，然后再进行操作。
• 使用utf-8包，它提供可以按rune计算字符串长度的方法。
• DecodeRuneInString 函数会返回第一个字符，以及字符所占的字节数。
• 所以Go里的函数可以返回多个值。

package main

import (
 "fmt"
 "unicode/utf8"
)

func main() {
 question := "español?"
 fmt.Println(len(question), "bytes")
 fmt.Println(utf8.RuneCountInString(question))

 c, size := utf8.DecodeRuneInString(question)
 fmt.Printf("First rune: %c %v bytes\n", c, size)
}

range

• 使用range关键字，可以遍历各种集合。

package main

import (
 "fmt"
)

func main() {
 question := "español ?"

 for i, c := range question {
  fmt.Printf("%v %c\n", i, c)
 }
  
  for _, c := range question {
  fmt.Printf("%c\n", c)
 }
}

作业题

1. L fdph, L vdz, L frqtxhuhg，每个字母向前移动3个位置，能得到什么字符串？

2. 把西班牙语 “Hola Estación Espacial Internacional”用ROT13进行加密

   1. 使用range关键字
   2. 带重音符号的字母要保留

十、类型间转换

类型不能混着用

• 连接两个字符串，使用+运算符：
  • countdown := "Launch in T minus " + "10 seconds."
• 如果想连接字符串和数值，是会报错的：
  • countdown := "Launch in T minus " + 10 + " seconds." 报错
• 整型和浮点类型也不能混着用：

age := 41
marsDays := 687
earthDays := 365.2425
fmt.Println("I am", age*earthDays/marsDays, "years old on Mars.")  // 报错

小测试

• Go语言里，“10” – 1这个表达式会报错吗？

数值类型间的转换

• 下例中，如果想把age转化成 浮点类型，需要使用目标类型将其“包裹”起来：

age := 41
marsAge := float64(age)

从浮点类型转为整数类型

• 可以从浮点类型转化为整数类型，小数点后边的部分会被截断，而不是舍入：

earthDays := 365.2425
fmt.Println(int(earthDays))

• 无符号和有符号整数类型之间也需要转换
• 不同大小的整数类型之间也需要转换

类型转换时需要谨慎

1996年，无人驾驶的阿丽亚娜5号火箭偏离飞行路线，解体，发射后仅40秒爆炸。报告的原因是从float64到int16的类型转换错误，其值超过了int16所能容纳的最大值32767。未处理的故障导致飞行控制系统没有方位数据，导致其偏离航向，解体，最终自毁。

类型转换时需谨慎

• “环绕行为”：

var bh float64 = 32768
var h = int16(bh)
fmt.Println(h) // -32768

• 可以通过math包提供的max、min常量，来判断是否超过最大最小值

var bh float64 = 32768

if bh < math.MinInt16 || bh > math.MaxInt16 {
  // handle out of range value
}

小测试

• 下列代码输出是什么？

v := 42
if v >= 0 && v <= math.MaxUint8 {
  v8 := uint8(v)
  fmt.Println("converted:", v8)
}

字符串转换

• 想把rune、byte转化为string，语法是一样的：‘

var pi rune = 960
var alpha rune = 940
var omega rune = 969
var bang byte = 33

fmt.Println(string(pi), string(alpha), string(omega), string(bang))

字符串转换

• 想把数值转化为string，它的值必须能转化为code point。
• strconv包的Itoa函数就可以做这件事:
• Itoa是Integer to ASCII的意思。
• Unicode是ASCII的超集，它们前128个code points是一样的（数字、英文字母、常用标点）。

countdown := 10

str := "Launch in T minus " + strconv.Itoa(countdown) + " seconds."
fmt.Println(str)

• 另外一种把数值转化为string的方式是使用Sprintf函数，和Printf略类似，但是会返回一个string：

countdown := 9
str := fmt.Sprintf("Launch in T minus %v seconds.", countdown)
fmt.Println(str)

• strconv包里面还有个Atoi（ASCII to Integer）函数。

• 由于字符串里面可能包含任意字符，或者要转换的数字字符串太大，所以Atoi函数可能会发生错误：

  • 如果err的值为nil，那么就代表没发生错误。

countdown, err := strconv.Atoi("10")
if err != nil {
  // oh no, something went wrong
  fmt.Println(err.Error())
}
fmt.Println(countdown)

小测试

• 说出两个函数，它们可以把整数类型转化为string

提示

• Go是静态类型语言，一旦某个变量被声明，那么它的类型就无法再改变了。

布尔类型的转换

• Print家族的函数，会把bool类型的值打印成true/false的文本

launch := false

launchText := fmt.Sprintf("%v", launch)
fmt.Println("Ready for launch:", launchText)

var yesNo string
if launch {
  yesNo = "yes"
} else {
  yesNo = "no"
}
fmt.Println("Ready for launch:", yesNo)

• 注意：如果你想使用string(false), int(false)；bool(1), bool(“yes”)等类似的方式进行转换，那么Go编译器会报错
• 某些语言里，经常把1和0当作true和false，但是在Go里面不行。

小测试

• 写一个程序，把布尔类型转化为整数类型，true -> 1，false -> 0

作业题

• 写一个程序，把字符串转化为布尔类型：
  • “true”, “yes”, “1”是true
  • “false”, “no”, “0”是false
  • 针对其它值，显示错误信息

十一、第二部分测试题

Vigenère cipher维吉尼亚加密算法

• 维吉尼亚加密算法是凯撒加密算法的变种。

• 凯撒算法：

  • 之前讲的凯撒算法例子是把字符串中的每个字母都向后移动了3位。
  • 假设A=0，B=1 … Z=25。那么，我们就用D=3来表示向后移动3位。

• 维吉尼亚加密算法使用的是密钥（keyword）

• 假设密钥是：GOLANG

第1题

• 编写一个程序来解密下面第一行的文字：
  • 它的密钥就是GOLANG
  • 所有字母都是大写的英文字母。

第2题

• 编写一个程序：
  • 使用维吉尼亚加密算法来加密信息。
  • 密钥为GOLANG
• 可能用到的函数：
  • strings.Replace
  • strings.ToUpper

十二、函数

为什么需要函数

• 做一件事通常需要很多步骤，每个步骤可以分解为独立的函数，这些函数以后可能会复用到。

函数声明

• Go在标准库文档中列出了标准库每个包中声明的函数。

• 例如：

  • rand包的Intn：func Intn(n int) int
  • 它的用法：num := rand.Intn(10)

• 使用func关键字声明函数

• 在Go里，大写字母开头的函数、变量或其它标识符都会被导出，对其它包可用。

• 小写字母开头的就不行。

• 形式参数：parameter

• 实际参数：argument

函数声明 – 多个参数

• 函数的参数可以是多个：

  • func Unix(sec int64, nsec int64) Time
  • 调用：future := time.Unix(12622780800, 0)

• 函数声明时，如果多个形参类型相同，那么该类型只写一次即可：

  • func Unix(sec int64, nsec int64) Time
  • func Unix(sec, nsec int64) Time

• 这种简化是可选的。

函数声明 – 返回多个值

• Go的函数可以返回多个值：
  • countdown, err := strconv.Atoi(“10”)
• 该函数的声明如下：
  • func Atoi(s string) (i int, err error)
• 函数的多个返回值需要用括号括起来，每个返回值名字在前，类型在后。声明函数时可以把名字去掉，只保留类型：
  • func Atoi(s string) (int, error)

函数声明 – 可变参数函数

• Println是一个特殊的函数，它可以接收一个、二个甚至多个参数，参数类型还可以不同：
  • fmt.Println(“Hello, playground”)
  • fmt.Println(186, “seconds”)
• Println的声明是这样的：
  • func Println(a …interface{}) (n int, err error)
  • … 表示函数的参数的数量是可变的。
  • 参数a的类型为interface{}，是一个空接口。
• … 和空接口组合到一起就可以接受任意数量、类型的参数了

小测试

1. 调用函数时使用的是实参还是形参？
2. 诸如Contains和contains这两个函数会有什么区别？
3. 函数声明中的 … 表示什么意思？

编写函数

• 例子

package main

import "fmt"

// kelvinToCelsius converts °K to °C
func kelvinToCelsius(k float64) float64 {
 k -= 273.15
 return k
}

func main() {
 kelvin := 294.0
 celsius := kelvinToCelsius(kelvin)
 fmt.Print(kelvin, "° K is ", celsius, "° C")
}

• 函数按值传递参数
• 同一个包中声明的函数在调用彼此时不需要加上包名。

小测试

• 将代码拆分为函数有什么好处？

作业题

package main

import "fmt"

// kelvinToCelsius converts °K to °C
func kelvinToCelsius(k float64) float64 {
 k -= 273.15
 return k
}

func main() {
 kelvin := 294.0
 celsius := kelvinToCelsius(kelvin)
 fmt.Print(kelvin, "° K is ", celsius, "° C")
}

• 修改这段代码：
  • 复用kelvinToCelsius函数，将233K转化为 ℃。
  • 编写celsiusToFahrenheit函数，它可将摄氏度转化为华氏度。
  • 公式为(c x 9.0/5.0) + 32.0
  • 编写kelvinToFahrenheit函数，看看它能否将0K转化为约-459.67℉

十三、方法

声明新类型

• 关键字type可以用来声明新类型：
  • type celsius float64
  • var temperature celsius = 20
• 虽然Celsius是一种全新的类型，但是由于它和float64具有相同的行为和表示，所以赋值操作能顺利执行。
• 例如加法等运算，也可以像float64那样使用。
• （例子）

package main

import "fmt"


func main() {
 type celsius float64

 const degrees = 20
 var temperature celsius = degrees

 temperature += 10

 fmt.Println("temperature: ", temperature)
}

• 为什么要声明新类型：极大的提高代码可读性和可靠性
• 不同的类型是无法混用的
• （例子）

type celsius float64

const degrees = 20
var temperature celsius = degrees

temperature += 10

var warmUp float64 = 10
temperature += warmUp // 报错

通过方法添加行为

• 在C#、Java里，方法属于类
• 在Go里，它提供了方法，但是没提供类和对象
• Go比其他语言的方法要灵活
• 可以将方法与同包中声明的任何类型相关联，但不可以是int、float64等预声明的类型进行关联。

type celsius float64
type kelvin float64

func kelvinToCelsius(k kelvin) celsius {
  return celsius(k - 273.15)
}

func (k kelvin) celsius() celsius { // celsius 是 kelvin 类型的方法
  return celsius(k - 273.15)
}

• 上例中，celsius方法虽然没有参数。但它前面却有一个类型参数的接收者。
• 每个方法可以有多个参数，但只能有一个接收者。
• 在方法体中，接收者的行为和其它参数一样。

方法调用

• 变量.方法()

package main

import "fmt"

func main() {
 var k kelvin = 294.0
  var c celsius
  
  c = kelvinToCelsius(k)
  c = k.celsius()

 fmt.Println("c: ", c)
}

type celsius float64
type kelvin float64

func kelvinToCelsius(k kelvin) celsius {
  return celsius(k - 273.15)
}

func (k kelvin) celsius() celsius { // celsius 是 kelvin 类型的方法
  return celsius(k - 273.15)
}

小测试

• 标识出这个方法声明中的接收者：func (f fahrenheit) celsius() celsius

作业题

• 编写一个程序：
  • 它包含三种类型：celsius、fahrenheit、kelvin
  • 3种温度类型之间转换的方法

十四、一等函数

一等函数

• 在Go里，函数是头等的，它可以用在整数、字符串或其它类型能用的地方:
  • 将函数赋给变量
  • 将函数作为参数传递给函数
  • 将函数作为函数的返回类型

将函数赋给变量

package main

import (
  "fmt"
  "math/rand"
)

type kelvin float64

func fakeSensor() kelvin {
  return kelvin(rand.Intn(151) + 150)
}

func realSensor() kelvin {
  return 0
}

func main() {
  sensor := fakeSensor
  fmt.Println(sensor())
  
  sensor = realSensor
  fmt.Println(sensor())
}

• 变量sensor就是一个函数，而不是函数执行的结果
• 无论sensor的值是fakeSensor还是realSensor，都可以通过sensor()来调用
• sensor这个变量的类型是函数，该函数没有参数，返回一个kelvin类型的值。
• 换一种声明形式的话：
  • var sensor func() kelvin

小测试

1. 如何区分“将函数本身赋给变量”和“将函数执行的结果赋给变量”这两种行为？
2. 如果存在一个返回celsius温度的groundSensor函数，我们可以把它赋给上例中的sensor变量吗？

将函数传递给其它函数

• （例子）

package main

import (
 "fmt"
  "math/rand"
  "time"
)

type kelvin float64

func measureTemperature(samples int, sensor func() kelvin) {
  for i := 0; i < samples; i++ {
    k := sensor()
    fmt.Printf("%v° K\n", k)
    time.Sleep(time.Second)
  }
}

func fakeSensor() kelvin {
  return kelvin(rand.Intn(151) + 150)
}

func main() {
  measureTemperature(3, fakeSensor)
}

小测试

• 拥有向其它函数传递函数的能力有什么好处？

声明函数类型

• 为函数声明类型有助于精简和明确调用者的代码。
  • 例如：type sensor func() kelvin
  • 所以：func measureTemperature(samples int, s func() kelvin)
  • 可以精简为：func measureTemperature(samples int, s sensor)

小测试

• 请使用函数类型重写一下函数的签名：
• func drawTable(rows int, getRow func(row int) (string, string))

闭包和匿名函数

• 匿名函数就是没有名字的函数，在Go里也称作函数字面值。
• 因为函数字面值需要保留外部作用域的变量引用，所以函数字面值都是闭包的。
• （例子）

例子一：

package main

import "fmt"

var f = func() {
  fmt.Println("Dress up for the masquerade.")
}

func main() {
  f()
}

例子二

package main

import "fmt"

func main() {
  f := func(message string) {
    fmt.Println(message)
  }
  f("Go to the party.")
}

例子三

package main

import "fmt"

func main() {
  func() {
    fmt.Println("Functions anonymous")
  }()
}

例子四

package main

import "fmt"

type kelvin float64

// sensor function type
type sensor func() kelvin

func realSensor() kelvin {
  return 0
}

func calibrate(s sensor, offset kelvin) sensor {
  return func() kelvin {
    return s() + offset
  }
}

func main() {
  sensor := calibrate(realSensor, 5)
  fmt.Println(sensor())
}

• 闭包（closure）就是由于匿名函数封闭并包围作用域中的变量而得名的。

例子五

package main

import "fmt"

type kelvin float64

func main() {
  var k kelvin = 294.0
  
  sensor := func() kelvin {
    return k
  }
  
  fmt.Println(sensor())
  
  k++
  fmt.Println(sensor())
}

小测试

1. 匿名函数在Go中的另一个名字是什么？
2. 闭包提供了哪些普通函数不具备的特性？

作业题

package main

import "fmt"

type kelvin float64

// sensor function type
type sensor func() kelvin

func realSensor() kelvin {
  return 0
}

func calibrate(s sensor, offset kelvin) sensor {
  return func() kelvin {
    return s() + offset
  }
}

func main() {
  sensor := calibrate(realSensor, 5)
  fmt.Println(sensor())
}

• 修改这段程序：

1. 声明一个变量，并将其用作calibrate函数的offset实参，而不是使用字面值数字5。在此之后，即使修改变量，调用sensor()的结果也仍然为5。这是因为offset形参接受的是实参的副本而不是引用，也就是所谓的按值传递。
2. 使用calibrate函数和今天讲的fakeSensor函数以创建新的sensor函数，然后多次调用这个新的sensor函数，看看它是否每次都会调用fakeSensor函数并产生随机的读数。

十五、第三部分习题

温度表

• 编写一个温度转换表格程序：

1. 画两个表格：
   1. 第一个表格有两列，第一列是摄氏度，第二列是华氏度。
      1. 从-40℃打印到100℃，间隔为5℃，并将摄氏度转化为华氏度。
   2. 第二个表格就是第一个表格的两列互换一下，从华氏度转化为摄氏度。
2. 负责画线和填充值的代码都应该是可复用的。画表格和计算温度应该用不同的函数分别来实现。
3. 实现一个drawTable函数，它接受一个一等函数作为参数，调用该函数就可以绘制每一行的温度。传入不同的函数就可以产生不同的输出数据。

十六、数组

数组

• 数组是一种固定长度且有序的元素集合。

var planets [8]string

访问数组元素

• 数组中的每个元素都可以通过[ ]和一个从0开始的索引进行访问。

package main

import "fmt"

func main() {
 var planets [8]string

 planets[0] = "Mercury"
 planets[1] = "Venus"
 planets[2] = "Earth"

 earth := planets[2]
 fmt.Println(earth)
}

• 数组的长度可由内置函数len来确定。

package main

import "fmt"

func main() {
 var planets [8]string

 planets[0] = "Mercury"
 planets[1] = "Venus"
 planets[2] = "Earth"

 earth := planets[2]
 fmt.Println(earth)
  
  fmt.Println(len(planets))
  fmt.Println(planets[3] == "")
}

• 在声明数组时，未被赋值元素的值是对应类型的零值。

小测试

1. 如何才能访问planets数组的第一个元素？
2. 对新创建的整数数组来说，其元素的默认值是什么？

数组越界

• Go编译器在检测到对越界元素的访问时会报错

package main

func main() {
  var plantes [8]string
  
  planets[8] = "Pluto" // 报错
  pluto := planets[8] // 报错
}

• 如果Go编译器在编译时未能发现越界错误，那么程序在运行时会出现panic
• Panic会导致程序崩溃

package main

import "fmt"

func main() {
  var planets [8]string
  
  i := 8
  planets[i] = "Pluto"
  pluto := planets[i]
  
  fmt.Println(pluto)
}

小测试

• 访问planets[11]会导致编译时错误还是运行时 panic？

使用复合字面值初始化数组

• 复合字面值（composite literal）是一种给复合类型初始化的紧凑语法。
• Go的复合字面值语法允许我们只用一步就完成数组声明和数组初始化两步操作：
  • dwarfs := [5]string{"Ceres", "Pluto", "Haumea", "Makemake", "Eris"}
• 可以在复合字面值里使用 … 作为数组的长度，这样Go编译器会为你算出数组的元素数量

package main

import "fmt"

func main() {
  planets := [...]string{
    "Mercury",
    "Venus",
    "Earth",
    "Mars",
    "Jupiter",
    "Saturn",
    "Uranus",
    "Neptune",
  }
  
  fmt.Println(planets)
}

• 无论哪种方式，数组的长度都是固定的。

遍历数组

• for循环

package main

import "fmt"

func main() {
  dwarfs := [5]string{"Ceres", "Pluto", "Haumea", "Makemake", "Eris"}
  
  for i := 0; i < len(dwarfs); i++ {
    dwarf := dwarfs[i]
    fmt.Println(i, dwarf)
  }
}

• 使用range

package main

import "fmt"

func main() {
  dwarfs := [5]string{"Ceres", "Pluto", "Haumea", "Makemake", "Eris"}
  
  for i, dwarf := range dwarfs {
    fmt.Println(i, dwarf)
  }
}

小测试

1. 使用range关键字遍历数组可避免哪些错误？
2. 什么情况下，使用for循环比range更合适？

数组的复制

• 无论数组赋值给新的变量还是将它传递给函数，都会产生一个完整的数组副本。

package main

import "fmt"

func main() {
  planets := [...]string{
    "Mercury",
    "Venus",
    "Earth",
    "Mars",
    "Jupiter",
    "Saturn",
    "Uranus",
    "Neptune",
  }
  
  planetsMarkII := planets
  
  planets[2] = "whoops"
  
  fmt.Println(planets)
  fmt.Println(planetsMarkII)
}

• 数组也是一种值，函数通过值传递来接受参数。所以数组作为函数的参数就非常低效。

package main

import "fmt"

// terraform accomplishes nothing
func terraform(planets [8]string) {
  for i := range planets {
    planets[i] = "New " + planets[i]
  }
}

func main() {
  planets := [...]string{
    "Mercury",
    "Venus",
    "Earth",
    "Mars",
    "Jupiter",
    "Saturn",
    "Uranus",
    "Neptune",
  }
 
  terraform(planets)
  fmt.Println(planets)
}

• 数组的长度也是数组类型的一部分。
  • 尝试将长度不符的数组作为参数传递，将会报错。
• 函数一般使用 slice 而不是数组作为参数。

数组的数组

package main

import "fmt"

func main() {
  var board [8][8]string
  
  board[0][0] = "r"
  board[0][7] = "r"
  
  for column := range board[1] {
    board[1][column] = "p"
  }
  
  fmt.Print(board)
}

小测试

• 如果我们要设计一个数独游戏程序，那么该如何声明9 x 9的整数网格？

作业题

package main

import "fmt"

func main() {
  var board [8][8]string
  
  board[0][0] = "r"
  board[0][7] = "r"
  
  for column := range board[1] {
    board[1][column] = "p"
  }
  
  fmt.Print(board)
}

1. 扩展上面例子的程序，使用字符kqrbnp表示上方的黑棋，字符KQRBNP表示下方的白棋，然后在棋子的起始位置是打印出所有的棋子。
2. 编写一个能够美观的打印出整个棋盘的函数
3. 使用[8][8]rune数组而不是字符串来表示棋

十七、Slice（切片）

Slice指向数组的窗口

• 假设planets是一个数组，那么planets[0:4] 就是一个切片，它切分出了数组里前4个元素。
• 切分数组不会导致数组被修改，它只是创建了指向数组的一个窗口或视图，这种视图就是slice类型。

切分数组

• Slice使用的是半开区间
  • 例如planets[0:4]，包含索引0、1、2、3对应的元素，不包括索引4对应的元素。

package main

import "fmt"

func main() {
  planets := [...]string{
    "Mercury",
    "Venus",
    "Earth",
    "Mars",
    "Jupiter",
    "Saturn",
    "Uranus",
    "Neptune",
  }
 
  terrestrial := planets[0:4]
  gasGiants := planets[4:6]
  iceGiants := planets[6:8]
  fmt.Println(terrestrizl, gasGiants, iceGiants)
}

小测试

1. 切分数组会产生什么？
2. 使用planets[4:6]切分数组时，结果包含多少个元素？

Slice的默认索引

• 忽略掉slice的起始索引，表示从数组的起始位置进行切分；
• 忽略掉slice的结束索引，相当于使用数组的长度作为结束索引。
• 注意：slice的索引不能是负数。

package main

import "fmt"

func main() {
  planets := [...]string{
    "Mercury",
    "Venus",
    "Earth",
    "Mars",
    "Jupiter",
    "Saturn",
    "Uranus",
    "Neptune",
  }
 
  terrestrial := planets[:4]
  gasGiants := planets[4:6]
  iceGiants := planets[6:]
  
  allPlenets := planets[:]
  fmt.Println(terrestrizl, gasGiants, iceGiants, allPlanets)
}

• 如果同时省略掉起始和结束索引，那就是包含数组所有元素的一个slice。
• 切分数组的语法也可以用于切分字符串

package main

import "fmt"

func main() {
  neptune := "Neptune"
  tune := neptune[3:]
  
  fmt.Println(tune)
  
  neptune = "Poseidon"
  fmt.Println(tune) // 将原来切片的值赋给一个新的值，并不会改变原来切片的值
}

• ​ 切分字符串时，索引代表的是字节数而非 rune 的数。

package main

import "fmt"

func main() {
  question := "¡Qué pasa!"
  fmt.Println(question[:6])
}

Slice的复合字面值

• Go里面很多函数都倾向于使用slice而不是数组作为参数。
• 想要获得与底层数组相同元素的slice，那么可以使用 [:] 进行切分
• 切分数组并不是创建slice唯一的方法，可以直接声明slice：
  • 例如[]string

package main

import "fmt"

func main() {
  dwarfArray := [...]string{"Ceres", "Pluto", "Haumea", "Makemake", "Eris"}
  
  dwarfSlice := dwarfArray[:]
  
  dwarfs := []string{"Ceres", "Pluto", "Haumea", "Makemake", "Eris"}
  
  fmt.Println(dwarfSlice, dwarfs)
}

小测试

• 使用格式化动词%T比较dwarfArray和dwarfs的类型。

切片的威力

package main

import "fmt"

// hyperspace removes the space surrounding worlds
func hyperspace(worlds []string) {
  for i := range worlds {
    worlds[i] = strings.TrimSpace(worlds[i])
  }
}

func main() {
  planets := []string{" Venus ", "Earth ", " Mars"}
  hyperspace(planets)
  
  fmt.Println(strings.Join(planets, ""))
}

小测试

• 访问Go标准库网站，查阅TrimSpace和Join函数的相关文档，说出他们的作用

带有方法的切片

• 在Go里，可以将slice或数组作为底层类型，然后绑定其它方法。

package main

import (
  "fmt"
  "sort"
)

type StringSlice []string

func (p StringSlice) Sort() {
  
}

func main() {
  planets := []string{
    "Mercury", "Venus", "Earth", "Mars",
    "Jupiter", "Saturn", "Uranus", "Neptune",
  }
  
  sort.StringSlice(planets).Sort()
  fmt.Println(planets)
}

小测试

• 执行代码sort.StringSlice(planets)会发生什么？

作业题

• 编写一个程序：
  • 它通过给字符串slice中所有的行星加上“New ”前缀来完成行星的地球化处理，然后使用该程序对Mars、Uranus、Neptune实行地球化
  • 必须使用planets类型，并为之实现相应的terraform方法。

十八、更大的slice

append函数

• append函数也是内置函数，它可以将元素添加到slice里面。

package main

import "fmt"

func main() {
  dwarfs := []string{"Ceres", "Pluto", "Haumea", "Makemake", "Eris"}
  
  dwarfs = append(dwarfs, "Orcus")
  
  dwarfs = append(dwarfs, "Salacia", "Quaoar", "Sedna")
  
  fmt.Println(dwarfs)
}

小测试

• 执行上例的代码后，dwarfs切片总共包含多少个矮行星？用什么函数能够获知这一点？

长度和容量（length & capacity）

• Slice中元素的个数决定了slice的长度。
• 如果slice的底层数组比slice还大，那么就说该slice还有容量可供增长。

package main

import "fmt"

// dump slice length, capacity, and contents
func dump(label string, slice []string) {
  fmt.Printf("%v: length %v, capacity %v %v\n", label, len(slice), cap(slice), slice)
}

func main() {
  dwarfs := []string{"Ceres", "Pluto", "Haumea", "Makemake", "Eris"}
  dump("dwarfs", dwarfs)
  dump("dwarfs[1:2]", dwarfs[1:2])
}

小测试

• 为什么dwarfs[1:2]这个slice的容量是4？

详解append

package main

import "fmt"

// dump slice length, capacity, and contents
func dump(label string, slice []string) {
  fmt.Printf("%v: length %v, capacity %v %v\n", label, len(slice), cap(slice), slice)
}

func main() {
  planets := []string{
    "Mercury", "Venus", "Earth", "Mars",
    "Jupiter", "Saturn", "Uranus", "Neptune",
  }
  terrestrial := planets[0:4:4]
  worlds := append(terrestrial, "Ceres")
  
  dump("planets", planets) // 8 8
  dump("terrestrial", terrestrial) // 4 4
  dump("worlds", worlds) // 5 8
}

小测试

• 对于上面例子中的dwarfs3这个slice，如果我们修改它的一个元素，那么dwarfs2和dwarfs1这两个切片会发生变化吗？dwarfs3[1] = “Pluto!”

三个索引的切分操作

• Go 1.2中引入了能够限制新建切片容量的三索引切分操作。

package main

import "fmt"

// dump slice length, capacity, and contents
func dump(label string, slice []string) {
  fmt.Printf("%v: length %v, capacity %v %v\n", label, len(slice), cap(slice), slice)
}

func main() {
  dwarfs := []string{"Ceres", "Pluto", "Haumea", "Makemake", "Eris"}
  dump("dwarfs", dwarfs)
  dump("dwarfs[1:2]", dwarfs[1:2])
}

小测试

• 什么时候应该使用三索引的切片操作？

使用make函数对slice进行预分配

• 当slice的容量不足以执行append操作时，Go必须创建新数组并复制旧数组中的内容。
• 但通过内置的make函数，可以对slice进行预分配策略。
  • 尽量避免额外的内存分配和数组复制操作。

package main

import "fmt"

// dump slice length, capacity, and contents
func dump(label string, slice []string) {
  fmt.Printf("%v: length %v, capacity %v %v\n", label, len(slice), cap(slice), slice)
}

func main() {
  dwarfs := make([]string, 0, 10)
  dump("dwarfs", dwarfs)
  
  dwarfs = append(dwarfs, "Ceres", "Pluto", "Haumea", "Makemake", "Eris")
  
  dump("dwarfs", dwarfs)
}

小测试

• 使用make函数创建slice有什么好处？

声明可变参数的函数

• 声明Printf、append这样的可变参数函数，需要在函数的最后一个参数前面加上 … 符号。

package main

import "fmt"

func terraform(prefix string, worlds ...string) []string {
  newWorlds := make([]string, len(worlds))
  
  for i := range worlds {
    newWorlds[i] = prefix + " " + worlds[i]
  }
  return newWorlds
}

func main() {
  twoWorlds := terraform("New", "Venus", "Mars")
  fmt.Println(twoWorlds)
  
  planets := []string{"Venus", "Mars", "Jupiter"}
  newPlanets := terraform("New", planets...)
  fmt.Println(newPlanets)
}

小测试

• 关于 … 符号，到目前为止，我们见过的3种用法分别是什么？

作业

• 编写一个程序：
  • 通过循环，持续的将元素追加到slice里
  • 在slice容量发生变化的时候打印出它的容量
  • 请判断append 函数在底层数组的空间被填满之后，是否会将数组的容量增加一倍？

十九、Map

map

• map是Go提供的另外一种集合：
  • 它可以将key映射到value。
  • 可快速通过key找到对应的value
  • 它的key几乎可以是任何类型

声明map

• 声明map，必须指定key和value的类型：map [string] int

package main

import "fmt"

func main() {
  temperature := map[string]int{
    "Earth": 15,
    "Mars": -65,
  }
  
  temp := temperature["Earth"]
  fmt.Printf("On average the Earth is %v° C.\n", temp)
  
  temperature["Earth"] = 16
  temperature["Venus"] = 464
  
  fmt.Println(temperature)
  
  moon := temperature["Moon"]
  fmt.Println(moon) // 返回对应的零值
}

逗号与ok写法

package main

import "fmt"

func main() {
  temperature := map[string]int{
    "Earth": 15,
    "Mars": -65,
  }
  
  temp := temperature["Earth"]
  fmt.Printf("On average the Earth is %v° C.\n", temp)
  
  temperature["Earth"] = 16
  temperature["Venus"] = 464
  
  fmt.Println(temperature)
  
  moon := temperature["Moon"]
  fmt.Println(moon) // 返回对应的零值
  
  if moon, ok := temperature["Moon"]; ok {
    fmt.Printf("On average the moon is %v° C.\n", moon)
  } else {
    fmt.Println("Where is the moon?")
  }
}

小测试

1. 如果你要声明一个key为64位浮点数，value为整数的map，那么应该使用什么类型？
2. 如果你修改上例的代码，将key “Moon”的值设为0，那么使用 逗号与ok语法将产生什么结果？

map不会被复制

• 数组、int、float64等类型在赋值给新变量或传递至函数/方法的时候会创建相应的副本
• 但map不会

package main

import "fmt"

func main() {
  planets := map[string]string {
    "Earth": "Sector ZZ9",
    "Mars": "Sector  ZZ9",
  }
  
  planetsMarkII := planets
  planets["Earth"] = "whoops"
  
  fmt.Println(planets)
  fmt.Println(planetsMarkII)
  
  delete(planets, "Earth")
  fmt.Println(planetsMarkII)
  fmt.Println(planets)
}

小测试

• 在上例中，为什么对planets修改会反映在planetMarkII中？
• 内置的delete函数有什么用？

使用make函数对 map 进行预分配

• 除非你使用复合字面值来初始化map，否则必须使用内置的make函数来为map分配空间。
• 创建map时，make函数可接受一个或两个参数
  • 第二个参数用于为指定数量的key预先分配空间
• 使用make函数创建的map的初始长度为0

package main

import "fmt"

func main() {
  temperature := make(map[float64]int, 8)
  
  fmt.Println(temperature)
  fmt.Println(len(temperature))
}

使用map作计数器

package main

import "fmt"

func main() {
  temperatures := []float64{
    -28.0, 32.0, -31.0, -29.0, -23.0, -29.0, -28.0, -33.0,
  }
  
  frequency := make(map[float64]int)
  
  for _, t := range temperatures {
    frequency[t]++
  }
  
  for t, num := range frequency {
    fmt.Printf("%+.2f occurs %d times\n", t, num)
  }
}

小测试

• 使用range关键字遍历map的时候，它会为两个变量提供什么数据？

使用map和slice实现数据分组

package main

import (
 "fmt"
  "math"
)

func main() {
  temperatures := []float64{
    -28.0, 32.0, -31.0, -29.0, -23.0, -29.0, -28.0, -33.0,
  }
  
  groups := make(map[float64][]float64)
  
  for _, t := range temperatures {
    g := math.Trunc(t/10) * 10
    groups[g] = append(groups[g], t)
  }
  
  for g, temperatures := range groups {
    fmt.Printf("%v: %v\n", g, temperatures)
  }
}

小测试

• 声明var groups map[string][]int中的key和value都是什么类型？

将map用作set

• Set这种集合与数组类似，但元素不会重复
• Go语言里没有提供set集合

package main

import "fmt"

func main() {
  var temperatures = []float64{
    -28.0, 32.0, -31.0, -29.0, -23.0, -29.0, -28.0, -33.0,
  }
  
  set := make(map[float64]bool)
  for _, t := range temperatures {
    set[t] = true
  }
  
  if set[-28.0] {
    fmt.Println("set member")
  }
  
  fmt.Println(set)
  
  unique := make([]float64, 0, len(set))
  for t := range set {
    unique = append(unique, t)
  }
  sort.Float64s(unique)
  
  fmt.Println(unique)
}

小测试

• 对于上面例子中的set集合，我们如何判断32.0是否是它的成员？

作业题

• 编写一个函数：
  • 它可以统计文本字符串中不同单词的出现频率，并返回一个词频map。
  • 该函数需要将文本转换为小写字母并移除包含的标点符号
  • strings包中的Fields、ToLower、Trim函数应该对此有所帮助
  • 使用该函数统计下文中各单词出现的频率，打印出现不止一次的单词和词频：As far as eye could reach he saw nothing but the stems of the great plants about him receding inthe violet shade, and far overhead the multiple transparency of huge leaves filtering the sunshineto the solemn splendour of twilight in which he walked. Whenever he felt able he ran again; theground continued soft and springy, covered with the same resilient weed which was the firstthing his hands had touched in Malacandra. Once or twice a small red creature scuttled across hispath, but otherwise there seemed to be no life stirring in the wood; nothing to fear—except thefact of wandering unprovisioned and alone in a forest of unknown vegetation thousands ormillions of miles beyond the reach or knowledge of man.

二十、第四部分习题

• 开天辟地
  • 观察世界
  • 激活细胞
• 适者生存
  • 存活还是死亡
  • 统计邻近细胞
  • 游戏逻辑
• 平行世界

二十一、结构

结构类型（struct）

• 为了将分散的零件组成一个完整的结构体，Go提供了struct类型。
• struct允许你将不同类型的东西组合在一起。
• 声明结构

package main

func distance(lat1, long1, lat2, long2 float64) float64 {
  return 0.0
}

func main() {
  var curiosity struct {
    lat float64
    long float64
  }
  
  curiosity.lat = -4.5895
  curiosity.long = 137.4417
  
  fmt.Println(curiosity.lat, curiosity.long)
  fmt.Println(curiosity)
}

小测试

1. 与独立的变量相比，使用struct的优势是什么？
2. 上例中，如果curiosity有一个海拔（altitude）字段，那么你如何给它赋值为-4400？

通过类型复用结构体

package main

func distance(loc1, loc2 location) dis {
  return dis{0.0, 0.0}
}

type location struct {
  lat float64
  long float64
}

// type dis location

type dis struct {
  lat float64
  long float64
}

func main() {
  //var curiosity struct {
   // lat float64
  //  long float64
  //}
  
  //type location struct {
    //lat float64
   // long float64
 // }
  
  var spirit location
  spirit.lat = -14.5684
  spirit.long = 175.472636
  
  var opportunity location
  opportunity.lat = -1.9462
  opportunity.long = 354.4734 
  
  fmt.Println(spirit, opportunity)
}

小测试

• 修改上面例子的代码，改用location类型表示好奇号火星探测器的位置

通过复合字面值初始化struct

• 两种形式：
  • 通过成对的字段和值进行初始化
  • 按字段定义的顺序进行初始化

package main

import "fmt"

func main() {
  type location struct {
    lat, long float64
  }
  
  opportunity := location{lat: -1.9462, long: 354.4734}
  fmt.Println(opportunity)
  
  insight := location{lat: 4.5, long: 135.9}
  fmt.Println(insight)
  
  spirit := location{-14.5684, 175.472636}
  fmt.Println(spirit)
}

• 打印struct

pakcage main

import "fmt"

func main() {
  type location struct {
    lat, long float64
  }
  
  curiosity := location{-4.5859, 137.4417}
  fmt.Printf("%v\n", curiosity)
  fmt.Printf("%+v\n", curiosity)
}

• %v，打印出{-4.5895 137.4417}
• %+v，打印出{lat:-4.5895 long:137.4417}

小测试

• 与只给定值的初始化方式相比，成对给定字段和值的初始化方式有哪些优势？

struct的复制

pakcage main

import "fmt"

func main() {
  type location struct {
    lat, long float64
  }
  
  bradbury := location{-4.5859, 137.4417}
  curiosity := bradbury
  
  curiosity.long += 0.0106
  
  fmt.Println(bradbury, curiosity)
}

小测试

• 如果将curiosity变量传递给函数，并在函数中对lat和long字段进行修改，那么调用者是否会看到这些变化？

由结构体组成的slice

package main

import "fmt"

func main() {
  type location struct {
    name string
    lat float64
    long float64
  }
  
  lats := []float64{-4.5859, -14.5684, -1.9462}
  longs := []float64{137.4417, 175.472636, 354.4734}
  
  locations := []location{
    {name: "Bradbury Landing", lat: -4.5859, long: 137.4417},
    {name: "Columbia Memorial Station", lat: -14.5684, long: 175.472636},
    {name: "Challenger Memorial Station", lat: -1.9462, long: 354.4734},
  }
  
  fmt.Println(lats, longs, locations)
}

小测试

• 使用多个相互关联的slice有什么坏处？

将struct编码为JSON

• JSON（JavaScript Object Notation，JavaScript对象表示法）

• 常用于Web API

• json包的Marshal函数可以将struct中的数据转化为JSON格式。

package main

import (
  "encoding/json"
  "fmt"
  "os"
)

func main() {
  type location struct {
    Lat, Long, float64
  }
  
  curiosity := location{-4.5895, 137.4417}
  
  bytes, err := json.Marshal(curiosity)
  exitOnError(err)
  
  fmt.Println(string(bytes))
}

// exitOnError prints any errors and exits.
func exitOnError(err error) {
  if err != nil {
    fmt.Println(err)
    os.Exit(1)
  }
}

• Marshal函数只会对struct中被导出的字段进行编码。

小测试

• JSON代表什么意思？

使用struct标签来自定义JSON

• Go语言中的json包要求struct中的字段必须以大写字母开头，类似CamelCase驼峰型命名规范。

• 但有时候我们需要snake_case蛇形命名规范，那么该怎么办？

• 可以为字段注明标签，使得json包在进行编码的时候能够按照标签里的样式修改字段名。

package main

import (
  "encoding/json"
  "fmt"
  "os"
)

func main() {
  type location struct {
    Lat float64 `json: "latitude"`
    Long, float64 `json: "longitude"`
  }
  
  curiosity := location{-4.5895, 137.4417}
  
  bytes, err := json.Marshal(curiosity)
  exitOnError(err)
  
  fmt.Println(string(bytes))
}

// exitOnError prints any errors and exits.
func exitOnError(err error) {
  if err != nil {
    fmt.Println(err)
    os.Exit(1)
  }
}

小测试

• 为什么在编码JSON数据的时候，Lat和Long字段必须以大写字母开头？

作业题

• 编写一个程序：
  • 能够以JSON格式打印出 上面例子中3台 探测器的着陆点。
  • 被打印的JSON数据必须包含每个着陆点的名称，并使用上面例子中展示的struct标签特性。
  • 请使用json包中的MarshalIndent函数让打印输出变得更加美观和易读。

二十二、Go语言没有class

Go语言里没有class

• Go和其它经典语言不同，它没有class，没有对象，也没有继承。
• 但是Go提供了struct和方法。

将方法关联到struct

• 方法可以被关联到你声明的类型上

package main

import "fmt"

// coordinate in degrees, minutes, seconds in a N/S/E/W hemisphere.
type coordinate struct {
  d, m, s float64
  h rune
}

// decimal converts a d/m/s coordinate to decimal degrees.
func (c coordinate) decimal() float64 {
  sign := 1.0
  switch c.h {
  case 'S', 'W', 's', 'w':
    sign = -1
  }
  return sign * (c.d + c.m/60 + c.s/3600)
}

func main() {
  // Bradbury Landing: 4°35'22.2" S, 137°26‘30.1“ E
  lat := coordinate{4, 35, 22.2, 'S'}
  long := coordinate{137, 26, 30.12, 'E'}
  
  fmt.Println(lat.decimal(), long.decimal())
}

小测试

• 上例中，decimal方法的接收者是谁？

构造函数

• 可以使用struct复合字面值来初始化你所要的数据。
• 但如果struct初始化的时候还要做很多事情，那就可以考虑写一个构造用的函数。

package main

import "fmt"

// coordinate in degrees, minutes, seconds in a N/S/E/W hemisphere.
type coordinate struct {
  d, m, s float64
  h rune
}

// decimal converts a d/m/s coordinate to decimal degrees.
func (c coordinate) decimal() float64 {
  sign := 1.0
  switch c.h {
  case 'S', 'W', 's', 'w':
    sign = -1
  }
  return sign * (c.d + c.m/60 + c.s/3600)
}

type location struct {
  lat, long float64
}

// newLocation from latitude, longitude d/m/s coordinates.
func newLocation(lat, long, coordinate) location {
  return location{lat.decimal(), long.decimal()}
}

func main() {
  // Bradbury Landing: 4°35'22.2" S, 137°26‘30.1“ E
  lat := coordinate{4, 35, 22.2, 'S'}
  long := coordinate{137, 26, 30.12, 'E'}
  
  fmt.Println(lat.decimal(), long.decimal())
  
  // curiosity := location{lat.decimal(), long.decimal()}
  curiosity := newLocation(lat, long)
  
  fmt.Println(curiosity)
}

• Go语言没有专用的构造函数，但以new或者New开头的函数，通常是用来构造数据的。例如newPerson()，NewPerson()

New函数

• 有一些用于构造的函数的名称就是New（例如errors包里面的New函数）。
• 这是因为函数调用时使用包名.函数名的形式。
• 如果该函数叫NewError，那么调用的时候就是errors.NewError()，这就不如errors.New()简洁

小测试

• 如果你想构建一个Universe类型的变量，那么你如何为该函数命名？

class的替代方案

• Go语言没有class，但使用struct并配备几个方法也可以达到同样的效果。

package main

import (
  "fmt"
  "math"
)

type location struct {
  lat, long float64
}

type world struct {
  radius float64
}

// distance calculation using the Spherical Law of Cosines.
func (w world) distance(p1, p2 location) float64 {
  s1, c1 := math.Sincos(rad(p1.lat))
  s2, c2 := math.Sincos(rad(p2.lat))
  clong := math.Cos(rad(p1.long - p2.long))
  return w.radius * math.Acos(s1*s2+c1*c2*clong)
}

// rad converts degrees to radians.
func rad(deg float64) float64 {
  return deg * math.Pi / 180
}

func main() {
  var mars = world{radius: 3389.5}
  spirit := location{-14.5684, 175.472636}
  opportunity := location{-1.9462, 354.4734}
  
  dist := mars.distance(spirit, opportunity)
  fmt.Printf("%.2f km\n", dist)
}

小测试

• 与不采用面向对象的方式相比，在world类型上声明一个distance方法的好处是什么？

作业题

1. 使用例子中的代码，编写一个程序。并为下表中每个 位置都声明一个location，以十进制度数打印出每个位置。
2. 使用例子中的distance方法，编写一个程序，来判定上题表中每对着陆点之间的距离。并回答：
   1. 哪两个着陆点之间最近？
   2. 哪两个着陆点之间最远？
   3. 计算伦敦到巴黎之间的距离（51°30’N 0°08’W），（48°51’N 2°21’E）,地球半径为6371公里。
   4. 计算你的城市到北京距离
   5. 计算火星上Mount Sharp (5°4’ 48”S, 137°51’E)到Olympus Mons (18°39’N,226°12’E)之间的距离。火星的半径是3389.5公里。

二十三、组合与转发 Composition and forwarding

组合

• 在面向对象的世界中，对象由更小的对象组合而成。
• 术语：对象组合或组合
• Go通过结构体实现组合（composition）。
• Go提供了“嵌入”（embedding）特性，它可以实现方法的转发（forwarding）
• 组合是一种更简单、灵活的方式。

组合结构体

例子一

package main

type report struct {
  sol int
  high, low float64
  lat, hong float64
}

func main() {
  
}

例子二

package main

type report struct {
  sol int 
  temperature temperature
  location location
}

type temperature struct {
  hign, low celsius
}

type location struct {
  lat, long float64
}

type celsius float64

func (t temperature) average() celsius {
  return (t.high + t.low) / 2
}

func (r report) average() celsius {
  return r.temperature.average()
}

func main() {
  bradbury := location{-4.5895, 137.4417}
  t := temperature{high: -1.0, low: -78.0}
  fmt.Println(t.average())
  report := report {
    sol: 15,
    temperature: t,
    location: bradbury
  }
  
  fmt.Println(report.temperature.average())
  fmt.Println(report.average())
  
  fmt.Printf("%+v\n", report)
  
  fmt.Printf("a balmy %v° C\n", report.temperature.high)
}

小测试

• 比较例子1和2的代码，你更喜欢哪一种？原因是什么？

转发方法

• Go可以通过struct嵌入 来实现方法的转发。
• 在struct中只给定字段类型，不给定字段名即可。

package main

import "fmt"

//type report struct {
//  sol int
//  temperature temperature
//  location location
//}

type report struct {
  sol int
  temperature
  location
}

type temperature struct {
  high, low celsius
}

type location struct {
  lat, long float64
}

type celsius float64

func (t temperature) average() celsius {
  return (t.high + t.low) / 2
}

func main() {
  bradbury := location{-4.5895, 137.4417}
  t := temperature{high: -1.0, low: -78.0}
  fmt.Println(t.average())
  report := report {
    sol: 15,
    temperature: t,
    location: bradbury
  }
  
  fmt.Println(report.average())
  
  fmt.Println(report.high)
  
  fmt.Printf("%+v\n", report)
  
  fmt.Printf("a balmy %v° C\n", report.temperature.high)
}

• 在struct中，可以转发任意类型。

package main

import "fmt"

//type report struct {
//  sol int
//  temperature temperature
//  location location
//}

type sol int

type report struct {
  sol 
  temperature
  location
}

type temperature struct {
  high, low celsius
}

type location struct {
  lat, long float64
}

type celsius float64

func (t temperature) average() celsius {
  return (t.high + t.low) / 2
}

func (s sol) days(s2 sol) int {
  days := int(s2 - s)
  if days < 0 {
    days = -days
  }
  return days
}

func main() {
  report := report {
    sol: 15,
  }
  
  fmt.Println(report.sol.days(1446))
  
  fmt.Println(report.days(1446))
}

小测试

• 结构体可以嵌入什么类型？
• 访问report.lat字段是否合法？如果合法，那么上面例子中它指向哪个字段？

命名冲突

package main

import "fmt"

//type report struct {
//  sol int
//  temperature temperature
//  location location
//}

type sol int

type report struct {
  sol 
  temperature
  location
}

type temperature struct {
  high, low celsius
}

type location struct {
  lat, long float64
}

type celsius float64

func (t temperature) average() celsius {
  return (t.high + t.low) / 2
}

func (s sol) days(s2 sol) int {
  days := int(s2 - s)
  if days < 0 {
    days = -days
  }
  return days
}

func (l location) days(l2 location) int {
  // To-do: complicated distance calculation
  return 5
}

func (r report) days(s2 sol) int {
  return r.sol.days(s2)
}

func main() {
  report := report {
    sol: 15,
  }
  
  fmt.Println(report.sol.days(1446))
  
  //fmt.Println(report.days(1446)) // 报错
  fmt.Println(report.days(1446))
}

继承 还是 组合？

• Favor object composition over class inheritance.
• 优先使用对象组合而不是类的继承。
• Use of classical inheritance is always optional; every problem thatit solves can be solved another way.
• 对传统的继承不是必需的；所有使用继承解决的问题都可以通过其它方法解决。

小测试

• 如果多个嵌入的类型都实现了同名的方法，那么Go编译器会报错吗？

作业题

实验：gps.go

二十四、接口

接口

• 接口关注于类型可以做什么，而不是存储了什么。
• 接口通过列举类型必须满足的一组方法来进行声明。
• 在Go语言中，不需要显式声明接口。

例子一

package main

var t interface {
  talk() string
}

func main() {
  
}

例子二

package main

import (
  "fmt"
  "strings"
)

var t interface {
  talk() string
}

type martian struct {}

func (m martian) talk() string {
  return "nack nack"
}

type laser int

func (l laser) talk() string {
  return strings.Repeat("pew ", int(l))
}

func main() {
  t = martian{}
  fmt.Println(t.talk())
  
  t = laser(3)
  fmt.Println(t.talk())
}

接口类型

• 为了复用，通常会把接口声明为类型。
• 按约定，接口名称通常以er结尾。

例子一

package main

import (
  "fmt"
)

type talker interface {
  talk() string
}

type martian struct {}

func (m martian) talk() string {
  return "nack nack"
}

type laser int

func (l laser) talk() string {
  return strings.Repeat("pew ", int(l))
}

func shout(t talker) {
  louder := strings.ToUpper(t.talk())
  fmt.Println(louder)
}

func main() {
  shout(martian{})
  shout(laser(2))
}

例子二

package main

import (
  "fmt"
)

type talker interface {
  talk() string
}

type martian struct {}

func (m martian) talk() string {
  return "nack nack"
}

type laser int

func (l laser) talk() string {
  return strings.Repeat("pew ", int(l))
}

func shout(t talker) {
  louder := strings.ToUpper(t.talk())
  fmt.Println(louder)
}

type starship struct {
  laser
}

func main() {
  s := starship{laser(3)}
  
  fmt.Println(s.talk())
  shout(s)
}