青训营Go第一课

Go语言 —— 谷歌出品的一门通用性计算机编程语言

• 特点：

  • 高性能高并发的语言
  • 与c++ java媲美的性能
  • 内建高并发支持，不像别的语言以库的形式支持
  • 语法简单易懂，类似C，并进行简化 只有for循环一种表示 好学（一周高并发开发）
  • 丰富的标准库
  • 稳定性兼容性保证，语言迭代带来的性能优化
  • 丰富工具链 ：如编译 代码格式化 错误检查 帮助文档 包管理 代码补充提示
  • 完整的单元测试框架，支持单元测试，性能测试，代码覆盖率，数值鉴真检测，性能优化
  • 所有编译结构默认静态链接，拷贝唯一一个可执行文件，不用加别的就能部署运行 体积小部署快
  • 编译速度快
  • 跨平台
  • 带垃圾回收

• 语法：

  package main //文件属于main包的一部分，main包是程序入口包
  
  import (
  	"fmt" //导入标准库的fmt包，往屏幕输入输出字符串格式化字符串
  )
  
  func main(){
      fmt.Println("hello world")
  }
  //运行：go run xxx.go
  //二进制编译： go build xxx.go 编译完 ./xxx 运行
  

  强类型语言，go里的字符串是内置类型，可以直接+ = 优先级大部分类似C/C++

  var name = value //自己识别
  var b, c int = 1, 2 //或者表示写出
  f := float32(e) //声明变量
  
  const name = value //常量 无确定类型，根据上下文自动确定
  
  if 表达式没括号 {//必须大括号，不能写成一行那种形式
      XXX
  }else{
      YYY
  }
  
  for 循环，无括号，其他同C/C++ Java等
  switch 默认 case 里面不用break, k可以使用任意类型如字符串，结构体……还能取代ifelse语句
  数组 var a [5]int
  	a[4] = 100
  	fmt.Println(a[4],len(a))
  	b := [5]int{1, 2, 3, 4, 5}
  	var twoD [2][3]int
  切片 可变长 make 创建  append 追加
      s := make([]string,3)
      s[0] = "a"
      fmt.Println(len(s))
      s = append(s,"d") // 底层可能发生扩容，要有返回
      c := make([]string,len(s))
      copy(c,s)
      fmt.Println(s[2:5]) //包括索引2不包括索引5
      fmt.Println(s[2:])
      fmt.Println(s[:5])
      good := []string{"g","o","o","d"}
      fmt.Println(good)
  map 完全无序 遍历时输出偏随机
      m := make(map[key类型]value类型)
      m["one"] = 1
      r , ok := m["unknow"]
      fmt.Println(r, ok) // 0 false ok:有没有这个key存在
      delete(m, "one")
      m2 := map[string]int{"one":1, "two":2}
      var m3 = map[string]int{"one":1, "two":2}
  range 快速遍历
      nums := []int{2,3,4}
      for i, num := range nums { //返回两个：索引，对应位置的值 / key value
          sum += num
          if num==2 {
              fmt.Println("index:",i,"num:",num)
          }
      }
  函数 变量类型后置 可返回多个值
      func add(a int, b int)int {
          ……
      }
      一般第一个返回真正结果，第二个可以是错误信息
      func exists(m map[string]string, k string) (v string, ok bool){
          v, ok = m[k]
          return v, ok
      }
      指针 对常用参数进行修改
          func add2(n int){
              n += 2
          }
          func add2ptr(n *int){
              *n += 2
          }
          func main(){
              n := 5
              add2(n)
              add2ptr(&n)
          }
  结构体 
      type user struct{
          name string
          password string
      }
      func main(){
          a := user{name: "wang",password: "1024"}
          b := user{"wang", "1024"}
          c := user{name: "wang"}
          c.password = "1024"
          var d user
          d.name = "wang"
          d.password = "1024"
      }
      func checkPassword(u user,password string) bool {
          return u.password == password
      }
      func checkPassword2(u *user,password string) bool { //调用时候 &a
          return u.password == password
      }
  结构体方法 (像类成员函数)
      type user struct{
          name string
          password string
      }
      func (u user) checkPassword(password string) bool {
          return u.password == password
      }
      func (u *user) resetPassword(password string) {
          u.password == password
      }
      func main(){
          a.resetPassword("2048")
      }
  错误处理
      import{
          "errors"
          "fmt"
      }
      func findUser(users []user, name string) (v *user, err error){
          for _, u := range users {
              if u.name == name {
                  return &u, nil
              }
          }
          return nil, errors.New("not found")
      }
      func main(){
          u, err := findUser([]user{{"wang", "1024"}}, "wang")
          if err != nil{
              fmt.Println(err)
              return
          }
          if u,err := findUser([]user{{"wang", "1024"}}, "li"); err != nil {
              fmt.Println(err)
              return
          }else{
              fmt.Println(u.name)
          }
      }
  字符串操作
      import{
          "fmt"
          "strings"
      }
      Strings.Contains(a,"ll")
      .Count(a,"l")   .HasPrefix(a,"he")   .HasSuffix(a,"he")   .Index(a,"ll")   .Join([]string{"he", "llo"},"-")
      .Repeat(a,2)   .Replace(a, "e", "E", -1)   .Split("a-b-c","-")   .ToLower(a)   .ToUpper(a)   len(a)
  字符串格式化   Printf(%v可输出任意类型 %+v详细输出 %#v更详细输出 %.2f , s)
  Json处理 
      import{
          "encoding/json"
          "fmt"
      }
      type userInfo struct{
          Name string
          Age int 'json:"age"' //默认风格是大写字母 Age:18，这里指定为小写的age:18
          Hobby []string
      }
      func main(){
          a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang","TypeScript"}}
          buf, err := Json.Marshal(a) // 序列化为byte数组
          if err != nil {
              panic(err)
          }
          fmt.Println(String(buf))// 不强转会输出一些十六进制编码
          var b userInfo
          err = json.Unmarshal(buf,&b) //反序列化到b里面
          if err != nil{
              panic(err)
          }
      }
  时间处理
      import{
          "fmt"
          "time"
      }
      func main(){
          now := time.Now()
          fmt.Println(now)
          t := time.Date(2022,3,27,1,25,36,0,time.UTC) //带时区
          fmt.Println(t.Year(),t.Month(),t.Day(),t.Hour(),t.Minute())
          diff := t2.Sub(t) //减法
          fmt.Println(f.Format("2006-01-02 15:04:05")) //格式化不用yymm，而是用特定时间
          t3, err := time.Parse("2006-01-02 15:04:05","2022-03-27 01:25:36") //解析字符串
          fmt.Println(now.Unix())//获取时间戳
      }
  字符串->数字
      import{
          "fmt"
          "strconv"
      }
      func main(){
          f, _ := strconv.ParseFloat("1.234", 64)
          f, _ := strconv.ParseInt("111", 10, 64)//字符串 进制（0则自动判断） 精度
          n2, _ := strconv.Atoi("123") //转十进制数
      }
  进程信息
      import{
          "fmt"
          "os"
          "os/exec"
      }
      os.Args : 进程在执行时一些命令行参数
      os.Getenv("PATH")   os.Setenv("AA","BB") 获取、写入环境变量
      exec.Command("grep","127.0.0.1","/etc/hosts") : 启动子进程并且获取些输入输出