简介
Go语言，全称Golang, 是由Google开发的一种开源编程语言，首次发布于2009年。它旨在提供简洁、高效、可靠的软件开发解决方案。Go语言是一种静态强类型、编译型语言，以其并发机制和新颖的类型系统著称，能够有效地利用多核与联网的计算机。
如今，Go语言已经被诸如字节、Google、腾讯、facebook、bilibili等诸多知名互联网公司采用。对于开发者而言，使用go的主要优势有：
简洁易学： Go语言的语法设计简洁，学习路线平滑。它的设计理念是让开发者专注于清晰和高效的代码，使新手也能较快上手。
高效的并发处理： Go的并发模型是其最显著的优势之一。Go 使用了go关键字来实现轻量级的并发处理。Goroutines 是 Go 的并发单元，创建和销毁开销非常小，可以在同一程序中同时执行大量的任务。
跨平台支持： Go 是跨平台的，可以在 Windows、macOS、Linux 和许多其他操作系统上运行。Go 编译的二进制文件是静态链接的，意味着它不依赖于外部的动态链接库，使得部署更加简单方便。
支持模块化和包管理： Go 提供了强大的包管理工具 (go mod)，使得开发者能够轻松管理项目的依赖。Go 的模块化设计让项目结构更加清晰、维护更加方便。
部署简单： Go 编译后的二进制文件是静态链接的，这意味着它不需要依赖外部的库或运行时环境。你只需将编译出来的二进制文件部署到目标机器上即可，极大简化了部署流程。
适合云原生和微服务： 由于 Go 语言的轻量级、并发性能和优秀的标准库，它特别适合用来构建云原生应用和微服务架构。Go 在分布式系统和高并发场景中表现尤为出色。
Go的HelloWorld
以下的部分需要有C或Java等语言的基础。另外不建议在没有学习过编程的前提下，就直接接触go语言。
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
虽然简单，但这个程序却蕴含了许多特性。对每一行代码的解释如下：
package main：这表示程序是一个可执行的包（而不是一个库）。
import "fmt"：fmt 是 Go 的标准库之一，用于格式化输入输出。这里导入 fmt 包，以便我们可以使用 fmt.Println 来输出文本。
func main()：main 函数是 Go 程序的入口点。
fmt.Println("Hello, World!")：这行代码会打印出 Hello, World! 到标准输出。
另外本文将不考虑安装Go的问题，这里推荐直接使用豆包MarsCOde 直接使用在线IDE, 可以有效节省初期不必要的麻烦。
变量
Go语言支持和传统语言一样显式声明类型，但也支持使用:=来自动推导，这个符号和SQL很相似。
package main
import "fmt"
func main() {
// 声明并初始化一个整数变量
var age int = 25
// 声明并初始化一个浮点数变量
var weight float64 = 70.5
// 声明并初始化一个字符串变量
var name string = "John"
// 使用简短声明进行变量声明和赋值
name1 := "Alice"
age1 := 30
weight1 := 65.5
// 在一行中声明多个变量
var name2, city2 string = "Bob", "New York"
var age2, score2 int = 28, 90
}
Go语言有以下基础类型：
- 布尔类型（Boolean Type）
bool：布尔类型，取值为 true 或 false。
- 数字类型（Numeric Types）Go 语言中的数字类型分为整型和浮点型。
整型（Integer Types）
有符号整型：
int8：8 位有符号整数，取值范围：-128 到 127
int16：16 位有符号整数，取值范围：-32,768 到 32,767
int32：32 位有符号整数，取值范围：-2,147,483,648 到 2,147,483,647
int64：64 位有符号整数，取值范围：-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
无符号整型：
uint8：8 位无符号整数，取值范围：0 到 255
uint16：16 位无符号整数，取值范围：0 到 65,535
uint32：32 位无符号整数，取值范围：0 到 4,294,967,295
uint64：64 位无符号整数，取值范围：0 到 18,446,744,073,709,551,615
int 和 uint：
int：平台相关的整数类型（32 位或 64 位），用于表示有符号整数。
uint：无符号的整数类型（32 位或 64 位），用于表示无符号整数。
浮点型（Floating-point Types）
float32：32 位浮点数，符合 IEEE-754 标准，精度较低。
float64：64 位浮点数，符合 IEEE-754 标准，精度较高，Go 中的默认浮点数类型。
复数类型（Complex Types）
complex64：由 float32 类型的实部和虚部构成的复数。
complex128：由 float64 类型的实部和虚部构成的复数。
- 字符串类型（String Type）
string：表示字符串类型。Go 中的字符串是由 UTF-8 编码的字符组成的不可变序列。
- 字节类型（Byte and Rune Types）
byte：实际上是 uint8 的别名，用来表示单个字节，通常用于表示字符。
rune：实际上是 int32 的别名，用于表示一个 Unicode 字符，通常表示一个字符。
- 指针类型（Pointer Type）
指针类型用来存储变量的内存地址。Go 语言的指针是类型安全的，不能进行算术运算。在Go中指针主要用作修改调用方函数的变量，也可以用作免复制引用传递。
Go语言由于有自动类型推导，所有不用过于关注基本类型的种类。但是Go作为一门支持面向对象和函数式编程的语言，其类型有一些复杂，这个后面再说。
if/else
这里的语法和C家族的很像了，有一点是编写go时会把多条；分割的语句一起放在if条件里，而且条件不需要加括号。
package main
import "fmt"
func main() {
score := 85
if score >= 90 {
fmt.Println("You got an A!")
} else if score >= 80 {
fmt.Println("You got a B!")
} else if score >= 70 {
fmt.Println("You got a C!")
} else {
fmt.Println("You failed!")
}
//条件里放多条语句
if temperature := 25; temperature > 30 {
fmt.Println("It's hot outside.")
} else {
fmt.Println("The weather is fine.")
}
}
循环
在 Go 语言中，循环支持传统for循环和range循环。
for 循环
Go 语言的 for 循环是唯一的循环结构，它可以像 C 语言那样使用三部分形式：初始化、条件判断和迭代操作。
package main
import "fmt"
func main() {
for i := 0; i < 5; i++ {
fmt.Println(i)
}
}
for 循环（无条件，类似 while）
Go 语言的 for 循环还可以省略初始化部分、条件部分和后置语句，从而使其像 while 循环一样使用：
package main
import "fmt"
func main() {
i := 0
for i < 5 {
fmt.Println(i)
i++
}
}
无限循环
Go 中的 for 循环可以用于无限循环，只需省略条件判断部分，形成一个永远为 true 的循环。
package main
import "fmt"
func main() {
count := 0
for {
count++
fmt.Println("Count:", count)
if count >= 5 {
break
}
}
}
for 循环带 range
Go 语言提供了 range 关键字，结合 for 循环可以非常方便地遍历数组、切片、字符串、map 和通道。
package main
import "fmt"
func main() {
arr := []int{10, 20, 30, 40, 50}
for i, value := range arr {
fmt.Printf("Index: %d, Value: %d\n", i, value)
}
}
如果只关心值，可以省略索引：
for _, value := range arr {
fmt.Println(value)
}
for 循环遍历 map
range 也可以用于遍历 map，返回键和值。
package main
import "fmt"
func main() {
m := map[string]int{
"apple": 5,
"banana": 3,
"cherry": 7,
}
for key, value := range m {
fmt.Printf("Key: %s, Value: %d\n", key, value)
}
}
跳出循环与继续下一次循环
Go 中提供了 break 和 continue 语句来控制循环的流程。
break：立即退出整个循环
continue：跳过当前循环的剩余部分，开始下一次循环
package main
import "fmt"
func main() {
for i := 1; i <= 10; i++ {
if i == 5 {
continue // 跳过当前循环，继续下一次循环
}
if i == 8 {
break // 退出循环
}
fmt.Println(i)
}
}
switch
Go的switch和C略有不同，它的case不需要加break.如果想要一个结果匹配多个条件，可以直接加case.
package main
import "fmt"
func main() {
x := 2
switch x {
case 1:
fmt.Println("x is 1")
case 2:
fmt.Println("x is 2")
case 3:
fmt.Println("x is 3")
default:
fmt.Println("x is something else")
}
}
package main
import "fmt"
func main() {
x := 5
switch x {
case 1, 2, 3:
fmt.Println("x is 1, 2, or 3")
case 4, 5, 6:
fmt.Println("x is 4, 5, or 6")
default:
fmt.Println("x is something else")
}
}
