优势：

  • 极简单的部署方式：可直接编译成机器码，不依赖其他库，直接运行即可部署
  • 静态类型语言：
    • 编译的时候检查出来隐藏的大多数问题
  • 语言层面的并发：
    • 天生支持
    • 充分利用多核
  • 标准库：
    • runtime系统调度机制
    • 高效的GC垃圾回收
    • 丰富的标准库
  • 简单易学
    • 25个关键字
    • C语言简洁基因
    • 跨平台
    • 面向对象

缺点：

  • 无泛化类型
  • 包管理大部分都在github上
  • 所有Exception都用error来处理
  • 对C的降级处理不是无缝的，不像C->asm那么完美(序列化问题)

Hello world

  1. package main
  3. import (
  4.         "fmt"
  5. )
  6. func main(){
  7.         var a int = 1
  8.         fmt.Println("hello go!")
  9. }

变量，常量

变量 var

有var就是=
没有就是:=

  1. 方法1：声明一个变量，默认值是0
  2. var a int 
  3. //默认a=0
  5. 方法2：声明一个变量并初始化
  6. var b int = 10
  8. 方法3：初始化时省略数据类型，自动匹配
  9. var c = 10
  10. //自动推导
  12. 方法4：直接自动匹配//不支持全局变量
  13. d:= 10

多个变量声明

  1. 单行写法
  2. var aa,bb int =100,200
  3. var cc,dd = 100, "miao"
  5. 多行写法
  6. var(
  7.     vv int = 100
  8.     gg bool = true
  9. )

常量，枚举，const与iota

  1. const 关键字可以用于定义常量
  2. const a int = 10
  4. const还可以定义枚举类型,iota用在const中作为一个每行+1的量 第一行iota=0 公式不变
  6. const (
  7.     SHANGHAI = 1
  8.     SHENZHEN = 2
  9.     BEIJING = 3
  10. )
  11. 与以下是一样的
  12. const (
  13.     SHANGHAI = iota
  14.     SHENZHEN 
  15.     BEIJING
  16. )
  18. //=================================
  20. const (
  21.     SHANGHAI = 10*iota
  22.     SHENZHEN 
  23.     BEIJING
  24. )
  25. 相当于
  26. const (
  27.     SHANGHAI = 0
  28.     SHENZHEN  = 10
  29.     BEIJING = 20
  30. )
  33. //================================
  35. const (
  36.     a,b = iota + 1, iota +2 //1,2
  37.     c,d //2,3
  38.     e,f = iota*2, iota*3 //6,9
  39.     c,d //8,12
  40. )

函数,多返回值

多返回值

  1. func foo1(a string, b int) {
  2.     blabla
  3. }
  5. func foo2(a string, b int) int {
  6.     blabla
  7.     c:=10
  8.     return c
  9. }
  11. func foo3(a string, b int) (int,int) {
  12.     blabla
  13.     c,d:=10,20
  14.        return c,d
  15. }
  17. func foo4(a string ,b int)(r1 int,r2 int){
  18.     r1:=10
  19.     r2:=20 //不赋值则默认0
  20.     //作用域是函数体整个空间内
  21.     return
  22. }

通常把对外开放的函数大写开头，私有函数小写开头

init函数与import导包

image.png
先层层import,init()执行后再返回
引入路径填相对于gopath的路径
可以给包起别名

  1. import(
  2.      _ "xxxx/xxxx" //匿名导入 可以不使用包内方法，但是init
  3.     mylib "yyyy" //mylib.AAA() 可以使用包的方法
  4.     "qqqqq/cccc" 
  5.     . "qqqqqqqqqq" //导入包中的全部方法 可以直接调用不需要加包名
  6. )

指针，引用

p 根据地址找内存
&a 取地址
p := &a p是int类型的
可以多多多级指针

defer

defer后面的表达式在结束之前执行，类似于析构函数，是一种压栈的形式
return先执行，defer后执行

  1. func A(){
  3. }
  5. func B(){
  7. }
  9. func C(){
  11. }
  13. func E(){
  15. }
  17. func main(){
  18.     defer A()
  19.     defer B()
  20.     defer C()
  21.     defer fmt.Println("D")
  22.     return E()
  23. }       
  25. E
  26. D
  27. C
  28. B
  29. A

数组，切片slice

  1. var myArray1 [10]int //普通数组
  2. var myArray2 [4]int{1,2,3,4} //普通数组
  5. for i:=0 ;i< len(myArray1);i++ {
  6.     fmt.Println(myArray1[i])
  7. }
  8. for index,value := range myArray2{
  9.     fmt.Println("index=",index,"value=",value)
  10. }   
  11. 数组在函数中传递时候传递的是一个拷贝的值，且根据不同的长度有不同的类型
  12. myArray1 的类型是[10]int, myArray2的类型是[4]int，在函数传递的时候会类型不匹配
  14. func A(arr [4]int) {
  15.     arr[0]=10 //无法改变实际上的arr[0]
  16. }

切片数组

  1. myArray:=[]int{1,2,3,4}
  2. func A(arr []int) {//引用传递
  3.     arr[0]=10 //可以改变实际上的arr[0]，传的是一个指针
  4. }

slice四种声明方式

  1. var a =make([]int,15)
  3. slice1 := []int{1,2,3}
  5. var slice2 []int
  6. slice2 = make([]int,3)
  8. var slice3 []int =make([]int,3)
  10. slice4 := make([]int,3)

判断slice是否为空

  1. if slice1 == nil {
  2.     blabla 空切片
  3. }else{
  4.     blabla 分配过的切片
  5. }

slice切片与追加

  1. var a =make([]int,3，5) //长度3容量5
  2. a=append(a,1) //长度4容量5
  3. a=append(a,2) //长度5容量5
  4. a=append(a,3) //长度6容量10   超出容量的时候容量会x2
  6. var b =make([]int,3) //长度3容量3 如果扩容就变成6

扩容机制：超出容量的时候容量会x2

截取

  1. s := []int{1,2,3}
  2. s1 := s[0:1] //前闭后开，和python一样 默认上限len(s)，默认下限0 [1:], [:2]都是可以的

这里指向的底层地址一致，改s1[0]也会改变s[0]
可以用copy得到深拷贝

  1. s2:= mask([]int,3)
  2. copy(s2,s) //s中的值拷贝至s2

image.png

map

  1. 三种声明方式
  3. //方法1
  4. 声明 MyMap1是一种map类型，key是string，value是int
  5. var myMap1 map[string]int
  6. 目前myMap1==nil
  8. myMap1=make(map[string]int,10) 使用map前需要先用make给map分配数据空间 一样能够自动扩容
  9. myMap1["one"]=10
  10. myMap2["two"]=20
  11. 必须make否则会报错
  13. //方法2
  14. myMap2 := make(map[string]int)
  15. myMap2["one"]=10
  16. myMap2["two"]=20
  19. //方法3
  20. myMap3 := map[string]string{
  21.     "one":10,
  22.     "two":20,
  23. }
  26. //===========================
  27. 使用
  28. //===========================
  29. //添加 略
  30. //遍历
  31. for key,value := range myMap3{
  32.     fmt.Println(key,value)
  33. }
  35. //删除
  36. delete(myMap3,"one")
  38. //修改和添加一样
  40. //传参的时候传的是指针
  41. func changeMap(mapa map[string]int){ //引用传递
  42.     mapa["one"]=1
  43. }
  45. //完全拷贝需要再定义一个map把值复制过去

struct类与对象

  1. type myint int 
  2. //声明一个int的别名叫myint
  4. //定义一个结构体
  5. type Book struct{
  6.     title string
  7.     auth string
  8. }
  10. func changeBook1(book Book){ //值传递
  11.     book.auth = "444" //不会变
  12. }
  14. func changeBook2(book *Book){ 
  15.     book.auth = "111" //会变
  16. }
  18. func main(){
  19.        var book1 Book
  20.     book1.title = "golang"
  21.     book1.auth = "zhang3"
  22.     fmt.Printf("%v\n",book1)//会逐个输出Book中的变量值 
  23.     //输出的会是 {golang zhang3}
  25.     changeBook1(book)
  26.     fmt.Printf("%v\n",book1)
  27.     //输出的会是 {golang zhang3}
  29.     changeBook2(&book1)
  30.     fmt.Printf("%v\n",book1)
  31.     //输出的会是 {golang 111}
  33. }

类

  1. //如果类名首字母大写表示其他包也能够定义这个对象
  2. type Hero struct{
  3.     Name string //如果说类的属性首字母大写表示该属性共有，否则的话只能够类的内部访问
  4.     Ad int
  5.     level int  //私有属性
  6. }
  8. func (this *Hero) Show(){ //方法首字母大写表示在其他包中能够调用 小写表示其他包不能调用
  9.     fmt.Println("",........)
  10. }
  12. func (this Hero) SetName(a strnig){ //这里传递的是this的一个拷贝
  13.     this.Name=a
  14. }
  16. func (this *Hero) SetName(a string){
  17.     this.Name=a
  18. }
  1. 注意this* 否则只能访问一个副本
  2. 注意首字母大小写有区别，大写表示对外访问，小写只能在本包内访问

继承

  1. type Human struct{
  2.     name string
  3.     sex string
  4. }
  6. func (this *Human) Eat(){
  7.     fmt.Println("Human.Eat()")
  8. }
  10. func (this *Human) Walk(){
  11.     fmt.Println("Human.Walk()")
  12. }
  14. typedef Superman struct{
  15.     Human //Superman类继承了Human类的方法
  17.     level int
  18. }
  20. //重定义父类方法
  21. func (this* Superman) Eat(){
  22.     fmt.Println("Superman.Eat()")
  23. }
  25. //子类新方法
  26. func (this* Superman) Fly(){
  27.     fmt.Println("Superman.Eat()")
  28. }
  30. func main(){
  31.     h:=Human{"zhang3","female"}
  32.     h.Eat()
  33.     h.Walk()
  35.     s:=Superman{Human{"li4","male"},88}
  36.     //或者
  37.     var s Superman
  38.     s.name = "li4"
  39.     s.sex = "male"
  40.     s.level = 88
  42.     s.Walk() //human walk
  43.     s.Eat() //superman eat
  44.     s.Fly() //superman fly
  47. }

多态 interface

基本要素

  • 有一个父类
  • 有子类，实现了父类的全部接口方法
  • 父类类型的变量(指针) 指向(引用) 子类的具体数据变量 ```go type AnimalIF interface{ //是一个指针！！！！！！！！！！！！！！！！ Sleep()
    GetColor() string //获取动物的颜色 GetType() string //获取动物的种类 }

//不需要把AnimalIF显式写下来，重写该接口的[所有]方法，就可以用一个AnimalIF指针指向Cat type Cat struct{ color string }

func (this* Cat) GetColor(){ return this.color }

func (this* Cat) GetType(){ return “Cat” }

func (this* Cat) Sleep(){ fmt.Println(“Cat sleeping”) }

type Dog struct{ color string }

func (this* Dog) GetColor(){ return this.color }

func (this* Dog) GetType(){ return “Dog” }

func (this* Dog) Sleep(){ fmt.Println(“Dog sleeping”) }

func showAnimal (animal AnimalIF){ animal.Sleep() //多态 fmt.Println(“color = “,animal.GetColor()) }

func main(){

  1. var animal AnimalIF //接口数据类型
  3. animal = &Cat{"Green"}
  4. animal.Sleep()
  6. animal = &Dog("Yellow")
  7. animal.Sleep()
  9. showAnimal(animal)
  1. <a name="gs0sb"></a>
  2. ## 空接口 interface{} 通用万能类型，类型断言
  3. int、string、float32、float64、struct 都实现了 interface
  5. ```go
  6. func myFunc(arf interface{}){
  7.     fmt.Println("myFunc called")
  8.     fmt.Println(arg)
  10.     //interface{}实际类型区分办法：断言
  11.     value,ok := arg.(string)
  12.     if ok{
  13.         是string类型
  14.     }else{
  15.         不是string类型
  16.         fmt.Printf("value type is %T\n", value)
  17.     }
  18. }
  20. type Book struct{
  21.     auth string
  22. }
  24. func main(){
  25.     bool:= Book{"Golang"}
  27.     myFunc(book)
  28.     myFunc(100)   
  29. }

反射

变量的结构

image.png
反射 通过一个变量得到type、值

  1. var a string
  2. //pair<statictype:string, value:"aceld">
  3. a="aceld"
  5. //pair<type:string,value:"aceld">
  6. var allType interface{}
  7. allType = a
  9. str,_:=allType.(string)
  10. fmt.Println(str) //aceld

断言可以用于强制转换

image.png
pair是不会变的.

image.png
image.png

reflect包:ValueOf,TypeOf

动态获取未知数据类型和值

  1. package main
  3. import(
  4.     "fmt"
  5.     "reflect"
  6. )
  8. func reflectNum(arg interface{}){
  9.     fmt.Println("type:", reflect.TypeOf(arg)," value:",reflect.ValueOf(arg))
  10. }
  12. type User struct{
  13.     Id int
  14.     Name string
  15.     Age int
  16. }
  18. func (this* User) Call(){
  19.     fmt.Println("User id called ..")
  20.     fmt.Printf("%v\n", this)
  21. }
  23. func man(){
  24.     var num float64 = 1.2345
  25.     user:= User{1,"Aceld",18}
  26. }
  28. func DoFIleAndMethod(input interface{}){
  29.     //获取type
  30.     inputType:= reflect.TypeOf(input)
  31.     fmt.Prinln("type is ",inputType.Name())
  33.     //获取value
  34.     inputValue:= reflect.ValueOf(input)
  35.     fmt.Prinln("value is ",inputValue)
  37.     //通过type获取里面的字段
  38.     for i :=0; i< inputType.NumField(); i++{
  39.         field := inputType.Field(i)
  40.         value := inputValue.Field(i).Interface()
  42.         fmt.Printf("%s:%v = %v\n",field.Name,field.Type,value)
  43.     }
  45.     //通过type获取里面的方法,调用
  46.     for i := 0; i< inputType.NumMethod();i++{
  47.         m:=inputType.Method(i)
  48.         fmt.Printf("%s:%v\n",m.Name,m.Type)
  49.     }
  50. }

image.png
详细接口看文档

结构体标签

  1. type resume struct{
  2.     Name string `info:"name" doc:"我的名字"`
  3.     Sex string `info:"sex"`
  4. }
  6. func findTag(str interface{}){
  7.     t:=reflect.TYpeOf(str).Elem()
  9.     for i:=0; i<t.NumField();i++{
  10.         taginfo :=t.Field(i).Tag.Get("info")
  11.         tagdoc := t.Field(i).Tag.Get("doc")
  12.     }
  13. }
  15. func main(){
  16.     var re resume
  17.     findTag(&re)
  18. }

结构体标签在json中的使用

image.png

可以应用在json编解码,orm映射关系等