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 int
	var f float64
	var b bool
	var s string
	fmt.Printf("%v %v %v %q\n", i, f, b, s)
}
//输出
0 0 false ""

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

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

var i, j int = 1, 2

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

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

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

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

• go基本类型

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // uint8 的别名

rune // int32 的别名
     // 表示一个 Unicode 码位

float32 float64

complex64 complex128

var (
	ToBe   bool       = false
	MaxInt uint64     = 1<<64 - 1
	z      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 个 0
  	Big = 1 << 100
  	// 再往右移 99 位，即 Small = 1 << 1，或者说 Small = 2
  	Small = 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, though
	return 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 main

import (
	"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, 2701

	p := &i         // 指向 i
	fmt.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:0
	p  = &Vertex{1, 2} // 创建一个 *Vertex 类型的结构体（指针）
)

func main() {
	fmt.Println(Vertex{1, 2})
	
	v := Vertex{3, 5}
	p2 := &v
	p2.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 int
		b 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:2
	fmt.Println(s)

	s = s[1:]//1:2
	fmt.Println(s)
}
[3 5 7]
[3 5]
[5]

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

func main() {
	s := []int{2, 3, 5, 7, 11, 13}
	printSlice(s)

	// 截取切片使其长度为 0
	s = 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 []int
	fmt.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)=5

b = 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 []int
	printSlice(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 main
 
import (
	"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]Vertex

func 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 main

import (
	"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]int
	m=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，传入 hypot
       fmt.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 main

import "fmt"

func adder() func(int) int {
	sum := 0
	return func(x int) int {
		sum += x
		return 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 := 0
       return func(x int) int {
           sum += x
           return 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 main

import "fmt"

// fibonacci 是返回一个「返回一个 int 的函数」的函数
func fibonacci() func() int {
	var a,b,c=1,0,0
	return func() int {
		c=a+b
		a=b
		b=c
		return a
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}