Go语言第二章(小无相功)

内功心法(小无相功)

Go 变量标准完整声明格式： `var 变量名 数据类型 = 初始值`

package main

import "fmt"

func main() {
	//关键字 变量名 类型 = 值
	var name string = "小满"
	fmt.Println(name)
}

以上便是变量声明的规则，我们声明了一个字符串类型的变量name，并赋值为"小满"，那什么时候该用字符串呢？你在网页中所看到大部分文本和文字都是字符串，比如："你好，世界！"、"Hello, World!"、"こんにちは、世界！"等。所以，当你需要存储文本、文字或任何字符序列时，就可以使用字符串类型。

类型推断

类型推断是Go语言的一种特性，它可以根据变量的值自动推断变量的类型。比如：

package main

import "fmt"

func main() {
	//关键字 变量名 类型 = 值
	var name = "小满"
	var age = 18 //int 表示整数类型
	fmt.Println(name, age) //输出：小满 18
}

当你鼠标悬浮在变量名上时，会自动显示变量的类型和值。如上所示，name 的类型为 string，age 的类型为 int。

自动零值

package main

import "fmt"

func main() {
	var name string
	var age int
	fmt.Println(name, age) //输出："" 0
}

我们可以声明变量不赋值，那么变量就会有一个默认值。 输出结果为："" 0，因为name和age没有赋值，所以默认值为空字符串和0。

变量简写

package main

import "fmt"

func main() {
	//变量名 := 值
	name := "小满"
	fmt.Println(name)
}

我们可以用 :=来简写变量声明，可以省略类型和关键字，但是不能省略变量名和值。

注意点：变量简写只能用于函数内部，不能用于全局变量。

多变量声明

package main

import "fmt"

func main() {
	//多个变量用逗号隔开
	age, name := 18, "小满"
	fmt.Println(age, name) //输出：18 小满
}

多个变量声明需要用,隔开，并且赋值的时候也是根据顺序赋值。例如 age = 18, name = "小满"。

作业

1. 声明一个变量，类型为字符串，值为"小满"。
2. 声明一个变量，类型为整数，值为18。
3. 并且使用多变量声明以及简写的方式，以及输出到终端。

核心内功(纯阳无极功)

字符串

package main

import "fmt"

func main() {
	text := "这是一段文本，苍天已死，黄天当立，岁在甲子，天下大吉。"
    text += "\n这是第二段文本，天地玄黄，宇宙洪荒，日月盈昃，辰宿列张。"
	fmt.Println(text)
}

Go 语言中字符串需要通过双引号包裹文本内容，如果有多段文本需要拼接，可以使用加号+进行拼接。如果需要换行，可以使用反斜杠\n进行换行。

输出内容如下:

这是一段文本，苍天已死，黄天当立，岁在甲子，天下大吉。

这是第二段文本，天地玄黄，宇宙洪荒，日月盈昃，辰宿列张。

数字

package main

import "fmt"

func main() {
	var age int = 18
	fmt.Println(age)
}

Go 语言中数字类型有多种，包括整数、浮点数、复数等。

整数包括有符号和无符号两种，有符号包括int8、int16、int32、int64，无符号包括uint8、uint16、uint32、uint64。

有符号和无符号的区别是：有符号可以表示正数和负数，无符号只能表示正数。

类型	占用字节数	取值范围
int8	1 字节	-128 ~ 127
int16	2 字节	-32768 ~ 32767
int32	4 字节	-2147483648 ~ 2147483647
int64	8 字节	-9223372036854775808 ~ 9223372036854775807
int	自适应	32 位系统同 int32，64 位系统同 int64

类型	占用字节数	取值范围
uint8	1 字节	0 ~ 255
uint16	2 字节	0 ~ 65535
uint32	4 字节	0 ~ 4294967295
uint64	8 字节	0 ~ 18446744073709551615
uint	自适应	32 位系统同 uint32，64 位系统同 uint64
uintptr	自适应	与 uint 范围一致，用于存储内存地址

浮点数包括单精度浮点数和双精度浮点数，分别对应float32和float64。

类型	名称	字节	有效精度
float32	单精度	4	5~7 位
float64	双精度	8	15~16 位

布尔

package main

import "fmt"

func main() {
	var isShow bool = true
	fmt.Println(isShow)
}

布尔值只有两个，true和false。一般用于条件判断，和状态表示。

例如：开关 如果开启则是(true)，如果关闭则是(false)。

数组 和 切片

package main

import "fmt"

func main() {
	//数组
	var arr [5]int // 定义一个长度为5的整型数组 但是未赋值 所以输出为[0 0 0 0 0]
	fmt.Println(arr)
	//----------------------------------------------------------------------
	arr2 := [5]int{1, 2, 3, 4, 5} // 定义一个长度为5的整型数组 并赋值为[1 2 3 4 5]
	fmt.Println(arr2)
	//----------------------------------------------------------------------
	//切片
	arr3 := []int{}                          // 定义一个空切片
	arr3 = append(arr3, 6, 6, 6, 6, 6, 6, 6) // 追加元素
	fmt.Println(arr3)                        // 输出为[6 6 6 6 6 6 6]
	fmt.Println(len(arr3))                   // 获取切片的长度 输出为7
}

数组 是长度固定的连续内存块，定义后长度不可变，未赋值的元素会使用对应类型的零值（整型为 0）。

切片 是对数组的抽象，长度可变，底层仍依赖数组。常用 append 追加元素，用 len 获取当前长度，用 cap 获取底层数组容量。

特性	数组	切片
长度	固定，定义时确定	可变
声明	[5]int	[]int
传参	值传递，会复制整个数组	引用传递，共享底层数据
适用场景	固定大小、性能敏感	日常开发中最常用

映射

package main

import "fmt"

func main() {
	// 定义一个 map，键为 string，值为 int
	scores := map[string]int{
		"张三": 90,
		"李四": 85,
		"王五": 92,
	}
	fmt.Println(scores["张三"]) // 输出：90

	// 添加或修改键值对
	scores["赵六"] = 88
	delete(scores, "李四") // 删除键值对

	// 判断键是否存在
	score, ok := scores["张三"]
	if ok {
		fmt.Println("张三的分数是", score)
	}
}

映射（map）是一种键值对集合，通过键快速查找对应的值。键的类型必须是可比较类型（如 string、int），值可以是任意类型。

常用操作：

• map[key] --- 读取值，键不存在时返回零值
• map[key] = value --- 添加或修改
• delete(map, key) --- 删除键值对
• value, ok := map[key] --- 判断键是否存在，ok 为 true 表示存在

结构体

package main

import "fmt"

// 定义结构体类型
type Person struct {
	Name string
	Age  int
}

func main() {
	// 创建结构体实例
	p := Person{
		Name: "小满",
		Age:  18,
	}
	fmt.Println(p.Name, p.Age) // 输出：小满 18

	// 访问和修改字段
	p.Age = 20
	fmt.Println(p.Age) // 输出：20
}

结构体（struct）用于将多个不同类型的字段组合成一个自定义类型，是面向对象编程的基础。通过 type 名称 struct { ... } 定义，用点号 . 访问字段。

结构体适合描述具有多个属性的实体，例如用户信息、商品详情、坐标点等。

接口

package main

import "fmt"

// 定义接口：包含一个 Speak 方法
type Animal interface {
	Speak() string
}

type Dog struct{}
type Cat struct{}

func (d Dog) Speak() string { return "汪汪" }
func (c Cat) Speak() string  { return "喵喵" }

func main() {
	var a Animal

	a = Dog{}
	fmt.Println(a.Speak()) // 输出：汪汪

	a = Cat{}
	fmt.Println(a.Speak()) // 输出：喵喵
}

接口（interface）定义了一组方法签名，任何实现了这些方法的类型都自动满足该接口，无需显式声明。这是 Go 实现多态的核心机制。

接口的特点：

• 隐式实现：只要类型实现了接口的所有方法，就满足该接口
• 空接口 interface{}（或 any）可以接收任意类型的值
• 组合接口：多个接口可以嵌入组合成更大的接口

接口让代码更灵活------函数可以接收接口类型参数，从而兼容所有实现了该接口的类型，便于扩展和测试。

作业

1. 字符串 ：声明两个字符串变量，分别存储你的姓名和学校名称，用 + 拼接后打印，中间用换行符 \n 分隔。
2. 数字 ：声明一个 int 类型的年龄变量和一个 float64 类型的身高变量（如 175.5），并打印输出。
3. 布尔 ：声明一个 bool 变量表示「是否在线」，初始值为 true，打印后将其改为 false 再打印一次。
4. 数组与切片 ：
   • 定义一个长度为 3 的整型数组，赋值为 [10, 20, 30] 并打印；
   • 定义一个空切片，用 append 依次追加 1, 2, 3，打印切片内容和长度 len。
5. 映射 ：创建一个 map[string]int，存储 3 位同学的姓名和分数，打印其中一位的分数，再添加一位新同学并删除其中一位，最后遍历打印所有键值对。
6. 结构体 ：定义一个 Book 结构体，包含 Title（书名）和 Price（价格）两个字段，创建一本书的实例并打印书名和价格。
7. 接口 ：定义一个 Shape 接口，包含 Area() float64 方法；再定义 Rectangle（矩形）结构体并实现该接口，创建实例后打印面积。
8. 综合练习 ：将上述 Book 结构体放入切片中，存储至少 3 本书，遍历切片打印每本书的信息。