最近开始尝试学习了go语言，毕竟在这么卷的环境下多掌握点技能总没错。

类型系统与结构化编程

Go语言特性 —— 先初步了解有个印象

自动垃圾回收，同时保留了指针操作基于协程和CSP模型的并发轻量级接口编程其它：跨平台、内置类型、多返回值

类型系统 —— TypeSystem

类型体系

Go语言的体系由运算和数据组成，所谓程序其实就是数据结构+算法实现，其实所有编程语言都一样的

常见的十种写法

直接常量
```
    fmt.Println("hello marx")
```
格式化变量
```
    fmt.Printf("%s","hello marx")
```

直接变量

    var str string = "hello marx"
    fmt.Printf("%s\n", str)

数字转义

    //%d 字符转数字  %c 数字转字符
    fmt.Printf("%d,%d,%d,%d,%d,", 'h','a','h','a','~')
    fmt.Printf("%d,%d,%d,%d,%d,", 1, 2, 5, 8, 0)
    fmt.Printf("%c,%c,%c,%c,%c,", 1, 2, 5, 8, 0)

切片实现

    var slice []string = make([]string, 0)
    slice = append(slice, "hello")
    slice = append(slice, " ")
    slice = append(slice, "切片")
    slice = append(slice, "！")
    var str2 string
    for i := 0; i < len(slice); i++ {
          str2 += slice[i]
    }
    fmt.Printf("%s\n", str2)

map实现

  var m1 map[int]string = make(map[int]string, 4)
  m1[1] = "hello"
  m1[2] = "marx"
  fmt.Printf("%s %s\n", m1[1], m1[2])

结构体实现

结构体需要预先声明, 有点像 C 写法包括println printf

    type hello struct {
        value string
    }

    var hw hello
    hw.value = "hello marx jaw"
    fmt.Println(hw.value)

接口实现

  func (hw hello) print() {
      fmt.Println(hw.value)
  }
  
  var showMe showhello = hw
  showMe.print()

    fmt.Println("hello marx")

闭包实现

我学习的教程解释是：闭包内部方法可以访问外部方法的局部变量我个人理解为类似于java的匿名函数

func closurePrint() {
      var str string = "hello marx a!"
      f := func(){
              fmt.Println(str)
      }

      f()
 }

channel实现

注意这里用到了time 需要import

  //主协程(当前main 方法) 通过channel 通道 与chan子协程进行通信
  var ch chan string = make(chan string, 8)
  //go 关键字 + 方法名称  相当于创建一个协程
  //异步操作  这里可能打印不出：由于子协程没创建完成时主协程main运行结束
  go chanPrint(ch)
  ch <- "hello"
  ch <- " "
  ch <- "world"
  ch <- "!"
  //通过让main 睡眠方式 使得子协程执行完毕打印结果
  time.Sleep(time.Second * 5)

定义chanPrint函数

func chanPrint(ch chan string) {
  for v := range ch {
      fmt.Print(v)
  }
}

以上十种方式在日常编程中最常用的五种分别是：切片、map、结构体、接口、channel

数据类型

基础类型 - 原子类型不可再拆分

布尔 bool
整型 int8 int16 int32 int64 uint8 uint16 uint32 uint64 int uintptr
浮点型 float32 float64
复数型 complex64 complex128
- 有理数、无理数
- 实数、虚数
字符型 rune
字符串 string
错误型 error

复合类型类型 - 可以拆分

数组 array
- 类型相同
- 长度固定
结构体 struct
- 类型不同
切片 slice
- 使用频率高
- 长度不固定
- java中是引入包，go是内置类型
字典 map
- 使用频率高
- java中是引入包，go是内置类型
通道 chan
- 协程通信时应用
指针 pointer
- go不仅有自动垃圾回收,同时保留了指针
接口 interface

常量

常量是编译时已知且不可改变的值，包括字面常量、const常量和预定义常量

公式：const name type = 字面常量

字面常量

    -6
    3.1415926
    2.6+8i
    true/false
    'A'
    "go language"

const常量

   const age int = 8
   const zero = 0.0
   const (
        x float32 = 1.2
        y float32 = 1.8
   )

预定义常量（枚举）

iota是个关键字，与const一同出现，const出现时归零，const每出现在一次 iota +1

    const (
        i0 = iota  //此时  iota = 0
        i1         // iota = 1
        i2         // iota = 2
    )
    const x = iota   //此时 iota 归零

变量

变量是内存中一块存储单元的名字，向其存放的数值类型要匹配公式：var name type = 字面常量

声明变量

 var v1 int 
 var v2 float 32

初始化变量

 // 先声明再初始化
 var num int32
 num = 8
 //声明同时初始化  推荐写法
 var num int32 = 8
 //声明初始化  自动推导类型
 var num = 8
 // 引用的简单写法  一般用于函数调用   推荐写法
 num := 8

GO语言初试