Golang初学基础范例（一）
Nadeal2022年2月9日 18:03个人博客300
列举的范例，是网友分享的，但是对于运行结果，我自己都运行过一遍。虽然是拿来主义，但是也要学习吸收。纯粹的照搬照抄，是没有意义的。
Go语言是一个被设计用来建立简单，快速和可信赖的软件的开源程序设计语言。下面通过带注释的例子程序去详细介绍 Go语言。学习一门编程语言，重点还是在于编程思想。程序语言众多，但是编程思想就是那几种。相同编程思想的程序语言，在编写代码过程中，区别大多都是大同小异的。
1. 值
Go 拥有各值类型，包括字符串，整形，浮点型，布尔型等:
package main
import "fmt"
func main() {
//字符串可以通过 + 连接
fmt.Println("go" + "lang")
//整数和浮点数
fmt.Println("1+1 =", 1+1)
fmt.Println("7.0/3.0 =", 7.0/3.0)
//布尔型，还有你想要的逻辑运算符。
fmt.Println(true && false)
fmt.Println(true || false)
fmt.Println(!true)
}
控制台打印结果如下：
2. 变量
在 Go 中，变量 被显式声明，并被编译器所用来检查函数调用时的类型正确性。
package main
import "fmt"
func main() {
//var 声明 1 个或者多个变量
var a string = "initial"
fmt.Println(a)
//也可以申明一次性声明多个变量。
var b, c int = 1, 2
fmt.Println(b, c)
//Go 将自动推断已经初始化的变量类型。
var d = true
fmt.Println(d)
//声明变量且没有给出对应的初始值时，变量将会初始化为零值 。例如，一个 int 的零值是 0。
var e int
fmt.Println(e)
// := 语句是申明并初始化变量的简写，例如这个例子中的 var f string = "short"。
f := "short"
fmt.Println(f)
}
控制台打印结果如下：
3. 常量
Go 支持字符、字符串、布尔和数值 常量 。
package main
import (
"fmt"
"math"
)
const s string = "constant"
func main() {
//const 用于声明一个常量
fmt.Println("s = ",s)
//const 语句可以出现在任何 var 语句可以出现的地方
const n = 500000000
fmt.Println("n = ", n)
//常数表达式可以执行任意精度的运算
const d = 3e20 / n
fmt.Println("d = 3e20/n : " , d)
//数值型常量是没有确定的类型的，直到它们被给定了一个类型，比如说一次显示的类型转化。
fmt.Println("int64(d) = ",int64(d))
//当上下文需要时，一个数可以被给定一个类型，比如变量赋值或者函数调用。
// 举个例子，这里的 math.Sin函数需要一个 float64 的参数。
fmt.Println("math.Sin(n) = ", math.Sin(n))
}
控制台打印结果如下：
4. for循环
for 是 Go 中唯一的循环结构。这里有 for 循环的三个基本使用方式。
package main
import (
"fmt"
)
func main() {
//1.最常用的方式，带单个循环条件
i := 1
for i <= 3 {
fmt.Println(i)
i = i + 1
}
//2.经典的初始化/条件/后续形式 for 循环。
for j := 7; j <= 9; j++ {
fmt.Println(j)
}
//3.不带条件的 for 循环将一直执行，直到在循环体内使用了 break 或者 return 来跳出循环。
for {
fmt.Println("loop")
break
}
}
控制台打印结果如下：
当我们学到 rang 语句，channels，以及其他数据结构时，将会看到一些 for 的其它使用形式
5. if/else 分支
if 和 else 分支结构在 Go 中当然是直接了当的了
package main
import (
"fmt"
)
func main() {
if 7%2 == 0 {
fmt.Println("7 is even") //7是偶数
} else {
fmt.Println("7 is odd") //7是奇数
}
//也可以不要 else 只用 if 语句。
if 8%4 == 0 {
fmt.Println("8 is divisible by 4")
}
//在条件语句之前可以有一个语句；任何在这里声明的变量都可以在所有的条件分支中使用。
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")
}
}
控制台打印结果如下：
6. 分支结构(switch)
switch ，方便的条件分支语句。
package main
import (
"fmt"
"time"
)
func main() {
//一个基本的 switch
i := 2
fmt.Print("write ", i, " as ")
switch i {
case 1:
fmt.Println("one")
case 2:
fmt.Println("two")
case 3:
fmt.Println("three")
}
//在一个 case 语句中，你可以使用逗号来分隔多个表达式。
// 在这个例子中，我们很好的使用了可选的default 分支。
switch time.Now().Weekday() {
case time.Saturday, time.Sunday:
fmt.Println("it's the weekend")
default:
fmt.Println("it's a weekday")
}
//不带表达式的 switch 是实现 if/else 逻辑的另一种方式。
// 这里展示了 case 表达式是如何使用非常量的。
t := time.Now()
switch {
case t.Hour() < 12:
fmt.Println("it's before noon")
default:
fmt.Println("it's after noon")
}
}
控制台打印结果如下：
7. 数组
在 Go 中，数组 是一个固定长度的数列。
package main
import (
"fmt"
)
func main() {
//创建了一个数组 a 来存放刚好 5 个 int。元素的类型和长度都是数组类型的一部分。
// 数组默认是零值的，对于 int 数组来说也就是 0。
var a [5]int
fmt.Println("emp:", a)
//可以使用 array[index] = value 语法来设置数组指定位置的值，
// 或者用 array[index] 得到值。
a[4] = 100
fmt.Println("set:", a)
fmt.Println("get:", a[4])
//使用内置函数 len 返回数组的长度
fmt.Println("len:", len(a))
//使用这个语法在一行内初始化一个数组
b := [5]int{1, 2, 3, 4, 5}
fmt.Println("dcl:", b)
//数组的存储类型是单一的，但是你可以组合这些数据来构造多维的数据结构。
var twoD [2][3]int
for i := 0; i < 2; i++ {
for j := 0; j < 3; j++ {
twoD[i][j] = i + j
}
}
fmt.Println("2d: ", twoD)
}
控制台打印结果如下：
8. 切片
Slice 是 Go 中一个关键的数据类型，是一个比数组更加强大的序列接口
package main
import (
"fmt"
)
func main() {
//不像数组，slice 的类型仅由它所包含的元素决定（不像数组中还需要元素的个数）。
// 要创建一个长度非零的空slice，需要使用内建的方法 make。
// 这里我们创建了一个长度为3的 string 类型 slice（初始化为零值）。
s := make([]string, 3)
fmt.Println("emp:", s)
//我们可以和数组一样设置和得到值
s[0] = "a"
s[1] = "b"
s[2] = "c"
fmt.Println("set:", s)
fmt.Println("get:", s[2])
//如你所料，len 返回 slice 的长度
fmt.Println("len:", len(s))
//作为基本操作的补充，slice 支持比数组更多的操作。
// 其中一个是内建的 append，它返回一个包含了一个或者多个新值的 slice。
// 注意我们接受返回由 append返回的新的 slice 值。
s = append(s, "d")
s = append(s, "e", "f")
fmt.Println("append:", s)
//Slice 也可以被 copy。
// 这里我们创建一个空的和 s 有相同长度的 slice c，并且将 s 复制给 c。
c := make([]string, len(s))
copy(c, s)
fmt.Println("copy:", c)
//Slice 支持通过 slice[low:high] 语法进行“切片”操作。
// 例如，这里得到一个包含元素 s[2], s[3],s[4] 的 slice。
l := s[2:5]
fmt.Println("切片之后 2-5 即s[2], s[3],s[4] 的 slice:", l)
//这个 slice 从 s[0] 到（但是包含）s[5]。
l = s[:5]
fmt.Println("从 s[0] 到（但是包含）s[5]", l)
//这个 slice 从（包含）s[2] 到 slice 的后一个值。
l = s[2:]
fmt.Println("从（包含）s[2] 到 slice 的后一个值", l)
//我们可以在一行代码中声明并初始化一个 slice 变量。
t := []string{"g", "h", "i"}
fmt.Println("dcl:", t)
//Slice 可以组成多维数据结构。内部的 slice 长度可以不同，这和多位数组不同。
twoD := make([][]int, 3)
for i := 0; i < 3; i++ {
innerLen := i + 1
twoD[i] = make([]int, innerLen)
for j := 0; j < innerLen; j++ {
twoD[i][j] = i + j
}
}
fmt.Println("2d: ", twoD)
}
控制台打印结果如下：
现在，我们已经看过了数组和 slice，接下来我们将看看 Go 中的另一个关键的内建数据类型：map。
9. 关联数组
map 是 Go 内置关联数据类型（在一些其他的语言中称为哈希 或者字典 ）。
package main
import (
"fmt"
)
func main() {
//要创建一个空 map，需要使用内建的 make:make(map[key-type]val-type).
m := make(map[string]int)
fmt.Println(m)
//使用典型的 make[key] = val 语法来设置键值对。
m["k1"] = 7
m["k2"] = 13
fmt.Println("map:", m)
//使用 name[key] 来获取一个键的值
v1 := m["k1"]
fmt.Println("v1: ", v1)
//当对一个 map 调用内建的 len 时，返回的是键值对数目
fmt.Println("len:", len(m))
//内建的 delete 可以从一个 map 中移除键值对
delete(m, "k2")
fmt.Println("map:", m)
//当从一个 map 中取值时，可选的第二返回值指示这个键是在这个 map 中。
// 这可以用来消除键不存在和键有零值，像 0 或者 "" 而产生的歧义。
_, prs := m["k2"]
fmt.Println("prs:", prs)
//你也可以通过这个语法在同一行申明和初始化一个新的map。
n := map[string]int{"foo": 1, "bar": 2,"zhang":3}
fmt.Println("map:", n)
}
控制台打印结果如下：
注意一个 map 在使用 fmt.Println 打印的时候，是以 map[k:v k:v]的格式输出的。
10. Range 遍历
range 迭代各种各样的数据结构。让我们来看看如何在我们已经学过的数据结构上使用 rang 吧。
package main
import (
"fmt"
)
func main() {
//这里我们使用 range 来统计一个 slice 的元素个数。数组也可以采用这种方法。
nums := []int{2, 4, 5, 3}
sum := 0
for _, num := range nums {
sum += num
}
fmt.Println("sum:", sum)
//range 在数组和 slice 中都同样提供每个项的索引和值。
//上面我们不需要索引，所以我们使用 空值定义符_ 来忽略它。
//有时候我们实际上是需要这个索引的。
for i, num := range nums {
if num == 3 {
fmt.Println("index:", i)
}
}
//range 在 map 中迭代键值对。
kvs := map[string]string{"a": "apple", "b": "banana"}
for k, v := range kvs {
fmt.Printf("%s -> %s\n", k, v)
}
//range 在字符串中迭代 unicode 编码。
// 第一个返回值是rune(符号，符文) 的起始字节位置，然后第二个是 rune 自己。
for i, c := range "go" {
fmt.Println(i, c)
}
}
控制台打印结果如下：
###########
很赞哦！
(
0
)
