备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

go 语言实战入门案例之命令行排版词典

2023-08-03 50
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： go 语言实战入门案例之命令行排版词典

文章和代码已经归档至【Github仓库：https://github.com/timerring/backend-tutorial 】或者公众号【AIShareLab】回复 go 也可获取。

命令行排版的词典

先看一下用到的 API ，以彩云科技提供的在线翻译为例。请打开彩云翻译的网页，然后右键检查打开浏览器的开发者工具。

此时我们点一下翻译按钮，浏览器会发送一系列请求，我们能很轻松地找到那个用来查询单词的请求。这是一个 HTTP 的 post 的请求。

请求头是一个 json 里面有两个字段，一个是代表你要你是从什么语言转化成什么语言， source 就是你要查询的单词。

API 的返回结果里面会有 Wiki 和 dictionary 两个字段。我们需要用的结果主要在dictionary.Explanations 字段里面。其他有些字段里面还包括音标等信息。

我们需要在 Golang 里面去发送这个请求。因为这个请求比较复杂，用代码构造很麻烦，实际上我们有一种非常简单的方式来生成代码，我们可以右键浏览器里面的 copy as curl。

copy 完成之后大家可以在终端粘贴一下 curl 命令，应该可以成功返回一大串 json。

然后打开一个代码转换网站： https://curlconverter.com/go/ 粘贴该 curl 请求，在右边的语言里面选 Golang 就能够看到一串很长的代码，我们直接把它 copy 到我们的编辑器里面。有几个 header 比较复杂，生成代码有转义导致的编译错误，删掉这几行即可。

我们来看一下这生成的代码。

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "strings"
)

func main() {
   
   
    // 首先我们创建了一个 HTTP client，创建的时候可以指定很多参数，包括比如请求的超时是否使用 cookie 等。
    client := &http.Client{
   
   }
    // 我们用了 strings.NewReader 来把字符串转换成一个流。这样我们就成功构造了一个 HTTP request
    var data = strings.NewReader(`{"trans_type":"en2zh","source":"good"}`)
    // 接下来是构造一个 HTTP 请求，这是一个 post 请求，然后会用到 HTTP.NewRequest  ，第一个参数是 http 方法 POST，第二个参数是 URL，最后一个参数是 body ，body 因为可能很大，为了支持流式发送，是一个只读流。
    req, err := http.NewRequest("POST", "https://api.interpreter.caiyunai.com/v1/dict", data)
    if err != nil {
   
   
        log.Fatal(err)
    }
    // 接下来我们需要对这个 HTTP request 来设置一堆 header。
    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")
    // 接下来我们把我们调用 client.do request ，就能得到 response
    resp, err := client.Do(req)
    // 如果请求失败的话，那么这个 error 会返回非 nil，会打印错误并且退出进程
    if err != nil {
   
   
        log.Fatal(err)
    }
    // 在golang里面，为了避免资源泄露，你需要加一个 defer 来手动关闭这个流，这个 defer 会在这个函数运行结束之后去执行。
    defer resp.Body.Close()
    // 接下来我们是用 ioutil.ReadAll 来读取这个流，能得到整个body。我们再用 print 打印出来。
    bodyText, err := ioutil.ReadAll(resp.Body)
    if err != nil {
   
   
        log.Fatal(err)
    }
    fmt.Printf("%s\n", bodyText)
}

首先第 12 行我们创建了一个 HTTP client，创建的时候可以指定很多参数，包括比如请求的超时是否使用 cookie 等。接下来是构造一个 HTTP 请求，这是一个 post 请求，然后会用到 HTTP .NewRequest ，第一个参数是 http 方法 POST，第二个参数是 URL，最后一个参数是 body ，body 因为可能很大，为了支持流式发送，是一个只读流。我们用了 strings. NewReader 来把字符串转换成一个流。这样我们就成功构造了一个 HTTP request ，接下来我们需要对这个 HTTP request 来设置一堆 header。接下来我们把我们调用 client. Do request ，就能得到 response 如果请求失败的话，那么这个 error 会返回非 nil，会打印错误并且退出进程。Response 有它的 HTTP 状态码， response header 和 body。 Body 同样是一个流，在 golang 里面，为了避免资源泄露，你需要加一个 defer 来手动关闭这个流，这个 defer 会在这个函数运行结束之后去执行。接下来我们是用 ioutil. ReadAll 来读取这个流，能得到整个 body。我们再用 print 打印出来。

我们来运行生成的代码，能看到我们已经能够成功地发出请求，把返回的 JSON 打印出来。但是现在那个输入是固定的，我们是要从一个变量来输入，我们需要用到 JSON 序列化。

生成 request body

在 Golang 里面。我们需要生成一段 JSON ，常用的方式是我们先构造出来一个结构体，这个结构体和我们需要生成的 JSON 的结构是一一对应的

在这个case里面， 这个结构体会是这样子的，包含三个字段。我们再来定义一个变量，初始化每个结构体成员，再调用 JSON.marshaler 来得到这个序列化之后的字符串。
不同于之前这里是个字符串，我们这里是个字节数组。所以我们把 strings.newReader 改成 bytes 点 new ready 然后来构造那个 request 上的 body 接下来代码不变。然后我们就能成功地进入一个变量来发送 HTTP 请求。

这一步完成之后，可以再执行一遍，应该结果是完全不变的。

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
)
// 在这个case里面， 这个结构体会是这样子的，包含三个字段。再来定义一个变量，初始化每个结构体成员。
type DictRequest struct {
   
   
    TransType string `json:"trans_type"`
    Source    string `json:"source"`
    UserID    string `json:"user_id"`
}

func main() {
   
   
    client := &http.Client{
   
   }
    request := DictRequest{
   
   TransType: "en2zh", Source: "good"}
    // 再调用 `JSON.marshaler` 来得到这个序列化之后的字符串
    buf, err := json.Marshal(request)
    if err != nil {
   
   
        log.Fatal(err)
    }
    // 不同于之前这里是个字符串，我们这里是个字节数组，把 strings.newReader 改成 bytes.NewReader 然后来构造那个 request 上的 body 接下来代码不变
    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 := ioutil.ReadAll(resp.Body)
    if err != nil {
   
   
        log.Fatal(err)
    }
    fmt.Printf("%s\n", bodyText)
}

解析 response body

接下来我们要做的是把这个 response body 来解析出来。在 js/Python 这些脚本语言里面，body 是一个字典或者 map 的结构， 可以直接从里面取值。 但是golang是个强类型语言，这种做法并不是最佳实践。

更常用的方式是和 request 的一样，写一个结构体，把返回的 JSON 反序列化到结构体里面。但是我们在浏览器里面可以看到这个 API 返回的结构非常复杂，如果要一一定义结构体字段，非常繁琐并且容易出错。

此时有一个小技巧的是，网上有对应的代码生成工具，我们可以打开如下网站，把 json 字符串粘贴进去，这样我们就能够生成对应结构体。

https://oktools.net/json2go

在某些时刻，我们如果不需要对这个返回结果，做很多精细的操作，我们可以选择转换嵌套，能让生成的代码更加紧凑。

package main

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

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 main() {
   
   
    client := &http.Client{
   
   }
    request := DictRequest{
   
   TransType: "en2zh", Source: "good"}
    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 := ioutil.ReadAll(resp.Body)
    if err != nil {
   
   
        log.Fatal(err)
    }
    // 先定一个 response 结构体的对象
    var dictResponse DictResponse
    // 用 JSON.unmarshal 把 body 反序列化到 这个结构体里面，再试图打印出来，注意这里要用&
    err = json.Unmarshal(bodyText, &dictResponse)
    if err != nil {
   
   
        log.Fatal(err)
    }
    // 这里打印的时候使用了 `%#v` ，这样可以让打印出来的结果比较容易读
    fmt.Printf("%#v\n", dictResponse)
}

这样就得到了一个 response 结构体。接下来修改代码，先定一个 response 结构体的对象，然后用 JSON.unmarshal 把 body 反序列化到这个结构体里面，再试图打印出来。现在再运行一下，这里打印的时候使用了 %#v ，这样可以让打印出来的结果比较容易读。我们现在离最终版本已经很近了，接下来我们需要修改代码为打印 response 里面的特定字段。

打印结果

观察那个网页的 json 可以看出我们需要的结果是在 Dictionary.explanations. 我们用 for range 循环来迭代它，然后直接打印结构，参照一些词典的显示方式，我们可以在那个前面打印出这个单词和它的音标。这里有英式音标和美式音标。同时加一个 StatusCode 的反馈，否则如果出错的话，底下反序列化解析出来的就是空，不方便排查问题。

结构完善

把代码的主体改成一个 query 函数，查询的单词作为参数传递进来。然后我们写一个简单的 main 函数，这个 main 函数首先判断一下命令和参数的个数，如果它不是两个，那么我们就打印出错误信息，退出程序。 否则就获取到用户输入的单词，然后执行 query 函数。



完整代码如下所示：

package main

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

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{
   
   }
    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 := ioutil.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)
    // 观察那个网页的 json 可以看出我们需要的结果是在 Dictionary.explanations. 我们用 for range 循环来迭代它，然后直接打印结构
    for _, item := range dictResponse.Dictionary.Explanations {
   
   
        fmt.Println(item)
    }
}

func main() {
   
   
    if len(os.Args) != 2 {
   
   
        fmt.Fprintf(os.Stderr, `usage: simpleDict WORD
example: simpleDict hello
        `)
        os.Exit(1)
    }
    word := os.Args[1]
    query(word)
}

参考：字节内部课 Go 语言原理与实践

文章标签：
云数据库 ClickHouse
JavaScript
Python
Go
自然语言处理
API
数据格式
开发者
JSON
关键词：
Go语言
Go入门
Go实战
Go案例
Go实战案例
timerring
目录
相关文章
牵着猫散步的鼠鼠
|
2天前
|
人工智能 Go 调度
掌握Go并发：Go语言并发编程深度解析
掌握Go并发：Go语言并发编程深度解析
牵着猫散步的鼠鼠
16 2
奔跑的数据
|
6天前
|
数据采集 存储 Go
使用Go语言和chromedp库下载Instagram图片：简易指南
Go语言爬虫示例使用chromedp库下载Instagram图片，关键步骤包括设置代理IP、创建带代理的浏览器上下文及执行任务，如导航至用户页面、截图并存储图片。代码中新增`analyzeAndStoreImage`函数对图片进行分析和分类后存储。注意Instagram的反爬策略可能需要代码适时调整。
奔跑的数据
30 1
使用Go语言和chromedp库下载Instagram图片：简易指南
长梦
|
2天前
|
Go 开发者
Golang深入浅出之-Go语言上下文（context）包：处理取消与超时
【4月更文挑战第23天】Go语言的`context`包提供`Context`接口用于处理任务取消、超时和截止日期。通过传递`Context`对象，开发者能轻松实现复杂控制流。本文解析`context`包特性，讨论常见问题和解决方案，并给出代码示例。关键点包括：1) 确保将`Context`传递给所有相关任务；2) 根据需求选择适当的`Context`创建函数；3) 定期检查`Done()`通道以响应取消请求。正确使用`context`包能提升Go程序的控制流管理效率。
长梦
7 1
长梦
|
2天前
|
安全 Go 开发者
Golang深入浅出之-Go语言并发编程面试：Goroutine简介与创建
【4月更文挑战第22天】Go语言的Goroutine是其并发模型的核心，是一种轻量级线程，能低成本创建和销毁，支持并发和并行执行。创建Goroutine使用`go`关键字，如`go sayHello("Alice")`。常见问题包括忘记使用`go`关键字、不正确处理通道同步和关闭、以及Goroutine泄漏。解决方法包括确保使用`go`启动函数、在发送完数据后关闭通道、设置Goroutine退出条件。理解并掌握这些能帮助开发者编写高效、安全的并发程序。
长梦
13 1
牵着猫散步的鼠鼠
|
2天前
|
SQL 关系型数据库 MySQL
Golang数据库编程详解 | 深入浅出Go语言原生数据库编程
Golang数据库编程详解 | 深入浅出Go语言原生数据库编程
牵着猫散步的鼠鼠
7 1
长梦
|
3天前
|
Go 开发者
Golang深入浅出之-Go语言流程控制：if、switch、for循环详解
【4月更文挑战第21天】本文介绍了Go语言中的流程控制语句，包括`if`、`switch`和`for`循环。`if`语句支持简洁的语法和初始化语句，但需注意比较运算符的使用。`switch`语句提供多分支匹配，可省略`break`，同时支持不带表达式的形式。`for`循环有多种形式，如基本循环和`for-range`遍历，遍历时修改原集合可能导致未定义行为。理解并避免易错点能提高代码质量和稳定性。通过实践代码示例，可以更好地掌握Go语言的流程控制。
长梦
11 3
Golang深入浅出之-Go语言流程控制：if、switch、for循环详解
长梦
|
3天前
|
Go
Golang深入浅出之-Go语言函数基础：定义、调用与多返回值
【4月更文挑战第21天】Go语言函数是代码组织的基本单元，用于封装可重用逻辑。本文介绍了函数定义（包括基本形式、命名、参数列表和多返回值）、调用以及匿名函数与闭包。在函数定义时，注意参数命名和注释，避免参数顺序混淆。在调用时，要检查并处理多返回值中的错误。理解闭包原理，小心处理外部变量引用，以提升代码质量和可维护性。通过实践和示例，能更好地掌握Go语言函数。
长梦
18 1
Golang深入浅出之-Go语言函数基础：定义、调用与多返回值
杭电码农-NEO
|
4天前
|
程序员 Go API
【Go语言快速上手(二)】 分支与循环&函数讲解
【Go语言快速上手(二)】 分支与循环&函数讲解
杭电码农-NEO
24 5
长梦
|
4天前
|
Go
Golang深入浅出之-Go语言基础语法：变量声明与赋值
【4月更文挑战第20天】本文介绍了Go语言中变量声明与赋值的基础知识，包括使用`var`关键字和简短声明`:=`的方式，以及多变量声明与赋值。强调了变量作用域、遮蔽、初始化与零值的重要性，并提醒读者注意类型推断时的一致性。了解这些概念有助于避免常见错误，提高编程技能和面试表现。
长梦
19 0
HannYang
|
4天前
|
编译器 Go 开发者
Go语言入门｜包、关键字和标识符
Go语言入门｜包、关键字和标识符
HannYang
22 0

热门文章

最新文章

  • 1
    开发语言详解（python、java、Go(Golong)。。。。）
  • 2
    《Go 简易速速上手小册》第10章：微服务与云原生应用（2024 最新版）（下）
  • 3
    掌握Go语言：Go语言中的字典魔法，高效数据检索与应用实例解析（18）
  • 4
    踏入网页抓取的旅程：使用 grequests 构建 Go 视频下载器
  • 5
    《Go 简易速速上手小册》第6章：错误处理和测试（2024 最新版）（上）
  • 6
    go语言基础语法
  • 7
    推荐一款go语言的开源物联网框架-opengw
  • 8
    Sublime Text 3配置Go语言开发环境
  • 9
    《Go 简易速速上手小册》第1章：Go 语言基础（2024 最新版）（上）
  • 10
    掌握Go语言：精通Go语言范围（range），高级应用及进销存系统实战（25）
  • 1
    什么是协程（Goroutine）？探索Go语言并发的奇妙世界
    33
  • 2
    Go语言中如何判断map中是否包含某个key？
    52
  • 3
    Go语言中tag的用处及详细介绍
    36
  • 4
    Go语言中的int和int32：同一个概念吗？
    64
  • 5
    Go语言的接口比较：两个interface能否比较？
    88
  • 6
    Go语言GC(垃圾回收)的工作原理
    28
  • 7
    Go语言协程泄漏(Goroutine Leak)：原因和解决方案
    56
  • 8
    Go面向对象是如何实现的？
    31
  • 9
    Go中的GMP状态详解
    31
  • 10
    Go语言在身份认证与访问控制中的应用
    323

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法
  • Go语言核心编程 - 基础语法、数组、切片、Map
  • Go语言核心编程 - 面向对象、文件、单元测试、反射、TCP编程
  • Go语言完全自学手册图文教程
  • Python语言基础 - 语法入门
  • Python基础快速入门实战教程

    • 相关电子书

    更多
  • Go语言路上踩过的坑
  • gohbase ：HBase go客户端
  • Go构建日请求千亿级微服务实践

    • 相关实验场景

    更多
  • 语言入门-1：环境构建
  • 云端Python及基本操作
  • Python网络通信程序典型应用
  • 实验手册指导文档
  • Python新手入门
  • Python入门
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）