首先Go语言拥有很多优点： 1：高性能和高并发 2：语法简单，学习曲线平缓 3：丰富的数据库 4：完善的工具链 5：快速编译 6：静态链接 7：跨平台 8：垃圾回收
如此多的优点下，Go语言被越来越多的程序员和厂家使用，例如：字节，脸书等。因此学好Go语言可以为自己新增加一门技术，那么接下来就是Go语言的基础语法。
在Go语言中，分号(;)是用来分隔语句的。在大多数情况下，可以使用换行代替分号来分隔语句，这样可以使代码更加简洁和易读。
hello world：第一个小程序
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
在上述代码中，我们首先声明了一个 main 包。在Go语言中，main 包是一个特殊的包，它定义了一个可执行程序的入口点。
然后，我们通过 import "fmt" 导入了 fmt 包，该包提供了格式化输入输出的功能。
最后，我们在 main 函数中调用了 fmt.Println() 函数，并传递字符串 "Hello, World!" 作为参数。这个函数的作用是将参数打印到标准输出。
变量
定义通常采用以下格式
var 变量名 类型
常见的var定义方式有以下几种：
1：最普通的定义方法
var age int = 18
var name string = "字节"
2：编译器会自动推断出变量的类型
var age = 18
var name = "字节"
- 声明多个变量并初始化：
var x, y, z int = 1, 2, 3
var a, b, c = 1, "hello", true
- 省略类型和初始化（使用默认值）：变量会被默认初始化为其对应类型的默认值，与其他语言类似
var age int
var name string
- 简短变量声明（仅在函数内部使用）：
age := 18
name := "字节"
与其他语言类似，Go的变量也有自己的作用范围，这一点和其他语言是一样的。
扩容知识：除了var关键字，还可以使用其他关键字如const和type来定义常量和类型。
const PI = 3.14
type MyString string
for
Go里面唯一的遍历循环方式
for initialization; condition; post {
// 循环体代码
}
使用示例：
for i := 0; i < 5; i++ {
if i == 2 {
continue
}
fmt.Println(i)
}
如果不写条件相当于while(true)
if else
if语句用于判断一个条件是否为真，并根据结果执行相应的代码块。else语句则用于在if条件为假时执行另一段代码。与其他语言不一样的是if里面不需要加（），用法如下：
if condition {
// 条件为真时执行的代码块
} else {
// 条件为假时执行的代码块
}
示例：
package main
import "fmt"
func main() {
age := 18
if age >= 18 {
fmt.Println("您已经成年了")
} else {
fmt.Println("您还未成年")
}
}
switch
在Go语言中，switch语句用于根据不同的条件执行不同的代码块。它提供了一种更简洁的方式来实现多分支的逻辑判断。与其他语言不一样的是每一个case后面不用写break。用法如下：
switch expression {
case value1:
// 当expression等于value1时执行的代码块
case value2:
// 当expression等于value2时执行的代码块
...
default:
// 当expression不等于任何一个case时执行的代码块
}
示例
package main
import "fmt"
func main() {
fruit := "apple"
switch fruit {
case "apple":
fmt.Println("这是一个苹果")
case "banana":
fmt.Println("这是一个香蕉")
default:
fmt.Println("未知水果")
}
}
数组
数组是一种固定长度、拥有相同数据类型的元素序列。可以使用数组来存储一组具有相似特性的数据。由于长度的固定，其实数组在Go里面并不常用。基本语法如下：
var arrayName [size]dataType
创建示例：
var numbers [5]int
访问和修改数组元素的示例：
numbers[0] = 10 // 设置第一个元素的值为10
x := numbers[1] // 获取第二个元素的值并赋值给变量x
fmt.Println(numbers[2]) // 打印数组第三个元素的值
带有初始化值的数组声明示例：
var numbers = [5]int{1, 2, 3, 4, 5}
切片：Go独有的内容
切片（slice）是一种动态长度的、灵活的数据结构，它是基于数组的封装。切片提供了方便的操作和灵活的扩展性，常用于处理变长数据。可以理解为是没有长度的数组，类似java里面的集合。
声明语法：
var slice []ElementType
示例：
package main
import "fmt"
func main() {
// 创建一个整数类型的切片
numbers := []int{1, 2, 3, 4, 5}
fmt.Println(numbers) // 打印切片的所有元素
// 访问切片元素
fmt.Println(numbers[0]) // 打印第一个元素
// 修改切片元素
numbers[1] = 10
fmt.Println(numbers) // 打印修改后的切片
// 添加元素到切片末尾
numbers = append(numbers, 6)
fmt.Println(numbers) // 打印添加元素后的切片
// 切片的长度和容量
fmt.Println("长度：", len(numbers))
fmt.Println("容量：", cap(numbers))
}
读者很容易注意到append，这是切片的一个方法，很容易想到还有其他方法：
copy：用于将一个切片的内容复制到另一个切片，如果目标切片长度不够，则只会复制到目标切片长度的部分。它的使用方式为 copy(destSlice, srcSlice)。
source := []int{1, 2, 3}
destination := make([]int, len(source))
copy(destination, source)
fmt.Println(destination) // [1 2 3]
len 和 cap：len 和 cap 函数分别用于获取切片的长度和容量。
numbers := []int{1, 2, 3, 4, 5}
fmt.Println(len(numbers)) // 5
fmt.Println(cap(numbers)) // 5
切片的切割：可以通过切片表达式来获取原切片的子切片。切片表达式的语法为 slice[low:high]，其中 low 是切片的起始索引，high 是切片的结束索引（不包括该索引对应的元素）。
numbers := []int{1, 2, 3, 4, 5}
subSlice := numbers[1:4]
fmt.Println(subSlice) // [2 3 4]
map
map 是一种集合类型，用于存储键值对（key-value）的无序集合。map 可以通过键来快速查找对应的值，类似于其他编程语言中的字典或哈希表，可以类比java学习。
声明语法：
var mapName map[KeyType]ValueType
使用示例：
package main
import "fmt"
func main() {
// 创建一个字符串到整数的映射
scores := make(map[string]int)
// 添加键值对
scores["Alice"] = 90
scores["Bob"] = 80
// 访问值
fmt.Println(scores["Alice"]) // 输出 90
// 修改值
scores["Bob"] = 85
// 删除键值对
delete(scores, "Alice")
// 判断键是否存在
score, ok := scores["Alice"]
fmt.Println(score, ok) // 输出 0 false
// 遍历map
for key, value := range scores {
fmt.Println(key, value)
}
}
range
range 是一个关键字，用于迭代遍历数组、切片、字符串、映射和通道等集合类型的元素。
以下是几种常见的使用方式：
//迭代数组或切片：
numbers := []int{1, 2, 3, 4, 5}
for index, value := range numbers {
fmt.Println(index, value)
}
//迭代字符串
str := "Hello, World!"
for index, char := range str {
fmt.Println(index, string(char))
}
//迭代映射（map）
scores := map[string]int{"Alice": 90, "Bob": 80}
for key, value := range scores {
fmt.Println(key, value)
}
函数
函数是一段完成特定任务的代码块，它可以接收输入参数（可选），执行特定的操作，并返回结果（可选），与其他语言类似。但是他可以返回多个值。
函数的定义使用关键字 func，其基本语法如下：
func functionName(parameter1 type1, parameter2 type2, ...) returnType {
// 函数体代码
// 可以使用参数进行计算或执行其他操作
return result // 可选，用于返回结果
}
简单的示例：
func add(a, b int) int {
sum := a + b
return sum
}
以下是一个返回多个值的示例：
func divide(a, b float64) (float64, error) {
if b == 0 {
return 0, errors.New("division by zero")
}
quotient := a / b
return quotient, nil
}
函数名为 divide，它接受两个 float64 类型的参数 a 和 b，并返回两个值：商和错误。
在函数体内，我们首先检查除数是否为零。如果除数为零，我们使用 errors.New 创建一个新的错误，并将其作为第二个返回值返回。否则，我们计算并返回除法的结果作为第一个返回值，并将第二个返回值设为 nil，表示没有发生错误。
指针
指针是一种特殊的数据类型，它存储了一个变量的内存地址。通过指针，我们可以直接访问和修改对应内存地址上的值。与c和c++类似，Go语言允许程序员使用指针。
使用实例：
func main() {
var num int = 10
var ptr *int // 声明一个指向int类型的指针
ptr = &num // 将指针指向num的内存地址
fmt.Println("Value of num:", num)
fmt.Println("Value of ptr:", ptr)
fmt.Println("Value at ptr:", *ptr) // 通过指针访问其指向的值
}
他在函数里面的使用的c++里面的使用是一样的，也有形参的区分。
结构体
结构体（Struct）是一种用户自定义的复合数据类型，用于组织和存储不同类型的数据字段。和c++里面的结构体是一样的。
使用实例：
//我们定义了一个名为 `Person` 的结构体，它有两个字段：`Name` 和 `Age`。这两个字段的类型分别是字符串和整数。
type Person struct {
Name string
Age int
}
//初始化：
p := Person{
Name: "Alice",
Age: 25,
}
结构体使用实例：
//结构体方法
type Rectangle struct {
Width float64
Height float64
}
func (r Rectangle) Area() float64 {
return r.Width * r.Height
}
我们定义了一个名为 Rectangle 的结构体，它有两个字段：Width 和 Height。然后，我们为 Rectangle 结构体定义了一个方法 Area，用于计算矩形的面积。
要调用结构体方法，需要使用结构体变量进行调用：
rect := Rectangle{
Width: 10,
Height: 5,
}
area := rect.Area()
fmt.Println("Area:", area)
