【Go语言学习之路 4】Go 基本命令和特性

Golang 基本命令

基本命令

1. go run 快速执⾏go⽂件，就像执⾏脚本⼀样
2. go build 编译程序，⽣成⼆进制可执⾏⽂件
3. go install 安装可执⾏⽂件到bin⽬录
4. go test 执⾏单元测试或压⼒测试
5. go env 显示go相关的环境变量
6. go fmt 格式化源代码，执行完成后源文件直接完成格式刷新。

Go程序结构

1. go源码按package进⾏组织，并且package要放到⾮注释的第⼀⾏
2. ⼀个可执⾏程序只有⼀个main包和⼀个main函数
3. main函数是程序的执⾏⼊⼝

注释

1. 单⾏注释 //
2. 多⾏注释 /* */

func main() {
	/* 多行注释
	a := 1 + 2
	b := 3 + 3
	*/
	// 单行注释
	fmt.Println("Hello World")
}

Golang 语言特性

垃圾回收

1. 内存⾃动回收，再也不需要开发⼈员管理内存
2. 开发⼈员专注业务实现，降低了⼼智负担
3. 只需要new分配内存，不需要释放

天然并发

1. 从语⾔层⾯⽀持并发，⾮常简单。只需要go⼀下
2. goroutine，轻量级线程，创建成千上万个goroute成为可能

func calc() { 
 //⼤量计算
} 
func main() { 
 go calc() // 这就可以创建一个线程
}

测试一下

calc.go文件

没有使用go并发

package main

import (
	"fmt"
	"time"
)

func calc() {
	for i := 0; i < 10; i++ {
		time.Sleep(1 * time.Second)
		fmt.Println("开始执行：", i, "次数")
	}
	fmt.Println("单次计算结束")
}

func main() {
	calc()
	fmt.Println("全部结束")
}

输出：

GOROOT=C:\Go #gosetup
GOPATH=E:\Go #gosetup
C:\Go\bin\go.exe build -o C:\Users\柏杉\AppData\Local\Temp\GoLand\___go_build_calc_go__1_.exe E:\Go\awesomeProject\src\main\calc.go #gosetup
C:\Users\柏杉\AppData\Local\Temp\GoLand\___go_build_calc_go__1_.exe
开始执行： 0 次数
开始执行： 1 次数
开始执行： 2 次数
开始执行： 3 次数
开始执行： 4 次数
开始执行： 5 次数
开始执行： 6 次数
开始执行： 7 次数
开始执行： 8 次数
开始执行： 9 次数
单次计算结束
全部结束

Process finished with the exit code 0

go并发

package main

import (
	"fmt"
	"time"
)

func calc() {
	for i := 0; i < 10; i++ {
		time.Sleep(1 * time.Second)
		fmt.Println("开始执行：", i, "次数")
	}
	fmt.Println("单次计算结束")
}

func main() {
	//calc()
	go calc()
	fmt.Println("全部结束")
	time.Sleep(11 * time.Second) // 等待一下
}

输出：

GOROOT=C:\Go #gosetup
GOPATH=E:\Go #gosetup
C:\Go\bin\go.exe build -o C:\Users\柏杉\AppData\Local\Temp\GoLand\___go_build_calc_go__1_.exe E:\Go\awesomeProject\src\main\calc.go #gosetup
C:\Users\柏杉\AppData\Local\Temp\GoLand\___go_build_calc_go__1_.exe
全部结束                                                                                                                                                
开始执行： 0 次数                                                                                                                                       
开始执行： 1 次数                                                                                                                                       
开始执行： 2 次数                                                                                                                                       
开始执行： 3 次数                                                                                                                                       
开始执行： 4 次数                                                                                                                                       
开始执行： 5 次数                                                                                                                                       
开始执行： 6 次数                                                                                                                                       
开始执行： 7 次数                                                                                                                                       
开始执行： 8 次数
开始执行： 9 次数
单次计算结束

Process finished with the exit code 0

并发是不是非常简单！

channel 管道

像个队列，先进先出。
子线程想要返回内容，通知主线程，只需要放到管道里面，主线程从管道读出来就可以了！

1. 管道，类似unix/linux中的pipe
2. 多个goroute之间通过channel进⾏通信
3. ⽀持任何类型

多返回值

⼀个函数返回多个值

package main

import "fmt"

func add(a int, b int) int {
	return a + b
}

func add1(a int, b int) (int, int) {
	return a + b, a - b
}

func main() {
	//sum := add(2, 5)
	sum, sub := add1(2, 5)
	fmt.Println(sum, sub)
}

编译型语⾔

1. 性能只比C语言相差10%
2. 开发效率和Python差不多