day1 go基本语法+ 字典小demo（彩云小译+金山翻译）

用户8558321257312
39 阅读5分钟

go语言学习 Day1

因为有学过其他的编程语言，所以只记录go与其他与语言不同的地方

变量声明

var a = "string"
var b = 1
​
// 指定类型
  var a int = 1
  var b string = "test"
​
// 冒号
  a := 1
  b := "test"
​
// 常量
  const a = 1
  const b string = "test"

选择语句

a := 1
  if a < 2{
    
  }else if a < 1{
    
  }else {
    
  }

循环语句

在go中，循环语句只有for 没有while和do while

  // 循环
  for b := 1; b < 9; b++ {
    
  }
​
  for {
    
  }
​
  for a <= 3 {
    
  }

分支语句

与其他语言不同的是，go中的switch 不需要在case后添加break来跳出，也可以将switch当做if else来使用

c := 1
  switch c {
    case 1:
    case 2:
    case 3:
    default:
  }
​
  switch {
    case c < 1:
    case c > 2:
    default:
    
  }

数组

var arr1 [5]int
  arr1[1] = 1
  fmt.Printf(arr1[1],len(arr1))
  arr2 := [5]int {1,2,3,4,5}

map

// map
  map1 := make(map[string]string)
  map1["test1"] = "test1"
​
​
  var map2 map[string]string;
  map2["aaa"] = "aaa"

函数

在go中

1.类型后置

2.允许多个返回值

// 函数
func add(a int, b int ) int {
  return a+b
}
​
func add2(a,b int) int {
  return a+b
}
​
func exist(contains map[int]string ,key int)  (index string,ok bool) {
  index,ok = contains[key]
}

结构体与结构体方法

type user struct {
  name string
  age int
}
​
// 结构体方法
func (u user) getName () string {
  return u.name;
}
​
func main() {
  a := user{name: "test",age: 12}
  fmt.Print(a.getName())
}

字典小项目

步骤;

  1. 导入了必要的包，包括fmt、bytes、encoding/json、io、log和net/http。
  2. 定义了两个结构体DictRequest和DictResponse，用于存储请求和响应的数据。
  3. 定义了一个query函数，用于发送查询请求并解析响应数据。函数中使用了http.Client来发送HTTP请求，使用json.Marshal和json.Unmarshal来处理JSON数据。
  4. 在main函数中，使用fmt.Scan函数循环读取用户输入的单词，直到输入"quit"为止。每次读取到单词后，调用query函数进行查询并输出结果。
  5. 在query函数中，首先创建了一个http.Client对象和一个DictRequest对象，然后使用json.Marshal将请求对象转换为JSON格式的字节流。
  6. 接着创建了一个http.Request对象，并设置了请求的URL、请求头和请求体。
  7. 使用client.Do(req)发送请求，并通过io.ReadAll读取响应的内容。
  8. 如果响应的状态码不是200，表示请求失败，程序会输出错误信息并终止。
  9. 使用json.Unmarshal将响应的内容解析为DictResponse对象，并输出其中的数据，包括英式发音和美式发音以及释义。
  10. 在main函数中，使用fmt.Scan函数读取用户输入的单词，并调用query函数进行查询和输出。如果输入的单词是"quit"，则退出循环。 以上就是对给定代码的简洁解释。该代码实现了一个简单的英文单词查询功能，通过发送HTTP请求获取单词的释义和发音信息，并将结果输出到控制台。
  1. respKing结构体用于存储金山翻译API的响应数据，包括Message和Status字段。
  2. Means结构体用于存储金山翻译API中的means字段，包括Part和Means字段。
  3. Message结构体用于存储金山翻译API中的message字段，包括Key、Paraphrase、Value和Means字段。
  4. queryByKing函数用于发送查询请求并解析响应数据。函数中使用了http.Client来发送HTTP请求，使用json.Unmarshal来处理JSON数据。
  5. 在queryByKing函数中，首先创建了一个http.Client对象和一个http.Request对象，设置了请求的URL、请求头和请求体。
  6. 使用client.Do(req)发送请求，并通过io.ReadAll读取响应的内容。
  7. 如果响应的状态码不是200，表示请求失败，程序会输出错误信息并终止。
  8. 使用json.Unmarshal将响应的内容解析为respKing对象，并输出其中的数据，包括翻译结果和相关结果。
  9. 在queryByKing函数中，使用range遍历respk.Message，并根据索引值输出不同的标题。然后输出每个Message对象中的Key和Paraphrase字段。
package main
​
import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "log"
    "net/http"
)
​
type DictRequest struct{
    TransType string `json:"trans_type"`
    Source    string `json:"source"`
}
​
​
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{}
    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("Connection", "keep-alive")
    req.Header.Set("DNT", "1")
    req.Header.Set("os-version", "")
    req.Header.Set("sec-ch-ua-mobile", "?0")
    req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.51 Safari/537.36")
    req.Header.Set("app-name", "xy")
    req.Header.Set("Content-Type", "application/json;charset=UTF-8")
    req.Header.Set("Accept", "application/json, text/plain, */*")
    req.Header.Set("device-id", "")
    req.Header.Set("os-type", "web")
    req.Header.Set("X-Authorization", "token:qgemv4jr1y38jyq6vhvi")
    req.Header.Set("Origin", "https://fanyi.caiyunapp.com")
    req.Header.Set("Sec-Fetch-Site", "cross-site")
    req.Header.Set("Sec-Fetch-Mode", "cors")
    req.Header.Set("Sec-Fetch-Dest", "empty")
    req.Header.Set("Referer", "https://fanyi.caiyunapp.com/")
    req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9")
    req.Header.Set("Cookie", "_ym_uid=16456948721020430059; _ym_d=1645694872")
    resp, err := client.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()
    bodyText, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }
​
  if resp.StatusCode != 200 {
        log.Fatal("bad StatusCode:", resp.StatusCode, "body", string(bodyText))
    }
    var dictResponse DictResponse
    err = json.Unmarshal(bodyText, &dictResponse)
    if err != nil {
        log.Fatal(err)
    }
​
  
  fmt.Println(word, "UK:", dictResponse.Dictionary.Prons.En, "US:", dictResponse.Dictionary.Prons.EnUs)
    for _, item := range dictResponse.Dictionary.Explanations {
        fmt.Println(item)
    }
}
​
type respKing struct {
    Message []Message `json:"message"`
    Status int `json:"status"`
}
type Means struct {
    Part string `json:"part"`
    Means []string `json:"means"`
}
type Message struct {
    Key string `json:"key"`
    Paraphrase string `json:"paraphrase"`
    Value int `json:"value"`
    Means []Means `json:"means"`
}
​
func queryByKing(word string) {
  client := &http.Client{}
  var url1 string
  var url2 string
​
  url1 = "https://dict.iciba.com/dictionary/word/suggestion?word="
  url2 = "&nums=5&ck=709a0db45332167b0e2ce1868b84773e&timestamp=1690276262836&client=6&uid=123123&key=1000006&is_need_mean=1&signature=248459c1d78a3e967c40bf1ffda885cb"
  
    req, err := http.NewRequest("GET", url1+word+url2, nil)
    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,ja;q=0.8")
    req.Header.Set("Connection", "keep-alive")
    req.Header.Set("Origin", "https://www.iciba.com")
    req.Header.Set("Referer", "https://www.iciba.com/")
    req.Header.Set("Sec-Fetch-Dest", "empty")
    req.Header.Set("Sec-Fetch-Mode", "cors")
    req.Header.Set("Sec-Fetch-Site", "same-site")
    req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36")
    req.Header.Set("sec-ch-ua", `"Not.A/Brand";v="8", "Chromium";v="114", "Google Chrome";v="114"`)
    req.Header.Set("sec-ch-ua-mobile", "?0")
    req.Header.Set("sec-ch-ua-platform", `"Windows"`)
    resp, err := client.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()
    bodyText, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }
​
  if resp.StatusCode != 200 {
        log.Fatal("bad StatusCode:", resp.StatusCode, "body", string(bodyText))
    }
    var respk respKing
    err = json.Unmarshal(bodyText, &respk)
    if err != nil {
        log.Fatal(err)
    }
​
  
   for index,value := range respk.Message{
     if index == 0 {
       fmt.Println("翻译结果：")
     }
     if index == 1{
       fmt.Println("相关结果")
     }
     fmt.Println(value.Key)
     fmt.Println(value.Paraphrase)
    fmt.Println();
     
   }
}
​
func main() {
    var word string
  for{
     fmt.Scan(&word)
    if word == "quit" {
      break;
    }
    fmt.Println("彩云小译结果如下：")
​
    query(word)
    fmt.Println();
    fmt.Println();
    fmt.Println("金山翻译结果如下：")
    queryByKing(word)
    fmt.Println();
    fmt.Println();
    
  }
 
}
avatar
文章
阅读
粉丝