GuoXin Li's Blog

golang specific notes

golang
字数统计: 1.6k阅读时长: 7 min
2021/08/18 Share

安装基础及概念

安装：

GO 安装官网：https://golang.org/dl/

GO 的三个环境变量重要概念：

  • GOROOT：GO语言安装目录
  • GOPATH：若干自定义的工作空间，也就是传统的工作区 （Workspace）
  • GOBIN：GO 程序生成的可执行文件路径

HelloWorld

  • go run helloworld.go 命令

  • 编译模式：

    在源码目录下进行 go install

    会自动生成 bin 文件夹，里面会有编译的 hello 可执行程序

    • go 编译程序时，会自动在 GOROOT/src 文件夹下 或者在 GOPATH/src文件夹下程序包里自动寻找 main 包的 main 函数入口函数进行编译。

环境变量的配置：

1
2
3
4
5
6
#go
#install go via 'brew install go'
export GOROOT="/usr/local/Cellar/go/1.16.6/libexec"
export GOPATH="/Users/xxx/go"
export PATH=$PATH:$GOPATH/bin
export PATH=$PATH:$GOROOT/bin

以上为 GOPATH 时代时的使用，但自从 go 1.11版本以后添加了 Modules 模块，Modules 为源代码交换和版本控制单元，go命令支持直接使用 modules，包括记录和解析对其他模块的依赖性。

go Modules 时代的设置：

1
2
3
go env -w GOBIN=/Users/guoxinli/go/bin
go env -w GO111MODULE=on	//on, off, auto: 当项目在 GOPATH/src 目录之外，并且项目根目录有 go.mod 文件时，开启 go moudle 模式。
go env -w GOPROXY=https://goproxy.cn,direct #使用七牛云服务

然后在任意目录：

1
2
3
4
5
$cd xxx
$go mod init xxx
$vim hello.go
$go build
$go install

go mod 命令作用：

  • go mod download 下载依赖包到本地（默认为 GOPATH/pkg/mod ）
  • go mod edit 编辑 go.mod 文件
  • go mod graph 打印模块依赖图
  • go mod init 初始化当前文件夹，创建 go.mod 文件
  • go mod tidy 增加缺少的包，删除无用的包
  • go mod vendor 将依赖复制到 vendor 目录下
  • go mod verify 校验依赖
  • go mod why 解释为什么需要依赖

Go 的执行原理

go run 执行过程

go run 主要用来执行一个命令源码文件以及若干个库源码文件，不能接收测试源码文件

Screen Shot 2021-08-24 at 23.49.27

生成的临时文件可以用 go run - work 来看到。

go run 生成了两个文件，一个是归档文件，一个时可执行文件，go run 第二次运行时，若导入的代码包没有发生改变，go run 不会再次编译这个导入的代码包，直接静态链接。

go build

go build 主要用于测试编译：

  • 普通包：go build 不会产生任何文件。

  • main包：会产生可执行文件，需要执行 go install 或者使用 go install -o 路径/可执行文件

  • 多个文件夹下多个文件，只执行某个文件需要: go build xxx.go

  • 可指定编译输出名字 go build -o xxx
  • go build 会忽略目录下以 “_” 或者 “.” 开头的 go 文件。

go build 用于编译我们指定的源码文件或代码包以及它们的依赖包。但是注意如果用来编译非命令源码文件，即库源码文件，go build 执行完是不会产生任何结果的。这种情况下，go build 命令只是检查库源码文件的有效性，只会做检查性的编译，而不会输出任何结果文件。

go install

编译并安装代码包或者源码文件。

go install 命令在内部实际上分成了两步操作：第一步是生成结果文件(可执行文件或者.a包)，第二步会把编译好的结果移到$GOPATH/pkg或者$GOPATH/bin。

  • 可执行文件： 一般是 go install 带main函数的go文件产生的，有函数入口，所有可以直接运行。

  • .a应用包： 一般是 go install 不包含main函数的go文件产生的，没有函数入口，只能被调用。

go install 比 go build 多干的事情：安装编译后的结果文件到指定目录。

包变量和函数

1
2
3
4
5
6
7
8
package main 
import {
  "fmt"
  "math/rand"
}
func main(){
  fmt.Println("Random number is :" rand.Intn(10));
}

变量声明：

1
2
3
4
5
6
//1. var name type
var numA int
//2. var name = value
var name = 10
//3. 
name :=10
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
package main

import "fmt"

func main() {
	fmt.Println("variable test")

	var numA int
	numA = 10
	fmt.Println(numA)

	var numB int = 20
	fmt.Println(numB)

	var name = "cyber"
	fmt.Println(name)

	cyber := "good boy"
	fmt.Println(cyber)

	var m float64 //m: 0.0
	fmt.Println(m)
	var s string //""
	fmt.Println(s)
	var s1 []int
	fmt.Println(s1)
	fmt.Println(s1 == nil)

	//constant variable
	const PATH string = "http://www.google.com"
	const PI = 3.1415925535
	fmt.Println(PATH)
	fmt.Println(PI)
	// define a group of constant variable
	const c1, c2, c3 = 100, 300, "test"
	const (
		MALE   = 0
		FEMALE = 1
		UNKNOW = 3
	)
	const (
		a int = 100
		b
		c string = "const string"
		d
	)
	fmt.Printf("%T, %d\n", a, a)
	fmt.Printf("%T, %d\n", b, b)
	fmt.Printf("%T, %s\n", c, c)
	fmt.Printf("%T, %s\n", d, d)

	//enumeration 
	const(
		SPRING = 0
		SUMMER = 1
		AUTUMN = 2
		WINTER = 3
	)
	

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
variable test
10
20
cyber
good boy
0

[]
true
http://www.google.com
3.1415925535
int, 100
int, 100
string, const string
string, const string

打印和输出

  • fmt.Print()
  • fmt.Printf()
  • fmt.Println

%v：源数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package main

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

func main(){
	fmt.Println("hello world")

	a := 1;
	b := 3.1415
	c := true
	d := "hello"
	e := 'e'
	f := "F"
	fmt.Printf("%T, %d\n", a, a)
	fmt.Printf("%T, %f\n", b, b)
	fmt.Printf("%T, %t\n", c , c)
	fmt.Printf("%T, %s\n", d, d)
	fmt.Printf("%T, %c\n", e, e)
	fmt.Printf("%T, %p\n", f, &f)

	fmt.Printf("%v\n", a)
	fmt.Printf("%v\n", b)
	fmt.Printf("%v\n", c)
	fmt.Printf("%v\n", d)
	fmt.Printf("%v\n", e)
	fmt.Printf("%v\n", f)

	/* -------------------- */
	var numA int
	var numB float32
	fmt.Scanln(&numA, &numB)
	fmt.Printf("numA: %d,numB: %f\n", numA, numB)
	fmt.Scanf("%d,%f", &numA, &numB)
	fmt.Printf("numA: %d, numB: %f\n", numA, numB )


	/* -------------------- */
	fmt.Println("Please input:")
	reader := bufio.NewReader(os.Stdin)
	s1, _ := reader.ReadString('\n')
	fmt.Println("Value of input: "+s1)

}

分支语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
package main

import "fmt"

func main() {
	num := 10
	if num > 10 {
		fmt.Println("bigger than 10")
	} else if num == 10 {
		fmt.Println("value equal to 10")
	} else {
		fmt.Println("smaller than 10")
	}

	/*
		using fallthrough to execute the following cases.
		but it can be stopped by break.
	*/
	switch x := 3; x {
	case 1:
		fmt.Println("x == 1")
	case 2:
		fmt.Println("x == 2")
	case 3:
		fmt.Println("x == 3")
		if x > 2 {
			break
		}
		fallthrough
	case 4:
		fmt.Println("x == 4")
	}
	sum := 0
	for i := 0; i <= 10; i++ {
		sum += i
	}
	fmt.Println(sum)

	/*
		equal to while in c/cpp
	*/
	// index := 1
	// for index == 1 {
	// 	fmt.Println("looping")
	// }

	strings := []string{"google", "runoob"}
	for i, s := range strings {
		fmt.Println(i, s)
	}

	numbers := [4]int{1, 2, 3, 5}
	for i, x := range numbers {
		fmt.Printf("第 %d 位 x 的值 = %d\n", i, x)
	}

}

循环语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
for key, value := range oldMap {
    newMap[key] = value
}


var b int = 15
var a int

numbers := [6]int{1, 2, 3, 5} 

/* for 循环 */
for a := 0; a < 10; a++ {
  fmt.Printf("a 的值为: %d\n", a)
}

for a < b {
  a++
  fmt.Printf("a 的值为: %d\n", a)
}

for i,x:= range numbers {
  fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
}
CATALOG
  1. 1. 安装基础及概念
    1. 1.1. HelloWorld
    2. 1.2. Go 的执行原理
      1. 1.2.1. go run 执行过程
      2. 1.2.2. go build
      3. 1.2.3. go install
    3. 1.3. 包变量和函数
    4. 1.4. 打印和输出
    5. 1.5. 分支语句
    6. 1.6. 循环语句
Total : 89
2022
2021
2020
2019
2018
essay Deep Learning Paper-reading learning-note C++ CUDA cmake LeetCode DataStructure Numpy OS-Linux PAT slidingwindow git golang BuaaAssignments CG
Machine-Learning Data-Structure