所提供的命令

在 Go modules 中，我们能够使用如下命令进行操作：

1.  在给一个文件打包时，该包对应一个文件夹，比如这里的 utils 文件夹对应的包名就是 utils,
文件的包名通常和文件所在的文件夹名一致，一般为小写字母。

2.  当一个文件要使用其它包函数或变量时，需要先引入对应的包
 引入方式 1:import “包名”

引入方式 2:

import (

“包名”

“包名”

)

package 指令在 文件第一行，然后是 import 指令。

在 import 包时，路径从 $GOPATH 的 src 下开始，不用带 src , 编译器会自动从 src 下开始引入

3.为了让其它包的文件，可以访问到本包的函数，则该函数名的首字母需要大写，类似其它语言
的 public ,这样才能跨包访问。比如 utils.go 的

4.在访问其它包函数，变量时，其语法是 包名.函数名， 比如这里的 main.go 文件中

5.  如果包名较长，Go 支持给包取别名， 注意细节:取别名后，原来的包名就不能使用了

说明: 如果给包取了别名，则需要使用别名来访问该包的函数和变量。 6.在同一包下，不能有相同的函数名(也不能有相同的全局变量名)，否则报重复定义

7.如果你要编译成一个可执行程序文件，就需要将这个包声明为 main , 即 package main .这个就是一个语法规范，如果你是写一个库 ，包名可以自定义

if 与传统语言的区别

判断条件不推荐 ➕（） 
无论执行语句多简单，必须 ➕{}
大括号必须在判断条件后，不得换行

1
2
3

if flag== false { //这里必须这样写 golang 语法强制要求
    fmt.Println("zzzzzz")
}

switch 与传统语言区别很大

1.匹配项后面也不需要再加 **break
**
2.case/switch 后是一个表达式( 即:常量值、变量、一个有返回值的函数等都可以)

3.case 后的各个表达式的值的数据类型，必须和 switch 的表达式数据类型一致

4.case 后面可以带多个表达式，使用逗号间隔。比如 case 表达式 1, 表达式 2 …

5.case 后面的表达式如果是常量值(字面量)，则要求不能重复

6.case 后面不需要带 break , 程序匹配到一个 case 后就会执行对应的代码块，然后退出 switch，如
果一个都匹配不到，则执行 default

7.default 语句不是必须的.

8.switch 后也可以不带表达式，类似 if –else 分支来使用。

9.switch 后也可以直接声明/定义一个变量，分号结束，不推荐。

10.switch 穿透-fallthrough ，如果在 case 语句块后增加 fallthrough ,则会继续执行下一个 case，也
叫 switch 穿透

11.Type Switch:switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际指向的
变量类型

switch 和 if 的比较

什么情况下使用 switch ,什么情况下使用 if

1. 如果判断的具体数值不多，而且符合整数、浮点数、字符、字符串这几种类型。建议使用 **swtich
   **语句，简洁高效。
2. 其他情况:对区间判断和结果为 bool **类型的判断，使用 if，if **的使用范围更广。

for 循环

1.循环条件是返回一个布尔值的表达式

2. for 循环的第二种使用方式

for 循环判断条件 {
//循环执行语句

}

将变量初始化和变量迭代写到其它位置

3.for 循环的第三种使用方式

for {

//循环执行语句

}

上面的写法等价 **for ; ; {} **是一个无限循环， 通常需要配合 **break **语句使用

4. Golang 提供 for-range 的方式，可以方便遍历字符串和数组.
   如果我们的字符串含有中文，那么传统的遍历字符串方式，就是错误，会出现乱码。原因是传统的

对字符串的遍历是按照字节来遍历，而一个汉字在 utf8 编码是对应 **3 **个字节。

如何解决 需要要将 str 转成 []rune 切片.

对应 for-range 遍历方式而言，是按照字符方式遍历。因此如果有字符串有中文，也是 ok

系统保留关键字

break   //退出循环
default  //选择结构默认项（switch、select）
func   //定义函数
interface //定义接口
select  //channel
case   //选择结构标签
chan   //定义 channel
const   //常量
continue  //跳过本次循环
defer   //延迟执行内容（收尾工作）
go   //并发执行
map   //map 类型
struct  //定义结构体
else   //选择结构
goto   //跳转语句
package  //包
switch  //选择结构
fallthrough  //switch 中 继续向下执行
if   //选择结构
range   //从 slice、map 等结构中取元素
type  //定义类型
for   //循环
import   //导入包
return   //返回
var  //定义变量

预定义标识符

基本用法

1. 基本数据类型，变量存的就是值，也叫值类型
2. 获取变量的地址，用&，比如: var num int, 获取 num 的地址:#

基本数据类型在内存的布局.

3. 指针类型，指针变量存的是一个地址，这个地址指向的空间存的才是值
   比如:var ptr *int = #

指针在内存的布局.

4. 获取指针类型所指向的值，使用:*，比如:var ptr int, 使用\ptr 获取 ptr 指向的值

5) 一个案例再说明

值类型和引用类型的使用特点

1. 值类型:变量直接存储值，内存通常在栈中分配
       值类型:基本数据类型 int 系列, float 系列, bool, string 、数组和结构体 struct

2) 引用类型:变量存储的是一个地址，这个地址对应的空间才真正存储数据(值)，内存通常在堆
上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，由 GC 来回收

引用类型:指针、slice 切片、map、管道 chan、interface 等都是引用类型

3) 内存的栈区和堆区示意图

整型

1. Golang 各整数类型分:有符号和无符号，int uint 的大小和系统有关。

2. Golang 的整型默认声明为 int 型

3. 如何在程序查看某个变量的字节大小和数据类型 (使用较多)

4. Golang 程序中整型变量在使用时，遵守保小不保大的原则，即:在保证程序正确运行下，尽量
   使用占用空间小的数据类型。【如:年龄】

5. bit: 计算机中的最小存储单位。byte:计算机中基本存储单元。[二进制再详细说] 1byte = 8 bit

小数/浮点类型

1.关于浮点数在机器中存放形式的简单说明,浮点数=符号位+指数位+尾数位

2.尾数部分可能丢失，造成精度损失。 -123.0000901

float64 的精度比 float32 的要准确.

如果我们要保存一个精度高的数，则应该选用 float64（系统默认是float64）

1. Golang 浮点类型有固定长度的范围和字段长度，不受具体 OS(操作系统)的影响。
2. Golang 的浮点型默认声明为 float64 类型。
3. 浮点型常量有两种表示形式

十进制数形式:如:5.12 .512 (必须有小数点)
科学计数法形式:如:5.1234e2 = 5.12 * 10 的 2 次方 5.12E-2 = 5.12/10 的 2 次方

4. 通常情况下，应该使用 float64 ，因为它比 float32 更精确。[开发中，推荐使用 float64]

字符类型

Golang 中没有专门的字符类型，如果要存储单个字符(字母)，一般使用 **byte **来保存。

字符串就是一串固定长度的字符连接起来的字符序列。

1. 字符常量是用单引号(‘’)括起来的单个字符。例如:var c1 byte = ‘a’ var c2 int = ‘中’ var c3
   byte = ‘9’

2. Go 中允许使用转义字符 ‘\’来将其后的字符转变为特殊字符型常量。例如:var c3 char = ‘\n’
   // ‘\n’表示换行符

3. Go 语言的字符使用 UTF-8 编码 ，如果想查询字符对应的 utf8 码值
   http://www.mytju.com/classcode/tools/encode_utf8.asp

英文字母-1 个字节 汉字-3 个字节

4. 在 Go 中，字符的本质是一个整数，直接输出时，是该字符对应的 UTF-8 编码的码值。

5. 可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的 unicode 字符   6) 字符类型是可以进行运算的，相当于一个整数，因为它都对应有 Unicode 码.

布尔类型

bool 类型占 1 个字节。

String 类型

1. Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本，这样 Golang 统一使用 UTF-8 编码,中文
   乱码问题不会再困扰程序员。

2. 字符串一旦赋值了，字符串就不能修改了:在 Go 中字符串是不可变的。

3. 字符串的两种表示形式

(1) 双引号, 会识别转义字符

(2) 反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果

4. 字符串拼接方式

5. 当一行字符串太长时，需要使用到多行字符串，可以如下处理（➕ 必须要在换行后面）
   

基本数据类型默认值

基本数据了型的相互转换

基本介绍

Golang 和 java / c 不同，Go 在不同类型的变量之间赋值时需要显式转换。也就是说 Golang 中数
据类型不能自动转换。

基本语法

表达式 T(v) 将值 v 转换为类型 T
T: 就是数据类型，比如 int32，int64，float32 等等
v: 就是需要转换的变量

基本数据类型转换

1. Go 中，数据类型的转换可以是从表示范围小–>表示范围大，也可以范围大—>范围小

2. 被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化!

3) 在转换中，比如将 int64 转成 int8 【-128—127】 ，编译时不会报错，只是转换的结果是按溢出处理，和我们希望的结果不一样。 因此在转换时，需要考虑范围.

string 转基本数据类型的注意事项

在将 String 类型转成 基本数据类型时，要确保 **String **类型能够转成有效的数据，比如 我们可以
把 “123” , 转成一个整数，但是不能把 “hello” 转成一个整数，如果这样做，Golang 直接将其转成 0 ，
其它类型也是一样的道理. float => 0 bool => false

type

介绍注释

用于注解说明解释程序的文字就是注释，注释提高了代码的阅读性;
注释是一个程序员必须要具有的良好编程习惯。将自己的思想通过注释先整理出来，再用代码去
体现。

在 Golang 中注释有两种形式

1) 行注释（官方推荐）

基本语法

// 注释内容

举例

2) 块注释(多行注释)

基本语法

/* 
注释内容

*/

举例

使用细节

1) 对于行注释和块注释，被注释的文字，不会被 Go 编译器执行。

2) 块注释里面不允许有块注释嵌套 [注意一下]

说明:常用的转义字符有如下:
 1. \t : 表示一个制表符，通常使用它可以排版。

2. \n :换行符

3.                           \\ :一个\
   

4.                           \" :一个"
   

5.                           \r :一个回车 fmt.Println("天龙八部雪山飞狐\r 张飞");
   

例子：

简介:

Go 语言保证了既能到达静态编译语言的安全和性能，又达到了动态语言开发维护的高效率，使用一个表达式来形容 Go 语言:Go = C + Python , 说明 Go 语言既有 C 静态语言程序的运行速度，又能达到 Python 动态语言的快速开发。

1) 从 C 语言中继承了很多理念，包括表达式语法，控制结构，基础数据类型，调用参数传值，指针等等，也保留了和 C 语言一样的编译执行方式及弱化的指针

举一个案例(体验)://go 语言的指针的使用特点(体验)

func testPtr(num *int) {

*num = 20

}

2) 引入包的概念，用于组织程序结构，Go 语言的一个文件都要归属于一个包，而不能单独存在。

3) 垃圾回收机制，内存自动回收，不需开发人员管理

4) 天然并发 (重要特点)

(1) 从语言层面支持并发，实现简单

(2) goroutine，轻量级线程，可实现大并发处理，高效利用多核。

(3) 基于 CPS 并发模型(Communicating Sequential Processes )实现 5) 吸收了管道通信机制，形成 Go 语言特有的管道 channel 通过管道 channel , 可以实现不同的 goroute 之间的相互通信。

6) 函数可以返回多个值。举例:

**//**写一个函数，实现同时返回 和，差

**//go **函数支持返回多个值

**    func getSumAndSub(n1 int, n2 int) (int, int ) {
**
sum := n1 + n2 //go **语句后面不要带分号.
sub := n1 - n2**
**return sum , sub
**
**}
**

7) 新的创新:比如切片 slice、延时执行 defer

Golang 执行流程分析

如果是对源码编译后，再执行，Go 的执行流程如下图

如果我们是对源码直接 执行 go run 源码，Go 的执行流程如下图

两种执行流程的方式区别      1) 如果我们先编译生成了可执行文件，那么我们可以将该可执行文件拷贝到没有 go 开发环境的机器上，仍然可以运行

2) 如果我们是直接 go run go 源代码，那么如果要在另外一个机器上这么运行，也需要 go 开发环境，否则无法执行。

3) 在编译时，编译器会将程序运行依赖的库文件包含在可执行文件中，所以，可执行文件变大了很多。