笔记标题 ｜青训营笔记

这是我参与「第五届青训营 」伴学笔记创作活动的第 1 天 基础语法——变量 变量声明 var a ="initial" var b,c int = 1,2 var d = true var e float64 f :=float32(e) g :=a+"foo" //输出g为initiapple 常量声明(常量无固定类型，根据使用的上下文自动确定)
const s string ="constant" 基础语法——循环(只有一种循环-for循环) package main

import "fmt"

func main() {

    i := 1
    for {           //最经典的for里面什么都不写就是死循环
          fmt.Println("loop")
          break
    }
    for j := 7; j < 9; j++{
          fmt.Println(j)
    }

    for n := 0; n < 5; n++ {
           if n%2 == 0 {
                   continue//继续循环，break跳出循环
           }
            fmt.Println(n)   
       }
       for i <= 3 {
              fmt.Println(i)
               i = i + 1
       }

}
基础语法——if-else 与c++很像，示例 package main

import "fmt"

func main() {

  if 7%2 ==0 {
         fm.Println("7 is even")
    }else{
          fmt.Println("7 is odd")
    }

   if 8%4 == 0 {
           fmt.Println("8 is divisible by 4")
    }

   if num := 9; num < 0 {
            fmt.Println(num, "is negative")
    }else if num < 10{
            fmt.Println(num, "has 1 dlight")
    }else {
             fmt.Println(num, "has multiple digits")
    }

} 基础语法——switch分支结构 package main

import ( "fmt" "time" )

func main() {

    a :=2
    switch a {
    case 1:
            fmt.Println("one")
    case 2:
             fmt.Println("two")
     case 3:
              fmt.Println("three")
      case 4,5:
               fmt.Println("four or five")
      default:
                fmt.Println("other")
      }

      t := time.Now()
      switch {
      case t.Hour() < 12: 
             //switch后面不写变量，在分支里面写条件
             fmt.Println("It's before noon")
       default :
             fmt.Println("It's after noon")
        }

} 基础语法——数组（长度固定，很少用） package main

import "fmt"

func main() {

  var a [5]int
  a[4] = 100          //写入第4个位置的值
  fmt.Println(a[4], len(a)) //读取第4个位置的值

  b := [5]int{1, 2, 3, 4, 5}
  fmt.Println(b)

  var twoD [2][3]int
  for i := 0; i < 2; i++{
        for j := 0; j < 3; j++ {
               twoD[i][j] = i + j
        }
   }
    fmt.Println("2d: ", twoD)

} twoD[i][j] = i+j } } fmt.Println("2d : ", twoD) } 基础语法——切片（可变长度的数组） package main

import "fmt"

func main() {

  s := make([]string, 3)
  s[0] = "a"
  s[1] = "b"
  s[2] = "c"
  fmt.Println("get:", s[2])  // c
  fmt.Println("get:", len(s))//3，需要len()取出长度

  s = append(s, "d")   //增加元素
  s = append(s, "e","f")   //append结果赋值给原数组
  fmt.Println(s)  //[a b c d e f]

  c := make([]string, len(s))  //创建切片，可以指定长度
  copy(c, s)   

//slice1 := []int{1, 2, 3, 4, 5} //slice2 := []int{5, 4, 3} //copy(slice2, slice1) // 只会复制slice1的前3个元素到slice2中 //copy(slice1, slice2) // 只会复制slice2的3个元素到slice1的前 3个位置 fmt.Println(c) // [a b c d e f]

  fmt.Println(s[2:5])  //[c d e]，第2~5个但不包括第5个元素
  fmt.Println(s[:5])    //[a b c d e]
  fmt.Println(s[2:])    //[c d e f]

  good := []string{"g", "o", "o", "d"}
  fmt.Println(good)   //[good]

} 基础语法——map(数据结构，哈希或者字典) package main

import "fmt"

func main() { m := make(map[string]int ) //make创建map[key]value m["one"] = 1 //通过[]写入或者读取键值对 m["two"] = 2 fmt.Println(m) //map[one : 1 two : 2] //随机顺序输出，无关先后顺序插入 fmt.Println(len(m)) //2 fmt.Println(m["one"]) //1 fmt.Println(m["unknow"]) //0

    r, ok := m["unknow"]   //通过ok判断m里面是否有r这个key
    fmt.Println(r, ok)              //0  false
 
    delete(m, "one")              //删除键值对

     m2 :=map[string]int{"one": 1,"two": 2}
     var m3 = map[string]int{"one": 1,"two": 2}
     fmt.Println(m2, m3)

} 基础语法——range(遍历数组或者map非常方便) package main

import "fmt"

func main() { nums := []int{2, 3, 4}
sum := 0 for i, num := range nums { sum += num if num == 2 { fmt.Println("index:", i, "num:", num)//index: 0 num: 2 //对于数组返回两个值，索引和对应位置的值 } } fmt.Println(sum) //9

  m := map[string]string{"a" : "A","b" : "B"}
  for k, v := range m {       //遍历map
       fmt.Println(k, v)  //b B;a A    //第一个值是k,第二个值是v
  }
  for k := range m {
        fmt.Println("key", k)  // key a; key b
  }

} 基础语法——指针(对于传入的参数进行修改) package main

import "fmt"

func add2(n int) { //不起作用 n += 2 }

func add2ptr(n *int) { //实现变量自增 *n += 2 }

func main() { n := 5 add2(n) fmt.Println(n) //5 add2ptr(&n) //指针类型，需要类型匹配，所以加& fmt.Println(n) //7 } 基础语法——函数 package main

import "fmt"

func add(a int, b int) int { return a + b }

func add2(a, b int) int { return a + b }

func exists(m map[string]string, k string) (v string, ok bool) { v, ok = m[k] return v, ok //返回两个值，v和是否存在的值 }

func main() { res := add(1, 2) fmt.Println(res) //3

   v,ok :=exists(map[string]string{"a": "A"},"a")
   fmt.Println(v, ok)  //A  True

} 基础语法——结构体(带类型的字段的集合) package main

import "fmt"

type user struct { //定义了一个user结构体，初始化结构体 name string //字段name password string //字段password }

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"

  fmt.Println(a, b, c, d) 
  //{wang 1024}{wang 1024}{wang 1024}{wang 1024}
  fmt.Println(checkPassword(a, "haha"))       //false
  fmt.Println(checkPassword(&a, "haha"))    //false

} //结构体能作为函数的参数，非指针用法 func checkPassword(u user, password string) bool { return u.password == password } //指针用法，避免一些大结构体的开销 func checkPassword2(u *user, password string) bool { return u.password == password } 基础语法——结构体方法(为结构体定义方法) 相似于其他的类成员函数 package main

import "fmt"

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 := user{name: "wang", password: "1024"} a.resetPassword("2048") fmt.Println(a.checkPassword("2048")) //true } 基础语法——错误处理 package main

import ( "errors" "fmt" )

type user struct { name string password string }

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 } fmt.Println(u.name) //wang //没出现错误,真正的返回值

  if u, err := findUser([]user{{"wang","1024"}},"li");err != nll{
       fmt.Println(err)       //not found
       return
 }else {
      fmt.Println(u.name)
 }

}
基础语法——字符串操作 package main

import ( "fmt" "strings" )

func main() { a := "hello" fmt.Println(strings.Contains(a, "ll")) //true,是否包含 fmt.Println(strings.Count(a, "l")) //2，字符串计数 fmt.Println(strings.HasPrefix(a, "he")) //true fmt.Println(strings.HasSuffix(a, "llo")) //true fmt.Println(strings.Index(a, "ll")) //2,查找字符串位置 fmt.Println(strings.Join([]string{"he"; "llo"}, "-"))
//he-llo,连接字符串 fmt.Println(strings.Repeat(a, 2)) //hellohello，重复 fmt.Println(strings.Replace(a, "e", "E", -1)) //hEllo fmt.Println(strings.Split("a-b-c", "-")) //[a b c] fmt.Println(strings.ToLower(a)) //hello fmt.Println(strings.ToUpper(a)) //hEllo fmt.Println(len(a)) //5 b := "你好" fmt.Println(len(b)) //6,一个中文对应多个字符 } 基础语法——数字解析：字符串与数字的转换在strconv包中 ParseFloat或ParseInt解析一个字符串， strconv.ParseInt("字符串",进制，进度位数)进制为0时自动推测 strconv.ParseFloat("字符串"，进度位数) strconv.Atoi("字符串")把10进制字符串转换为数字 strconv.Itoa(数字)把10进制数字转换为字符串 例如：n2, _ := strconv.Atoi("123") 数字输入不合法的话会返回错误 例如: n2, err := strconv.Atoi("AAA") fmt.Println(n2, err) 基础语法——字符串格式化 package main

import "fmt"

type point struct { x, y int }

func main() { s := "hello" n := 123 p := point{1, 2} fmt.Println(s, n) //hello 123 fmt.Println(p) //{1, 2}

 fmt.Println("s=%v/n", s)    //s=hello
 fmt.Println("n=%v\n",n)    //n=123
 fmt.Println("p=%v\n",p)    //p={1 2}
 fmt.Println("p=%+v\n",p)   //p={x:1 y: 2}
 fmt.Println("p=%#v\n",p)  //p=main.point{x:1 y: 2}

 f := 3.141592653
 fmt.Println(f)    //3.141592653
 fmt.Println("%.2f\n" f)    //3.14

}