gogogo+无闻go编程基础笔记

Go语言做Web编程非常方便，并且在开发效率和程序运行效率方面都非常优秀。相比于Java，其最大的优势就是简便易用，而相比于PHP，它最大的优势就是性能好。

(go做web)推荐Gorilla的库，里面的路由，csrf的包用起来都很方便。

如果你要使用Go语言做Web后端开发，我推荐你用Beego。如果你对性能有超高的要求（不想因为用了框架而降低一点点性能），我推荐你用Gin。

Go语言要求public的变量必须以大写字母开头,private变量则以小写字母开头

无闻视频笔记

代码部分并未格式化！！

第一讲：go 常用命令

go get 获取远程包（需提前安装git）
go run 运行
go build 测试编译(package main 的文件)
go fmt 格式化代码
go install 编译包文件和整个程序
go test 运行测试文件（**_test.go是测试文件，命名自己文件的时候需要注意）
go doc 查看文档（本地官网 go -http=:8080 & 后台执行）

注释：

 //
/* */

go结构

第二讲：go程序结构

1. package main包含main函数
   一个程序有且只有一个main包和一个main函数
2. package 要放在非注释的第一行
3. package 后加import,import 引入非main包
4. 一般建议package的名称和目录名一致 pacage 名称不要使用驼峰标记法,使用下划线

var 全局变量
type 基本类型 比如：type newtype struct/interface{（内容）}

packagename.funcname包中方法的调用

改包名：
import abc "fmt"/import . "fmt"
调用的时候
abc.Println/Println

不推荐使用.那种，容易混淆

第三讲 go 可见性规则（大小写！）

首字母大小写决定 常量，变量，类型，接口，结构 是否可以被外部调用
函数名首字母小写=private
函数名首字母大写=public

问：声明多个全局变量，常量，结构体能不能像import那样一起弄呢？
答：可以，组。只能全局变量，函数体中不可以
type(
newtype int
type1 string
)
函数体中aaa, bbb = 1, 2 就可以了
a, b, c, d := 1, 2, 3, 4
(注意：:=这种声明方式不能使用在函数外，函数外的每个语法块都必须以关键字开始。)

第三讲 go 基本类型

• bool 必须true、false。数字不行
• int/uint/int8/unit8(最后一个，64位，8字节)
• byte(unit8)
• int32(rune)提示处理unicode字符
• 复数：complex64/complex128
• 足够保存指针的32、64位整数型
• 引用类型：slice，map，chan
• interface
• func,可以赋值给变量

类型零值：某种类型的默认值，eg：int--0，bool--false，string--空字符串：“”，数组不给类型--空数组[] 数组指定int(var a []int)--[0]

类型别名type（byte int8）奇奇怪怪的东西，给类起个自己喜欢的名字 ┑(￣Д ￣)┍

var b （int可要可不要） = 1 声明的同时赋值
如果不加类型，系统会自己判断的,如果后面要用的类型和现在声明的时候不一样，声明的时候最好标出之后想使用的类型
d := 456

_下划线，空白标识符，可以忽略

变量类型转换

1. （没有隐式转换）
2. 只能在两种互相兼容的类型之间转换
3. 类型转换格式：
   var a float32 = 1.1
   b := int(a)

第四讲：常量和常量枚举

常量枚举

1. 定义常量组：如果不提供初始值，则使用上行表达式
2. 使用相同表达式不代表具有相同值
3. iota是常量计数器，从0起，组中每定义一个常量自动递增1
4. 通过初始化规则和iota可以达到枚举效果
5. 每遇到一个const关键字，iota就重置为0
   eg

   const(
    a='A'
    b
    c=iota
    d
   )
   output: 65 65 2 3

第四讲，最后讲了移位运算，感觉短时间用不到，马一下有空再看

第五讲 指针，递增递减，控制语句

指针

用 . 来操作
&
*
默认值nil 而非NULL

正常运用：

a:=1
var p *int = &a
fmt.Println(p)
//output:addr
fmt.Println(*p)
//output:1即a

递增递减语句

a++,a-- 不能给参数赋值，必须单独放一句
--，++也不能放在变量左边

if

没有括号，空格分隔

if a := 1 ; a > 1
//a为局部变量
if a, b :=1, 2; a > 0
//判断多个

for 循环

注：条件语句中建议不使用函数；左大括号需要和语句在同一行

三种for循环

1. 第一种（只写核心代码）

   a:=1
   for{
    a++
    if a > 3 {
      break
    }
   fmt.Println(a)
   }
   fmt.Println("over")

2. 第二种

   a:=1
   for a <= 3{
    a++
    fmt.Println(a)
   }
   fmt.Println("over")

3. 比较常见的形式

   a:=1
   for i:= 0; i < 3; i++{
    a++
    fmt.Println(a)
   }
   fmt.Println("over")

switch 不用break，匹配自动停，如果匹配还想继续，要fallthrough

支持初始化表达式，右侧要分号（switch a := 1; {...）这个初始化 都是局部变量，出了switch就不能用了

goto； break； continue

配合标签名使用
break 和 continue 可跳出多层循环(结合label使用，label在哪级就可以跳到哪级)

问题是：continue换成goto会怎么样，--无限循环

数组

数组长度也算是类型
var a [2]int
var b [1]int
a =b 不合法
a := [...]int{0:1,1:2,2:3}
//初始化可以不给定元素个数，索引也可以只指定某一个值
var p [100]int = &a 指向数组的指针
a := [...]int{&x,&y} 一个数组保存了两个变量的指针

两种传递方式：

1. 数组是值类型，传递的时候是拷贝的而不是传地址的
2. 如果想传地址，叫引用类型，slice，可以实现，类似动态数组，引用传递

数组之间可以 == 或者 ！=（看上面，不同类型的数组不可以做任何直接比较）

指向数组的指针(new的返回值是指针，一般不new)
p := new([10]int)//输出也是指向数组的指针

多元数组（最外层最好定义好每个数组长度，不要用...）

a := [2][3]int {
  {1，1，1}
  {2，2，2}
}

第七讲 slice

1. 本身不是数组，指向底层数组，可以关联底层的局部或全部
2. 类型
3. len()获取元素个数，cap()获取容量，容量就是后面连续的内存块还有多少就是多少，比如数组1-10，slice3-5，cap3-10
4. 多个slice指向相同底层数组数据，改动一个，全部改动
5. 声明var si []int / a:= []int和数组的区别在于[]中没有数字也没有...
   也可以用make()声明
   s1 := make([]int,3,10) int型，3个元素，cap10，如果大于10，会变成20，不设置容量会认为容量=元素个数

slice今天遇到的一个小坑，初始化slice的时候，想给slice的长度的个变量，只能用exampleSlice:=make([]int,variableA+1)这种make的初始化方式，examSlice:=[]int{variableA+1:0}这种也不行，必须是个const，var那种显然也不行，问题跟这个一样

new和make的区别:

func new(Type) *Type
 # 返回一个指针 
func make(Type,size,IntegerType) Type
 # Type必须是引用类型(Slice,Map,Channal等)返回一个对象,而非指针

reslice

在slice上slice
越界会报错

append

在slice尾部追加元素，或者追加另一个slice（很像拼接两个数组）
如果超过cap，会拷贝原始数据

第一次追加后，输出的地址不变，因为没超过cap，第二次追加后地址变，超过了的话会拷贝到重新分配的内存处

copy

第八讲，map

key-value 比线性查找快，但比索引（数组和slice）慢很多
key必须是可以比较的，slice,func不可以
声明： var m map[int]string /m: = make(map[int]string)

赋值：m[1] = "ok"//key=1,value="ok"
删除： delete(m,1)

var m map[int]map[int]string
m=make(map[int]map[int]string)//只初始化外层map
m[1] = make(map[int]string)
m[1][1] = "ok"
a:= m[1][1]
输出a为ok

迭代
for range(类似for each)

一般形式：for i,v := range slice {输出i,v},相当于枚举，v是元素值，但是是拷贝，不能修改slice本身的元素值，但可以修改slice[i]

for k,v := range map{输出键值对，但都是对拷贝值的操作,map[k]才可以改变map中值}
map[k]

有一个传说中很牛逼的例子

func main(){
  sm := make([]map[int]string,5)//以map为元素的slice
  for _,v := range sm {
    v= make(map[int]string,1)
    v[1] = "OK"
    fmt.Println(v)//打印map[1:ok]
  }
  fmt.Println(sm)//打印空map，因为v改变不影响slice
}

输出结果map[1:OK]map[1:OK]map[1:OK]map[1:OK]map[1:OK][map[] map[] map[] map[] map[]]

果然很牛逼的例子，有点绕
应用：可以通过对mapkey排序从而达到给map排序
把key转为int放在一个slice里然后sort.ints(s)

作业：把map中v,k对调，
解：for k,v := range m1{
m2[v] = k}

第九讲：func

1. 不支持嵌套，重载，默认参数
2. 支持 不需要声明原型就可以使用， 不定长度变参（参数地方可以写 ... ）， 多返回值， 命名返回值参数， 匿名函数， 闭包
3. 可以作为类型使用
4. 关键字func {要在同一行

声明：如果参数类型一样（参数和返回值处type1=type2，可以只写最后一个；返回值可以不起名） func funcname (para1 type1, para2 type2) (returnvalue1 type1, returnvalue2 type2){
}

匿名函数

a := func(){
fmt.Println("Func A")
}
a()

a是后面那个函数的类型的变量，那个函数叫匿名函数

闭包

需要编程基础和对闭包的理解
闭包
另一个闭包例子，看懂一个就都能看懂了

返回一个匿名函数

defer

1. 类似析构函数
2. 函数体执行结束后，按调用顺序相反顺序执行
3. 函数有严重错误也会执行
4. 支持匿名函数
5. 应用：资源清理，解锁，记录时间，文件关闭，return后修改计算结果
6. 如果函数体内某个变量作为defer时匿名函数的参数，则在定义defer时就获得了拷贝，否则是引用，引用地址
   比如：

   for i:=0; i<3；i++{
   defer func(){打印i}
   }
   //输出210，i作为参数传递进去
   for i:=0; i<3；i++{
   defer func(){
    打印i
   }() //这个括号是类似defer a()
   }
   //输出333，闭包，i一直作为引用

go中的异常处理机制，类似finaly--panic/recover 模式来处理，panic可以在任何地方引发，recovery只有在defer中才有效

panic（），执行的话程序会终止

作业：

先输出的是fs[i],然后用下一个for循环输出fs这个slice的值，i为外层for循环中i的引用地址，执行完第一个for循环，i=4，所以第二个for循环输出的都是=4
然后执行第一次第一个for循环中的第二个defer，第一个defer是值拷贝，所以值被修改了。。。其实并不是很懂┑(￣Д ￣)┍

第十讲 结构struct

1. go 中没有class，struct类似class
2. 比较，名字等各个地方都一样才可以比较，名字不一样也不可以，名字不一样是不同类型
3. 支持匿名，匿名结构可用于map，可以比较
4. 允许通过指针读写结构成员
5. 初始化：

   meStruct := new(SmallSoho) //初始化一个空的结构体，返回指针
   meStruct := &SmallSoho{} //同上
   meStruct := SmallSoho{} //返回一个空结构体
   meStruct := &SmallSoho{Name:"SmallSoho"} //也可以键值对这样来初始化

   
   

   struct init
   
   
   
   

   如果想让func中的修改对原数据生效，需要取地址，不然的话得到的是一个值拷贝，改变一下并不能改变原来的值
   
   推荐： 对struct初始化的时候习惯加上取地址符eg：&person，方便后续操作
6. 匿名结构

   a := &struct {
   Name string
   Age int
   }{
   Name: "Joe",
   Age : 19,
   }
   fmt.Println(a)

   嵌套结构体（像继承），匿名结构
   
   
   

   嵌套的结构体，匿名，用.调用，name age 这些也可以不写，如果不写，需要注意顺序

如果想设置sex，a := teacher{Name: "joe",Age:19,human:human{Sex:0}}
如果想修改

a.Name = "Joe2"
a.Sex = 100//注意，这里直接加sex就可以了

十一讲 method

func(a A)print(){}
调用的时候 a.print
A类型的a是接收者

同级名称不能冲突

调用最先找到的方法

方法访问权限问题：
同一个包里：方法可以访问struct的私有和公有字段

作业：

十二讲 interface

1. 只有声明，没有实现，没有数据
2. 实现接口：structural typing，只要实现某类型拥有该接口所有方法的签名，就算是实现接口
3. 通过接口实现类似继承的功能，
4. go中所有类型都实现了空接口，空接口可以作为任何类型数据的容器
5. 接口转换，大接口转小接口可以，嵌套进去的小接口转不了大街口
6. 对象赋值给接口时发生拷贝, 所以不能通过修改对象改变接口内容
7. 接口存储的类型和对象都是nil 接口才是nil，如果接口里存的是指向nil的指针，也不行
8. 类型断言 ok pattern/ type switch 类型判断，接口转换

接口
若某个具体类型实现了某个接口,则: 这个具体类型的值既可以当做该接口类型的值来使用, 也可以当做该具体类型的值

注解：指针方法集，如果传进来指针，可以调用reveicer是指针和不是指针的方法，如果传进来的是非指针方法集（拷贝的）不能调用指针方法解，所以接口的receiver不做自动转换，因为是拷贝的

十三讲reflect

（开始有点听不懂了，目前看代码阶段，估计了解几个基本方法就会跳过，以后再看）

1. TypeOf ValueOf 从接口中获取信息，结合空接口interface{}使用

reflect包中field 反射出结构信息

反射
Go语言实现了反射,反射就是动态运行时的状态。我们一般用到的包是reflect包。

使用reflect一般分成三步，下面简要的讲解一下：要去反射是一个类型的值(这些值都实现了空interface)，首先需要把它转化成reflect对象(reflect.Type或者reflect.Value，根据不同的情况调用不同的函数)。

这两种获取方式如下：
t := reflect.TypeOf(i) //得到类型的元数据,通过t我们能获取类型定义里面的所有元素
v := reflect.ValueOf(i) //得到实际的值，通过v我们获取存储在里面的值，还可以去改变值

转化为reflect对象之后我们就可以进行一些操作了，也就是将reflect对象转化成相应的值，例如
tag := t.Elem().Field(0).Tag //获取定义在struct里面的标签
name := v.Elem().Field(0).String() //获取存储在第一个字段里面的值

动态调用方法

十四讲 并发 concurrency

goroutine 超级线程池
每个实例4-5k，轻便

并发不是并行：并发是由切换时间来实现“同时”运行，并行是多核多线程

goroutine 通过通信来共享内存，而不是共享内存来通信

一个基本的并发

---