finalheart

Golang基础

前言

这两个月看的golang的教程也不少。但是总感觉自己的基础知识不扎实。本篇为看完一本书记载的。后续会不断补充。

本篇博客不会记录太基础的知识。如果需要基础知识，教程有的是。本篇记录一下一些重要的用法和自己的理解。本篇也不会写的很深因为我golang水平并不高。只是作为一个入门笔记。

在本篇之前可以学习下基础教程：Go Tutorial - Learn Go from the Basics with Code Examples

一初识Go

go语言是 2006年1月2号下午3点4分5秒。这个时间创立的。所以一些时间的format函数用到了这个奇葩的时间。

go语言是由Google公司开发的一款静态型(运行之前检查编译)&编译型语言。带有垃圾回收(很关键，不用我们释放)对并发支持非常牛逼的语言。因为go中 goroutines的存在允许以协程态运行任务。一个线程可以跑多个任务而不阻塞。从而高效的使用CPU计算资源来完成运转。 go的goroutines与nginx这种 epoll事件驱动属于两种多路IO的形式。多个goroutines用通道通信。

go语言的代码可以直接输出为目标操作系统的可执行文件(windows linux...) Go不像java使用虚拟机。go只有运行时(runtime)提供垃圾回收和goroutines 调度。go有自己的链接器，不依赖操作系统。因此使用Go写的代码，编译成可执行文件。直接运行就成为一个进程了。

go 使用并发编译。所以说编译也很快的！

go弃了 i++ ++i 这个对于编程语言初学者的来说不太好理解的东西。比如java里面 a = i ++ a=++i a是两个值。

但是在go里面 i++这种东西变成了一个语句。也就是 a:=i++ 会编译报错。

写Go就像java似的，先在电脑上面搞一个SDK。

例如 Windows版的。go1.12.1.windows.amd64.msi 代表Windows 64位CPU 默认goroot是在c://go下、

二语法&&流程控制

Go声明变量跟java不太一样。go将类型放在变量的后面。

吐槽一下 type s *[]*Hello 这玩楞你看着不懵？这种类型写法真恶心。

也可以在函数中 a:=1这么赋值。不过 := 这个符号只能是左边变量没有全部被初始化(声明)过才可以、

var a int 声明之后变量有一个初始值。切片，函数，map，channel，struct，指针变量的初始化为nil，数字型(整,浮点)为0

go实现两个变量的换值也是非常方便，不需要再使用临时变量了。

a,b:=10,9
fmt.Println(a,b)  //10  9
a,b=b,a
fmt.Println(a,b)  //9  10

go中有匿名变量这个操作(哑元变量) a,_ :=GetElements(); 假设这个函数返回两个值。第二个值我们不需要。那么用_在对应位置替换，就不会分配命名空间和内存了。是一个不错的特性。

go是一个比java还强类型的语言(我认为)。go中的 int64 int32 uint32 这种被认为是三个数据类型。

[3]int []int [4]int这也被认为是三个数据类型。-_-切片和数组。任何不一样大小的数组就被认为是多个类型。

我们不用声明具体是多少位的，go会根据编译时的操作系统来给变量分配是多少位的来满足性能。

go的强制类型转换是 int(field) 这样 java是 (int) 对于整型强转换要小心位数不够导致数值不对！！

c:=10.02                                -----go
fmt.Println(int(c))   //10

double v = 10.02;                       -----java
System.out.println((int)v);

Go中的字符串处理采用uint8也就是byte 和 rune也就是int32 两种。第一种是ascll码。第二种是UTF-8编码。

Unicode ASCLL都是字符集。字符集为每个字符分配一个唯一ID UTF-8是一种编码规则。比如几个字节认为是一个字(汉字)UTF-8是变长的。1-4个字节不等来编码一个字、

Go中也是有指针的。想当初我学C的时候，指针真的是听挺难理解的概念。 * &
var a int &a就获取到a变量的内存地址了。指针的值实际上就是内存地址的值 32/64平台对应位数的地址。

b:=&a b此时就可以理解为是一个指针了(内存地址) *b就是对内存地址的取值。 *&是互补的

&获取内存地址 *获取内存地址存储的值。 go中有个方法为创建对应类型的指针 new(Type)

程序的内存分配离不开栈和堆。在java中是这样。在go中依然是这样的。

对于栈来说。下面程序label处会进行栈内存分配。stack函数退出即释放内存地址。栈内存比较快，但是比较少。

func stack() (d int){
   var a int    //label
   a = a + 1
   var c int    //label
   d = c + b
   return 
}

对于堆来说。可以分配大量的内存。速度较栈慢、对于堆的内存是由垃圾回收器进行回收的。

在内存分配时会出现变量逃逸这个变量分配方式。决定在内存分配时是使用栈还是堆。这是属于编译器层面的东西。

变量是否被取地址||变量是否发生逃逸是分配在堆还是栈的判断条件。

取长度的len()函数这个字符串默认取的是ASCLL码。所以汉字的话长度就不一定是多少了。每个中文占3个字节。

i, j := len("我的妈呀"), len("asdf")
fmt.Println(i, "---", j) //12 --- 4

此时len肯定不行啊，这跟我们想要的4不一样。所以我们使用其他方法来获取汉字字符串的长度。如下获取和遍历

n := utf8.RuneCountInString("这个还行asd")
fmt.Println(n)    //7
str:="哈哈哈asdf"
for _,s:=range str{
   fmt.Printf("%c \n",s)
}

或者使用 []rune数组转一下字符串先、

i, j := len([]rune("我的妈呀")), len("asdf")

对于strings.Index等方法采用的是len的计算长度方式，所以中文算3个字节。

Go中的字符串也是不可变的，跟java一样。不可变就表明线程安全无需加锁。不需要写时复制。hash值也是一份。

如下代码，我们是通过修改[]byte这个切片来修改字符串的。

a:="hello world"
b:=[]rune(a)                   //可以用[]rune  也可以用 []byte   rune中文不会乱码 
fmt.Println(string(b),"--",&b)
for i:=5;i<10;i++{
   b[i] = ' ' 
}
fmt.Println(string(b),"--",&b)

字符串中类似java中stringBuilder玩法。我们知道java中String做拼接会生成很多对象，多个+操作非常耗时、所以引入stringbuilder和stringBuffer builder只能在线程安全的环境下使用。其本身是线程不安全的。

go中也是有类似这个stringBuilder的东西来进行高效的字符串连接的。 bytes.Buffer是线程不安全的。没有锁、

var stringBuilder bytes.Buffer        //声明字节缓冲
stringBuilder.WriteString("哈喽")   //把字符串写入缓冲区
stringBuilder.WriteString("沃德")   
fmt.Println(stringBuilder.String())   //将缓冲以字符串形式输出

go的特殊常量 iota

这个常量在遇到 const 的时候就会被重置为0 然后在const的()内递增。只要遇到const就是0起始、

例如如下代码 name = 0 a= 0 b=1 c=2

const name = iota
const (
a = iota
b
c
)
在定义常量组时，如果不提供初始值，则表示将使用上行的表达式。

即下面 i = 1<<0 j = 3<<1 k = 3 <<2 j = 3<<3 左移就是扩大2倍。移位操作。所以 i = 1 j = 6 k = 12 j = 24 k使用j的表达式，l使用k的表达式。

const (
   i = 1 << iota //1左移itoa
   j = 3 << iota //3左移itoa
   k             //3左移itoa
   l
)
func main() {
   //i= 1  j= 6  k= 12  l= 24
   fmt.Println("i=", i," j=", j," k=", k, " l=", l)
}

类型别名

如下所示带等号 = 的那个是设置的别名。在代码的时候会有感觉，但是编译后跟int就是一个东西。

type coin int              //类型定义
type intAlias = int        //类型别名
func main() {
   var a coin
   fmt.Printf("%T \n",a)  //main.coin 
   var b intAlias
   fmt.Printf("%T",b)     //int
}

类型定义是定义一个完全新的类型。享有原类型的方法和结构。

类型别名跟原类型是一个东西。在编译后会变成原类型。

对于使用别名的类型，不能在本地添加成员方法，因为不是一个包。

对于一些流程控制的使用

if err:=connect();err!=nil {    //执行了connect函数。函数出错就输出一下日志。 控制了变量err的作用域
   doSomething
}

还有一个for循环非常好用的 range 可以作用于数组，切片，字符串，map，channel 获取索引&值

arr:=[]int{1,2,3,4}
for i,v:=range arr{
   fmt.Printf("index %d,val %v \n",i,v)
}

对于switch 语句go语言默认每个case 都有break 如果想顺延需要加 fallthrough

goto这个东西规范都是禁止的。其他流程意义类似java

三存储

这小节记录一下容器。java中的collection这种东西。

go有数组和切片的概念。区别就是数组的长度是固定的，切片的长度理解为动态的。

切片的底层实现是一个指向数组的指针，一个len 一个cap属性。

切片的截取采用 a[1:3] 这样。 1是开始元素下标，3是截止元素下标。左闭右开区间。 a[1:]1往后都要。

可以用make([]int, 2, 10 )创建切片参数表示： type，len，cap 被make的切片是被直接分配内存的。

append方法是给切片追加元素，cap不够就按原cap两倍扩容。超过1024字节就按原cap的四分之一扩。

append有个坑就是，追加的元素没超过原cap不会生成新的slice切片、会在原切片操作。操作不当会造成值的覆盖

当超过原cap时进行扩充，生成新的slice 就没事了。

要想删除切片中的元素，就需要将该元素的前后切片append到一起。

map是有删除函数的 delete(map,key) go没有直接清空一个map的方法。可以新创建一个map 没用的map等垃圾回收就可以用了。垃圾回收效率也非常高。但是map是线程不安全的。不能同时进行读写操作。会抛异常。
fatal error: concurrent map read and map write

map的数据结构是哈希链表。使用链地址法。听上去跟java一样。但是实现不太一样。

go中的map有 bucket hmap等数据结构。

sync.map是支持并发读写的线程安全容器。如下store 存/改 load取 delete 删 a.delete(key)

//a:=make(map[string]int)
a:=sync.Map{}
go func() {
   for{
      a.Store("a",1)
   }
}()
go func() {
   for{
      fmt.Println(a.Load("a"))
      time.Sleep(time.Second)
   }
}()
a.Range(func(key, value interface{}) bool {     //遍历
   fmt.Println("---",key,value) 
   return true
})
wg:=&sync.WaitGroup{}
wg.Add(1)
wg.Wait()

sync.map没有直接获取长度的方法，只能自己遍历++算一下。因此性能很差。毕竟加锁，肯定相对差一点。

go中的链表。 container/list包中类似 java中的 List