```

feat(day01): 新增Go语言基础类型和变量作用域文档

- 创建基础类型文档，详细介绍Go语言的数据类型，包括整型、浮点型、
  复数、字符、字符串、布尔类型等
- 添加类型别名说明，包括byte和rune的使用场景和区别
- 补充字符串类型详解，包含可解析字符串和原生字符串的使用方法
- 增加布尔类型和自定义类型的说明，以及iota枚举生成器的应用
- 创建变量作用域文档框架
- 更新目录结构，将基础类型和变量作用域独立成单独的文档
- 修改语法文档，将基础类型章节替换为关键字和词法标记详解
- 添加完整的Go语言词法标记列表和关键字说明
- 增加示例代码展示各种数据类型的使用方法
```

day01/README.md

@@ -19,7 +19,6 @@
 + [第一个程序](./hello_world/README.md)
 + [开发环境搭建](./env/README.md)
 + [基础语法](./syntax/README.md)
-+ 基础类型
++ [基础类型](./base_type/README.md)
-+ 变量常量与值
++ [变量作用域](./scope/README.md)
-+ 变量作用域
 + 运算符

day01/base_type/README.md

@@ -0,0 +1,158 @@
+# 基础类型
+
+在Go中所有变量都是有类型的, 比如前面的int, string, float32 这些, 因此在接下来我们将先讲解下Go的基础类型
+
+静态: 变量值是有类型, 这个变量里面 只能放这个类型的值
+
+go在语言成面定义了如下几种基础类型:
+
++ 整形  12345
++ 浮点型  123.45
++ 复数  123.45i
++ 字符   'a'
++ 字符串  "abc"
++ 布尔类型 true, false
++ 枚举类型 iota
++ 自定义类型 
+
+## 字面量(值)
+
+字面量是值的表示方法，常用与对变量/常量进行初始化，主要分为：
+
++ 标识基础数据类型值的字面量，例如：0, 1.1, true, 3 + 4i, 'a', "我爱中国"
++ 构造自定义的复合数据类型的类型字面量，例如：type Interval int
++ 用于表示符合数据类型值的复合字面量，用来构造 array、slice、map、struct 的值，
+例如：{1, 2, 3}
+
+## 整形(整数)
+
+```go
+var age = 99
+```
+
+|  类型名   | 字节宽度  | 取值范围 |
+|  ----  | ----  | --- |
+|int     |与平台有关| 32 位系统 4 字节，64 位系统 8 字节 有符号整型|
+|uint | 与平台有关|32 位 系统 4 字节，64 位 系统 8 字节 无符号整形|
+|int8 |1 字节| 用 8 位表示的有符号整型 取值范围为:[-128, 127]|
+|int16 |2 字节| 用 16 位表示的有符号整型  取值范围为：[-32768,32767]|
+|int32  | 4 字节 | 用 32 位表示的有符号整型，取值范围为：[-2147483648,2147483647] |
+|int64  |8 字节  |用 64 位表示的有符号整型，取值范围为：[-9223372036854775808,9223372036854775807]|
+|uint8 |1 字节 | 用 8 位表示的无符号整型，取值范围为：[0,255]|
+|uint16 |2 字节 | 用 16 位表示的无符号整型，取值范围为：[0,65535]|
+|uint32 |4 字节 | 用 32 位表示的无符号整型，取值范围为：[0,4294967295]|
+|uint64 | 8 字节 | 用 64 位表示的无符号整型，取值范围为：[0,18446744073709551615] |
+|uintptr |与平台有关|32 位系统 4 字节，64 位系统 8 字节指针值的无符号整型|
+
+
+## 浮点(小数)
+
+```go
+var score = 99.5
+```
+
+|  类型名   | 字节宽度  | 取值范围 |
+|  ----  | ----  | --- |
+| float32| 4字节 | IEEE-754 32位浮点型数|
+| float64| 8字节 | IEEE-754 64位浮点型数|
+| complex64| 8字节| 由两个 float32 组成的复数（实部+虚部）|
+| complex128| 16字节| 由两个 float64 组成的复数（实部+虚部）|
+
+
+## 别名
+
+```go
+a := []byte{}
+
+// %+v 打印结构体字段名
+// []
+fmt.Printf("%+v \n", a)
+
+// 字符采用unicode编码, 这里的 值得这个字符串编码是 97
+b := 'a'
+fmt.Printf("%+v", b)
+```
+
+```go
+// 用于描述字节, []byte{}, 就是字节流
+// 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
+
+// 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
+```
+
+|  类型名   | 字节宽度  | 取值范围 |
+|  ----  | ----  | --- |
+|byte |1 字节| 字节类型，取值范围同 uint8|
+|rune |4 字节| Unicode 码点 取值范围同 uint32|
+
+## 字符串类型
+
+```go
+name := "bob"
+```
+
+Go 语言内置了字符串类型，使用 string 表示
+
+字面量：
+
++ 可解析字符串：通过双引号(")来创建，不能包含多行，支持特殊字符转义序列
++ 原生字符串：通过反引号(`)来创建，可包含多行，不支持特殊字符转义序列
+
+特殊字符：
+
++ \\：反斜线
++ \'：单引号
++ \"：双引号
++ \a：响铃
++ \b：退格
++ \f：换页
++ \n：换行
++ \r：回车
++ \t：制表符
++ \v：垂直制表符
++ \ooo：3 个 8 位数字给定的八进制码点的 Unicode 字符（不能超过\377）
++ \uhhhh：4 个 16 位数字给定的十六进制码点的 Unicode 字符
++ \Uhhhhhhhh：8 个 32 位数字给定的十六进制码点的 Unicode 字符
++ \xhh：2 个 8 位数字给定的十六进制码点的 Unicode 字符
+
+## 布尔类型
+
+布尔类型用于表示真假，类型名为 bool，只有两个值 true 和 false，占用一个字节宽度，零值为 false
+```go
+var (
+    IsBoy  = true
+    IsGirl = true
+)
+
+// if IsBoy {}
+```
+
+## 自定义类型与枚举类型
+
+在 go 语言中使用 type 声明一种新的类型，语法格式为： type TypeName Formatter
+
+比如我们可以定义自己
+```go
+type Gender string
+```
+
+常使用 iota 生成器用于初始化一系列相同规则的常量，批量声明常量的第一个常量使用
+iota 进行赋值，此时 iota 被重置为 0，其他常量省略类型和赋值，在每初始化一个常量则
+加 1
+
+```go
+// 自定义类型
+type Status string
+
+const (
+	// 自定义类型的值，常量不允许修改, 充当枚举(可选项)
+	STATUS_ONLINE  Status = "online"
+	STATUS_OFFLINE Status = "offline"
+	STATUS_UNKNOW  Status = "unknow"
+)
+```

day01/base_type/main.go

@@ -0,0 +1,41 @@
+package main
+
+import "fmt"
+
+// 自定义类型
+type Status string
+
+const (
+	// 自定义类型的值，常量不允许修改, 充当枚举(可选项)
+	STATUS_ONLINE  Status = "online"
+	STATUS_OFFLINE Status = "offline"
+	STATUS_UNKNOW  Status = "unknow"
+)
+
+func main() {
+	a := []byte{}
+
+	// %+v 打印结构体字段名
+	// []
+	fmt.Printf("%+v \n", a)
+
+	// 字符采用unicode编码, 这里的 值得这个字符串编码是 97
+	b := 'a'
+	fmt.Printf("%+v\n\\n", b)
+
+	name := "bob \"引号\""
+	// 用于格式化 string类型的值
+	fmt.Printf("hello, %+v\n", name)
+
+	multiLine := `这是一个多行字符串
+可以包含换行符号
+	也可以包含 "双引号"
+	还可以包含 '单引号'`
+	fmt.Printf("\n%+v", multiLine)
+
+	// 判断变量是否online
+	status := STATUS_UNKNOW
+	if status == STATUS_ONLINE {
+
+	}
+}

day01/scope/README.md

@@ -0,0 +1,2 @@
+# 变量作用域
+

day01/syntax/README.md

@@ -91,16 +91,8 @@ func main() {
 }
 ```
 
-## Go的基础类型(基础数据结构)
-
-
-
-
-
-
-
-
 
+## 关键字 (拓展)
 
 在这个结构里面必须要符合Go程序的语法, 编写出来的程序才是合法的，才能被编译器识别, 编译器识别代码的基础单位是Lexical Token(词法标记)，比如 如下一段代码:
 ```go
@@ -110,7 +102,7 @@ func main() {
 ```
 
 他包含的Lexical Token(词法标记)，有如下12个:
-```
+```go
 func     // 关键字 func
 main     // 标识符 函数名称
 (        // LPAREN 左小括号
@@ -123,4 +115,112 @@ Println  // 标识符 函数名称
 )        // RPAREN 右小括号
 }        // RBRACE 右花括号
 		  // （此处无多余 token，上一行已闭合）
+```
+
+go 语言支持的所有词法标记如下:
+```go
+var tokens = [...]string{
+        // 特殊词法
+	ILLEGAL: "ILLEGAL",
+	EOF:     "EOF",
+	COMMENT: "COMMENT",
+
+        // 标识符
+	IDENT:  "IDENT",
+
+        // 基本类型
+	INT:    "INT",
+	FLOAT:  "FLOAT",
+	IMAG:   "IMAG",
+	CHAR:   "CHAR",
+	STRING: "STRING",
+
+        // 操作符（节选）
+	ADD: "+",
+	SUB: "-",
+	MUL: "*",
+	QUO: "/",
+	REM: "%",
+
+	AND:     "&",
+	OR:      "|",
+	XOR:     "^",
+	SHL:     "<<",
+	SHR:     ">>",
+	AND_NOT: "&^",
+
+	ADD_ASSIGN: "+=",
+	SUB_ASSIGN: "-=",
+	MUL_ASSIGN: "*=",
+	QUO_ASSIGN: "/=",
+	REM_ASSIGN: "%=",
+
+	AND_ASSIGN:     "&=",
+	OR_ASSIGN:      "|=",
+	XOR_ASSIGN:     "^=",
+	SHL_ASSIGN:     "<<=",
+	SHR_ASSIGN:     ">>=",
+	AND_NOT_ASSIGN: "&^=",
+
+	LAND:  "&&",
+	LOR:   "||",
+	ARROW: "<-",
+	INC:   "++",
+	DEC:   "--",
+
+	EQL:    "==",
+	LSS:    "<",
+	GTR:    ">",
+	ASSIGN: "=",
+	NOT:    "!",
+
+	NEQ:      "!=",
+	LEQ:      "<=",
+	GEQ:      ">=",
+	DEFINE:   ":=",
+	ELLIPSIS: "...",
+
+	LPAREN: "(",
+	LBRACK: "[",
+	LBRACE: "{",
+	COMMA:  ",",
+	PERIOD: ".",
+
+	RPAREN:    ")",
+	RBRACK:    "]",
+	RBRACE:    "}",
+	SEMICOLON: ";",
+	COLON:     ":",
+
+        // 25个关键字
+	BREAK:    "break",
+	CASE:     "case",
+	CHAN:     "chan",
+	CONST:    "const",
+	CONTINUE: "continue",
+
+	DEFAULT:     "default",
+	DEFER:       "defer",
+	ELSE:        "else",
+	FALLTHROUGH: "fallthrough",
+	FOR:         "for",
+
+	FUNC:   "func",
+	GO:     "go",
+	GOTO:   "goto",
+	IF:     "if",
+	IMPORT: "import",
+
+	INTERFACE: "interface",
+	MAP:       "map",
+	PACKAGE:   "package",
+	RANGE:     "range",
+	RETURN:    "return",
+
+	SELECT: "select",
+	STRUCT: "struct",
+	SWITCH: "switch",
+	TYPE:   "type",
+	VAR:    "var",
+}
 ```