语言特性

类型

值类型:int bool string float struct

引用类型：slice map chan 指针  interface

值类型和引用类型都是一次将原有内容拷贝过去的副本，值类型是整个内存拷贝过去（1kb的内容就产生1kb的副本），引用类型是将内存的地址拷贝过去。

像int，要引用传递就要使用*int

像chan，slice，本身就是引用传递，不需要加*

// 交换ab的值
package main

import "fmt"

// 把ab的地址给函数，ab的地址发生了内存拷贝
// 然后这个地址指向的内存空间的内容被改变了
// 所以ab的值变了
func swap(a,b *int) {
	t := *a // 把a的地址给t
	*a = *b // b的地址给a
	*b = t
}

func main() {
	a,b := 1,2
	swap(&a, &b)
	fmt.Println(a,b)
}

　　

// 这样就是把ab的地址传递进来，然后不是去改变地址指向的内容
// 而是在改地址这个值，这是内存拷贝，ab内容不会变
func swap(a,b *int) {
	t := a
	a = b
	b = t
}

func main() {
	a,b := 1,2
	swap(&a, &b)
	fmt.Println(a,b)
}

　　

变量作用域

在函数内部的变量，生命周期只有在这个函数里面

在包里面的变量，如果是首字母小写，只能包能访问。如果首字母大写，可以在整个程序中访问

// 在全局变量中
// 申明a为100
// 申明b，同时执行b = 100 的代码，这是不行的。
// 全局变量只能声明，不能执行代码块
var a int = 100
var b int
b = 100

　　

数据类型

int，int8，int16， int32， int64

int8 的范围是-127 -- 127

float32 四个字节， float64 8个字节　　没有float。

 

// 即使同样是整型，int8 和int16之间也要类型转换
// 字符串里要加“”，就用``，它表示里面的内容不会转义,比如\n,比如换行
func test() {
	var a int8 = 10
	var b int16 = int16(a)
	var s string = `
		my name is "jabbok"
		i am a christian
	`
	fmt.Println(b)
	fmt.Println(s)
}

　　

天然并发goroute

轻量级线程，比物理线程轻，可以同时开上万个。

每个goroute是独立的调度单位。一个goroute无法访问另一个goroute内存中的变量。

c++里用的是物理线程，如果同时开上万个机器就挂了。

使用go命令，就会并发调用add函数。100个add函数会同时执行。

如果没有time.Sleep(time.Second*2)这条语句，子线程还没执行完，主线程就已经退出，子线程会来不及执行。

 

package main

import (
	"fmt"
	"time"
)

func add(a,b int) {
	sum := a^b * a^b
	fmt.Println(sum)
}

func main(){
	for i := 0; i < 100; i++ {
		go add(i, i)
	}
	time.Sleep(time.Second*2)
}

　　

channel

在linux中由pipe的概念。原来两个进程之间是无法数据通信的，管道可以让b进程读取a进程的数据。

channel的作用是goroute之间数据通信

// 创建一个管道，make分配一个内存空间，定义一个int类型的chan，容量是3
// 把几个int值放进管道，放2个，len就是2.如果放4个，最新的数据不会丢，但会阻塞，就会报错：
// fatal error: all goroutines are asleep - deadlock!
// 从管道取数据是先进先出，取出后，len减少。
func test_chan(){
	pipe := make(chan int, 3)
	pipe <- 1
	pipe <- 2
	pipe <- 3
	fmt.Println(len(pipe))

	t1 := <- pipe
	fmt.Println(t1)
	fmt.Println(len(pipe))
}

　　

goroute之间通过pipe数据通信

// 申明一个pipe，然后传参到add
// 在main里调用100个add线程，把结果放到pipe
// 从pipe取值到value时，因为pipe还没有数据集，所以会阻塞
// 主线程不会提前退出，会从pipe里取到100个元素后才会退出。
var pipe chan int

func add(a ,b int, pipe chan int) {
	pipe <- (a + b)
}

func main() {
	pipe := make(chan int,100)
	for i:=0; i < 100; i++ {
		go add(i,i,pipe)
	}

	for i:=0; i < 100; i++ {
		value := <- pipe
		fmt.Println(value)
	}
}

　　

多返回值

在python里要返回多个数据，基本是用list或者dict，go里可以直接返回多个返回值

func add(a ,b int) (int,int){
	sum := a + b
	avg := sum/2
	return sum,avg
}

func main() {
	sum,avg := add(1,2)
	fmt.Printf("sum=%d,avg=%d",sum,avg)
}

　　

// 对于一个有多个返回值的func，如果我只需要一个返回值，其他的用_代替
func main() {
	sum,_ := add(1,2)
	fmt.Printf("sum=%d",sum)
}

　　

包管理package

在 package main里，，必须有且只有一个main函数。这是入口函数，package main是用于生成可执行文件的。

在go里，package和文件夹对应，比如一个user相关的包就是一个user的文件夹 

 

内存管理new&make

new用于给值类型分配内存，make给引用类型分配内存

// new返回地址，所以i是个地址
// *i是具体的内容
// 因为i是地址，所以赋值要用*i
func new_exc() {
	i := new(int)
	fmt.Println(i)
	fmt.Println(*i)
	*i = 100
	fmt.Println(*i)
}

　　

错误处理

day4 内置函数，暂时不想看了

 

项目目录结构

project

　　/src/代码文件

　　　　app/main/main.go入口文件

　　　　app/calc/xx.go功能函数等

　　/bin/可执行文件

　　/vender/第三方包

　　/pkg/依赖的静态库

export GOPATH = project目录

 

导入import

函数名首字母必须大写

导入其他package时以src为根目录，比如导入src/go_test/calc这个目录，就是import "go_exc/calc"

编译

go run是类似运行一个python脚本

go build是组织目录结构，编译带main package的包生成一个可执行文件，编译其他package生成lib库

go编译只生成一个文件，不会有各种依赖库问题，在本地编译好了，放到线上直接就能跑，不依赖任何环境。

gofmt是代码格式化命令，-w参数表示写入源文件

# go run时，在同一个包下的calc里的func，只要引入main，就会自动被main找到，但要在run时加上去
D:\code\go\gotest\src\go_exc>go run main.go calc.go

　　

D:\code\go\gotest>go build go_exc/main

#在项目目录下执行go bulid编译
#go_exc是src下的一个目录，里面有一个main入口函数
#go build后面不需要加src，它会自动去src下找这个目录
#编译完成后在项目目录生成exe文件

　　

D:\code\go\gotest>go build -o bin/main go_exc/main
#指定生成目录和文件名