diff --git a/.idea/.gitignore b/.idea/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..73f69e0958611ac6e00bde95641f6699030ad235
--- /dev/null
+++ b/.idea/.gitignore
@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
+# Editor-based HTTP Client requests
+/httpRequests/
diff --git a/.idea/misc.xml b/.idea/misc.xml
new file mode 100644
index 0000000000000000000000000000000000000000..639900d13c6182e452e33a3bd638e70a0146c785
--- /dev/null
+++ b/.idea/misc.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/.idea/modules.xml b/.idea/modules.xml
new file mode 100644
index 0000000000000000000000000000000000000000..b3b6543b48d4e9acc1a9d04fdaac3803463ab894
--- /dev/null
+++ b/.idea/modules.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/practical-go-lessons.iml" filepath="$PROJECT_DIR$/.idea/practical-go-lessons.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file
diff --git a/.idea/practical-go-lessons.iml b/.idea/practical-go-lessons.iml
new file mode 100644
index 0000000000000000000000000000000000000000..d6ebd4805981b8400db3e3291c74a743fef9a824
--- /dev/null
+++ b/.idea/practical-go-lessons.iml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
\ No newline at end of file
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 0000000000000000000000000000000000000000..94a25f7f4cb416c083d265558da75d457237d671
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>
\ No newline at end of file
diff --git a/chap-8-variables-constants-and-basic-types/8-example.md b/chap-8-variables-constants-and-basic-types/8-example.md
new file mode 100644
index 0000000000000000000000000000000000000000..6c0c808f3ae4d798d7440b92aed89c219ebffbf7
--- /dev/null
+++ b/chap-8-variables-constants-and-basic-types/8-example.md
@@ -0,0 +1,577 @@
+# 第八章：变量，常量和基本类型
+
+![Variables, constants and basic types](imgs/variables-consts.1cf1af40.jpg)
+
+## 1 你能在本章节学到什么？
+
+- 什么是变量？我们为什么需要变量？
+- 什么是类型？
+- 如何创建一个变量？
+- 如何给一个变量赋值？
+- 如何使用变量？
+- 什么是常量？常量和变量有什么区别？
+- 如何定义一个常量？
+- 如何使用常量？
+
+## 2 本章节所涵盖的技术概念
+
+- 变量
+- 常量
+- 类型
+- 无类型常量
+
+## 3 变量是内存中的一个空间
+
+变量（variable）是计算机内存中的一个可以包含可变数据的空间。 「variable」一词来自拉丁语「variabilis」，意思是「可变的」。在程序中，我们可以创建变量，这些变量使我们能够存储之后要用到的信息。
+
+例如，我们想要跟踪酒店的客人数量。因为客人的数量是一个会变化的数字，因此我们可以创建一个变量来存储这些信息（参见图 [1](#fig:A-variable-is-space-memory)）。
+
+![A variable is a space in computer memory[fig:A-variable-is-space-memory]](imgs/what_is_a_variable.87f49327.png)
+
+<span id="fig:A-variable-is-space-memory">变量是内存中的一个空间[fig:A-variable-is-space-memory]</span>
+
+> 本书的纸质版和数字版均可用！[更多信息在这里](https://www.practical-go-lessons.com/buy-digital-or-hard-copy)。
+
+## 4 变量存储在哪里？
+
+我们之前讨论过 ROM、RAM 和辅助存储器。Go 变量存储在哪里？答案很简单：你无法选择存储地点。这是编译器的责任，而不是你的责任！
+
+## 5 变量标识符（名称）
+
+在大多数编程语言中（以及在 Go 中），当我们创建一个变量时，我们将它与一个 **标识符** 相关联。标识符是变量的「名称」。给变量赋予标识符可以让我们在程序中快速使用它们。标识符由字母和数字组成。变量的标识符将在程序内部使用，以指定存储在其中的值。标识符必须简短且具有描述性。
+
+创建标识符，程序员可以很有创意。但他们必须遵守这些简单的规则：
+
+1. 标识符由以下元素所组成
+   1. <span id="fnref1">Unicode 字母<sup>[1](#fn1)</sup></span>
+      1. 例如：A，a，B，b，Ô，...
+   2. <span id="fnref2">Unicode 数字<sup>[2](#fn2)</sup></span>
+      1. 例如：0，9，3，...
+2. 标识符必须以字母或下划线字符（_）开头。
+3. 某些标识符无法使用，因为它们被语言 **保留**
+   1. **保留字有**：reak，default，func，interface，select，case，defer，go，map，struct，chan，else，goto，package，switch，const，fallthrough，if，range，type，continue，for，import，return，var
+
+```go
+numberOfGuests
+```
+
+是有效的变量标识符。
+
+```go
+113Guests
+```
+
+是无效的变量标识符，因为它以数字开头。
+
+## 6 基本类型
+
+我们可以将信息存储到变量中。但这样表述是模糊的；我们必须更加精确。我们需要存储数字（1，2000，3）、浮点数（2.45665）、文本（"Room 112 non-smoking"）吗？变量有一个合法值的集合，我们可以用这个集合给变量分配值。这个集合就是变量的 **类型**。类型是有名称的。
+
+Go 语言预先声明了一组可以立即在程序中使用的基本类型。你也可以定义你的类型（我们稍后会看到）。目前，我们将只关注最常用的类型：
+
+- 字符串：
+  - <u>类型名</u>：string
+  - <u>例子</u>："management office"，"room 265"，...
+- 无符号整数：
+  - <u>类型名</u>：uint，uint8，uint16，uint32，uint64
+  - <u>例子</u>：2445，676，0，1，...
+- 整数：
+  - <u>类型名</u>：int，int8，int16，int32，int64
+  - <u>例子</u>：-1245，65，78，...
+- 布尔值：
+  - <u>类型名</u>：bool
+  - <u>例子</u>：true，false
+- 浮点数：
+  - <u>类型名</u>：float32, float64
+  - <u>例子</u>：12.67
+
+### 6.1 关于数字 8、16、32 和 64
+
+你可能已经注意到我们有五种类型的整数：int，int8，int16，int32，int64。无符号整数也是如此。我们有 uint，uint8，uint16，uint32 和 uint64。浮点数的选择更为有限：我们可以使用 float32 或 float64。
+
+如果要存储没有符号的数字，可以使用无符号整数类型。这些类型有 5 种口味：
+
+- uint8
+- uint16
+- uint32
+- uint64
+- uint
+
+除了最后一个，每个都有一个附加的数字。这个数字对应分配给存储它的内存位数。
+
+如果你已阅读过第一章，你就会知道：
+
+- 使用 8 位内存，我们可以存储从 0 到 $2^{7}+2^{6}+...+2^{0}=255$ 的整数
+- 使用 16 位（2 字节）内存，我们可以存储从 0 到 $2^{15}+2^{14}+...+2^{0}=65,535$ 的整数
+- 使用 32 位（4 字节）内存，我们可以存储从 0 到 $2^{31}+2^{30}+...+2^{0}=4,294,967,295$ 的整数
+- 使用 64 位（8 字节）内存，我们可以存储从 0 到 $2^{63}+2^{62}+...+2^{0}=18,446,744,073,709,551,615$ 的整数
+
+你可以注意到，64 位的最大十进制值非常高。记住这一点！如果需要存储不超过 255 的值，请使用 uint8 而不是uint64。否则，你将浪费存储空间（因为你只使用了内存中分配的 64 位中的 8 位！）
+
+最后一种类型是 **uint**。如果你在程序中使用此类型，则为无符号整数分配的内存将 **至少** 为 32 位。这取决于运行程序的系统。如果是 32 位系统，它将相当于 uint32 。如果系统为 64 位，则 **uint** 的存储容量将与 **uint64** 的存储容量相同。（为了更好地理解 32 位和 64 位之间的区别，你可以查看上一章）
+
+## 7 变量声明
+
+如果你想在你的程序中使用一个变量，你需要先声明它。
+
+### 7.1 声明变量时执行的三个动作
+
+当你声明一个变量时，它会：
+
+1. 将 **标识符** 绑定到变量
+2. 将 **类型** 绑定到变量
+3. 将变量值 **初始化** 为 **类型** 的 **默认值**
+
+如果你习惯于前两个动作的编程，那么前两个动作是很常见的。但第三个不是。**Go 为你将变量值初始化为其类型的默认值**。Go中不存在未初始化的变量。
+
+### 7.2 没有初始化的变量声明
+
+![Variable declation syntax[fig:Variable-declation-syntax]](imgs/variable_initialization.a908a70e.png)
+
+<span id="fig:Variable-declation-syntax">变量声明语法[fig:Variable-declation-syntax]</span>
+
+在图 [2](#fig:Variable-declation-syntax) 中，您可以看到如何声明变量。在第一个示例中，我们声明了一个 int 类型的变量 roomNumber。在第二个示例中，我们在同一行中声明两个变量：roomNumber 和 floorNumber。它们是 int 类型的，值将是 0（int 类型的零值）。
+
+```go
+// variables-constants-and-basic-types/declaration-without-initializer/main.go
+package main
+
+import "fmt"
+
+func main() {
+    var roomNumber, floorNumber int
+    fmt.Println(roomNumber, floorNumber)
+
+    var password string
+    fmt.Println(password)
+}
+```
+
+该程序输出：
+
+```go
+0 0
+
+```
+
+string 类型的变量 **password** 由 string 类型的零值初始化，该值为空字符串 ""。变量 roomNumber 和 floorNumber 被初始化为 int 类型的零值，即0。
+
+程序输出的第一行是 `fmt.Println(password)` 的结果。第二行是 `fmt.Println(roomNumber, floorNumber)` 的结果。
+
+### 7.3 有初始化的变量声明
+
+![Variable declation with initialization syntax[fig:Variable-declation-with-initializer]](imgs/variable_decl_with_initialization.31e0cb43.png)
+
+<span id="fig:Variable-declation-with-initializer">带有初始化语法的变量声明[fig:Variable-declation-with-initializer]</span>
+
+你还可以声明一个变量并直接初始化其值。图 [3](#fig:Variable-declation-with-initializer) 描述了可能的语法。让我们举个例子：
+
+```go
+// variables-constants-and-basic-types/declaration-variant/main.go
+package main
+
+import "fmt"
+
+func main() {
+    var roomNumber, floorNumber int = 154, 3
+    fmt.Println(roomNumber, floorNumber)
+
+    var password = "notSecured"
+    fmt.Println(password)
+}
+```
+
+在 `main` 函数中，第一条语句声明了两个 `int` 类型变量 roomNumber 和 floorNumber 并用 154 和 3 初始化，然后打印这些变量。
+
+等号左边有一个表达式或表达式列表。我们将在另一章详细介绍表达式。
+
+然后定义变量 `password` 并用 `"notSecured"` 初始化。请注意，这里没有写入类型，Go 将为变量提供初始化值的类型。这里 `"notSecured"` 的类型是一个字符串；因此，变量 `password` 的类型是字符串。
+
+### 7.4 短变量声明
+
+![Short variable declaration[fig:Short-variable-declaration]](imgs/short_variable_declaration.ada142f1.png)
+
+<span id="fig:Short-variable-declaration">短变量声明[fig:Short-variable-declaration]</span>
+
+短变量声明语法去除了 **var** 关键字， `=` 符号转换为 `:=`，使用此语法同样可以一次定义多个变量。
+
+```go
+roomNumber := 154
+```
+
+类型没有明确写入。编译器将从表达式（或表达式列表）中推断出变量的类型。
+
+这是一个例子：
+
+```go
+// variables-constants-and-basic-types/short-declaration/main.go
+package main
+
+import "fmt"
+
+func main() {
+    roomNumber, floorNumber := 154, 3
+    fmt.Println(roomNumber, floorNumber)
+}
+```
+
+- 警告：不能在函数外使用短变量声明！
+
+```go
+// will not compile
+package main
+
+vatRat := 20
+
+func main(){
+
+}
+```
+
+- 警告：不能将 `nil` 用于短变量声明，因为这样编译器将无法推断变量的类型。
+
+> 本书的纸质版和数字版均可用！[更多信息在这里](https://www.practical-go-lessons.com/buy-digital-or-hard-copy)。
+
+## 8 什么是常量？
+
+Constant 来自拉丁语 「**constare**」，意思是「<u>站立不动</u>」。常量是程序中一个稳定的值，在执行过程中不会改变。变量可以在运行时改变，常数则不会，它将保持不变。
+
+例如，我们可以在一个常量中存储：
+
+- 程序的版本，例如：「1.3.2」，该值将在程序运行时保持稳定。我们会在编译另一个版本的程序时更改此值。
+- 程序的构建时间。
+- 电子邮件模板（如果我们的应用程序无法配置）。
+- 一条错误信息。
+
+总之，当你确定一个值在程序执行期间永远不需要更改时，请使用常量。我们说常量是 **不可变的**。常量有两种形式：有类型和无类型。
+
+## 9 类型常量
+
+这是一个类型化的常量：
+
+```go
+const version string = "1.3.2"
+```
+
+关键字 const 向编译器表明我们将定义一个 **常量**。在 const 关键字之后，设置了常量的标识符。在这个示例中，标识符是 "version"。类型是明确定义的（**string**），常量的值也是明确定义的（以表达式的形式）。
+
+![Typed constant declaration](imgs/constant_declaration.5011f7f9.png)
+
+类型常量声明
+
+## 10 无类型常量
+
+这是一个无类型化的常量：
+
+```go
+const version = "1.3.2"
+```
+
+无类型化常量：
+
+- 没有类型
+- 有默认类型
+- 没有限制
+
+### 10.1 无类型常量没有类型
+
+举个例子：
+
+```go
+// variables-constants-and-basic-types/untyped-const/main.go
+package main
+
+import "fmt"
+
+func main() {
+    const occupancyLimit = 12
+
+    var occupancyLimit1 uint8
+    var occupancyLimit2 int64
+    var occupancyLimit3 float32
+
+    // 将无类型常量分配给 uint8 变量
+    occupancyLimit1 = occupancyLimit
+    // 将无类型常量分配给 int64 变量
+    occupancyLimit2 = occupancyLimit
+    // 将无类型常量分配给 float32 变量
+    occupancyLimit3 = occupancyLimit
+
+    fmt.Println(occupancyLimit1, occupancyLimit2, occupancyLimit3)
+}
+```
+
+在这个程序中，我们首先定义一个值为 12 的无类型常量 `occupancyLimit`。这个常量没有特定的类型，但它被设置为整数值。
+
+然后我们定义了 3 个变量：`occupancyLimit1`、`occupancyLimit2`、`occupancyLimit2`（这些变量的类型是 uint8、int64、float32）。
+
+之后我们将 `occupancyLimit` 的值分配给这些变量。也就是说，常量的值可以放入不同类型的变量中！
+
+### 10.2 无类型常量的默认类型
+
+为了理解默认类型的概念，让我们举另一个例子：
+
+```go
+// variables-constants-and-basic-types/default-type/main.go
+package main
+
+import "fmt"
+
+func main() {
+    const occupancyLimit = 12
+
+    var occupancyLimit4 string
+
+    occupancyLimit4 = occupancyLimit
+
+    fmt.Println(occupancyLimit4)
+}
+```
+
+在这个程序中，我们定义了一个常量 `occupancyLimit`，它的值为 12（一个整数）。我们定义了一个字符串类型的变量 `occupancyLimit4`，然后我们尝试将常量的值分配给 `occupancyLimit4`。
+
+我们尝试把一个整数转换成一个字符串。这个程序能编译吗？答案是否定的！编译错误为：
+
+```go
+./main.go:10:19: cannot use occupancyLimit (type int) as type string in assignment
+```
+
+无类型常量具有默认类型，该类型由分配给它的值在编译时定义。在我们的示例中，`occupancyLimit` 的默认类型为 `int`。不能将 `int` 分配给 `string` 变量。
+
+无类型常量默认类型是：
+
+- bool（对于任何布尔值）
+- rune（对于任何 rune 值）
+- int（对于任何整数值）
+- float64（对于任何浮点数值）
+- complex128（对于任何复数值）
+- string（对于任何字符串值）
+
+```go
+// variables-constants-and-basic-types/untyped-default/main.go
+package main
+
+func main() {
+
+    // 默认类型是 bool
+    const isOpen = true
+    // 默认类型是 rune (int32 的别名)
+    const MyRune = 'r'
+    // 默认类型是 int
+    const occupancyLimit = 12
+    // 默认类型是 float64
+    const vatRate = 29.87
+    // 默认类型是 complex128
+    const complexNumber = 1 + 2i
+    // 默认类型是 string
+    const hotelName = "Gopher Hotel"
+
+}
+```
+
+### 10.3 无类型常量没有限制
+
+无类型常量没有类型，需要时有默认类型。无类型常量的值可能会溢出其默认类型。这样的常量没有类型；因此，它不依赖于任何类型限制。举个例子：
+
+```go
+// variables-constants-and-basic-types/untyped-no-limit/main.go
+package main
+
+func main() {
+    // int 的最大值是 9223372036854775807
+    // 9223372036854775808 (max + 1 ) 溢出了 int 的最大值
+    const profit = 9223372036854775808
+    // 程序编译
+}
+```
+
+在这个程序中，我们创建了一个名为 `profit` 的无类型常量，它的值是 922,3372,0368,5477,5808，溢出了 int 允许的最大值（在我的 64 位机器上为 int64）：922,3372,0368,5477,5807。然后这个程序能够完美地编译。但是当我们尝试将此常量值分配给类型化变量时，程序将无法编译。举个例子来证明它：
+
+```go
+// variables-constants-and-basic-types/untyped-no-limit-2/main.go
+package main
+
+import "fmt"
+
+func main() {
+    // int 的最大值是 9223372036854775807
+    // 9223372036854775808 (max + 1 ) 溢出了 int 的最大值
+    const profit = 9223372036854775808
+    var profit2 int64 = profit
+    fmt.Println(profit2)
+}
+```
+
+该程序定义了一个 `int64` 类型的变量 `profit2`，然后我们尝试将无类型常量 `profit` 的值分配给 `profit2`。
+
+让我们尝试编译程序：
+
+```go
+$ go build main.go
+# command-line-arguments
+./main.go:9:7: constant 9223372036854775808 overflows int64
+```
+
+得到一个编译错误，这说明我们试图做的事情是非法的。
+
+### 10.4 为什么要使用常量？
+
+- 提高程序的可读性
+  - 如果选择得当，常量标识符将为读者提供比原始值更多的信息
+
+比较以下两段程序：
+
+```go
+loc, err := time.LoadLocation(UKTimezoneName)
+if err != nil {
+  return nil, err
+}
+```
+
+```go
+loc, err := time.LoadLocation("Europe/London")
+if err != nil {
+  return nil, err
+}
+```
+
+我们使用常量 `UKTimezoneName ` 而不是原始值 `"Europe/London"` 。我们向读者隐藏了时区字符串的复杂性。除此之外，读者会明白我们的意图是什么——我们要加载英国的时区。
+
+- 你允许潜在的重用值（由另一个程序或在您自己的程序中）。
+- 编译器可能会改进生成的机器代码。你对编译器说这个值永远不会改变；如果编译器很聪明（而且确实如此），它就会巧妙地使用它。
+
+## 11 选择标识符（变量名、常量名）
+
+命名变量和常量不是一件容易的事。选择名称时，必须确保所选名称提供了有关其名称的适当信息量。如果你选择了一个好的标识符名称，从事同一项目的其他开发人员将非常感激，因为阅读代码将更容易。当我们说「传达适当数量的信息」时，「正确」一词是含糊不清的。命名程序构造没有科学的规则，但即使如此，我也可以给你一些我们社区共享的建议。
+
+1. 避免使用一个字母命名：它传达的有关存储内容的信息太少。
+   1. 例外情况是计数器通常被命名为 `k`、`i` 和 `j`（在循环内部，我们将在后面介绍）
+2. 使用小驼峰命名法：这是 Go 社区中一个完善的约定。
+   1. `occupancyLimit` 比 `occupancy_limit`<sup id="fnref3">[3](#fn3)</sup> 或者 `occupancy-limit`<sup id="fnref4">[4](#fn4)</sup> 更好
+3. 不超过两个单词
+   1. 比起 `profitValue` , `profitValueBeforeTaxMinusOperationalCosts` 就太长了
+4. 避免在名称中提及类型
+   1. `descriptionString` 错误, `description` 正确
+   2. Go 已经是静态类型的；您不需要向读者提供类型信息。（在一些松散类型的语言中，有时需要避免混淆）
+
+> 本书的纸质版和数字版均可用！[更多信息在这里](https://www.practical-go-lessons.com/buy-digital-or-hard-copy)。
+
+## 12 实践应用
+
+### 12.1 任务
+
+#### 12.1.1 编程
+
+编写一个满足以下要求的程序：
+
+- 创建一个名为 `hotelName` 且值为 `"Gopher Hotel"` 的字符串常量
+- 创建两个分别包含 24.806078 和 -78.243027 的无类型常量，这两个常量的名称是 `longitude` 和 `latitude`。（巴哈马的某个地方）
+- 创建一个名为 `occupancy` 的 `int` 类型变量，其初始化值为 12。
+- 在新的一行中打印 `hotelName`、`longitude`、`latitude` 和 `occupancy` 。
+
+#### 12.1.2 奖励问题
+
+1. `longitude` 和 `latitude` 的默认类型是什么？
+2. `longitude` 的类型是什么？
+3. 变量 `occupancy` 是 `int` 类型。它是 64、32 还是 8 位整数？
+
+### 12.2 参考答案
+
+#### 12.2.1 示例程序
+
+```go
+// variables-constants-and-basic-types/mission-solution/main.go
+package main
+
+import "fmt"
+
+func main() {
+    const hotelName string = "Gopher Hotel"
+    const longitude = 24.806078
+    const latitude = -78.243027
+    var occupancy int = 12
+    fmt.Println(hotelName, longitude, latitude)
+    fmt.Println(occupancy)
+}
+```
+
+我们从字符串常量 `hotelName` 与无类型常量 `longitude` 和 `latitude` 的定义开始，然后我们定义 `int` 型变量 `occupancy` 并将其值设置为 12。请注意，另一种语法是可能的：
+
+- 短变量声明
+
+```go
+occupancy := 12
+```
+
+- 标准声明中可以省略类型
+
+```go
+var occupancy = 12
+```
+
+- 我们可以分两步进行变量的声明和赋值
+
+```go
+var occupancy int   
+occupancy = 12
+```
+
+### 12.2.2 奖励问题答案
+
+1. `longitude` 和 `latitude` 的默认类型是什么？
+   1. float64
+2. `longitude` 的类型是什么？
+   1. 无类型，`latitude` 也一样。
+3. 变量 `occupancy` 是 `int` 类型。它是 64、32 还是 8 位整数？
+   1. `int` 是一种在不同位数计算机上具有特定于实现的大小的类型。在 32 位计算机上，它将是一个 32 位整数（int32）；在 64 位计算机上，它将是一个 64 位整数（int64）
+
+## 13 自测
+
+### 13.1 问题
+
+1. 什么是标识符？
+2. 标识符应该以哪些类型的字符开头？
+3. 变量的类型是什么？
+4. 什么是字节？
+5. 当你声明一个类型 bool 变量时，它的值是什么（在初始化之后）？
+6. 无类型常量的两个主要特征是什么？
+
+### 13.2 答案
+
+1. 什么是标识符？
+   1. 标识符是由字母和数字组成的一组字符。
+2. 标识符应该以哪些类型的字符开头？
+   1. 一个字母或一个下划线。
+3. 变量的类型是什么？
+   1. 变量的类型是一组允许的变量值。
+4. 什么是字节？
+   1. 一个字节由8位二进制数字组成。
+5. 当你声明一个类型 bool 变量时，它的值是什么（在初始化之后）？
+   1. false。当声明一个变量时，它被初始化为其类型的默认值。
+6. 无类型常量的两个主要特征是什么？
+   1. 没有类型
+   2. 有默认类型
+   3. 没有限制
+
+## 14 关键要点
+
+- 变量或常量的名称称为标识符
+- 标识符一般使用小驼峰命名法
+- 变量和常量允许你再内存中保存一个值
+- 常量是不可变的，这意味着我们不能在程序执行期间更改它们的值
+- 变量有一个类型，它定义了它们可以保存的值的集合
+- 创建一个变量时，它的值被初始化为其类型的零值
+  - 这个超级重要！
+  - 它可能是错误的来源。
+  - Go 中没有未初始化的变量。
+- 常量有两类：
+  - 有类型的
+  - 无类型的
+    - 除了默认类型之外没有任何类型，并且可以溢出其默认类型。
+
+---
+
+1. <span id="fn1">在 Go 规范中，Unicode 字母是 Unicode 规范 8.0 中 Lu、Ll、Lt、Lm 或 Lo 列表中的任何字符[↩︎](#fnref1)</span> 
+2. <span id="fn2">在 Go 规范中，Unicode 数字是来自 Unicode 规范 8.0 的 Nd 列表中的任何字符[↩︎](#fnref2)</span> 
+3. <span id="fn3">Snake case[↩︎](#fnref3)</span> 
+4. <span id="fn4">Kebab case[↩︎](#fnref4)</span> 
diff --git a/chap-8-variables-constants-and-basic-types/imgs/constant_declaration.5011f7f9.png b/chap-8-variables-constants-and-basic-types/imgs/constant_declaration.5011f7f9.png
new file mode 100644
index 0000000000000000000000000000000000000000..6d866c05f1bb59f273ab9208170c0f2b3f59b822
Binary files /dev/null and b/chap-8-variables-constants-and-basic-types/imgs/constant_declaration.5011f7f9.png differ
diff --git a/chap-8-variables-constants-and-basic-types/imgs/short_variable_declaration.ada142f1.png b/chap-8-variables-constants-and-basic-types/imgs/short_variable_declaration.ada142f1.png
new file mode 100644
index 0000000000000000000000000000000000000000..9da9f569e673048a1533d135539b31c9f0f09858
Binary files /dev/null and b/chap-8-variables-constants-and-basic-types/imgs/short_variable_declaration.ada142f1.png differ
diff --git a/chap-8-variables-constants-and-basic-types/imgs/variable_decl_with_initialization.31e0cb43.png b/chap-8-variables-constants-and-basic-types/imgs/variable_decl_with_initialization.31e0cb43.png
new file mode 100644
index 0000000000000000000000000000000000000000..bc93547bcd5d4f162a119dd304410371a6ba4cdd
Binary files /dev/null and b/chap-8-variables-constants-and-basic-types/imgs/variable_decl_with_initialization.31e0cb43.png differ
diff --git a/chap-8-variables-constants-and-basic-types/imgs/variable_initialization.a908a70e.png b/chap-8-variables-constants-and-basic-types/imgs/variable_initialization.a908a70e.png
new file mode 100644
index 0000000000000000000000000000000000000000..8a35247a3f214fffc6087f14d07c982b189123de
Binary files /dev/null and b/chap-8-variables-constants-and-basic-types/imgs/variable_initialization.a908a70e.png differ
diff --git a/chap-8-variables-constants-and-basic-types/imgs/variables-consts.1cf1af40.jpg b/chap-8-variables-constants-and-basic-types/imgs/variables-consts.1cf1af40.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..5e756be183eafe519d8caa03345fd7a481cf85af
Binary files /dev/null and b/chap-8-variables-constants-and-basic-types/imgs/variables-consts.1cf1af40.jpg differ
diff --git a/chap-8-variables-constants-and-basic-types/imgs/what_is_a_variable.87f49327.png b/chap-8-variables-constants-and-basic-types/imgs/what_is_a_variable.87f49327.png
new file mode 100644
index 0000000000000000000000000000000000000000..50735a9067466c5ce0ea5f650f8d3fda6473a39b
Binary files /dev/null and b/chap-8-variables-constants-and-basic-types/imgs/what_is_a_variable.87f49327.png differ