刚刚要上手，打个招呼——Hello, Golang!
package main
import (
"fmt"
)
func main() {
fmt.Println("Hello, Golang!")
}
在如上这段代码中，我们导入了fmt这个软件包，并使用了该软件包中的Println方法，实现文本的输入输出功能。
变量
在Go语言中，我们可以使用关键字var来声明变量。变量声明的一般语法是：var 变量名 类型。例如，声明一个整数变量可以使用var num int。
当我们在声明多个同一类型的变量时，我们可以串联起来，例如var b, c int = 1, 2，这样可以极大的缩减代码量，使代码更加简洁。
我们还可以使用:=来进行变量的简短声明和赋值，例如num := 10，这样的声明方式可以实现对变量类型的自推断。
以下是一段简单的示例：
package main
import (
"fmt"
"math"
)
func main() {
var a = "initial"
var b, c int = 1, 2 //这是一个串联声明多个变量的实例
var d = true
var e float64
f := float32(e)
g := a + "foo" //字符串可以直接相加
fmt.Println(a, b, c, d, e, f) // initial 1 2 true 0 0
fmt.Println(g) // initialapple
const s string = "constant" //常量没有类型，会自己判断
const h = 500000000
const i = 3e20 / h
fmt.Println(s, h, i, math.Sin(h), math.Sin(i))
}
注意，Go语言是静态类型语言，对于同一变量而言，变量一旦声明，其类型就不能改变。
循环——for
Go语言只提供了for循环用于重复执行一段代码，没有while。与C++区别为该语言循环判断语句不用加括号。
for循环有三种形式：基本的for循环、for循环的变种for range和无限循环for。下面是这三种形式的示例：
- 基本的
for循环：
for 初始化语句; 循环条件; 后续语句 {
// 循环体
}
例如：
for i := 0; i < 5; i++ {
fmt.Println(i)
}
for range循环：for range循环用于遍历数组、切片、字符串、映射等数据结构。
for index, value := range collection {
// 循环体
}
例如：
nums := []int{1, 2, 3, 4, 5}
for index, value := range nums {
fmt.Println(index, value)
}
- 无限循环：
for循环的条件部分可以省略，这将导致无限循环。可以使用break语句来跳出循环。
for {
// 循环体
if condition {
break
}
}
判断——if-else
在Go语言中，if-else语句的语法如下：
if condition {
// condition为真时执行的代码块
} else {
// condition为假时执行的代码块
}
我们可以看到，condition部分并没有添加圆括号
例如：
if num := 9; num < 0 {
fmt.Println(num, "is negative")
} else if num < 10 {
fmt.Println(num, "has 1 digit")
} else {
fmt.Println(num, "has multiple digits")
}
switch语句
Go语言的switch语句用于根据表达式的值选择不同的执行路径，不用break。下面是switch语句的语法：
switch expression {
case value1:
// 表达式等于value1时执行的代码块
case value2:
// 表达式等于value2时执行的代码块
...
default:
// 表达式不等于任何value时执行的代码块
}
例如：
t := time.Now()
switch {
case t.Hour() < 12:
fmt.Println("It's before noon")
default:
fmt.Println("It's after noon")
}
数组（Array）
数组是一种固定长度且具有相同类型元素的数据结构。在Go语言中，可以使用以下语法声明一个数组：
var arrayName [length]Type
其中，arrayName是数组的名称，length是数组的长度，Type是数组元素的类型。例如：
var nums [5]int
可以使用索引来访问数组元素，索引从0开始。例如：
nums[0] = 1
nums[1] = 2
还可以使用数组字面量来初始化数组：
nums := [5]int{1, 2, 3, 4, 5}
二维数组
var twoD [2][3]int
for i := 0; i < 2; i++ { //赋值
for j := 0; j < 3; j++ {
twoD[i][j] = i + j
}
切片（Slice）
切片是对数组的一个连续片段的引用，它是动态大小的。切片提供了一种方便的方式来操作和管理数据。
以下是切片的基本语法：
var sliceName []Type
其中，sliceName是切片的名称，Type是切片元素的类型。例如：
var nums []int
上述代码声明了一个名为nums的切片，用于存储整数类型的元素。
切片可以通过数组或其他切片创建。可以使用切片操作符[:]从数组中创建切片。例如，假设有一个数组array：
array := [5]int{1, 2, 3, 4, 5}
或者
array := make([]int, 5)
array[0] = "1"
array[1] = "2"
array[2] = "3"
array[3] = "4"
array[4] = "5"
可以使用切片操作符从数组中创建切片：
array1 := array[1:4] // 创建一个从索引1到索引3的切片
上述代码创建了一个名为array1的切片，它包含了数组array中索引1到索引3的元素。
注意，此处的startIndex和endIndex的其中一个可以不定义。若没有定义某个参数，则索引到给定数组的未定义的参数所在方向的边界。
切片还可以使用切片字面量来初始化：
slice := []int{1, 2, 3, 4, 5}
上述代码中，我们创建了一个名为slice的切片，包含了整数1到5的元素。
切片具有动态增长的能力，可以使用内置的append函数向切片中添加元素。例如：
slice := []int{1, 2, 3, 4, 5}
slice = append(slice, 6)
上述代码中，实现了将整数6追加到切片slice的末尾。
切片还有一些有用的属性和方法。可以使用len函数获取切片的长度：
length := len(slice)
可以使用cap函数获取切片的容量：
capacity := cap(slice)
切片的容量是指底层数组中可用于切片的元素个数。
切片还支持切片操作，可以通过指定起始索引和结束索引来获取切片的子切片。例如：
slice := []int{1, 2, 3, 4, 5}
subSlice := slice[1:3] // 获取从索引1到索引2的子切片
上述代码将创建一个名为subSlice的切片，包含了切片slice中索引1到索引2的元素。
切片是引用类型，当多个切片引用同一个底层数组时，它们会共享相同的数据。修改一个切片的元素会影响到其他引用同一底层数组的切片。
映射（Map）
映射是一种无序的键值对集合，也称为字典。它提供了一种便捷的方式来存储和检索数据，其中每个键都是唯一的。在Go语言中，映射使用map关键字声明。
以下是映射的基本语法：
var mapName map[KeyType]ValueType
其中，mapName是映射的名称，KeyType是键的类型，ValueType是值的类型。例如：
var m map[string]int
上述代码中，我们声明了一个名为m的映射，键的类型为string，值的类型为int。
映射的创建可以使用make函数：
m := make(map[string]int)
上述代码中，我们创建了一个空的映射m，可以用于存储字符串键和整数值的对应关系。
可以使用方括号[]操作符来访问和修改映射中的值。例如，要设置映射中键"one"对应的值为1：
m["one"] = 1
我们可以使用键来检索映射中的值：
fmt.Println(m) // map[one:1 two:2]
如果映射中不存在指定的键，则返回值类型的零值。
想删除映射中的键值对时，我们可以使用内置的delete(delete(map, key))函数：
delete(m, "one")
上述代码将从映射one中删除键为"one"的键值对。
映射还提供了一个有用的特性，即可以通过多重赋值来检查映射中某个键是否存在。例如：
value, exists := m["one"]
if exists {
fmt.Println("m1:", value)
} else {
fmt.Println("m does not exist")
}
上述代码中，exists变量将被设置为true或false，以指示键"one"是否存在于映射中。
映射是无序的，每次迭代映射的键值对顺序可能不同。可以使用range关键字迭代映射的键值对：
m2 := map[string]int{"one": 1, "two": 2}
for key, value := range m2 {
fmt.Println(key, value)
}
上述代码将遍历映射m2中的键值对，并将键存储在key变量中，将值存储在value变量中。
映射是一种非常有用的数据结构，可以用于解决各种问题，例如存储配置信息、缓存数据、实现关联数组等。
range
range关键字用于迭代数组、切片、映射或字符串。它返回索引和对应的值。例如：
nums := []int{1, 2, 3, 4, 5}
for index, value := range nums {
fmt.Println(index, value)
}
还可以使用range迭代映射的键值对：
scores := map[string]int{"Alice": 90, "Bob": 80, "Charlie": 70}
for key, value := range scores {
fmt.Println(key, value)
}
