这是我参与「第五届青训营 」伴学笔记创作活动的第 1 天

Go语言

1.背景

Go语言作为服务器编程语言：适合处理日志、数据打包、虚拟机处理、文件系统、分布式系统、数据库代理等

网络编程方面：广泛应用web应用、api应用、下载应用等

其他方面：内存数据库、云平台等领域

1.1. go语言安装

官网：go.dev/dl/

下载go中文网站：studygolang.com/dl

测试安装成功：

配置环境变量：

环境变量GOROOT和（GOPATH：用来放项目代码）：

查看命令：go env

如果没生效，将用户变量也修改

1.2. 开发工具

下载地址：www.jetbrains.com/go/download…

1.3.Hello World

package main //有且仅有一个main包
​
import "fmt"
​
func main() {
    fmt.Println("Hello World")
}

2.基础语法

2.1.变量

package main
​
import "fmt"
​
func main() {
    var name string = "liuxiang" //关键字 var
​
    var age int = 18
    name = "zhangsan"
    fmt.Print(name,age)
}
​
//定义多个变量
​
package main
import "fmt"
func main() {
    var (
        name    string
        age     int
        address string
    )
    name = "liuxiang"  //赋值
    age = 25
    address = "zhongguo"
    /*
    string默认值：空
    int默认值：0
    浮点默认值：0.0
    布尔值默认值：false
     */
    fmt.Print(name, age, address)
}
//赋值
    name := "liuxiang" //自动推导赋值 不需定义 左边需要是新变量
    age := 16
​
    fmt.Println(name, age)
    fmt.Printf("%T,%T", name, age) //输出变量类型
//地址
    var age int
    age = 16
    fmt.Printf("num:%d,内存地址:%p", age, &age) //取地址符号

2.2 变量变换

func main() {
    var a int = 100
    var b int = 200
    b, a = a, b //go语言交换变量的值
    fmt.Println(a, b)
}

2.3 匿名变量

func test() (int, int) {
    return 100, 200
}
​
func main() {
    a, _ := test() //废弃b 不用b的值
    fmt.Println(a)
}

2.4 变量的作用域

package main
​
import "fmt"
​
// 全局变量
var name string = "xxx"
​
func main() {
    //局部变量
    var name string = "liuxiang"
    var age int = 17
    fmt.Println(name, age)
    aa()
}
func aa() {
    fmt.Println(name)
}
​

2.5 常量

数据类型：布尔型、数字型（整数）

func main() {
    const URL string = "www.baidu.com"
    const URL2 = "1213213"
    const a, b, c = 3.15, "liuxiang", "www.1231.com"
    fmt.Printf(URL)
    fmt.Printf(URL2)
    fmt.Println(a, b, c)
}

2.6 iota 特殊常量

package main
​
import "fmt"
​
func main() {
    const (
        a = iota //0
        b //1
        c //2
        d = "xx" //xx iota 3
        e //xx iota 4
        f = 100 //100 iota 5
        g //100 ipta 6
        h = iota //iota 7
        i // iota 8
    )
    const(
        x = iota //新计数
        y
    )
    fmt.Println(a, b, c, d, e, f, g, h, i)
}
​

3. 基本数据类型

Go是静态类型的编程语言，数据类型用于声明函数和变量。

3.1布尔型

默认值是false

func main() {
    var xx bool = true
    fmt.Println(xx)
    fmt.Printf("%T,%t\n", xx, xx) //bool,true %v可以输出所有形式
}

3.2 数值型

func main() {
    var age int = 16
    fmt.Printf("%T,%d\n", age, age)
    var money float32 = 120.14 
    //默认是6位小数打印
    fmt.Printf("%T,%f\n", money, money)
    fmt.Printf("%T,%f.1\n", money, money) //保留1位
}

序号	类型和描述
1	uint8 无符号8位整型(0-255)
2	uint16 无符号16位整型(0-65535)
3	uint32 无符号31位整型(0-4294967295)
4	uint64 无符号64位整型
5	int8 有符号8位整型(-128-127)
6	int16 有符号16位整型(-32768-32767)
7	int32 有符号32位整型(-22147483648-2147483647)
8	int63 有符号64位整型

类型的别名

byte	uint8
rune	int32
int	int64

3.3 字符与字符串

func main() {
    var str string = "hello liuxiang"
    fmt.Printf("%T,%s\n", str, str) //%s是输出字符串
    //单引号
    v1 := 'A'
    v2 := '中'
    //全世界的编码表：Unicode编码表
    fmt.Printf("%T,%d\n", v1, v1) //int32 65 ascII编码表
    fmt.Printf("%T,%d\n", v2, v2) //中文表 GBK int32
    //字符串拼接
    fmt.Println("hello" + ",xxx")
    //转义字符 \
    fmt.Println("hello"xxx")
    //制表符 \t 4个字符
    fmt.Println("hello\txxxx")
}s

3.4 数据类型转换

func main() {
    a := 5   //默认是int
    b := 5.0 //float64
    fmt.Printf("%T\n", a)
    fmt.Printf("%T\n", b)
    c := float64(a) //类型转换
    fmt.Printf("%T\n", c)
    d := int(b)
    fmt.Printf("%T\n", d)
    //整型不能转换为bool类型
}

4.运算符

4.1算术运算符

+（加）,-（减）,*（乘）,/（除）,%（取余）,++（自增）,--（自减）

func main() {
    var a int = 2
    var b int = 6
​
    fmt.Println(a + b)
    fmt.Println(a - b)
    fmt.Println(a * b)
    fmt.Println(a / b)
    fmt.Println(a % b)
    a++
    fmt.Println(a)
}

4.2关系运算符

==(相等),!=（不等）,>（大于）,<（小于）,>=（大于等于）,<=（小于等于）

func main() {
    var a int = 2
    var b int = 6
​
    fmt.Println(a == b) // = 是赋值运算
    fmt.Println(a < b)
    fmt.Println(a != b)
    fmt.Println(a <= b)
    fmt.Println(a >= b)
}

4.3逻辑运算符

&&(逻辑真)，||（有一个为真即为真），！（逻辑非）

func main() {
    var a bool = true
    var b bool = false
    fmt.Println(a && b)
    fmt.Println(a || b)
    fmt.Println(!a)
}

4.4位运算符

针对二进制

&(全1为1)，|（有1为1），^(不同为1，相同为0），>>(右移)，>>（左移）

func main() {
    var a uint = 60 //0011 1100
    var b uint = 13 //0000 1101
    //位运算
    fmt.Printf("%T,%b\n", a&b, a&b)
    fmt.Printf("%T,%b\n", a|b, a|b)
    fmt.Printf("%T,%b\n", a^b, a^b)
    fmt.Printf("%T,%b\n", a>>2, a>>2) //右移
    fmt.Printf("%T,%b\n", a<<2, a<<2) //左移
}

4.5赋值运算符

=，+=（相加后再赋值）,-=(相减后再赋值),*=（相乘后再赋值）,>>=（右移后再赋值),&=(按位与后再赋值)，^=(按位异或后再赋值)，|=（按位或后赋值）

func main() {
    var a uint = 60 //0011 1100
    var b uint = 13 //0000 1101
    a += a
    fmt.Printf("%T,%d\n", a, a)
    b -= b
    fmt.Printf("%T,%d\n", b, b)
​
}

4.6 键盘输入

func main() {
    var x int
    var y float64
    fmt.Println("请输入两个数 整数 浮点数：")
    //fmt.Scan()         //接收输入
    //fmt.Scanf()        //接收输入 格式化输入
    fmt.Scanln(&x, &y) //接收输入
    fmt.Println("x,y", x, y)
}

5.流程控制

顺序结构：从上到下

选择结构：条件满足才执行

• if
• switch
• select

循环结构：条件满足代码反复执行0-N次

• for

func main() {
    var a int = 91
    if a > 0 && a < 60 {
        fmt.Println("hhhh")
    } else if a > 70 && a < 90 {
        fmt.Println("yyyy")
    } else {
        fmt.Println("kkkk")
    }
}

func main() {
​
    if 7%2 == 0 {
        fmt.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 digit")
    } else {
        fmt.Println(num, "has multiple digits")
    }
}

func main() {
​
    i := 1
    for {
        fmt.Println("loop")
        break
    }
    for j := 7; j < 9; j++ {
        fmt.Println(j)
    }
    
    for n := 0; n < 5; n++ {
        if n%2 == 0 { //0 2 4
            continue
        }
        fmt.Println(n) //1 3
    }
    for i <= 3 {
        fmt.Println(i)
        i = i + 1
    }
}

switch

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:
        fmt.Println("It's before noon")
    default:
        fmt.Println("It's after noon", t)
    }
}

6.标准库

数组

func main() {
​
    var a [5]int
    a[4] = 100
    fmt.Println("get:", a[2])
    fmt.Println("len:", len(a))
​
    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)
}

切片slice

可变长度的数组：使用make命令

func main() {
​
    s := make([]string, 3)
    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("get:", s[2])   // c
    fmt.Println("len:", len(s)) // 3
​
    s = append(s, "d") //追加元素
    s = append(s, "e", "f")
    fmt.Println(s) // [a b c d e f]
​
    c := make([]string, len(s)) //指定长度
    copy(c, s)
    fmt.Println(c) // [a b c d e f]
​
    fmt.Println(s[2:5]) // [c d e] 不包括第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) // [g o o d]
}

map

func main() {
    m := make(map[string]int) //k：string v：int
    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是判断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

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 {
        fmt.Println(k, v) // b 8; a A
    }
    for k := range m {
        fmt.Println("key", k) // key a; key b
    }
}

函数

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] //ok代表返回的错误信息
    return v, ok
}
​
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
}

指针

作用：对常用的参数进行修改

func add2(n int) { //传入的是拷贝 对拷贝相加无效
    n += 2 //n = n+2
}
​
func add2ptr(n *int) { //写成指针类型 *
    *n += 2
}
​
func main() {
    n := 5
    add2(n)
    fmt.Println(n) // 5
    add2ptr(&n)
    fmt.Println(n) // 7
}

结构体

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"
​
    fmt.Println(a, b, c, d)                 // {wang 1024} {wang 1024} {wang 1024} {wang 1024}
    fmt.Println(checkPassword(a, "haha"))   // false
    fmt.Println(checkPassword2(&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
}

结构体方法

可以使用对象.调用方法

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
}

错误处理

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 != nil {
        fmt.Println(err) // not found
        return
    } else {
        fmt.Println(u.name)
    }
}

字符串string

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
}

json处理

结构体的每个字段的第一个字母大写即可用json.Marshal()序列化成数组

package main
​
import (
    "encoding/json"
    "fmt"
)
​
type userInfo struct {
    Name  string
    Age   int `json:"age"` //给一个tag变成小写
    Hobby []string
}
​
func main() {
    a := userInfo{Name: "wang", Age: 18, Hobby: []string{"Golang", "TypeScript"}}
    buf, err := json.Marshal(a)
    if err != nil {
        panic(err)
    }
    fmt.Println(buf)         // [123 34 78 97...]
    fmt.Println(string(buf)) // {"Name":"wang","age":18,"Hobby":["Golang","TypeScript"]}
​
    buf, err = json.MarshalIndent(a, "", "\t")
    if err != nil {
        panic(err)
    }
    fmt.Println(string(buf))
​
    var b userInfo
    err = json.Unmarshal(buf, &b)
    if err != nil {
        panic(err)
    }
    fmt.Printf("%#v\n", b) // main.userInfo{Name:"wang", Age:18, Hobby:[]string{"Golang", "TypeScript"}}
}
​

时间

func main() {
    now := time.Now()
    fmt.Println(now) // 2022-03-27 18:04:59.433297 +0800 CST m=+0.000087933
    t := time.Date(2022, 3, 27, 1, 25, 36, 0, time.UTC)
    t2 := time.Date(2022, 3, 27, 2, 30, 36, 0, time.UTC)
    fmt.Println(t)                                                  // 2022-03-27 01:25:36 +0000 UTC
    fmt.Println(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute()) // 2022 March 27 1 25
    fmt.Println(t.Format("2006-01-02 15:04:05"))                    // 2022-03-27 01:25:36
    diff := t2.Sub(t) //取时间差
    fmt.Println(diff)                           // 1h5m0s
    fmt.Println(diff.Minutes(), diff.Seconds()) // 65 3900
    t3, err := time.Parse("2006-01-02 15:04:05", "2022-03-27 01:25:36")
    if err != nil {
        panic(err)
    }
    fmt.Println(t3 == t)    // true
    fmt.Println(now.Unix()) // 1648738080
}

字符串和数字之前的转换

import (
    "fmt"
    "strconv"
)
​
func main() {
    f, _ := strconv.ParseFloat("1.234", 64)
    fmt.Println(f) // 1.234
​
    n, _ := strconv.ParseInt("111", 10, 64)
    fmt.Println(n) // 111
​
    n, _ = strconv.ParseInt("0x1000", 0, 64) //字符串 进制 64位精度整数
    fmt.Println(n)                           // 4096
​
    n2, _ := strconv.Atoi("123") //转换成数字
    fmt.Println(n2) // 123
​
    n2, err := strconv.Atoi("AAA")
    fmt.Println(n2, err) // 0 strconv.Atoi: parsing "AAA": invalid syntax
}

进程信息

func main() {
    // go run example/20-env/main.go a b c d
    fmt.Println(os.Args)           // [/var/folders/8p/n34xxfnx38dg8bv_x8l62t_m0000gn/T/go-build3406981276/b001/exe/main a b c d]
    fmt.Println(os.Getenv("PATH")) // /usr/local/go/bin...
    fmt.Println(os.Setenv("AA", "BB"))
​
    buf, err := exec.Command("grep", "127.0.0.1", "/etc/hosts").CombinedOutput()
    if err != nil {
        panic(err)
    }
    fmt.Println(string(buf)) // 127.0.0.1       localhost
}

7.猜数字游戏

1.随机生成一个数字

func main() {
    maxNum := 100
    secretNumber := rand.Intn(maxNum)
    fmt.Println("The secret number is ", secretNumber)
}

2.用时间戳初始化随机数种子

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

3.读取用户输入

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.Println("Please input your guess")
    reader := bufio.NewReader(os.Stdin) //输入流
    input, err := reader.ReadString('\n') //读取一行输入
    if err != nil {
        fmt.Println("An error occured while reading input. Please try again", err)
        return
    }
    input = strings.Trim(input, "\r\n") //去掉换行符
​
    guess, err := strconv.Atoi(input) //转换成数字
    if err != nil {
        fmt.Println("Invalid input. Please enter an integer value")
        return
    }
    fmt.Println("You 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!")
    }
}

4.实现游戏循环

func main() {
    maxNum := 100
    rand.Seed(time.Now().UnixNano())
    secretNumber := rand.Intn(maxNum)
​
    fmt.Println("Please input your guess")
    reader := bufio.NewReader(os.Stdin)
    for {
        input, err := reader.ReadString('\n')
        if err != nil {
            fmt.Println("An error occured while reading input. Please try again", err)
            continue
        }
        input = strings.Trim(input, "\r\n")
​
        guess, err := strconv.Atoi(input)
        if err != nil {
            fmt.Println("Invalid input. Please enter an integer value")
            continue
        }
        fmt.Println("You 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
        }
    }
}

5.用键盘输入实现

func main() {
    var input int
    maxNum := 100
    rand.Seed(time.Now().UnixNano())
    secretNumber := rand.Intn(maxNum)
​
    fmt.Println("Please input your guess")
    for {
        fmt.Scanln(&input)
        fmt.Println("You guess is", input)
        if input > secretNumber {
            fmt.Println("Your guess is bigger than the secret number. Please try again")
        } else if input < secretNumber {
            fmt.Println("Your guess is smaller than the secret number. Please try again")
        } else {
            fmt.Println("Correct, you Legend!")
            break
        }
    }
}

8.在线词典

(curlconverter.com/go/) 将curl转换为go语言

(oktools.net/json2go) json转go生成对应结构体工具

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)
    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)
}
​