Golang入门简介与基本语法学习
简介
Golang的出现背景
Go语言，或我们通常称之为Golang，它的设计哲学深受其创造者的软件开发经验影响，它旨在实现快速编译、高性能、静态类型检查以及简洁明了的代码风格。
是由Google开发的一个开源编程语言，它首次公布于2009年11月，由Robert Griesemer, Rob Pike, 和 Ken Thompson联合设计。
这三位在计算机科学领域有着不俗的成就，Ken Thompson特别以其对UNIX操作系统和C语言的贡献闻名。
Go语言的诞生是为了解决当时Google内部面临的巨大软件工程问题，主要包括提升软件开发效率、简化大规模的软件系统开发及维护，并且优化多核处理器的并发处理能力。
Go语言摒弃了传统语言的冗余和复杂性，取而代之的是一种更加简单直接的方式来管理依赖和并发，这使得Go语言在现代软件开发中特别受欢迎。
Go以其并发编程模型、内存安全和垃圾回收等特性，为开发者提供了一个既强大又灵活的开发环境。
环境搭建
可以参考我的另一篇文章：Windows环境下Golang开发环境的安装
安装Go语言环境
要开始使用Golang，首先得在你的机器上安装Go编译器和工具链。
Go的官方网站提供了适用于Windows、Mac和Linux系统的安装包。
只需下载对应系统的安装程序，一般而言安装过程中会自动配置好Go的环境变量，安装完成后，你可以在命令行中运行go version来验证安装是否成功。
配置Go环境变量
Go语言的环境变量配置是其工作流的重要部分，GOPATH是最关键的环境变量之一，它定义了你的工作空间位置，是你所有Go语言项目的存放地。
此外，GOROOT环境变量则指向Go语言安装的位置。通常，你需要将$GOPATH/bin添加到PATH环境变量中，这样你就可以从任意位置运行编译后的Go程序了。
（你也可以将安装目录下的bin的文件路径直接添加到PATH环境变量中）
Go开发工具介绍
对于刚入门的Go开发者来说，选择一个合适的开发环境非常重要。
你可以选用文本编辑器如Visual Studio Code或Sublime Text，并配置相应的Go语言插件。
对于需要更全面功能的开发者，JetBrains的GoLand更不错的IDE，它具有代码补全、调试、性能分析等高级功能，不过这是一个收费软件，并且不便宜，你可能需要一些其他方式才能免费使用。
Go的基础结构
Go程序的基本结构
每个Go程序都是由包（package）组成的。最基本的Go程序是由一个名为main的包组成，它包含一个同名的main函数。这个函数是程序开始执行的入口点。所有的Go文件都应该在第一行声明它们所属的包。
包的概念和导入方式
包是Go语言的基本组织单位，每个Go文件开头通过package关键字来声明其包名。当你需要使用其他包中的函数或类型时，可以通过import语句来导入这些包。Go的工具链自带依赖管理，能自动获取远程包。
可执行程序和库文件的区别
在Go语言中，可执行程序和库文件是通过包的类型来区分的。
如果一个包声明为main，编译后将生成一个可执行文件；如果包名不是main，则编译后为库文件，其他程序可以导入并使用其中的代码。
变量与数据类型
变量的声明和初始化
在Go语言中，变量必须先声明再使用。Go提供了多种声明变量的方法，可以使用var关键字进行声明，也可以使用:=进行短变量声明（同时进行声明和初始化）。
package main
import "fmt"
func main() {
var a int // 声明一个int型变量a
a = 10 // 给变量a赋值为10
var b = 20 // 声明一个int型变量b，并初始化为20
c := 30 // 短变量声明，同时声明和初始化变量c为30
fmt.Println(a, b, c) // 输出变量的值
}
Go的基本数据类型
Go语言中有许多内建的数据类型，包括但不限于：
- 整型（int, int8, int16, int32, int64, uint, uintptr等）
- 浮点型（float32, float64）
- 复数类型（complex64, complex128）
- 布尔型（bool）
- 字符串（string）
- 错误类型（error）
这些数据类型支持Go语言强大的系统编程能力，为操作系统级的底层编程提供了支持。
类型转换和别名
在Go语言中，类型之间不会自动转换，必须显式进行类型转换：
package main import ( "fmt" "strconv" ) func main() { var i int = 42 var f float64 = float64(i) var u uint = uint(f) fmt.Println(i, f, u) // 输出：42 42 42 // 字符串转换为整型 if intValue, err := strconv.Atoi("42"); err == nil { fmt.Println(intValue) // 输出：42 } }Go语言也允许用户通过类型别名来给已存在的数据类型指定一个新名字，增加代码的可读性。
package main import "fmt" type Celsius float64 // 为float64起一个别名Celsius，表示摄氏温度 type Fahrenheit float64 // 为float64起一个别名Fahrenheit，表示华氏温度 // CToF 将摄氏温度转换为华氏温度 func CToF(c Celsius) Fahrenheit { return Fahrenheit(c*9/5 + 32) } func main() { var c Celsius = 100 var f Fahrenheit = CToF(c) fmt.Println(c, "C is", f, "F") // 输出：100 C is 212 F }接下来，我们来探讨Go中的控制结构。
控制结构
条件判断：if-else, switch-case
在Go语言中，条件判断是通过if-else语句实现的。Go的if语句可以包含一个初始化语句，其作用域被限定在if语句中。
package main import "fmt" func main() { // 使用if-else进行条件判断 if num := 9; num循环：for
在Go语言中，所有的循环类型都可以使用for关键字来实现，包括传统的for循环以及类似其他语言中的while和until循环。
package main import "fmt" func main() { // 像while一样使用for sum := 1 for sum跳转：break, continue, goto
Go支持在循环中使用break和continue来控制循环的执行。break用来退出循环体，而continue用来跳过当前循环迭代。Go也支持goto语句，但其使用并不被推荐，因为它会使得代码难以理解和维护。
package main import "fmt" func main() { // 使用break跳出循环 for i := 0; i 5 { break } fmt.Println(i) } // 使用continue跳过某次循环迭代 for i := 0; i函数
函数的定义和调用
在Go语言中，函数是一等公民。函数的定义形式为func关键字后跟函数名、参数列表、返回类型和函数体。
package main import "fmt" // 定义一个加法函数 func add(x, y int) int { return x + y } func main() { fmt.Println(add(42, 13)) // 调用函数并输出结果 }参数传递：值传递与引用传递
Go语言中的所有参数传递都是值传递。这意味着在调用函数时，实际上是传递了参数值的一个副本。如果想要在函数内部改变参数的值，必须使用指针。
来来来，接着往下看，看看用指针怎么偷梁换柱，把两个数字给掉个儿：
package main import "fmt" // 定义一个交换两个数的函数，这里使用指针来直接修改变量的值 func swap(x *int, y *int) { temp := *x *x = *y *y = temp } func main() { a := 20 b := 30 fmt.Println("交换前 a 和 b 的值：", a, b) // 交换前 a 和 b 的值： 20 30 swap(&a, &b) // 这里传递的是变量的地址，也就是指向这些变量的指针 fmt.Println("交换后 a 和 b 的值：", a, b) // 交换后 a 和 b 的值： 30 20 }我们通过传递变量地址给swap函数，然后在swap函数内部通过指针去改变这些变量的值，这样改动就能在函数外部看到了。这种方式在Go中获取和修改外部变量的常用手法，就是典型的引用传递。
返回值和命名返回值
Go函数不仅可以返回单个值，还可以返回多个值。当你想从函数返回更多的信息时，这个特性就显得非常有用了。此外，Go还支持命名返回值，也就是在函数声明返回值时给它们命名，这样可以增加代码的清晰度。
package main import "fmt" // 定义一个分割整数的函数，返回商和余数 func divmod(a, b int) (int, int) { quo := a / b // 商 rem := a % b // 余数 return quo, rem } // 使用命名返回值的方式来返回多个值 func divmodNamed(a, b int) (quo, rem int) { quo = a / b // 商 rem = a % b // 余数 return // 不需要明确指定返回值，因为已经在函数签名中命名 } func main() { quo, rem := divmod(7, 3) fmt.Println("分割7和3得到：商 =", quo, "余数 =", rem) // 分割7和3得到：商 = 2 余数 = 1 quoNamed, remNamed := divmodNamed(7, 3) fmt.Println("命名返回值分割7和3得到：商 =", quoNamed, "余数 =", remNamed) // 命名返回值分割7和3得到：商 = 2 余数 = 1 }在divmodNamed这个函数里，我们就用到了命名返回值。它在返回的时候，就不用再写返回值的名字了，直接一个return搞定，简洁清晰。
复合类型
这些类型可以把简单的类型组合成复杂的数据结构，主要包括数组、切片、映射（map）、结构体（struct）以及它们的方法。
数组和切片
数组是一个固定长度的序列，而切片则是一个可以动态改变大小的序列。切片比数组更常用，因为它们更灵活。
package main import "fmt" func main() { // 数组的定义和初始化 var arr [5]int arr[0] = 1 arr[1] = 2 // 省略的部分为零值 // 切片的定义和初始化 slice := []int{1, 2, 3, 4, 5} // 切片字面量 // 切片操作 fmt.Println(slice[1:3]) // 输出切片的第2个到第4个元素，不包括索引为3的元素 }映射（map）
映射是一种无序的键值对的集合。Map是使用哈希表实现的。
package main import "fmt" func main() { // 映射的定义和初始化 m := make(map[string]int) m["k1"] = 7 m["k2"] = 13 // 访问映射 fmt.Println("map:", m) // 删除操作 delete(m, "k2") fmt.Println("map:", m) }结构体（struct）和方法
结构体是一种聚合数据类型，它用于将不同或相同类型的数据组织成一个有意义的单元。
package main import "fmt" // 定义结构体 type person struct { name string age int } // 定义结构体的方法 func (p person) sayHello() { fmt.Printf("Hi, I'm %s, %d years old.\n", p.name, p.age) } func main() { // 初始化结构体 p := person{name: "Jack", age: 23} // 调用方法 p.sayHello() // 输出: Hi, I'm Jack, 23 years old. }结构体的方法就是那些能够使用该结构体类型的变量或者实例来调用的函数。方法的声明和普通函数类似，只是在方法名前面增加了一个额外的参数，这个参数叫做接收器（receiver），它的类型就是结构体类型。
这些复合类型是Go数据组织的基石，特别是切片和映射，它们在实际开发中运用广泛，可以灵活高效地处理数据集合。结构体通过方法为Go语言提供了面向对象的能力，使得Go能够以更加结构化的方式来处理复杂的数据。
接口
接口在Go中扮演着超级重要的角色，它们让我们的代码更加灵活和模块化。
接口的定义
接口定义了一套方法签名，任何具有这些方法的类型都可以说实现了该接口。
package main import "fmt" // 定义一个接口 type Greeter interface { greet() string } // 实现接口的具体类型 type English struct{} func (e English) greet() string { return "Hello!" } // 实现接口的具体类型 type Chinese struct{} func (c Chinese) greet() string { return "你好！" } func greetSomeone(g Greeter) { fmt.Println(g.greet()) } func main() { var e English var c Chinese greetSomeone(e) // 输出：Hello! greetSomeone(c) // 输出：你好！ }转换和实现
一个类型可以实现多个接口，而一个接口也可以被多个类型实现。类型转换可以在不同的接口和类型之间进行。
package main import "fmt" type Walker interface { walk() string } type Talker interface { talk() string } type Human struct{} func (h Human) walk() string { return "I'm walking." } func (h Human) talk() string { return "I'm talking." } func main() { var h Human // Human实现了Walker接口 var w Walker = h fmt.Println(w.walk()) // Human实现了Talker接口 var t Talker = h fmt.Println(t.talk()) }接口的组合
接口可以组合其他接口，这样可以很容易地创建出拥有多个方法的新接口。
package main import "fmt" type Mover interface { move() string } type Shaker interface { shake() string } // Combiner接口组合了Mover和Shaker接口 type Combiner interface { Mover Shaker } type Animal struct{} func (a Animal) move() string { return "Animal is moving." } func (a Animal) shake() string { return "Animal is shaking." } func main() { var a Animal // Animal实现了Combiner接口 var c Combiner = a fmt.Println(c.move()) fmt.Println(c.shake()) }并发编程
Go语言在并发编程方面有着天然的优势，它的设计使得并发变得简单易用。
Go协程（goroutines）
Go协程是轻量级的线程，由Go运行时管理。
package main import ( "fmt" "time" ) func say(s string) { for i := 0; i通道（channels）
通道是Go语言中的一种类型，专门用来传递数据，以实现不同的协程之间的通信。
package main import "fmt" func main() { // 创建一个通道 messages := make(chan string) // 启动一个新的协程 go func() { messages const grs = 2 var mu sync.Mutex // 互斥锁保护计数器 for i := 0; i