go语言基础总结,三个案例收获|青训营笔记

128 阅读3分钟

这是我参与「第三届青训营 -后端场」笔记创作活动的的第1篇笔记」,今天正式步入了青训营的学习。第一节课也是比较基础的一节课,讲解了关于go语言的基础语法,并在老师的带动下完成了三个小的demo。

go语言基础

1.go中变量的定义以及函数的声明

go语言中变量声明以及赋值,相较于其他语言有着独一无二的语法。

var i = "initial" // 首先一点与其他解释性语言不同的是,他有着类型推导,像在java,c++等语言中不具备的类似python脚本语言的功能

var a ,c int = 1, 2 其次,如果显式声明,他的变量类型在变量的后方

d := 3.123 另外他有着自己独一无二的定义初始化加赋值方式

2.函数的声明以及返回值

另外其函数的返回值相较于其他语言,可以为多个返回值(猜测是为了取代像java中的异常抛出机制,进而更简洁的实现报错功能)

    func funcion() (result int,err error) {
        return 1,nil
    }

3.循环

同时go语言省略的for以外的while dowhile循环,通过for来实现其他循环,进一步简化了代码

    for { // 死循环
        
    }
    
    for j := 0 ; j < 10 ; j ++{ // 循环10次的for循环
    
    }
    
    for i <= 3{ // 循环3次的while循环
        
    }

4.数据结构

数组的使用(由于大小固定,大部分使用“切片”)

    var a[5] int // 初始化数组,所有值为0
    a[4] = 199 // 对第五个元素赋值
    len(a) // 通过len函数统计a数组的大小

切片(类似于java中的ArrayList集合,随着内容的增加会自动扩容) 由于使用类似数组,并且有更多的函数方法,因此大部分采用切片

     s := make([]string,3)
     s[0] = "a" // 类似数组的使用方式
     s[1] = "b"
     s[2] = "c" // 此时切面已满
     
     s = append(s,"d") // 切片会自动扩容
     

map(类似java中的hashMap)但是go中键值对几乎无序

    m := make(map[string]int) // 这里中括号内代表key的类型 括号外代表value的类型
    // 等同与以下声明方式
    m1 := map[string]int{"one":1,"two":2} // 类似json的格式
    var m2 = map[string]int{"one":1,"two":2}
    m["one"] = 1 // 使用起来也类似数组 ( make(map[int]int)这样的map就更像数组了 )
    delete(m,"one) // 删除函数传入map,再传入删除的键值对的key

指针以及结构体类似c语言,就不一一介绍 这里说明一下go中结构体的“成员函数”

type user struct{
    name string
    password string
}

func (u user) checkPassword(password string) bool{  // 这里是一个结构体方法,通过结构体对象直接.调用方法
    return u.password = password
}

func main(){
    a := user{name:"blite",password="0523"}
    a.checkPassword("0415") // flase
}

三个demo程序

1.猜数游戏

 package main

 import (
    "bufio"
    "fmt"
    "math/rand"
    "os"
    "strconv"
    "strings"
    "time"
 )

 func main() {
    maxNum := 100
    rand.Seed(time.Now().UnixNano())
    secretNumber := rand.Intn(maxNum)
    //fmt.Println("The secret number is ", secretNumber)

    fmt.Printf("Please input your guess:")
    reader := bufio.NewReader(os.Stdin)
    for {
       input, err := reader.ReadString('\n')
       if err != nil {
          fmt.Println("An error occurred while reading input.Please try again", err)
          continue
       }
       input = strings.TrimSuffix(input, "\n")
       guess, err := strconv.Atoi(input)
       if err != nil {
          fmt.Println("Invalid input.Please enter an integer value")
          continue
       }
       //fmt.Println("your guess is", guess)
       if guess > secretNumber {
          fmt.Println("Your guess is bigger than the secret number. Please try again")
       } else if guess < secretNumber {
          fmt.Println("Your guess is smaller than the secret number.Please try again")
       } else {
          fmt.Println("Correct,you legend!")
          break
       }
    }
 }

从这个案例巩固了基础的变量的声明,以及for循环的使用,最重要的是math.rand中的rand需要随机数种子,使用当前时间来作为种子

2.简单在线词典

 package main

 import (
    "bufio"
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "os"
    "strings"
 )

 type DictRequest struct {
    TransType string `json:"trans_type"`
    Source    string `json:"source"`
    UserId    string `json:"user_id"`
 }

 type DictResponse struct {
    Rc   int `json:"rc"`
    Wiki struct {
       KnownInLaguages int `json:"known_in_laguages"`
       Description     struct {
          Source string      `json:"source"`
          Target interface{} `json:"target"`
       } `json:"description"`
       ID   string `json:"id"`
       Item struct {
          Source string `json:"source"`
          Target string `json:"target"`
       } `json:"item"`
       ImageURL  string `json:"image_url"`
       IsSubject string `json:"is_subject"`
       Sitelink  string `json:"sitelink"`
    } `json:"wiki"`
    Dictionary struct {
       Prons struct {
          EnUs string `json:"en-us"`
          En   string `json:"en"`
       } `json:"prons"`
       Explanations []string      `json:"explanations"`
       Synonym      []string      `json:"synonym"`
       Antonym      []string      `json:"antonym"`
       WqxExample   [][]string    `json:"wqx_example"`
       Entry        string        `json:"entry"`
       Type         string        `json:"type"`
       Related      []interface{} `json:"related"`
       Source       string        `json:"source"`
    } `json:"dictionary"`
 }

 func query(word string) {
    client := &http.Client{}
    //var data = strings.NewReader(`{"trans_type":"en2zh","source":"good"}`)
    //request := DictRequest{TransType: "en2zh", Source: "good"}
    request := DictRequest{TransType: "en2zh", Source: word}
    buf, err := json.Marshal(request)
    if err != nil {
       log.Fatal(err)
    }
    var data = bytes.NewReader(buf)
    req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
    if err != nil {
       log.Fatal(err)
    }
    req.Header.Set("Accept", "application/json, text/plain, */*")
    req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9")
    req.Header.Set("Connection", "keep-alive")
    req.Header.Set("Content-Type", "application/json;charset=UTF-8")
    req.Header.Set("Origin", "https://fanyi.caiyunapp.com")
    req.Header.Set("Referer", "https://fanyi.caiyunapp.com/")
    req.Header.Set("Sec-Fetch-Dest", "empty")
    req.Header.Set("Sec-Fetch-Mode", "cors")
    req.Header.Set("Sec-Fetch-Site", "cross-site")
    req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.54 Safari/537.36")
    req.Header.Set("X-Authorization", "token:qgemv4jr1y38jyq6vhvi")
    req.Header.Set("app-name", "xy")
    req.Header.Set("os-type", "web")
    req.Header.Set("sec-ch-ua", `" Not A;Brand";v="99", "Chromium";v="101", "Google Chrome";v="101"`)
    req.Header.Set("sec-ch-ua-mobile", "?0")
    req.Header.Set("sec-ch-ua-platform", `"macOS"`)
    resp, err := client.Do(req)
    if err != nil {
       log.Fatal(err)
    }
    defer resp.Body.Close()
    bodyText, err := ioutil.ReadAll(resp.Body)
    if err != nil {
       log.Fatal(err)
    }
    if resp.StatusCode != 200 {
       log.Fatal("bad StatusCode:", resp.Status, "body", string(bodyText))
    }
    //fmt.Printf("%s\n", bodyText)
    var dictResponse DictResponse
    err = json.Unmarshal(bodyText, &dictResponse)
    if err != nil {
       log.Fatal(err)
    }
    //fmt.Printf("%#v\n", dictResponse)
    fmt.Println(word, "UK:", dictResponse.Dictionary.Prons.En, "US:", dictResponse.Dictionary.Prons.EnUs)
    for _, item := range dictResponse.Dictionary.Explanations {
       fmt.Println(item)
    }
 }

 func main() {
    reader := bufio.NewReader(os.Stdin)
    for {
       fmt.Printf("请输入需要查询的单词,输入0退出查询:")
       input, err := reader.ReadString('\n')
       input = strings.TrimSuffix(input, "\n")
       if err != nil {
          log.Fatal(err)
          continue
       }
       if input == "0" {
          fmt.Println("Welcome to use next time,bye! ....")
          break
       }
       query(string(input))
       fmt.Println("------------------------------------------")
    }
 }

这个案例更多的教会了我抓包和使用一些工具,例如将cURL转化为go中代码,还有就是将json数据反序列话生成结构体将json格式数据反向生成结构体