mac安装Golang开发环境及快速入门

目录
一、Mac brew 安装go环境
1.1 安装步骤
1.2 设置GOPATH 及环境变量
1.3 编写第一个go程序
二、快速入门
2.1 快速入门需求
2.2 go学习（自用）
2.2.1 go底子程序
2.2.2 变量声明
2.2.3 常量和枚举
2.2.4 函数与多种返回值
2.2.5 init函数与import导包
2.2.6 import匿名、别名导包
2.2.7 defer调用次序
2.2.8 数组的表示和动态数组 slice
2.2.9 map的声明使用
三、debug
3.1 go: cannot run *_test.go files
3.2 深拷贝（copy）和浅拷贝（slice切片）
3.3 引用传递

---

一、Mac brew 安装go环境

1.1 安装步骤

1）终端输入，也可以指定下载go版本

1. brew install go

复制代码

2）查看golang当前版本

1. go version

复制代码

3）查看当前golang环境 执行

1. go env

复制代码

1.2 设置GOPATH 及环境变量

1）GOPATH 是工作目录，工作空间目录 go_project 就是一个目录，此中包含三个子目录：
   

• src 目录包含Go的源文件，它们被构造成包（每个目录都对应一个包），
  
• pkg 目录包含包对象，
  
• bin 目录包含可执行命令。
  

  如下图：

​2） 终端输入 vim .zshrc 添加:
GOPATH 后面加你自己的工作空间，这里是我自己建立的go_project

1. export GOPATH="/Users/mima6ge0/Documents/yanhan_practice/go_project"
3. export PATH = $PATH:$GOPATH/bin

复制代码

执行 source ~/.zshrc 生效，使用go env查看是否修改成功

留意：GOROOT,GOPATH,GO111MODULE的用处与区别

1.3 编写第一个go程序

1）新建hellow.go文件

1. package main
3. import "fmt"
5. func main() {
6.     fmt.Println("hello, world")
7. }

复制代码

2）进入文件所在目录，执行go run hellow.go，成功，如下图

二、快速入门

2.1 快速入门需求

• 具备1种后端编程语言开发履历(C/C++/Java/Python/PHP)
  
• 具备根本的网络编程能力和并发头脑
  
• 相识盘算机根本体系布局
  
• 相识Linux底子知识
  

2.2 go学习（自用）

2.2.1 go底子程序

v%表示打印任何一种类型的格式化

1. package main //程序的包名
2. // main函数
3. //多个文件导入
4. import (
5.         "fmt"
6.         "time"
7. )
9. func main() { //函数的"{"必须和函数名在一行，换到下一行就是语法错误，强制代码风格
10.         fmt.Println("hellow Go!")
11.         //go语言不需要";",可有可无
12.         time.Sleep(10 * time.Second)
13. }

复制代码

2.2.2 变量声明

1. package main
2. /*
3. 变量的声明方法
4. */
5. import "fmt"
6. //全局变量,冒等方法不支持全局，其他的都可以
7. var A int = 100
8. func main() {
9.         //声明变量默认值是0
10.         var a int
11.         fmt.Println("a = ", a)
12.         fmt.Printf("type of a = %T\n", a)
13.         //声明变量,初始化
14.         var b int = 100
15.         fmt.Println("b = ", b)
16.         fmt.Printf("type of v = %T\n", b)
17.         //初始化可以省去变量类型，通过值去匹配变量的树枝类型
18.         var c = 100
19.         fmt.Println("c = ", c)
20.         fmt.Printf("type of c = %T\n", c)
21.         //字符串
22.         var d string = "dasda"
23.         fmt.Println("d = ", d)
24.         fmt.Printf("type of d = %T\n", d)
25.         //最常用方法:冒等，省略var，直接自动匹配,":="初始化加赋值，函数内部使用
26.         e := 3213.432
27.         fmt.Println("e = ", e)
28.         fmt.Printf("type of e = %T\n", e)
30.         fmt.Println("A = ", A)
31.         fmt.Printf("type of A = %T\n", A)
33.         //声明多个变量
34.         var x, y int = 100, 100
35.         fmt.Println("x = ", x, ", y = ", y)
36.         var m, n = 100, "88090"
37.         n = "kjuhku"
38.         fmt.Println("m = ", m, ", n = ", n)
39.         //多行多变量声明
40.         var (
41.                 xx int = 121
42.                 zz bool = true
43.         )
44.         fmt.Println("xx = ", xx, ", zz = ", zz)
45. }

复制代码

2.2.3 常量和枚举

1. package main
3. import "fmt"
5. //const 可以定义枚举类型
6. const (
7.         //可以在const里面添加一个关键字 iota,每行的iota都会累加1，第一行的iota的默认值是0
8.         BEIJING = 10 * iota // iota = 0
9.         SHANGHAI                //iota = 10
10.         SHENZHEN                //iota = 20
11. )
13. const (
14.         a, b = iota + 1, iota + 2 //iota = 0, a = 1, b = 2
15.         c, d                                          //iota = 1, c = 2, d = 3
16.         e, f                                          //iota = 2, e = 3, f = 4
17.         g, h = iota * 2, iota * 3 //iota = 3, g = 6, h = 9
18.         i, k                                          //iota = 4, i = 8, k = 12
19. )
21. func main() {
22.         //常量，只读,不允许修改
23.         const a int = 100
24.         fmt.Println("a = ", a)
25.         fmt.Println("BEIJING = ", BEIJING)
26.         fmt.Println("SHANGHAI = ", SHANGHAI)
27.         fmt.Println("SHENZHEN = ", SHENZHEN)
29.         fmt.Println("a = ", a, "b = ", b)
30.         fmt.Println("c = ", c, "d = ", d)
31.         fmt.Println("e = ", e, "f = ", f)
32.         fmt.Println("g = ", g, "h = ", h)
33.         fmt.Println("i = ", i, "k = ", k)
34.         //iota只能在const里面使用,var里面不可以
35.        
37. }

复制代码

2.2.4 函数与多种返回值

1. package main
3. import "fmt"
5. //返回一个值，匿名
6. func foo1(a string, b int) int {
7.         fmt.Println("a = ", a)
8.         fmt.Println("b = ", b)
9.         c := 100
10.         return c
11. }
13. //返回多个值，匿名
14. func foo2(a string, b int) (int, int) {
15.         fmt.Println("--------foo2----------")
16.         fmt.Println("a = ", a)
17.         fmt.Println("b = ", b)
18.         return 888, 9999
19. }
21. //返回多个返回值，有形参名称
22. func foo3(a string, b int) (r1 int, r2 int) {
23.         fmt.Println("--------foo3----------")
24.         fmt.Println("a = ", a)
25.         fmt.Println("b = ", b)
27.         r1 = 1000
28.         r2 = 100000
29.         return
30. }
32. func foo4(a string, b int) (r1, r2 int) {
33.         fmt.Println("--------foo4----------")
34.         fmt.Println("a = ", a)
35.         fmt.Println("b = ", b)
37.         //r1, r2属于foo3的形参，初始化默认的值是0，作用域空间是整个foo4函数{}的整体
38.         fmt.Println("未赋值：r1 = ", r1)
39.         fmt.Println("未赋值：r2 = ", r2)
40.         r1 = 1000
41.         r2 = 100000
42.         return
43. }
45. func main() {
46.         c := foo1("func1", 1)
47.         fmt.Println("c = ", c)
48.         ret1, ret2 := foo2("func2", 2)
49.         fmt.Println("ret1 = ", ret1)
50.         fmt.Println("ret2 = ", ret2)
52.         r1, r2 := foo3("func3", 3)
53.         fmt.Println("r1 = ", r1)
54.         fmt.Println("r2 = ", r2)
56.         r1, r2 = foo4("func4", 4)
57.         fmt.Println("r1 = ", r1)
58.         fmt.Println("r2 = ", r2)
60. }

复制代码

2.2.5 init函数与import导包

文件目录树状图

lib1.go 代码：

1. package lib1
3. import "fmt"
5. //当前lib1包提供的API
6. //首字母大写的话代表当前接口对外开放，首字母小写只能在该文件下使用
7. func Lib1Test () {
8.         fmt.Println("Lib1Test() ...")
9. }
11. func init () {
12.         fmt.Println("lib1 init ...")
13. }

复制代码

lib2.go 代码： 

1. package lib2
3. import "fmt"
5. //当前lib2包提供的API
6. func Lib2Test () {
7.         fmt.Println("Lib2Test() ...")
8. }
10. func init () {
11.         fmt.Println("lib2 init ...")
12. }

复制代码

main.go代码：

1. package main
3. //需要在GOPATH下
4. import (
5.         "GolangStudy/5_init/lib1"
6.         "GolangStudy/5_init/lib2"
7. )
10. func main () {
11.         lib1.Lib1Test()
12.         lib2.Lib2Test()
13. }

复制代码

2.2.6 import匿名、别名导包

基于2.2.5的代码

1. package main
3. //需要在GOPATH下，go语言语法比较严格，导入必须使用
4. import (
5.         // _ 匿名导包，导入但是不使用，不会报错
6.         _ "GolangStudy/5_init/lib1"
8.         //mylib2是lib2的别名
9.         //mylib2 "GolangStudy/5_init/lib2"
11.         //可以不写包名直接使用Lib2Test(),把方法导入当前main包里面，不建议使用，如果有重名函数，会出现问题
12.         . "GolangStudy/5_init/lib2"
13. )
16. func main () {
17.         //lib1.Lib1Test()
19.         //mylib2.Lib2Test()
21.         Lib2Test()
22. }

复制代码

总结：

2.2.7 defer调用次序

1. package main
2. /*
3. defer的执行顺序是在函数体全部执行完以后和结束之前，
4. 多个defer语句是压栈的，defer在return后面执行
5. */
6. import "fmt"
8. func func1() {
9.         fmt.Println("A")
10. }
12. func func2() {
13.         fmt.Println("B")
14. }
16. func func3() {
17.         fmt.Println("C")
18. }
20. func main () {
21.         defer func1()
22.         defer func2()
23.         defer func3()
24. }

复制代码

2.2.8 数组的表示和动态数组 slice

1）固定长度数组表示，遍历等(不建议，不常用)

1. package main
2. import "fmt"
4. //不建议使用，可以使用动态数组
5. func printArray (array [4]int){
6.         //值拷贝
7.         fmt.Println("---------------输出函数--------------")
8.         for i := 0; i < len(array); i++ {
9.                 fmt.Println("array2_value = ", array[i])
10.         }
12.         //如果要对数组的值进行修改，下面这种传参是改不了的
13.         // array[0] = 10000
14. }
15. func main () {
16.         // 固定长度数组
17.         var array1 [10]int
18.         for i := 0; i < len(array1); i++ {
19.                 fmt.Println("array1_value = ", array1[i])
20.         }
21.         array2 := [10]int{1, 2, 4, 5}
22.         array3 := [4]int{1, 2, 4, 5}
23.         for index, value := range array2 {
24.                 fmt.Println("array2_index = ", index, "array2_value = ", value)
25.         }
27.         printArray(array3)
29.         // 打印数组类型
30.         fmt.Printf("array1 type : %T\n", array1)
31.         fmt.Printf("array2 type : %T\n", array2)
32.         fmt.Printf("array3 type : %T\n", array3)
34. }

复制代码

2）动态数组，切片，slice

1. package main
2. import "fmt"
4. func printArray(array []int) {
5.         // 引用拷贝，传递的是数组指针，所以array[0]会被修改为100
6.         array[0] = 100
7.         // _ 表示匿名的变量，不被使用也不会发生问题
8.         for _, value := range array {
9.                 fmt.Println("value = ", value)
10.         }
11. }
12. func main() {
13.         // 动态数组，切片，slice
14.         array := []int{1, 2, 3, 4}
15.         //查看array的类型
16.         fmt.Printf("array type : %T\n", array)
18.         printArray(array)
20. }

复制代码

3）slice四种界说声明方式

1. package main
3. import (
4.         "fmt"
6. )
7. func main() {
9.         // 声明slice1是一个切片，并且初始化，长度是3，默认值是1， 2， 3
10.         // slice1 := []int{1, 2, 3}
12.         // 声明slice1是一个切片，但是没有分配空间，len = 0,value = []
13.         // var slice1 []int
14.         // 可以通过make来开辟几个空间，这时候len = 3,value = [0， 0， 0]
15.         // slice1 = make([]int, 3)
17.         // 声明slice1是一个切片，通过make来开辟3空间，这时候len = 3,value = [0， 0， 0]
18.         // var slice1 []int = make([]int, 3)
20.         // 声明slice1是一个切片，通过make来开辟3空间，这时候len = 3,value = [0， 0， 0],通过:=推测出他是一个切片
21.         slice1 := make([] int, 3)
23.         fmt.Printf("len = %d , value = %v\n", len(slice1), slice1)
25.         // 判断一个切片是否为空
26.         if slice1 == nil {
27.                 fmt.Println("slice1 is null!")
28.         } else {
29.                 fmt.Println("slice2 is not null!!")
30.         }
31. }

复制代码

4）slice切片追加与截取

1. package main
3. import "fmt"
4. func main () {
5.         // 切片中len和cap是不同的
6.         var numbers = make([] int, 3, 5) // len = 3, cap容量 = 5
7.         fmt.Printf("len = %d, cap = %d, value = %v\n", len(numbers), cap(numbers), numbers)
8.         //追加一个元素7
9.         numbers = append(numbers, 7)
10.         fmt.Printf("len = %d, cap = %d, value = %v\n", len(numbers), cap(numbers), numbers)
11.         numbers = append(numbers, 8)
12.         // 当追加元素时，容量已满，则自动扩充为原来一开始定义的cap的二倍，扩充为10
13.         numbers = append(numbers, 9)
14.         fmt.Printf("len = %d, cap = %d, value = %v\n", len(numbers), cap(numbers), numbers)
16.         // 没有定义容量的情况，但是在容量已满的情况下追加元素，直接扩充为len的二倍
17.         var numbers2 = make([] int, 3)
18.         fmt.Printf("len = %d, cap = %d, value = %v\n", len(numbers2), cap(numbers2), numbers2)
19.         numbers2 = append(numbers2, 4)
20.         fmt.Printf("len = %d, cap = %d, value = %v\n", len(numbers2), cap(numbers2), numbers2)
22.         // slice切片
23.         s := [] int{1, 2, 3, 4}
24.         s1 := s[0:2] //s1是s中的索引在[0, 2)区间的元素，和python类似
25.         fmt.Println("s1 = ", s1)
26.         s2 := s[1:] //s1是s中的索引在[1, len(s))区间的元素，和python类似
27.         fmt.Println("s2 = ", s2)
28.         //如若修改s1里面的元素，s也会随之改变，因为这种切片相当于指针指向了s，所以改s1值,s和s1会一起发生改变（浅拷贝）
29.         s1[0] = 20000
30.         fmt.Println("s = ", s)
32.         // go提供了copy函数，切片的时候只将值复制过来，（深拷贝）
33.         s3 := make([] int, 3) //[0, 0, 0]
34.         // 将s2的值依次拷贝到s3中
35.         copy(s3, s2)
36.         fmt.Println("s3 = ", s3)
37. }

复制代码

2.2.9 map的声明使用

1）map的声明

1. package main
3. import "fmt"
4. func main() {
5.         // 第一种声明方式
6.         var map1 map[string]string
7.         if map1 == nil {
8.                 fmt.Println("map1是一个空map!!")
9.         }
10.         // 使用前，需要通过make来给map分配数据空间
11.         map1 = make(map[string]string, 3)
12.         map1["one"] = "java"
13.         map1["two"] = "php"
14.         map1["three"] = "python"
15.         fmt.Println("map1 = ", map1)
17.         // 第二种声明方式，直接:=
18.         map2 := make(map[int]string)
19.         map2[1] = "baidu"
20.         map2[2] = "tengxun"
21.         map2[3] = "ali"
22.         fmt.Println("map2 = ", map2)
24.         // 第三种声明方式,一般带有初始化的map用这种方式
25.         map3 := map[string]string{
26.                 "王八": "绿豆",
27.                 "傻子": "小丑",
28.         }
29.         fmt.Println("map3 = ", map3)
30. }

复制代码

2）map的使用

1. package main
3. import (
4.         "fmt"
5. )
7. func printMap (city_map map[string]string) {
8.         // 遍历
9.         for key, value := range city_map {
10.                 fmt.Println("key = ", key, ", value = ", value)
11.         }
12. }
14. func changeMap (city_map map[string]string) {
15.         // city_map是一个引用传递，传递过来是地址，可以修改city_map
16.         city_map["UK"] = "london"
17. }
18. func main() {
19.         cityMap := make(map[string]string)
20.         cityMap["china"] = "beijing"
21.         cityMap["USA"] = "DC"
22.        
23.        
24.         printMap(cityMap)
26.         // 删除
27.         delete(cityMap, "china")
28.         fmt.Println("-----------删除后---------------")
29.         printMap(cityMap)
31.         // 修改
32.         cityMap["USA"] = "london"
33.         fmt.Println("-----------修改后---------------")
34.         printMap(cityMap)
36.         // 增加
37.         cityMap["china"] = "beijing"
38.         fmt.Println("-----------增加后---------------")
39.         printMap(cityMap)
41.         changeMap(cityMap)
42.         fmt.Println("-----------函数增加后---------------")
43.         printMap(cityMap)
47. }

复制代码

2.2.10 面向对象

1）布局体的使用

1. package main
3. import "fmt"
5. // 声明一种数据类型，myint是int的别名
6. type myint int
7. // 声明结构体
8. type Book struct{
9.         title string
10.         auth string
11. }
13. func changeBook (book Book) {
14.         // 传递了一个book的副本
15.         book.title = "三体"
16. }
18. func changeBook2 (book *Book) {
19.         // 指针传递
20.         book.title = "生死疲劳"
21. }
23. func main () {
24.         var a myint = 232
25.         fmt.Println("a = ", a)
26.         fmt.Printf("type of a is %T\n", a)
28.         var book1 Book
29.         book1.title = "活着"
30.         book1.auth = "余华"
31.         fmt.Printf("%v\n", book1)
33.         changeBook(book1)
34.         // 使用上面changeBook，修改值并没有成功
35.         fmt.Printf("%v\n", book1)
37.         // 参数是地址，所以要加"&"
38.         changeBook2(&book1)
39.         fmt.Printf("%v\n", book1)
41. }

复制代码

2）面向对象类的表示
A、封装

1. package main
3. import "fmt"
5. // 类名、属性名、方法名、首字母大写代表其他包可以访问，首字母小写代表私有，只有本包内可以使用
6. type Hero struct {
7.         Name string
8.         Ad int
9.         Level int
10. }
12. // 如果不写*Hero，这里传进去的一个副本，如果想在函数内对其进行修改，要用*Hero
13. func (this Hero) Show() {
14.         // 副本
15.         fmt.Println("Name : ", this.Name)
16.         fmt.Println("Ad : ", this.Ad)
17.         fmt.Println("Level : ", this.Level)
18. }
20. func (this Hero) GetName() string {
21.         return this.Name
22. }
24. func (this *Hero) SetName(name string) {
25.         // 这样才是当前对象
26.         this.Name = name
27. }
29. func main() {
30.         hero := Hero{ Name: "freezing", Ad: 33, Level: 1}
31.         hero.Show()
32.         hero.SetName("rebecca")
33.         hero.Show()
35. }

复制代码

B、继续

1. package main
3. import "fmt"
5. type Human struct {
6.         name string
7.         age int
8. }
10. func (this *Human) Walk() {
11.         fmt.Println("Human walk .....")
12. }
14. func (this *Human) Eat() {
15.         fmt.Println("Human eat .....")
16. }
19. type Superhero struct {
20.         // 继承Human写法
21.         Human
22.         level int
23. }
25. // 重定义（方法重写）父类方法
26. func (this *Superhero) Eat() {
27.         fmt.Println("Superhero eat .....")
28. }
30. // 子类的新方法
31. func (this *Superhero) Fly() {
32.         fmt.Println("Superhero fly .....")
33. }
35. func main() {
36.         human := Human{"freezing", 20}
37.         human.Eat()
38.         human.Walk()
39.         superhero := Superhero{Human{"rebecca", 30}, 1}
40.         superhero.Walk() // 父类方法
41.         superhero.Eat()  // 子类方法
42.         superhero.Fly()  // 子类方法
43.     // 另外一种初始化对象的方法
44.         var s Superhero
45.         s.age = 24
46.         s.level  = 1
47.         s.name = "cookie wan"
48. }

复制代码

C、多态

1. package main
3. import "fmt"
5. // interface是一个指针,一个接口实现两个具体的类
6. type Animal interface {
7.         Sleep()
8.         GetColor() string // 获取动物颜色
9.         GetType() string // 获取动物种类
10. }
12. type Cat struct{
13.         // 继承需要把类写在里面,实现多态不需要
14.         color string
15. }
18. //实现多态，只需要把这些接口里面的方法实现就行，必须完全实现接口里面的全部东西
19. func (this *Cat) Sleep() {
20.         fmt.Println("cat is sleep .....")
21. }
23. func (this *Cat) GetColor() string{
24.         return this.color
25. }
27. func (this *Cat) GetType() string{
28.         return "小猫"
29. }
32. type Dog struct{
33.         // 继承需要把类写在里面,实现多态不需要
34.         color string
35. }
37. //实现多态，只需要把这些接口里面的方法实现就行，必须完全实现接口里面的全部东西
38. func (this *Dog) Sleep() {
39.         fmt.Println("Dog is sleep .....")
40. }
42. func (this *Dog) GetColor() string{
43.         return this.color
44. }
46. func (this *Dog) GetType() string{
47.         return "小猫"
48. }
50. func showAnimal(animal Animal){
51.         animal.Sleep()
52.         fmt.Println(animal.GetType(), "的颜色:", animal.GetColor())
54. }
56. func main() {
57.         var animal Animal // 接口的数据类型，父类指针
58.         animal = &Cat{"Green"}
59.         // cat := Cat{"Green"}
60.         showAnimal(animal)
61.         animal = &Dog{"Red"}
62.         showAnimal(animal)
63.         // animal.Sleep() // 调用的是dog的sleep，和catsleep并不相同，就是多态的体现
64.         // fmt.Println("狗的颜色:", animal.GetColor())
65. }

复制代码

2.2.11 json
1）json.Unmarshal反序列化，将json布局解析，假如解析过程中发生错误，json.Unmarshal 会返回一个非空的错误对象。

1. package main
3. import (
4.         "encoding/json"
5.         "fmt"
6. )
8. type Person struct {
9.         Name string `json:"name"`
10.         Age  int    `json:"age"`
11. }
13. func main() {
14.         jsonData := []byte(`{"name":"John", "age":30}`)
15.         var person Person
16.         // 用于将 JSON 格式的数据解析（反序列化）为 Go 对象
17.         err := json.Unmarshal(jsonData, &person)
18.         if err != nil {
19.                 fmt.Println("解析 JSON 失败:", err)
20.                 return
21.         }
22.         // John 30
23.         fmt.Println(person.Name, person.Age)
24. }

复制代码

2.2.11 interface万能接口和反射
接口是fu leifulei，通过变量查出type和value

1. package main
3. import "fmt"
5. // interface是万能数据类型
6. func myFunc(arg interface{}) {
7.         fmt.Println("myFunc is called...")
8.         fmt.Println(arg)
10.         // 想知道arg是什么类型,想区分interface底层到底是什么数据类型？
11.         // 给interface提供了类型断言机制
12.         value, ok := arg.(string) // 判断是否是string
13.         if !ok{
14.                 fmt.Println("arg is not string...")
15.         }else{
16.                 fmt.Println("arg is string type, value = ", value)
17.                 fmt.Printf("value type is %T\n", value)
18.         }
19. }
21. type Book struct {
22.         auth string
23. }
26. func main() {
27.         var a string
28.         //a变量里面的pair，<static type:string, value:"dsfs">
29.         a = "dsfs"
31.         // pair，<static type:string, value:"dsfs">
32.         var allType interface{}
33.         allType = a // 连续不变的传递这个pair
34.         value, ok := allType.(string)
35.         if !ok{
36.                 fmt.Println("不是sring")
37.         }else{
38.                 fmt.Println("类型是string, value是", value)
39.         }
41.         book := Book{"Freezing"}
42.         myFunc(book)
43.         myFunc(100)
44.         myFunc("abc")
45.         myFunc(3.3242343)
46. }

复制代码

2.2.12 反射

1. package main
3. import (
4.         "fmt"
5.         "io"
6.         "os"
7. )
9. func main(){
10.         // /dev/tty代表终端
11.         // tty:pair<type:*os.File, value:"/dev/tty"文件描述符>
12.         tty, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
13.         if err != nil{
14.                 fmt.Println("open file error", err)
15.                 return
16.         }
17.         //         不管复制给谁都不会变
18.         var r io.Reader
19.         // r:pair<type:*os.File, value:"/dev/tty"文件描述符>
20.         r = tty
22.         var w io.Writer
23.         // w:pair<type:*os.File, value:"/dev/tty"文件描述符>
24.         w = r.(io.Writer)
25.         w.Write([]byte ("HEllo this is a test!!\n"))
27. }

复制代码

三、debug

3.1 go: cannot run *_test.go files

背景：将go文件定名成array_test.go报错go: cannot run *_test.go files
缘故原由：_test.go 是golang专用的测试文件
办理：改名
3.2 深拷贝（copy）和浅拷贝（slice切片）

https://blog.csdn.net/weixin_45440484/article/details/131740125
3.3 引用传递

   引用传递是一种变量传递的方式，它不是直接传递变量的值，而是传递变量的内存地点（引用）。在引用传递中，被调用函数可以通过引用修改原始变量的值。
  3.4 检测并发程序的正确性 -race选项

在 go 命令加上 -race 选项，例如

结果显示，程序中存在 2 个 goroutine 非同步读写变量 t。
3.5 Go的常用包

3.5.1 time包

   

• time.Time：表示时间的类型，常见的有两种方式：
  
  
  
  • time.Now()：获取当前的时间
    
  • time.Date()：根据指定的年、月、日、时、分、秒、纳秒等创建时间
    
  
  
• time.Duration：表示两个时间点之间颠末的时间，以纳秒为单位，最长时间段大约 290 年
  
• 格式化时间：time.Format()、time.Parse()
  

  

  
Go 的时间操纵_go 时间类型-CSDN博客
3.6 函数后面有Locker

y缘故原由：函数会修改全局变量，须要加锁后再用

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。