我献出这篇 go 精华总结，阁下该如何应对

文章目录

• • 1.初识包管理
  • 2.输出
  • 3.注释
  • 4.初识数据类型
  • 5.变量
  • • [5.1 声明变量的意义？](#5.1 声明变量的意义？)
    • [5.2 变量名要求](#5.2 变量名要求)
    • [5.3 变量简写](#5.3 变量简写)
    • [5.4 作用域](#5.4 作用域)
    • [5.5 赋值及内存相关](#5.5 赋值及内存相关)
    • • 注意事项
  • 阶段练习题
  • 6.常量
  • • [6.1 因式分解](#6.1 因式分解)
    • [6.2 全局](#6.2 全局)
    • [6.3 iota](#6.3 iota)
  • 7.输入
  • 8.条件语句
  • • [8.1 最基本](#8.1 最基本)
    • [8.2 多条件判断](#8.2 多条件判断)
    • [8.3 嵌套](#8.3 嵌套)
  • [9. 荐书 《Go编程进阶实战：开发命令行应用、HTTP应用和gRPC应用》](#9. 荐书 《Go编程进阶实战：开发命令行应用、HTTP应用和gRPC应用》)
  • • [9.1 内容简介](#9.1 内容简介)
    • [9.2 作者简介](#9.2 作者简介)
    • [9.3 目录](#9.3 目录)

1.初识包管理

关于包管理的总结：

• 一个文件夹可以称为一个包。
• 在文件夹（包）中可以创建多个文件。
• 在同一个包下的每个为文件中必须指定 包名称且相同

重点：关于包的分类

• main包，如果是main包，则必须写一个main函数，此函数就是项目的入口（main主函数）。 编译生成的就是一个可执行文件。
• 非main包，用来将代码进行分类，分别放在不同的包和文件中。

注意：

• 调用其他包的功能，需要先 import 导入，然后再使用；调用自己包中的功能时，直接调用即可（无需导入）

• 文件中的函数首字母是小写，表示此函数只能被当前包内部文件调用。首字母是大写，则意味着任何包都可以调用。

2.输出

在终端将想要展示的数据显示出来，例如：欢迎登录、请输入用户名等。。。

• 内置函数（不推荐）
  • print
  • println
• fmt包（推荐）
  • fmt.Print
  • fmt.Println

扩展：进程里有 stdin/stdout/stderr 。

package main

import "fmt"

func main() {
	// 基于内置函数（不推荐）
	//print("你好 \n")
	//print("我是马云 \n")
	//println("你好")
	//println("我是马云")

	// fmt包（推荐）
	//fmt.Print("你好 \n")
	//fmt.Print("我是马云 \n")
	//fmt.Println("你好")
	//fmt.Println("我是马云")
	//fmt.Println("我叫", "马云", "我媳妇", "是个", "....")
	//fmt.Println("我叫马云我媳妇是个....")

	// fmt包 扩展：格式化输出
	// %s，占位符 "文本"
	// %d，占位符 整数
	// %f，占位符 小数（浮点数）
	// %.2f，占位符 小数（保留小数点后2位，四舍五入）
	// 百分比
	fmt.Printf("老汉开着%s,去接%s的媳妇，多少钱一次？%d块。嫂子给打折吧，%.2f怎么样？小哥哥包你100%%满意", "车", "老男孩", 100, 3.889)
}

3.注释

• 单行注释， //
• 多行注释， /* */

快捷：contrl + ?

4.初识数据类型

• 整型，整数
• 字符串，文本
• 布尔型，真假

package main

import "fmt"

func main() {
	// 整型
	fmt.Println(666)
	fmt.Println(6 + 9)
	fmt.Println(6 - 9)
	fmt.Println(6 * 9)
	fmt.Println(16 / 9) // 商
	fmt.Println(16 % 9) // 余数

	// 字符串类型，特点：通过双引号
	fmt.Println("好人")
	fmt.Println("离离原上草，一岁一枯荣")
	fmt.Println("aaa" + "sss")
	//fmt.Println("alex" + 666)
	fmt.Println("aaa" + "666")
	// 对比
	fmt.Println("1" + "2") // 结果："12"
	fmt.Println(1 + 2)     // 结果：3

	// 布尔类型，真假
	fmt.Println(1 > 2) // false  假
	fmt.Println(1 < 2) // true   真
	fmt.Println(1 == 2)
	fmt.Println(1 >= 2)
	fmt.Println("AAA" == "aaa")

	// 超前
	if 2 > 1 {
		fmt.Println("222")
	} else {
		fmt.Println("111")
	}

}

5.变量

可以理解为昵称。

• 声明 + 赋值

  var sd string = "wowoow"
  fmt.Println(sd)
  
  var age int = 73
  fmt.Println(age)
  
  var flag bool = true
  fmt.Println(flag)

• 先声明后赋值

  // 声明了一个字符类型变量 sd
  var sd string
  // 给sd变量赋值
  sd = "wowoow"
  fmt.Println(sd)

5.1 声明变量的意义？

• 编写代码省事

  // 文本，请将文本输出3次："伤情最是晚凉天，憔悴斯人不堪怜。"
  var message string = "伤情最是晚凉天，憔悴斯人不堪怜。"
  fmt.Println(message)
  fmt.Println(message)
  fmt.Println(message)
  

• 存储结果，方便之后使用

  // 存储结果，方便之后使用
  var v1 int = 99
  var v2 int = 33
  var v3 int = v1 + v2
  var v4 int = v1 * v2
  var v5 int = v1 + v2 + v3 + v4
  fmt.Println(v1, v2, v3, v4, v5)
  

• 存储用户输入的值

  var name string
  fmt.Scanf("%s", &name) // 用户输入字符串并赋值给name变量
  if name == "sss" {
      fmt.Println("用户名输入正确")
  } else {
      fmt.Println("用户名输入失败")
  }

5.2 变量名要求

• 【要求】变量名必须只包含：字母、数字、下划线

  var %1 string，错误
  var $ string，错误

• 【要求】数字不能开头

  var 1 string  错误
  var 1name string  错误
  var _ string 正确

• 【要求】不能使用go语言内置的关键字

  var var string = "南通州北通州南北通州通南北"  错误
  
  break、default、func、interface、select、case、defer、go、map、struct、chan、else、goto、package、switch、const、fallthrough、if、range、type、continue、for、import、return、var
  

• 建议

  • 变量名见名知意：name/age/num ; v1、v2、v3
  • 驼峰式命名：myBossName / startDate

练习题：

var n1 int 
var data bool
var _9 string

5.3 变量简写

• 声明+赋值

  var name string = "www"
  
  var name = "www"
  
  name := "www"  // 推荐

• 先声明再赋值

  var name string
  var message string
  var data string
  
  var name,message,data string
  name = "wwwwww"
  message = "中奖了"
  data = "中了5000w"

因式分解，例如：声明5个变量，分别有字符串、整型

var (
    name   = "李白"
    age    = 18
    hobby  = "吟诗作对"
    salary = 1000000
    gender string  // 只声明但不赋值，有一个默认： ""
    length int     // 只声明但不赋值，有一个默认： 0
    sb bool     // 只声明但不赋值，有一个默认： false
)
fmt.Println(name, age, hobby, salary, gender,length,sb)

扩展：go编译器会认为声明变量不使用 就是浪费资源。

5.4 作用域

如果我们定义了大括号，那么在大括号中定义的变量。

• 不能被上级使用。
• 可以在同级使用。
• 可以再子级使用。

package main

import "fmt"

func main() {
	name := "韩信"
	fmt.Println(name)
	if true {
		age := 18
		name := "alex"
		fmt.Println(age)
		fmt.Println(name)
	}
	fmt.Println(name)
}

全局变量和局部变量

• 全局变量，未写在函数中的变量称为全局变量；不可以使用v1:=xx方式进行简化；可以基于因式分解方式声明多个变量；项目中寻找变量时最后一环。
• 局部变量，编写在{}里面的变量；可以使用任意方式简化；可以基于因式分解方式声明多个变量；

package main

import "fmt"

// 全局变量（不能以省略的方式）
var school string = "清华大学" // 可以
//var school = "清华大学" 	 // 可以
//school := "清华大学"  		 // 不可以

var (
	v1 = 123
	v2 = "你好"
	v3 int
)

func main() {

	name := "露娜" // 局部变量
	fmt.Println(name)
	if true {
		age := 18      // 局部变量
		name := "tom" // 局部变量
		fmt.Println(age)
		fmt.Println(name)
	}
	fmt.Println(name)
	fmt.Println(school)
	fmt.Println(v1, v2, v3)
}

5.5 赋值及内存相关

示例1：

name := "妲己"

示例2：

name := "wwwwww"
nickname := name

注意：这一点与 python 不同。

package main

import "fmt"

func main() {
	name := "小乔"
	nickname := name

	fmt.Println(name, &name)
	fmt.Println(nickname, &nickname)
}

示例3：

name := "甄姬"
nickname := name

name = "luna"

package main

import "fmt"

func main() {
	name := "www"
	nickname := name
	fmt.Println(name, &name)
	fmt.Println(nickname, &nickname)

	name = "wwwwww"
	fmt.Println(name, &name)
	fmt.Println(nickname, &nickname)
}

注意事项

使用int、string、bool这三种数据类型时，如果遇到变量的赋值则会拷贝一份。【值类型】

name := "大乔"
nickname := name

提示：后续在数据类型中会详细再讲解。

阶段练习题

1. package main的作用？

2. 单行注释和多行注释分别是什么？

3. 下面声明变量的方式错误的有哪些？

   var name = "武松"
   var age int = 18
   hobby = "嫂子"
   nickName string = "一米八大高个"
   webSite := "我在景阳冈打老虎"

   var age int = 18
   age = 19

4. 下面声明变量的方式正确的有哪些？

   var v1,v2,v3 int
   var (
   	v6 = 123
       v7 string
   )
   var v4,v5 = 11,22
   v4,v5 = 11,22
   v4,v5 := 11,22

5. 变量名规范。

6. 看代码写结果

   package main
   
   import "fmt"
   
   var number = 9999
   
   func main() {
   	number := 666
   	fmt.Println(number)
   }

7. 看代码写结果

   package main
   
   import "fmt"
   
   var number = 99
   
   func main() {
   	number := 66
   	if true {
   		number := 33
   		fmt.Println(number)
   	}
   	fmt.Println(number)
   }

8. 看代码写结果

   package main
   
   import "fmt"
   
   var number = 99
   
   func main() {
   	number := 66
   	if true {
   		number := 33
   		fmt.Println(number)
   	}
   	number = 88
   	fmt.Println(number)
   }

9. 看代码写结果

   package main
   
   import "fmt"
   
   var number = 99
   
   func main() {
   	if true {
   		fmt.Println(number)
   	}
   	number = 88
   	fmt.Println(number)
   }

10. 看代码写结果

    package main
    
    import "fmt"
    
    var number = 99
    
    func main() {
    	number := 88
    	if true {
    		number = 123
    		fmt.Println(number)
    	}
    	fmt.Println(number)
    }

11. 看代码写结果

    package main
    
    import "fmt"
    
    var number = 99
    
    func main() {
    	fmt.Println(number)
    	number := 88
    	if true {
    		number = 123
    		fmt.Println(number)
    	}
    	fmt.Println(number)
    }

6.常量

不可被修改的变量。

package main

import "fmt"

func main() {
	// 定义变量
	//var name string = "林冲"
	//var name = "林冲"
	name := "林冲"
	name = "lc"
	fmt.Println(name)

	// 定义常量
	//const age int = 98
	const age = 98
	fmt.Println(age)
}

6.1 因式分解

package main

import "fmt"


func main() {
	// 定义变量
	//var name string = "林冲"
	//var name = "林冲"
	name := "林冲"
	name = "lc"
	fmt.Println(name)

	// 定义常量
	//const age int = 98
	const age = 98
	fmt.Println(age)

	// 常量因式分解
	const (
		v1 = 123
		v2 = 456
		pi = 9.9
	)
	fmt.Println(v1, v2, pi, gender)
}

6.2 全局

package main

import "fmt"

const Data = 999
const (
	pi     = 3.1415926
	gender = "男"
)

func main() {
	// 定义变量
	//var name string = "林冲"
	//var name = "林冲"
	name := "林冲"
	name = "lc"
	fmt.Println(name)

	// 定义常量
	//const age int = 98
	const age = 98
	fmt.Println(age)

	// 常量因式分解
	const (
		v1 = 123
		v2 = 456
		//pi = 9.9
	)
	fmt.Println(v1, v2, pi, gender)
}

6.3 iota

可有可无，当做一个在声明常量时的一个计数器。

package main

const (
	monday = iota + 1
	tuesday
	wednesday
	thursday
	friday
	saturday
	sunday
)

const (
	n1 = iota
	n2
	n3
)

func main() {

	// iota
	// 示例1
	/*
		const (
			v1 = 1
			v2 = 2
			v3 = 3
			v4 = 4
			v5 = 5
		)
		fmt.Println(v1, v2, v3, v4, v5)
	*/

	// 示例2
	/*
		const (
			v1 = iota
			v2
			v3
			v4
			v5
		)
		fmt.Println(v1, v2, v3, v4, v5)
	*/

	// 示例3
	/*
		const (
			v1 = iota + 2
			v2
			v3
			v4
			v5
		)
		fmt.Println(v1, v2, v3, v4, v5)
	*/

	// 示例4：
	/*
		const (
			v1 = iota + 2
			_
			v2
			v3
			v4
			v5
		)
		fmt.Println(v1, v2, v3, v4, v5)
	*/

}

7.输入

让用户输入数据，完成项目交互。

• fmt.Scan
• fmt.Scanln
• fmt.Scanf

package main

import "fmt"

func main() {
	// 示例1：fmt.Scan
	/*
		var name string
		fmt.Println("请输入用户名：")
		fmt.Scan(&name)
		fmt.Printf(name)
	*/

	// 示例2：fmt.Scan
	var name string
	var age int

	fmt.Println("请输入用户名：")
	// 当使用Scan时，会提示用户输入
	// 用户输入完成之后，会得到两个值：count,用户输入了几个值；err，用输入错误则是错误信息
	_, err := fmt.Scan(&name, &age)
	if err == nil {
		fmt.Println(name, age)
	} else {
		fmt.Println("用户输入数据错误", err)
	}
	// 特别说明：fmt.Scan 要求输入两个值，必须输入两个，否则他会一直等待。
}

package main

import "fmt"

func main() {
	// 示例1：fmt.Scanln
	/*
		var name string
		fmt.Print("请输入用户名：")
		fmt.Scanln(&name)
		fmt.Printf(name)
	*/

	// 示例2：fmt.Scanln

	var name string
	var age int
	fmt.Print("请输入用户名：")
	// 当使用Scanln时，会提示用户输入
	// 用户输入完成之后，会得到两个值：count,用户输入了几个值；err，用输入错误则是错误信息
	count, err := fmt.Scanln(&name, &age)
	fmt.Println(count, err)
	fmt.Println(name, age)

	// 特别说明：fmt.Scanln 等待回车。
}

package main

import "fmt"

func main() {
	var name string
	var age int

	fmt.Print("请输入用户名：")
	_, _ = fmt.Scanf("我叫%s 今年%d 岁", &name, &age)
	fmt.Println(name, age)
}

无法解决的难题？

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	// line，从stdin中读取一行的数据（字节集合 -> 转化成为字符串）
	// reader默认一次能4096个字节（4096/3)
	//    1. 一次性读完，isPrefix=false
	// 	  2. 先读一部分，isPrefix=true，再去读取isPrefix=false
	line, _, _ := reader.ReadLine()
	data := string(line)
	fmt.Println(data)
}

8.条件语句

8.1 最基本

if 条件 {
    成立后，此代码块执行
}else{
    不成立，此代码块执行
}

if 条件 {
    成立后，此代码块执行
}

示例：

package main

func main() {
	/*
		if true {
			fmt.Println("666")
		}else{
			fmt.Println("999")
		}
	*/

	/*
		if 1 > 2 {
			fmt.Println("666")
		} else {
			fmt.Println("999")
		}
	*/

	/*
		flag := false
		if flag {
			fmt.Println("条件成立")
		}else{
			fmt.Println("条件不成立")
		}
	*/

	// 练习题1:用户输入姓名，判断是否正确
	/*
		var name string
		fmt.Print("请输入姓名：")
		fmt.Scanln(&name)
		if name == "alex" {
			fmt.Println("用户名输入正确")
		} else {
			fmt.Println("用户名输入错误")
		}
	*/
	// 练习题2:用户输入数字，判断奇数、偶数
	/*
		var number int
		fmt.Print("请输入数字：")
		fmt.Scanln(&number)
		if number % 2 == 0{
			fmt.Println("您输入的是偶数")
		}else{
			fmt.Println("您输入的是奇数")
		}
	*/
	// 练习题3:用户和密码，判断用户名密码是否正确。
	/*


		var username, password string
		fmt.Print("请输入用户名：")
		fmt.Scanln(&username)

		fmt.Print("请输入密码：")
		fmt.Scanln(&password)

		if username == "alex" && password == "sb" {
			fmt.Println("欢迎登录pornhub")
		} else {
			fmt.Println("用户名或密码错误")
		}
	*/
	// 练习题4:请输入用户名校验是否是VIP
	/*
		var username string
		fmt.Print("请输入用户名：")
		fmt.Scanln(&username)

		if username == "snow" || username == "马云" {
			fmt.Println("上等客房")
		} else {
			fmt.Println("轰出去")
		}
	*/
}

8.2 多条件判断

if 条件A{
    ...
}else if 条件B{
    ...
}else if 条件C{
    ...
}else{
    ...
}

示例：

package main

import "fmt"

func main() {
	var length int
	fmt.Print("请输入你的年龄：")
	fmt.Scanln(&length)

	if length < 1 {
		fmt.Println("小孩子")
	} else if length < 6 {
		fmt.Println("大孩子")
	} else if length < 18 {
		fmt.Println("快是大人了")
	} else {
		fmt.Println("大人")
	}
}

8.3 嵌套

package main

import "fmt"

func main() {
	fmt.Println("欢迎致电10086，1.话费相关；2.业务办理；3.人工服务。")

	var number int
	fmt.Scanln(&number)

	if number == 1 {
		fmt.Println("话费服务，1.交话费；2.查询。")
		var n1 int
		fmt.Scanln(&n1)
		if n1 == 1 {
			fmt.Println("缴话费啦")
		} else if n1 == 2 {
			fmt.Println("查话费了")
		} else {
			fmt.Println("输入错误")
		}
	} else if number == 2 {
		fmt.Println("业务办理")
	} else if number == 3 {
		fmt.Println("人工服务")
	} else {
		fmt.Println("输入错误")
	}
	
	// 建议：条件的嵌套不要太多
}

9. 荐书 《Go编程进阶实战：开发命令行应用、HTTP应用和gRPC应用》

9.1 内容简介

主要内容

● 编写命令行应用程序

● 编写HTTP服务和客户端

● 使用gRPC编写RPC应用程序

● 为网络客户端和服务器编写中间件

● 在云对象存储和SQL数据库中存储数据

● 使用惯用的技术测试应用程序

● 为应用程序增加可观察性

● 管理应用程序的配置数据

9.2 作者简介

Amit Saha 是位于澳大利亚悉尼市的Atlassian公司的高级DevOps工程师。Amit曾撰写Doing Math with Python: Use Programming to Explore Algebra, Statistics, Calculus, and More!和Write Your First Program等书籍。Amit已在软件行业工作10年，曾加盟Sun Microsystems、RedHat和多家初创公司。Amit在技术杂志、会议论文集和研究期刊上发表过大量文章。

9.3 目录

第1章 编写命令行应用程序 1

1.1 我们的第一个应用程序 1

1.2 编写单元测试 8

1.3 使用flag包 14

1.4 改进用户界面 22

1.4.1 删除重复的错误消息 22

1.4.2 自定义用例消息 23

1.4.3 通过位置参数接收姓名 24

1.5 更新单元测试 27

1.6 小结 32

第2章 高级命令行应用程序 33

2.1 实现子命令 33

2.1.1 子命令驱动的应用程序架构 37

2.1.2 测试main包 43

2.1.3 测试cmd包 45

2.2 使应用程序更健壮 47

2.2.1 带有超时的用户输入 48

2.2.2 处理用户信号 51

2.3 小结 55

第3章 编写HTTP客户端 57

3.1 下载数据 57

3.2 反序列化接收到的数据 61

3.3 发送数据 65

3.4 使用二进制数据 71

3.5 小结 78

第4章 高级HTTP客户端 79

4.1 使用自定义HTTP客户端 79

4.1.1 从过载的服务器下载 79

4.1.2 测试超时行为 83

4.1.3 配置重定向行为 86

4.2 定制请求 89

4.3 实现客户端中间件 90

4.3.1 了解RoundTripper接口 90

4.3.2 日志中间件 91

4.3.3 给所有请求添加一个标头 94

4.4 连接池 97

4.5 小结 101

第5章 构建HTTP服务器 103

5.1 我们的第一个HTTP服务器 103

5.2 设置请求处理程序 106

处理程序 106

5.3 测试服务器 109

5.4 Request(请求)结构 112

5.4.1 方法 112

5.4.2 URL 112

5.4.3 Proto、ProtoMajor和ProtoMinor 113

5.4.4 标头 113

5.4.5 主机 113

5.4.6 正文 113

5.4.7 Form、PostForm 113

5.4.8 MultipartForm 114

5.5 将元数据附加到请求 115

5.6 处理流请求 118

5.7 将流数据作为响应 123

5.8 小结 128

第6章 高级HTTP服务器应用程序 129

6.1 处理程序的类型 129

6.2 跨处理程序共享数据 130

6.3 编写服务器中间件 135

6.3.1 自定义HTTP处理程序技术 135

6.3.2 HandlerFunc技术 136

6.3.3 链接中间件 138

6.4 为复杂的服务器应用程序编写测试 142

6.4.1 组织代码 143

6.4.2 测试处理程序 148

6.4.3 测试中间件 151

6.4.4 测试服务器启动 153

6.5 小结 155

第7章 生产级HTTP服务器 157

7.1 终止请求处理 157

7.1.1 终止请求处理的策略 160

7.1.2 处理客户端断开连接 165

7.2 服务器范围的超时 168

7.2.1 为所有处理程序实现超时 169

7.2.2 实现服务器超时 169

7.3 实施优雅的关机 174

7.4 使用TLS保护通信 178

7.4.1 配置TLS和HTTP/2 179

7.4.2 测试TLS服务器 183

7.5 小结 186

第8章 使用gRPC构建RPC应用程序 187

8.1 gRPC和协议缓冲区 187

8.2 编写第一个服务 190

8.2.1 编写服务器 192

8.2.2 编写一个客户端 196

8.2.3 测试服务器 201

8.2.4 测试客户端 204

8.3 protobuf消息的详细介绍 207

8.3.1 序列化和反序列化 207

8.3.2 向前和向后兼容 212

8.4 多个服务 214

8.5 错误处理 219

8.6 小结 221

第9章 高级gRPC应用 223

9.1 流通信 223

9.1.1 服务器端流传输 223

9.1.2 客户端流传输 231

9.1.3 双向流 233

9.2 接收和发送任意字节 241

9.3 使用拦截器实现中间件 250

9.3.1 客户端拦截器 251

9.3.2 服务器端拦截器 257

9.3.3 包装流 262

9.3.4 链接拦截器 264

9.4 小结 265

第10章 生产级gRPC应用 267

10.1 使用TLS保护通信 267

10.2 服务器健壮性 270

10.2.1 实施健康检查 270

10.2.2 处理运行时错误 277

10.2.3 终止请求处理 280

10.3 客户端健壮性 289

10.3.1 提高连接配置 289

10.3.2 处理瞬态故障 291

10.3.3 为方法调用设置超时 296

10.4 连接管理 297

10.5 小结 299

第11章 使用数据存储 301

11.1 使用对象存储 302

11.1.1 与包服务器集成 303

11.1.2 测试包上传 312

11.1.3 访问底层驱动类型 315

11.2 使用关系数据库 316

11.2.1 与包服务器集成 318

11.2.2 测试数据存储 328

11.2.3 数据类型转换 332

11.2.4 使用数据库事务 335

11.3 小结 337

------ 以下部分通过扫描封底二维码获取 ------

附录A 使应用程序可观察 339

附录B 部署应用程序 356

附录C 配置Go开发环境 362

购买链接：https://item.jd.com/13542283.html