go语言学习001

1、安装

1、go run xxx.go命令源文件（一个main包，里面一个main函数），
还有库源文件，go程序都是以包来管理的，
go build，管理的包，只能有一个main命令源文件，其他都是库文件，
go install ，把编译好的可执行程序mv到bin目录下，把其他编译好的库文件.a文件，mv到pkg目录下，

1、1 ubuntu虚拟机安装vscode

sudo apt-get update
 sudo apt-get install ubuntu-make
$ umake ide visual-studio-code （该步需要指定安装路径choose installation path，再根据提示输入a即可安装完成）

Choose installation path: /home/yym/.local/share/umake/ide/visual-studio-code
Downloading and installing requirements                                                                |
100% |#################################################################################################|
Installing Visual Studio Code
|######################################################################################################|
Installation done


# 再建一个软连接
ln -s /home/yym/.local/share/umake/ide/visual-studio-code/code code

# 然后执行 ./code 就可以唤出vscode的图形界面了

1、1 ubuntu虚拟机安装go开发环境

1、以 root 或者其他 sudo 用户身份运行下面的命令，下载并且解压 Go 二进制文件到/usr/local目录：

sudo  wget -c https://dl.google.com/go/go1.14.2.linux-amd64.tar.gz -O - | sudo tar -xz -C /usr/local

2、调整环境变量使生效

vi /etc/profile
export GOROOT=/usr/local/go  // 安装目录
export PATH=$PATH:/usr/local/go/bin  // 可执行目录
export GOPATH=$HOME/goprojects  // 工作目录

3、测试
使用vscode编写代码：

package main
import "fmt"
func main(){
	fmt.Println("hello")
}

//使用ctrl + ~ 唤出控制台
执行go run test.go

指定生成名字：go build -o hello hello.go

go build 和go run的区别？
1、编译 —> 编译+执行
2、编译完，可以搞到没有go环境下执行，而go run 要有go的编译环境
3、依赖的文件也会搞到可执行文件中去，所以可执行文件会变大

在windows系统下，选中目录，然后cmd,就会进来。

转义字符
回车：光标移动到行首 \r
换行：光标移动到下一行 \n

package main

import "fmt"
func main(){
	fmt.Println("hello\tworld")  // 制表符
	fmt.Println("xueshanfeihu\"hahahahh")
	fmt.Println("xueshanfeihu\\hahahahh")
	fmt.Println("123456\n123456")  // 换行
	fmt.Println("98765555\rqqq")  // 回车，不换行，后边的覆盖掉前边的
	fmt.Println("name\taddress\tage\tprovince\njack\tHebei\t18\tcangzou")
}

不在同一个文件夹下边，自然不在同一个包里。同一个包只能有一个main函数。

ctrl + / 一次多行注释
选中之后，shift + Tal往左缩进， 直接Tal往右缩进
gofmt -w main.go 对齐格式化, -w写入
一行特别长，就使用双引号，和逗号，把这个字符串分开。
go官网

dos disk operation system 磁盘操作系统
vscode快捷键：shift + alt + 向下的箭头 ==> 赋值当前行到下一行

36

2、基础语法

1、iota从0开始，每增加一个const常量，这个iota就自加1，
2、go语言中只有一个i++，没有–i,
3、变量就是一块内存地址，名字，
4、核心特性，基于编译（运行快）、垃圾回收、并发，
5、%T输出数据类型，%t是bool的数据类型占位符，
数据类型：int8、int64,后面直接加二进制的位数，
特点：
6、有指针，包的概念(组织代码结构)，编译型的c,脚本型语言python、php
7、垃圾回收，自动回收
8、天然并发（语言支持）
9、管道通信
10、多个返回值
11、切片slice, 延时执行defer

string也直接是基础数据类型
int 和系统操作系统有关，uint,和int如果都是64位操作系统，都是64但不能相互赋值，
byte和uint8是一回事可以互换
rune和int32是一样的，
float32、float64 %.3f,%.6f
类型推断是float64
int默认推断是int
字符串：多个byte的集合，
强制类型转换：
int8 a := 4
int64 b = int64(a)
兼容类型才可以转换，bool不能和int转换，一个是逻辑值，一个是数值
常数，在有需要的时候自动转换，变量需要指定转换
print打印
println打印换行
printf(占位符)格式化打印 %v原样输出
%b二进制格式打印
%o 8进制
%x 16进制
%p指针地址
格式输入

var a int
var b float64
fmt.Scanln(&a,&b)  // 阻塞 等待输入读取
fmt.Scanf(format: "%d,%f",&a,&b)


读文件：
bufio包
reader := bufio.NewReader(os.Stdin)
s1,_ = reader.ReadString(delim:'\n')

分支语句switch中有一个击穿fallthrough,前一个case匹配，则后一个case直接打印
math.Sqrt(64.00)

goto无条件跳转到目标标签
定义一个标签
LOOP:

还可以把标签写到后面，中间写return，这样就可以避免跳到标签处了
https://golang.google.cn/pkg/

num := rand.Int()
num1 := rand.Intn(n:10)

rand.Seed(seed:1)
num2 := rand.Intn(n:10)

rand.Seed(time.Now().UnixNano()) 
for i := 0; i < 10; i++{
	println(a:"------>" ,rand.Intn(n:100))
}

h获取3 - 48之间的随机数
[0,45]+3
Intn(n):[0,n)
num3 := rand.Intn(n:46)+3

go run hello.go

go build hello.go

2、复合数据类型

array数组，len（）当前长度、cap（）数组最大容量，
数组的数据类型【个数】+类型
arr3 := arr2
数组是值传递的
还有基础基础数据类型，string也是基础数据类型,
结构体也是，指传递，都是拷贝一份新的数据，不过可以通过传递引用作为参数，进行修改它本身。
引用类型：切片，map
值传递可以用来比较，arr2 == arr4,只是比较数组中的每个值而已，不比较地址

3.使用make创建引用类型，

make([]int,4,5) // 类型，长度，容量
make(map,…)
make( chan,…)
切片的append函数，向切片长度之后的位置追加元素，如果超过cap，就重新分配内存，所以要重新赋值给数组，s2 = append(s2,3,4)
追加其他切片的内容,要加3个点

s2 = append(s2,s3...)
~~
%p地址占位符
切片自动扩容：2倍扩容
切片本身不存储东西，都是底层数组存储，切片随着数组扩容，数组地址改变而改变引用的指向

值类型都是深拷贝(数组，结构题)，引用类型都是浅拷贝，map,slice,chan
如何做到切片的深拷贝？
1、把切片中的元素，通过循环一个一个的拷贝过去，
2、通过copy函数进行深拷贝，s2拷贝s1中的数据：
copy(s2,s1)如果s1短，就有几个拷贝几个，s2中后面的不改变
如果s1长，就是s2能装几个就拷贝几个
也可以固定位置，拷贝到固定位置

map的3中创建方式
~~~go
var map1 map[int] string
var map2 = make(map[int] string)
var map3 = map[string] int{"java":2 , "cpp":3}
fmt.Println(map3)

怎么判断map返回的是不存在的初始零值，还是本身就是零值？
通过val,ok = map1[34]
if ok {

}else
{}

删除：
delete(map1,4)
根据map名字和key进行删除

sort.Ints(arr1)
sort.Strings(s1)

将map存到切片中，
s1 :=make([]map[string]string,0,3)

字符------>对应编码表中的编码值，
操作的都是编码值
字节byte–>uint8
字符串不能修改
遍历打印string,打印出来的是对应的字节编码，一个汉字对应3个字节

函数是一个数据类型，可以作为参数传给别的函数，高阶函数，参数有函数的复杂函数，函数名是一个指向函数代码块的引用，可以赋值，通过加小括号来调用函数，如果没有小括号，就是只使用函数的地址，可以当成回调函数，或者赋值使用。匿名函数。

闭包结构：一个外层函数内部又一个内层函数，内层函数作为外层函数的返回值，内层函数会操作外层函数的局部变量，外层函数销毁时，当在外层函数的外部有内层函数的引用时，外层函数的局部变量的生命周期发生改变，不会随外层函数销毁而销毁，会跟随内层函数一样。
内层函数+外层函数的局部变量 构成闭包结构

匿名结构体：只能用一次
结构体中的匿名字段：等价于结构体中的类型当成名字了

结构体嵌套，
人结构体：people
学生结构体：student
1、模拟继承关系， is—>a
学生结构体中使用匿名的people成员（只写类型），student就默认包含了所有的people属性，
类似：子类可以访问父类的属性和方法

student中的匿名结构体people中的字段叫做提升字段：name,age
stu.People.name=“yang”
也可以简写：stu.name=“yan”
2、聚合关系 has —> a
就是常规的结构体嵌套，内部的结构体不是匿名，需要通过外层结构体的一个变量名两次点出来

方法和函数：
方法需要指定接收者（结构体，命名类型，指针），才能调用，
而函数可以直接调用
方法：

func(t, Type)methodName(paralist)(return list){

}

接收者可以在方法内部访问，
函数不能重名，方法如果接收者不同，就可以重名
方法：某个固定类型的行为方法
函数：一段独立功能的代码，可以直接调用

子类如果重写了基类的方法，调用的直接就是子类自己的方法了
结构体中的匿名结构体，提升字段，（提升方法）

接口是方法的签名
声明一些方法，不实现
哪些类型（结构体）实现了这些方法，这个结构体就实现了这个接口。

当需要接口类型的对象时，可以使用任意实现类对象代替
接口对象不能访问实现类中的属性，
接口和实现类

空接口是是go语言实现多态的方式，
空接口：没有函数声明，任意的数据类型都是空接口的实现。

4、判断接口对象的实际类型：断言

func getType(s Shape){
 	if instance ,ok := s.(Trangle);ok{
		fmt.println("s is 三角形")
	}
}




type intmy int   // 定义新的类型，int 和intmy不是同一种类型
type intmy=int  // 重命名
type可以定义函数的简单表达，可以做其他函数的形参，和返回值

错误是一种数据类型：error，和int一样是一种数据类型，可以定义一个错误变量，把错误信息存进来。
错误是可预见的错误
异常是不该发生的坏事情，发生了