Golang 尚硅谷入门笔记(持续更新)

2022-04-16 14:58:16   24  举报





AI智能生成

这是一份详尽的Golang入门笔记，由尚硅谷提供。这份笔记以易理解的方式解释了Golang的基本概念和语法，适合初学者阅读。它涵盖了Golang的各个方面，包括数据类型、控制结构、函数、接口、并发编程等。此外，这份笔记还包含了大量的实例代码和练习题，帮助读者更好地理解和掌握Golang。尚硅谷的这份入门笔记是学习Golang的理想资源，无论你是编程新手还是有一定基础的开发者，都能从中受益。这份笔记将持续更新，以适应Golang语言的发展和变化。

Golang

作者其他创作

大纲/内容

Golang 的所在前面的话

应用领域

区块链

服务端/游戏开发

分布式/云计算

Docker

K8s

Go 语言的诞生和相关故事

Go 语言的特点

1. 函数可以返回多个值

2. 支持高并发

3. 每一行之后不需要分号

4. 切片slice (动态数组)、延迟执行 defer

语法基础

Hello World

语法基础

组成

关键字

标识符

变量

字符串

符号

分隔符

Go 语言一行代表一个语句的结束，不像 C 家族语言一样以分号结束

如果一个语句写多行就需要加一个分号，不推荐

字符串连接

Go 语言字符串连接通过 `+` 实现

案例： fmt.Println("Google " + "Runoob")

关键字

关键字或保留字

预定义标识符

Go 语言的空格

1. 变量声明必须用空格隔开。例如: var age int

2. 语句中适当的空格可以提升代码的可读性，容易理解。

数据类型

1. 布尔类型(bool)

基本介绍

1. 布尔类型也叫 bool 类型，bool 类型数据只允许取值 ture 和 flase

2. bool 类型占 1个字节

3. bool 类型适用与逻辑运算，一般用于程序流程控制

运用场景

if 条件控制语句

for 循环控制语句

测试案例

2. 数字类型

int , float32, float64 ， Go 语言支持整型和浮点数字，并且支持复数，其中位运算采用补码

数字类型

uint8

无符号 8 位整性 0 - 256

uint16

无符号 16 位整型 (0 到 65535)

uint32

无符号 32 位整型 (0 到 4294967295)

uint64

无符号 64 位整型 (0 到 18446744073709551615)

int8

有符号 8 位整型 (-128 到 127)

int16

有符号 16 位整型 (-32768 到 32767)

int32

有符号 32 位整型 (-2147483648 到 2147483647)

int64

有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)

浮点类型

float32

IEEE-754 32位浮点型数

float64

IEEE-754 64位浮点型数

complex64

32 位实数和虚数

complex128

64 位实数和虚数

所占字节

与uint等同等所占字节

3. 字符串类型（string）

字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。
Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。 Go 的字符串不同，它是由字节组成的。

如果需要存储单个的字符串字母，一般使用 byte 来保存。

我们直接输出 byte 的时候他是直接输出了字符的码值

如果我们需要输出对应的字符，需要格式化输出

测试案例

实验案例

注意事项（使用细节）

1. Golang 字符串的字节使用 UTF-8编码进行表示 Unicode 文本，这样golang 统一适用了 utf-8 变么，就能避免了中文乱码的问题

2. 字符串一旦定义就不能修改

错误案例：
var str1 string = "124"
str1[1] = "3"

3.字符串的两种形式

1）双引号，会识别转义字符

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

4.字符串拼接的方式

1）通过 + 加号链接

5. 字符串多行拼接的时候，换行的时候 + 加号需要放到前行的尾部

4. 字符类型（char）

1. 字符常量是用单引号（''）括起来的单个字符，例如 var c1 char = 'a', var c2 char = '中' var c3 char = '9'

2. Go 中有女婿使用转义字符 '\' 来将后面的字符串转变为特殊字符类型常量。例如：var c3 = '\n' // '\n' 表示换行符

3. Go 语言的字符串使用 UTF-8(英文字母1个字节，汉字3个字节)

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

5. 可以直接给某个变量赋一个数字，然后按照格式化输出时 %c, 会输出该字符串对饮的 unicode 字符

6. 字符类型可以进行运算的，相当于一个函数，因为他们都有对应的 Unicode 码

字符类型的本质

1. 字符型存储到计算机中，需要讲字符对应的码值（整数）找出来

存储：字符串 -> 对应码值--> 二进制 --> 存储

读取：二进制 --> 码值 --> 字符 --> 读取

2. 字符和码值的对应关系是通过字符编码表决定的（是规定好的）

2.Go语言的编码都统一成了 utf-8 . 非常方便，很统一，不会有编码乱码的困扰

6. 其他数字类型

byte

类似 uint8

rune

类似 int32

uint

32 或 64 位

int

与 uint 一样

uintptr

无符号整形，用于存放指针

7.基本数据类型的默认值

整型 ==> 0

浮点型 ==> 0

字符串 ==> ""

布尔类型 false

测试案例

8. 基本数据类型的相互转换

介绍：Golang 和 Java/C 不同， Go 在不同类型的变量之间的赋值时需要显式转换，就是说Golang不能自动转换

基本语法

表达式 T(v) 将 v 转换为类型 T

T 就是数据类型，比如： int32

v 就是变量

细节说明

1. Go 中数据乐行可以从表示范围小 --> 表示范围大，也可以表示范围大 --> 表示范围小

2. 被转换的是变量存储的数据（即值），变量本省的数据类型并没有变化

3.在转换中，比如将 int64 转换为 int8, 编译的时候不会报错（需要考虑数据范围），
只是转换的结果是按照溢出处理，和我们希望的结果不一样。

测试案例

9. 基本数据类型和 string 的转换

介绍：开发过程中，我们经常需要将基本数据类型转换为 string , 或者讲 string 转换为基本数据类型

基本语法

1. fmt.Sprintf("%参数"，表达式)，需要参数和表达式的类型匹配

2. strconv .. 返回转换后的字符串

测试案例

fmt.Sprintf

strconv 函数

string 类型转换为基本类型

1. 使用 strconv 包的函数

转换函数如下

func ParseBool(str string) (value bool, err error)
func ParseInt(s string, base int, bitSize int) (i int64, err error)
func ParseUint(s string, base int, bitSize int) (n uint64, err error)
func ParseFloat(s string, bitSize int) (f float64, err error)

2. 案例演示

测试代码

因为返回的是int64 , float64 , 如果需要得到的是int32, float32 等需要做如下处理

var num5 int32
num5 = int32(num)

注意细节

在将 string 类型转换为为基本类型时，要确保 string 类型够能够转换成有效的数据，比如我们可将 "123" 转换成一个整数，
但是不能将一个 “Hello” 转换为整数，如果这样做，golang 直接转换成 0

案例演示

5. 派生类型

(a) 指针类型（Pointer）

基本介绍

1）基本数据了类型，变量存的值，也叫作值类型

2）获取变量的地址，用&, 比如: var num int, 获取 num 的地址： &num

3）指针类型，变量村的是一个地址，这个地址执行的空间存的才是值，比如：var ptr *int = &num

4) 获取指针的类型所指向的值，使用:* , 比如：var *ptr int , 使用 *ptr 来获取 p 指向的的值

举例说明

var num int = 1

var i = 999

var ptr *int = &i

案例分析

func main() {
var a int = 100
var ptr *int = a // 错误，正确方式 &a
}

func main() {
var a int = 100
var ptr *float32 = &a // 错误，类型不匹配
}

fun main {
var a int = 300 //
var b int = 400 //
var ptr *int = *a //ok
*ptr = 100 // a = 100
ptr = &b
*ptr = 200 // b=200
fmt.Printf("a=%d, b=%d, *ptr=%d", a, b *ptr)
}
// 输出结果
a=100, b =200, *ptr = 200

指针的使用细节

值类型，都有对应的指针类型，形式为 *数据类型，比如 int 的指针类型就是 *int, float32 对应的指针类型就是 *float ，以此类推。

值类型包括：基本数据类型 int 系列， bool, string , 数组和结构体 struct

(b) 数组类型

(e) 函数类型

(f) 切片类型

(g) 接口类型（interface）

(h) Map 类型

语言变量

概念：变量相当于内存中一个数据存储空间的表示，你可以把变量看作是一个房间的门牌号，
通过门牌号我们可以找到房间，同样的道理，通过变量名可以访问到变量的值。

声明变量

第一种，指定变量类型，如果没有初始化，则变量默认为零值。

第二种，根据值自行判定变量类型。

第三种，省略 var, 注意 := 左侧如果没有声明新的变量，就产生编译错误，格式：

多个变量声明

子主题

语言常量

常量是简单的标识符，在运行时，不会被修改的量

常量中的数据类型可以是布尔类型，数字型（整数型，浮点型和复数）和字符串类型

const 关键字

常量定义格式：const identifier [type] = value

举例：const b string = "abc" 或者 const b string = "abc"

iota 关键字

iota，特殊常量，可以认为是一个可以被编译器修改的常量。

iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，
const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

代码示例

语言函数

概述

函数是基本的代码块，用于执行一个任务。

Go 语言最少有个 main() 函数。

你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。

函数声明（函数签名）告诉了编译器函数的名称，返回类型，和参数。

Go 语言标准库提供了多种可动用的内置的函数。例如，len() 函数可以接受不同类型参数并返回该类型的长度。
如果我们传入的是字符串则返回字符串的长度，如果传入的是数组，则返回数组中包含的元素个数。

定义

函数定义如下：
fun function_name ([parameter list]) [return_types] {
函数体
}

简单函数调用

函数返回多个值

函数参数

值传递

值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

例子

引用传递

引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

例子

函数用法

函数作为一另外一个函数的实参

定义：函数定义后可作为另外一个函数的实参数传入

例子

闭包

定义：闭包是匿名函数，可在动态编程中使用

例子

方法

定义：方法就是一个包含了接受者的函数

例子

值类型和引用类型

值类型：基本数据类型 int 系列，bool , string , 数组和结构体 struct

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

使用特点

1. 值类型，变量直接存储值，通常在栈中分配

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

标识符概念

概念

Golang 堆各种变量，方法，函数等命名使用的字符序列成为标识符

凡是自己可以起名的地方都叫做标识符

标识符命名规则

1. 由 26 个英文字母大小写，0-9, _ 组成

2. 数字不可以开头

3. Golang 中严格区分大小写

4. 标识符不能包含空格

5. 下划线 “_”本身在 Go 中是一个特殊的标识符，成为空标识符。可以代表任何其他的标识符，但是它对应的值会被忽略（比如：忽略某个返回值）。
所以仅能够被作为占位符使用，不能作为标识符使用

6. 不能以系统保留字作为标识符，比如： brack , if 等

保留关键字介绍

在Golang 中为了简化编码编译过程中对代码的解析，其定义的保留关键字有25 个

系统保留关键字列表

实验代码

举例子说明
hello //ok
hello12 //ok
1hello //error ，不能数字开头
h-b //error 不能使用 -
x h // error 不能有空格
h_4 //ok
_ab //ok
int //ok 不推荐使用
float32 //ok 不推荐使用
_ //error
Abc // ok

标识符命名注意事项

1. 包名，保持package的名字和目录的名字保持一直，尽量采用有意义的包名，简短，有意义，不要和标准库冲突

2. 变量名，函数名，常量名，采用驼峰命名

3. 如果变量名、函数名、长两名首字母大写，则可以被其他的包访问；如果首字母小写，则只能在本包内使用
（注意：可以简单的理解为，首字母大写是公有的，首字母小写是私有的）

注意事项的案例

预定义标识符

介绍：除了保留关键字外，Go 还提供了 36 个预定义的标识符，其中包括基础类型和系统嵌入函数

预定义标识符

变量

运算符

1. 算术运算符

算数运算符就是对数值类型的变量进行运算的，比如，加减乘除。在Go中运用非常的多

算数运算符

除法演示

//说明，如果运算的数都是整数，那么除后，将会去除小数位
fmt.Println(10 / 4) //2

var n1 float32 = 10 / 4
fmt.Println(n1) //2

//如果我们希望保留小数，那么就需要有浮点数参与运算
fmt.Println(10 / 4.0) //2.5

取模演示

//演示 % 的使用
//看一个公式 a % b = a - a / b * b
fmt.Println("10%3=", 10%3) //=1
fmt.Println("-10%3=", -10%3) //=-1 ==> -10 - ( -10) / 3*3 = -10 - (-9) = -1
fmt.Println("10%-3=", 10%-3) //=1
fmt.Println("-10%-3=", -10%-3) //=-1

++ 和 --

//++ -- 的使用
var i int = 10
i++ // i=i+1
fmt.Println("i=", i) // =11
i-- // i=i-1
fmt.Println("i=", i) // =10

细节说明

1. 对于除号 "/" 它的整除和小数除是有区别的，整数之间做除法时，只保留整数部分而舍弃小数部分。例如：x:= 19/5（结果：3.8）结果是 3

2. 当对一个数取模的时候，可以等价为 a%b = a-a/b*b, 这样我们可以看到取模的一个本质运算

3. Golang 的自增只能当做一个独立的语言使用时，不能这样使用
b := a++ 或者 b := a--

错误用法

4. Golang 的 ++ 和 -- 只能写在变量的后面，不能写在变量的前面，即，只有 a++, a-- 没有 ++a, --A

错误演示

5. Golang 的设计者去掉了 c/java 中自增和自减的容易混淆的写法，让golang 更加简介，统一（强制性）

测试题目

题目

1. 假如还有 97 天放假，请问：xx 个星期零 xx 天

2. 定义一个变量保存华氏摄氏度，华式摄氏度转换摄氏度的公式为：5/9*（华氏摄氏度-100），
请求出华氏摄氏度的对应摄氏度温度。

答案代码

2. 关系运算符

基本介绍

1. 关系运算符的结果都是 bool 类型，要么是 true , 要么是 false

2. 关系表达式，经常在 if 结构的条件中或者循环结构的条件中

关系运算法（比较运算符）

关系运算符表格

案例代码

细节说明

1. 关系运算符的结果都是 bool 类型，也就是要么是 true，要么是 false

2. 关系运算符组成的表达式，我们称为关系表达式： a > b

3.比较运算符 “==” 不能写成 “=” ！！

3. 逻辑运算符

用于连接多个条件（一般来讲及时关系表达式），最终的结果也就是一个 bool 值

逻辑运算符

代码演示

逻辑运算的基本细节

1. && 也叫短路与; 如果第一个条件为 false , 则第二个条件不会判断，最终结果为 false

2. || 也叫做短路或，如果第一个条件为 true ，则第二个条件也不会判断，最终结果为 true

结论验证代码

4. 赋值运算符

赋值运算符就是讲某个运算后的值，赋给指定的变量

赋值运算符分类

运算符分类

使用案例

测试题目：交换 a , b 的值，不创建中间的临时变量

实现代码

5. 运算符优先级

运算符优先级

1）运算符不同的优先级，所谓优先级就是表达运算符中的与那苏娜顺序，如下表所示，上一行运算符总优于下一行。

运算符优先级

2）只有单目运算符、赋值运算符是从右向左运算的。

3）大致的顺序整理

1. 括号， ++， --

2. 单目运算

3. 算数运算符

4.移位运算符

5.关系运算符

6. 位运算符

7. 逻辑运算符

8. 赋值运算符

9.逗号

6. 位运算符

定义：位运算符对整数在内存中的二进制位进行操作。

位运算符一览表

7. 其他运算符

其他运算符列表

Go 语言明确不支持三元运算符

演示代码

8.键盘输入语句

介绍

在变成中，需要接受yoghurt输入的数据，就可以使用键盘输入语句来获取

步骤

1. 导入 fmt 包

2. 调用fmt 包的 fmt.Scanln() 或者 fmt.Scanf()

案例

要求：可以从控制台接受用户信息（姓名、年龄，薪酬）

1. 使用 fmt.Scanln() 获取

演示代码

2. 使用 fmt.Sacnf() 获取

演示代码

9. 进制

对于整数有四种表示方式

1. 二进制， 0，1 满二进一

2. 8进制 0-7 满 8 进 1，以数字0开头

3 十进制，0-9 满10进1

4. 十六进制，0-9， A-F 满16 进一，以 0x 或者 0X 开头， A-F 不区分大小写；例子0x21F + 1 = 0X21B0

演示案例

进制图示

进制转换

10. 位运算

二进制在运算中的说明

二进制是逢二进位的进制位，0、 1是基本符

现代的电子计算机技术全部采用的是二进制，因为它只使用0 、1 两个数字符号，非常简单方便，易于是电子方式实现。
计算机内部处理的信息，都是采用二进制来表示的。二进制（Binary）数用0 和 1两个数字及组合来表示任何数，规则是“逢二进一”，
数字1在不同的位上表示不同的值，按右到左的次序，这个值二倍递增

原码、反码、补码

1. 二进制的最高位是符号位，0 表示正数，1表示负数

2. 正数的原码，反码，补码都一样

3. 负数的补码=它的原码符号位不变，其他位取反（0->1. 1->0）

4. 负数的补码 = 它的反码 + 1

5. 0 的反码，补码都是 0

6. 在计算机运算的时候，都是以补码的方式来运算的

计算推导

原码
1 ==> [0000 0001] -1 ==>[1000 0001]

1 ==> 原码 [0000 0001] 反码 [0000 0001] 补码 [0000 0001]
-1 ==> 原码 [1000 0001] 反码 [1111 1110] 补码 [1111 1111]

Golang 中的三个位运算符

分别是按位与 & ，按位或 | 、按位异或 ^ 他们的规则如下

按位与 & ：两位全为1，结果为 1 ，否则为 0

按位或| ：两位有一个 1 ，结果为 1 ，否则为 0

按位异或^: 两位一个为 0，一个为 1 ，结果为 1 ，否则为0

比如：2 & 3 ？ 2 |3=? 2^3 = ？

案例计算：
位运算
2 & 3 = 2
2 => 0000 0010
3 => 0000 0011
2 & 3 = 0000 0010 =>2

2 | 3 =
0000 0010
0000 0011
2 | 3 = 0000 0011 => 3

2 ^3 =
0000 0010
0000 0011
2 ^ 3 = 0000 0001 => 1

带负数的计算
-2 & 2
-2 原码 1000 0010 反码 1111 1101 补码 1111 1110
2
补码 0000 0010

-2 & 2
结果：补码 1111 1100 反码 1111 1011 原码 1000 0100 => -1

位运算与移位运算符

>> 、<< 右移和左移，运算规则

右移运算符：>> 低位溢出，符号位不变，并用符号位补溢出的高位

左移运算符：<< 符号位不变，低位补0

计算题：a := 1 >>2

计算案例：
// 左移，右移
a := 1 >> 2
0000 0001 ==> 0000 0000 = 0
a: = 1 << 2
0000 0001 => 0000 0100 = 4

程序流程控制

程序流程控制的基本介绍

在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要是有三大流程控制语句。

1. 顺序控制

2. 分支控制

3. 循环控制

循环语句

for 循环

举个例子

循环嵌套

循环控制

break

continue 语句

goto 语句

无限循环

条件语句

if 语句

if .. else 语句

if 嵌套语句

switch 语句

select 语句

顺序控制

介绍：程序从上倒下逐行地执行，中间没有任何判断和跳转

注意事项

Golang 定义变量时采用合法的 向前引用

案例:
//正确案例
var num1 int = 10
var num2 int = num1 + 10
fmt.Println(num2);

//错误案例
var num4 int = num3 + 10
var num3 int = 10
fmt.Println(num4);

分支控制

介绍：让程序有选择的执行。有下面三种形式

1. 单分支

基本语法

if 条件语句 {
//执行代码块
}

说明：当前体哦傲剑表达式为 true 的时候，就会执行 {} 内的代码，注意
{} 必须是有的，就算你只写一行代码。

案例说明：
编写一个程序，可以输入人的年龄，如果该通知的年龄大于18 岁，则输出 “你的年龄大于 18 ，要对自己的行为负责”

案例代码

2. 双分支

基本语法

if 条件语句 {
//执行代码块1
} else {
//执行代码块2
}

说明：当前条件成立，即执行代码块1，否则执行代码块 2，{} 也是必须有的。

3. 多分支

循环控制

高级特征

Go 语言作用域

定义

作用域为已声明标识符所表示的常量、类型、变量、函数或包在源代码中的作用范围。

申明

函数内定义的变量称为局部变量

函数外定义的变量称为全局变量

函数定义中的变量称为形式参数

局部变量

全局变量

形式参数

错误处理

Go 语言通过内置的错误接口提供了非常简单的错误处理机制。

error类型是一个接口类型，这是它的定义：
type error interface {
Error() string
}

数组

定义

数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整形、字符串或者自定义类型。
相对于去声明 number0, number1, ..., number99 的变量，使用数组形式 numbers[0], numbers[1] ..., numbers[99] 更加方便且易于扩展。
数组元素可以通过索引（位置）来读取（或者修改），索引从 0 开始，第一个元素索引为 0，第二个索引为 1，以此类推。

声明数组

var variable_name [SIZE] variable_type

初始化数组

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

案例：数组打印和初始化

多维数组

案例

数组使用细节图

二维数组

定义

数组里再镶嵌一维数组

二维数组使用①

二维数组使用②

二维数组在内存的布局

二维数组的遍历

指针

定义

Go 语言中指针是很容易学习的，Go 语言中使用指针可以更简单的执行一些任务。

Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。

什么是指针？

一个指针变量指向了一个值的内存地址。

指针的使用流程

1. 定义指针变量。

2. 为指针变量赋值。

3. 访问指针变量中指向地址的值。

空指针

当指针被定义后没有分配到任何变量时，它的值为 nil

nil 指针也是空指针

nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。

一个指针变量通常缩写为 ptr。

拓展内容

指针数组

你可以定义一个指针数组来存储地址

案例

指向指针的指针

Go 支持指向指针的指针

向函数传递指针参数

通过引用或地址传参，在函数调用时可以改变其值

结构体

结构体描述

Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

定义结构体

语法格式

variable_name := structure_variable_type {value1, value2...valuen}

variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}

结构体使用实例

实例1

访问结构体成员

结构体作为函数参数

结构体指针

切片(Slice)

Go 语言切片是对数组的抽象。(不固定长度的数组)

Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片("动态数组"),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

切片内存图

1.通过引用数组-切片

2.通过make创建切片

切片内存图总结

1.slice的确是一个引用类型

2.slice从底层来说，其实就是一个数据结构(struct结构体)

切片使用的三种方式

方式一和方式二的区别(面试)

切片的遍历(跟数组遍历差不多)

切片注意事项和细节说明

1、

2、

3、

通过append内置函数追加切片

内存示意图

底层原理

代码实现

通过copy拷贝切片

string和slice联系

1.string底层是一个byte数组，因此string也可以进行切片处理

案例演示

2.string和切片在内存的形式，以"abcd"画出内存示意图

示意图

3.string是不可变的，也就说不能通过str[0]='z'方式来修改字符串

案例演示

4.如果需要修改字符串，可以现将string->[]byte/或者[]rune->修改->重写转成string

案例演示

课堂练习

范围(Range)

Go 语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。
在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对。

Map(集合)

Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。

Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，
这是因为 Map 是使用 hash 表来实现的。

案例

delete() 函数

delete() 函数用于删除集合的元素, 参数为 map 和其对应的 key。

递归函数

递归，就是在运行的过程中调用自己。

猴子吃桃

类型转换

类型转换用于将一种数据类型的变量转换为另外一种类型的变量。

案例

接口

Go 语言提供了另外一种数据类型即接口，它把所有的具有共性的方法定义在一起，
任何其他类型只要实现了这些方法就是实现了这个接口。

案例

并发

Go 语言支持并发，我们只需要通过 go 关键字来开启 goroutine 即可。

goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的。

goroutine 语法格式：
go 函数名（参数列表）

例子： go f(x, y, z)

通道（channel）

通道缓冲区

Go 遍历通道与关闭通道

包的基本概念

说明：Go与语言的每个文件都属于一个包，也就是说go 是以包的行是来管理文件和项目目录结构的。

作用

1. 区分相同名字的函数、变量标识符等

2.当程序文件很多的时候，可以很好的管理项目

3.控制函数、变量等访问范围，即作用域

使用

包的基本语法： package util

包的基本用法 import "包的路径"

注意事项

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

2.当一个文件需要使用其他函数或者变量的时候，需要先引入对饮的包名

1. 引入方式 import "包名"

2. 引入放方式：
import (
"包名"
"包名"
)

3. package 指令在文件的第一行，然后是 import 指令

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

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

6. 在访问其他包的函数时，其语法是 包名.函数名。

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

8. 在同一个包下面，不能有相同的函数名，否则会报错

常见文件

1. 提示找不到包
main.go:7:2: package demoserver/commlib is not in GOROOT (c:\go\src\demoserver\commlib)
main.go:8:2: package demoserver/handleservice is not in GOROOT (c:\go\src\demoserver\handleservice)

处理方案

1. 如果要用 gopath模式引入包从src目录下开始引入需要关闭 go mod 模式
export GO111MODULE=off

2. 如果使用go mod 模式
export GO111MODULE=on
并且在目录下执行 go mod init

Golang 数据操作

MySQL 数据库操作

Redis 操作