go 基础语法 【教程 go tour】

go 基础语法 【1】

教程go tour

1 包 变量 函数

• 变量不用声明

func swap(x, y string) (string, string) {return y, x
}func main() {a, b := swap("hello", "world")fmt.Println(a, b)
}

• 也可以声明：

• 没有明确初始化的变量声明会被赋予对应类型的 零值。

  零值是：

  • 数值类型为 0，
  • 布尔类型为 false，
  • 字符串为 ""（空字符串）。

func main() {var i intvar f float64var b boolvar s stringfmt.Printf("%v %v %v %q\n", i, f, b, s)
}
//输出
0 0 false ""

• 变量声明可以包含初始值，每个变量对应一个。

  如果提供了初始值，则类型可以省略；变量会从初始值中推断出类型。

var i, j int = 1, 2func main() {var c, python, java = true, false, "no!"fmt.Println(i, j, c, python, java)
}

• 在函数中，短赋值语句 := 可在隐式确定类型的 var 声明中使用。

  函数外的每个语句都 必须 以关键字开始（var、func 等），因此 := 结构不能在函数外使用。

var i, j = 1, 2k := 3c, python, java := true, false, "no!"
//等价于 var c, python, java = true, false, "no!"

• go基本类型

boolstringint  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptrbyte // uint8 的别名rune // int32 的别名// 表示一个 Unicode 码位float32 float64complex64 complex128

var (ToBe   bool       = falseMaxInt uint64     = 1<<64 - 1z      complex128 = cmplx.Sqrt(-5 + 12i)
)func main() {fmt.Printf("类型：%T 值：%v\n", ToBe, ToBe)fmt.Printf("类型：%T 值：%v\n", MaxInt, MaxInt)fmt.Printf("类型：%T 值：%v\n", z, z)
}

• 常量

  • 常量的声明与变量类似，只不过使用 const 关键字。
  • 常量可以是字符、字符串、布尔值或数值。
  • 常量不能用 := 语法声明。

  const World = "世界"
  const Truth = true
  const Pi = 3.14
  

• 数值常量

  数值常量是高精度的 值。

  一个未指定类型的常量由上下文来决定其类型。

  const (// 将 1 左移 100 位来创建一个非常大的数字// 即这个数的二进制是 1 后面跟着 100 个 0Big = 1 << 100// 再往右移 99 位，即 Small = 1 << 1，或者说 Small = 2Small = Big >> 99
  )
  

2流程控制

for

• 初始化语句和后置语句是可选的。
• 可以去掉分号，因为 C 的 while 在 Go 中叫做 for。

for i := 0; i < 10; i++ {sum += i}
for ; sum < 1000; {sum += sum
}
for sum < 1000 {sum += sum
}
//无限循环
for {}

if

• if 语句可以在条件表达式前执行一个简短语句。

  该语句声明的变量作用域仅在 if 之内。

func pow(x, n, lim float64) float64 {if v := math.Pow(x, n); v < lim {return v}return lim
}

• （在 main 的 fmt.Println 调用开始前，两次对 pow 的调用均已执行并返回其各自的结果。）

func pow(x, n, lim float64) float64 {if v := math.Pow(x, n); v < lim {return v} else {fmt.Printf("%g >= %g\n", v, lim)}// can't use v here, thoughreturn lim
}func main() {fmt.Println(pow(3, 2, 10),pow(3, 3, 20),)
}//输出：注意输出顺序
27 >= 20
9 20

*循环与函数练习：

题目

实现一个平方根函数：给定一个数 x，我们需要找到一个数 z 使得 z² 尽可能地接近 x。

计算机通常使用循环来计算 x 的平方根。从某个猜测的值 z 开始，我们可以根据 z² 与 x 的近似度来改进 z，产生一个更好的猜测：

z -= (z*z - x) / (2*z)

重复调整的过程，猜测的结果会越来越精确，得到的答案也会尽可能接近实际的平方根。

请在提供的 func Sqrt 中实现它。无论输入是什么，可以先猜测 z 为 1。 首先，重复计算 10 次并连续打印每次的 z 值。观察对于不同的 x 值（1、2、3 …）， 你得到的答案是如何逼近结果的，以及猜测改进的速度有多快。

实现

package mainimport ("fmt""math"
)func Sqrt(x float64) float64 {z := 1.0 // 修正了变量声明t := math.Abs(z*z - x)for i := 0; i < 10; i++ {if z*z > x { // 修正了条件语句的语法z -= (z*z - x) / (2 * z)} else {z += (z*z - x) / (2 * z)}fmt.Printf("当前是第%d次，z:%f,z*z:%f,x:%f\n", i, z,z*z, x) // 修正了格式化字符串t = math.Abs(z*z - x)fmt.Printf("当前t值为：%f\n",t)if t==0.0 {break}}return z
}func main() {fmt.Println(Sqrt(102))
}

• 当x很小时，基本7、8次就可以得到结果

switch 分支

• Go 只会运行选定的 case，而非之后所有的 case。 在效果上，Go 的做法相当于这些语言中为每个 case 后面自动添加了所需的 break 语句。
• 在 Go 中，除非以 fallthrough 语句结束，否则分支会自动终止。
• Go 的另一点重要的不同在于 switch 的 case 无需为常量，且取值不限于整数。

func main() {t := time.Now()switch {case t.Hour() < 12:fmt.Println("早上好！")case t.Hour() < 17:fmt.Println("下午好！")default:fmt.Println("晚上好！")}
}

• switch 的 case 语句从上到下顺次执行，直到匹配成功时停止。

defer 推迟

defer 语句会将函数推迟到外层函数返回之后执行。

推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用

• 推迟调用的函数调用**会被压入一个栈中**。 当外层函数返回时，被推迟的调用会按照后进先出的顺序调用。

func main() {defer fmt.Println("world1")fmt.Println("hello")defer fmt.Println("world2")defer fmt.Println("world3")fmt.Println("hello2")
}//输出
hello
hello2
world3
world2
world1

3.结构体 切片 映射

指针

Go 拥有指针。指针保存了值的内存地址。

• 类型 *T 是指向 T 类型值的指针，其零值为 nil。

var p *int

• & 操作符会生成一个指向其操作数的指针。

i := 42
p = &i

• * 操作符表示指针指向的底层值。

fmt.Println(*p) // 通过指针 p 读取 i
*p = 21         // 通过指针 p 设置 i

这也就是通常所说的「解引用」或「间接引用」。

• 与 C 不同，Go 没有指针运算。

func main() {i, j := 42, 2701p := &i         // 指向 ifmt.Println(*p) // 通过指针读取 i 的值*p = 21         // 通过指针设置 i 的值fmt.Println(i)  // 查看 i 的值p = &j         // 指向 j*p = *p / 37   // 通过指针对 j 进行除法运算fmt.Println(j) // 查看 j 的值
}
42
21
73

结构体

• 一个 结构体（struct）就是一组 字段（field）。

type Vertex struct {X, Y int
}var (v1 = Vertex{1, 2}  // 创建一个 Vertex 类型的结构体v2 = Vertex{X: 1}  // Y:0 被隐式地赋予零值v3 = Vertex{}      // X:0 Y:0p  = &Vertex{1, 2} // 创建一个 *Vertex 类型的结构体（指针）
)func main() {fmt.Println(Vertex{1, 2})v := Vertex{3, 5}p2 := &vp2.X = 1e9 //等价于(*p2).X fmt.Println(v)fmt.Println(v1, p, v2, v3)
}
//输出
{1 2}
{1000000000 5}
{1 2} &{1 2} {1 0} {0 0}

数组

• 类型 [n]T 表示一个数组，它拥有 n 个类型为 T 的值。

• 表达式

  var a [10]int
  

• 数组的长度是其类型的一部分，因此数组不能改变大小。

var a [2]string
a[0] = "Hello ww"
a[1] = "World"
fmt.Println(a[0], a[1])
fmt.Println(a)primes := [6]int{2, 3, 5, 7, 11, 13}
//var primes = [6]int{2, 3, 5, 7, 11, 13}

切片

• 类型 []T 表示一个元素类型为 T 的切片。.

• 切片通过两个下标来界定，一个下界和一个上界，二者以冒号分隔：

  a[low : high]
  

• 它会选出一个半闭半开区间，包括第一个元素，但排除最后一个元素。

• 长度为high-low

• 更改切片的元素会修改其底层数组中对应的元素。和它共享底层数组的切片都会观测到这些修改。

func main() {names := [4]string{"John","Paul","George","Ringo",}fmt.Println(names)a := names[0:2]b := names[1:3]fmt.Println(a, b)b[0] = "XXX"fmt.Println(a, b)fmt.Println(names)
}[John Paul George Ringo]
[John Paul] [Paul George]
[John XXX] [XXX George]
[John XXX George Ringo]

• 切片字面量

[3]bool{true, true, false}
//等价于
[]bool{true, true, false}s := []struct {i intb bool}{{2, true},{3, false},{5, true},{7, true},{11, false},{13, true},}

• 默认行为：切片下界的默认值为 0，上界则是该切片的长度。

//等价表达式
a[0:10]
a[:10]
a[0:]
a[:]

func main() {s := []int{2, 3, 5, 7, 11, 13}s = s[1:4]fmt.Println(s)s = s[:2] //0:2fmt.Println(s)s = s[1:]//1:2fmt.Println(s)
}
[3 5 7]
[3 5]
[5]

• 切片的容量不会改变，长度会改变
• 切片的长度就是它所包含的元素个数。 len(s)
• 切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。cap(s)

func main() {s := []int{2, 3, 5, 7, 11, 13}printSlice(s)// 截取切片使其长度为 0s = s[:0]printSlice(s)// 扩展其长度s = s[:4]printSlice(s)// 舍弃前两个值s = s[2:]printSlice(s)
}func printSlice(s []int) {fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
}//输出
len=6 cap=6 [2 3 5 7 11 13]
len=0 cap=6 []
len=4 cap=6 [2 3 5 7]
len=2 cap=4 [5 7]

• 使用切片会比直接使用数组更方便

• 切片的零值是 nil。nil 切片的长度和容量为 0 且没有底层数组。

func main() {var s []intfmt.Println(s, len(s), cap(s))if s == nil {fmt.Println("nil!")}
}
[] 0 0
nil!

• make：用内置函数 make 来创建切片

a := make([]int, 5)  // len(a)=5
//指定容量
b := make([]int, 0, 5) // len(b)=0, cap(b)=5b = b[:cap(b)] // len(b)=5, cap(b)=5
b = b[1:]      // len(b)=4, cap(b)=4

• 举例，注意容量是和底层的数组容量相关

func main() {a := make([]int, 5)printSlice("a", a)b := make([]int, 0, 5)printSlice("b", b)c := b[:2]d := c[2:5]c[1]=1	printSlice("c", c)printSlice("d", d)
}func printSlice(s string, x []int) {fmt.Printf("%s len=%d cap=%d %v\n",s, len(x), cap(x), x)
}
//结果
a len=5 cap=5 [0 0 0 0 0]
b len=0 cap=5 []
//c 的 cap 是 5，因为它的起始下标是底层数组的 0，容量就是 5-0=5。
//d 的 cap 是 3，因为它的起始下标是底层数组的 2，容量就是 5-2=3。
c len=2 cap=5 [0 1]
d len=3 cap=3 [0 0 0]

• 追加元素 append

func main() {var s []intprintSlice(s)// 可在空切片上追加s = append(s, 0)printSlice(s)// 这个切片会按需增长s = append(s, 1)printSlice(s)// 可以一次性添加多个元素s = append(s, 2, 3, 4)printSlice(s)
}
len=0 cap=0 []
len=1 cap=1 [0]
len=2 cap=2 [0 1]
len=5 cap=6 [0 1 2 3 4]

• range遍历

使用 for 循环遍历切片时，每次迭代都会返回两个值。

• 第一个值为当前元素的下标
• 第二个值为该下标所对应元素的一份副本。

var pow = []int{1, 2, 4, 8, 16, 32}func main() {for i, v := range pow {fmt.Printf("2**%d = %d\n", i, v)}
}
2**0 = 1
2**1 = 2
2**2 = 4
2**3 = 8
2**4 = 16
2**5 = 32//忽略
for i, _ := range pow
for _, value := range pow
//只需索引
for i := range pow

*切片练习

题目：

实现 Pic。它应当返回一个长度为 dy 的切片，其中每个元素是一个长度为 dx，元素类型为 uint8 的切片。当你运行此程序时，它会将每个整数解释为灰度值 （好吧，其实是蓝度值）并显示它所对应的图像。

图像的解析式由你来定。几个有趣的函数包括 (x+y)/2、x*y、x^y、x*log(y) 和 x%(y+1)。

（提示：需要使用循环来分配 [][]uint8 中的每个 []uint8。）

（请使用 uint8(intValue) 在类型之间转换；你可能会用到 math 包中的函数。）

实现

package mainimport ("golang.org/x/tour/pic""math"
)func Pic(dx, dy int) [][]uint8 {matrix := make([][]uint8,dy)//循环分配for row := range matrix {matrix[row] = make([]uint8, dx) // 为每一行分配列for i:=range matrix[row]{//1 matrix[row][i]=(uint8(i)+uint8(row))/2//2 matrix[row][i]=(uint8(i+1)*uint8(row+1))//3 matrix[row][i]=(uint8(i)^uint8(row))//4 matrix[row][i]=(uint8(i)*uint8(math.Log(float64(row+1))))}}return matrix}
func main() {pic.Show(Pic)
}

map

• 映射，key-value
• 映射的零值为 nil 。nil 映射既没有键，也不能添加键。
• make 函数会返回给定类型的映射，并将其初始化备用。

//m = make(map[ key ] value)
type Vertex struct {Lat, Long float64
}
var m map[string]Vertexfunc main() {m = make(map[string]Vertex)m["Bell Labs"] = Vertex{40.68433, -74.39967,}m["11 Labs"] = Vertex{41.68433, -73.39967,}fmt.Println(m["Bell Labs"])fmt.Println(m["11 Labs"])fmt.Println(len(m))
}//输出
{40.68433 -74.39967}
{41.68433 -73.39967}
2

映射字面量（Map literals）

• 必须有键名

var m = map[string]Vertex{"Bell Labs": Vertex{40.68433, -74.39967,},"Google": Vertex{37.42202, -122.08408,},
}

修改映射

在映射 m 中插入或修改元素：

m[key] = elem

获取元素：

elem = m[key]

删除元素：

delete(m, key)

通过双赋值检测某个键是否存在：

• 若 key 在 m 中，ok 为 true ；否则，ok 为 false。
• 若 key 不在映射中，则 elem 是该映射元素类型的零值。

短变量声明：

elem, ok = m[key]

*练习：映射

实现 WordCount。它应当返回一个映射，其中包含字符串 s 中每个“单词”的个数。 函数 wc.Test 会为此函数执行一系列测试用例，并输出成功还是失败。

实现：

package mainimport ("golang.org/x/tour/wc""strings"
)func WordCount(s string) map[string]int {//strings.Fields 会根据空白字符分割字符串并返回一个字符串切片str :=strings.Fields(s)//定义一个映射（map）时，必须使用 make 函数或直接初始化//var m = make(map[string]int)等价于下面的两行var m map[string]intm=make(map[string]int)for _,word:=range str{m[word]+=1}	return m
}func main() {wc.Test(WordCount)
}

• 注意使用strings.Fields方法
• 注意map需要初始化

函数值

• 函数可以像值一样传递
• 函数值可以用作函数的参数或返回值。

func compute(fn func(float64, float64) float64) float64 {return fn(3, 4)
}func main() {hypot := func(x, y float64) float64 {return math.Sqrt(x*x + y*y)}fmt.Println(hypot(5, 12))fmt.Println(compute(hypot))fmt.Println(compute(math.Pow))
}

解释：

1. compute 函数：

   func compute(fn func(float64, float64) float64) float64 {return fn(3, 4)
   }
   

   • compute 接受一个函数 fn，该函数参数是两个 float64 类型，并返回一个 float64。
   • 在 compute 中，调用 fn(3, 4)，并返回结果。

2. main 函数：

   func main() {hypot := func(x, y float64) float64 {return math.Sqrt(x*x + y*y)}fmt.Println(hypot(5, 12)) // 计算 5 和 12 的斜边长度fmt.Println(compute(hypot)) // 调用 compute，传入 hypotfmt.Println(compute(math.Pow)) // 调用 compute，传入 math.Pow
   }
   

   • hypot 是一个匿名函数，用于计算给定两个直角边 x 和 y 的斜边长度（使用勾股定理）。
   • fmt.Println(hypot(5, 12)) 计算并打印斜边长度，即 13。

3. compute(hypot)：

   • 调用 compute，传入 hypot 函数，返回 hypot(3, 4) 的结果，即 5。

4. compute(math.Pow)：

   • math.Pow 是一个标准库函数，计算 x 的 y 次方。
   • compute(math.Pow) 将调用 math.Pow(3, 4)，结果是 81。

函数闭包

闭包是一个函数值，它引用了其函数体之外的变量。 该函数可以访问并赋予其引用的变量值，换句话说，该函数被“绑定”到了这些变量。

package mainimport "fmt"func adder() func(int) int {sum := 0return func(x int) int {sum += xreturn sum}
}func main() {pos, neg := adder(), adder()for i := 0; i < 10; i++ {fmt.Println(pos(i),neg(-2*i),)}
}
0 0
1 -2
3 -6
6 -12
10 -20
15 -30
21 -42
28 -56
36 -72
45 -90

这段 Go 代码展示了闭包的概念。闭包是一个函数，它捕获了其外部作用域的变量。下面逐步解释代码的每个部分。

解释

1. adder 函数：

   func adder() func(int) int {sum := 0return func(x int) int {sum += xreturn sum}
   }
   

   • adder 函数返回一个匿名函数（闭包）。
   • 在 adder 内部，定义了一个变量 sum，初始值为 0。
   • 返回的匿名函数接受一个 int 类型参数 x，每次调用时将 x 加到 sum 上，并返回新的 sum 值。

2. main 函数：

   func main() {pos, neg := adder(), adder()for i := 0; i < 10; i++ {fmt.Println(pos(i),neg(-2*i),)}
   }
   

   • 调用 adder 两次，分别创建两个闭包 pos 和 neg。
   • pos 用于计算正数的累加和，neg 用于计算负数的累加和。
   • 在循环中，从 0 到 9 迭代，调用 pos(i) 和 neg(-2*i)。

输出解释

• pos(i) 将 i 依次加到 sum 中，输出 0 到 9 的累加和。
• neg(-2*i) 将 -2*i 依次加到 sum 中，输出 0 到 -18 的累加和。

闭包的特性

• 状态保持：每个闭包都有自己的 sum 变量，互不影响。pos 和 neg 各自维护自己的状态。
• 函数作为第一类公民：在 Go 中，函数可以作为返回值，允许创建灵活的和可重用的代码。

允许每个 adder 实例独立维护其状态，通过返回的函数可以对状态进行修改和访问。

*练习：斐波纳契闭包

题目：

实现一个 fibonacci 函数，它返回一个函数（闭包），该闭包返回一个斐波纳契数列 (0, 1, 1, 2, 3, 5, …)。

实现：

package mainimport "fmt"// fibonacci 是返回一个「返回一个 int 的函数」的函数
func fibonacci() func() int {var a,b,c=1,0,0return func() int {c=a+ba=bb=creturn a}
}func main() {f := fibonacci()for i := 0; i < 10; i++ {fmt.Println(f())}
}