Go 语言入门到初步进阶

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

学习一门语言，就要从基本语法开始学习，当然，学习语言少不了动手实战！！

一、Go 语言简介

Go语言全称为Golang，是Google公司自主研发的一款开源编程语言，从2007年由Robert Griesemer, Rob Pike, Ken Thompson主持开发，并最终于2009年11月开源，在2012年早些时候发布了Go 1稳定版本。现在Go的开发已经是完全开放的，并且拥有一个活跃的社区。

由于其简洁、安全、内存管理和编译迅速等特点，Go语言现已在各个互联网公司中广泛应用。

基本用法：

1.搭载 Web 服务器

2.存储集群或类似用途的巨型中央服务器

由于其提供的海量并行的支持，Go语言运用在游戏服务器的开发中是非常合适的，现在不管是腾讯还是米哈游，在游戏服务器的开发上，都能看到Go语言的身影。

在学习之语法之前，首要任务当然是下载本地环境并且安装一个合适的IDE以供自己学习

我安装了Go1.19.5的环境,至于IDE本来我是打算采用官方的Goland,正如之前从C/C++转到Java没有继续采用Vscode而是采用了IDEA，但是由于自己的配置错误一直无法使用成功，网上教程又很少(~~我是菜鸟~~)，于是重新选择了Vscode进行学习（真香~~主要是这个确实好用hhh~~）

本地目录.png 已经讲上课的全部代码写(copy)过去了hhh~

二、 Go 的基础语法

1.Go程序基本结构

包声明
引入包
函数
变量
语句 & 表达式
注释

e.g

package main
import "fmt"
func main() {
    fmt.Println("Hello, World!")
}

1.第一行代码 package main 定义了包名。在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。

2.下一行 import fmt 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数。

3.下一行 func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。

4.下一行 fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。这一点和Java中的输出非常相似。

需要注意的是： { 不能单独放在一行！！ 否则会报错，这与C/C++、Java不同（其实在Java中也习惯了这样的格式，这样看起来舒服一丢丢 ~~bushi~~）。

2.格式化字符串

Go 语言中使用 fmt.Sprintf 或 fmt.Printf 格式化字符串并赋值给新串：

Sprintf 根据格式化参数生成格式化的字符串并返回该字符串。
Printf 根据格式化参数生成格式化的字符串并写入标准输出。

package main

import (
    "fmt" 
)

func main() {
    // %d 表示整型数字，%s 表示字符串
    var number = 123
    var name = "ysq"
    var url="%d is %s's favourate number"
    var str1 = fmt.Sprintf(url, number, name)
    fmt.Println(str1) 
}

输出结果为：123 is ysq's favourate number

3.变量声明

Go语言的变量声明有三种常用的方法：

3.1 指定变量类型，如果没有初始化，则变量默认为零值。

e.g：

package main  
import "fmt"  
func main() {  
  
    // 声明一个变量并初始化  
    var a = "ysq"  
    fmt.Println(a)  
  
    // 没有初始化就为零值  
    var b int  
    fmt.Println(b)  
  
    // bool 零值为 false  
    var c bool  
    fmt.Println(c)  
}

输出结果为：

ysq
0
false

3.2 根据值自行判定变量类型。

e.g：

package main  
import "fmt"  
func main() {  
    var d = true  
    fmt.Println(d)  
}

输出结果为：true

3.3 使用`:=`代替var

num := 1等价于

val num int
num = 1

4.Go语言常量

常量是一个简单值的标识符，在程序运行时，不会被修改的量。

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

（1）const

Go 语言中，const的用法和C++里面的差不多。

（2）iota

iota，特殊常量，可以认为是一个可以被编译器修改的常量。

iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

e.g：

package main  
  
import "fmt"  
  
func main() {  
    const (  
            a = iota   //0  
            b          //1  
            c          //2  
            d = "hh"   //独立值，iota += 1  
            e          //"hhhh"   iota += 1  
            f = 100    //iota +=1  
            g          //100  iota +=1  
            h = iota   //7,恢复计数  
            i          //8  
    )  
    fmt.Println(a,b,c,d,e,f,g,h,i)  
}

输出结果为：

0 1 2 hh hh 100 100 7 8

5.Go 语句条件语句

Go的条件语句和C++的都差不多啊，但是这里要着重看一下switch，这个和C++的有一些区别，用法要多元一些

switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加 break。

switch 默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用 fallthrough 。

6.Go 语句循环语句

Go语言的循环语句，有点像是C++和Python的结合体。

Go语言中循环语句是不带括号的，这也是Go语言比较方便的原因之一。Go语言的for循环一般来说有三种格式：

1.for init; condition; post { }

2.for condition { }

3.for { }

for循环中的range格式可以对数组、map、slice等进行迭代循环。格式如下：

for key, value := range oldMap {
    newMap[key] = value
}

如果只是想读取key值或者是value值，可以采取以下办法：

for key := range oldMap

如果是只读取value的值，则可以这样：

for _, value := range oldMap

7.Go 语言函数

Go语言的函数写法和C++的相比，主要是格式上有一些变化，然后就是可以返回多个值。

Go语言函数定义格式如下：

func function_name( [parameter list] ) [return_types] {
   函数体
}

Go 函数可以返回多个值

e.g：

package main  
  
import "fmt"  
  
func swap(x, y string) (string, string) {  
   return y, x  
}  
  
func main() {  
   a, b := swap("Google", "Baidu")  
   fmt.Println(a, b)  
}

输出结果为：Baidu Google

8.Go 语言数组

Go语言的数组声明和C++差别稍微大一些，但是应该和Python差不太多。

Go 语言数组声明需要指定元素类型及元素个数，语法格式如下：

var variable_name [SIZE] variable_type

数组初始化 e.g:

var nums = [4]float32{100.0, 23.2, 3.44, 31.0, 89.29}

如果数组长度不确定，可以使用 ... 代替数组的长度，编译器会根据元素个数自行推断数组的长度：

nums := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

如果设置了数组的长度，我们还可以通过指定下标来初始化元素：

//  将索引为 2 和 4 的元素初始化
balance := [5]float32{2:2.0,4:7.0}

9.Go 语言指针

（1）指针的定义

Go语言中指针的概念和C++的一致的，在Go语言中，指针的定义格式如下：

var var_name *var-type

e.g：

var a *int        /* 指向整型*/
var b *float32    /* 指向浮点型 */

（2）空指针

当一个指针被定义后没有分配到任何变量时，它的值为 nil nil在概念上和null、nullptr、NULL是一样的。

三、实践练习例子

学习了基本语法还需要通过练习巩固自己的学习，以下通过三个进阶小项目学习提升自己。

（1）guessing-game

这个项目就是简单的猜数字游戏，需要注意的是生成随机数的时候，要加上时间戳，这样才能使每次生成的数都是随机的。（这个跟以前学习的都十分类似，于是学习的时候没有太大压力）最终完整代码如下：

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.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
		}
	}
}

（2）simpledict

在线字典的项目，要注意的是整个抓包的过程，第一次接触的话，会比较吃力，需要考虑到很多，包括一些前后端的基本知识（所以还没办法独立完成，需要结合老师的代码 ~~我是菜鸟~~）

最终完整代码如下：

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

（3）proxy

~~这个不会，开摆 ! !~~

今后还需要好好学一下，看第一遍没完全理解，看视频涉及到计算机网络的相关知识点，今后还要多次学习这个内容。具体代码如下：

package main

import (
	"bufio"
	"context"
	"encoding/binary"
	"errors"
	"fmt"
	"io"
	"log"
	"net"
)

const socks5Ver = 0x05
const cmdBind = 0x01
const atypIPV4 = 0x01
const atypeHOST = 0x03
const atypeIPV6 = 0x04

func main() {
	server, err := net.Listen("tcp", "127.0.0.1:1080")
	if err != nil {
		panic(err)
	}
	for {
		client, err := server.Accept()
		if err != nil {
			log.Printf("Accept failed %v", err)
			continue
		}
		go process(client)
	}
}

func process(conn net.Conn) {
	defer conn.Close()
	reader := bufio.NewReader(conn)
	err := auth(reader, conn)
	if err != nil {
		log.Printf("client %v auth failed:%v", conn.RemoteAddr(), err)
		return
	}
	err = connect(reader, conn)
	if err != nil {
		log.Printf("client %v auth failed:%v", conn.RemoteAddr(), err)
		return
	}
}

func auth(reader *bufio.Reader, conn net.Conn) (err error) {
	// +----+----------+----------+
	// |VER | NMETHODS | METHODS  |
	// +----+----------+----------+
	// | 1  |    1     | 1 to 255 |
	// +----+----------+----------+
	// VER: 协议版本，socks5为0x05
	// NMETHODS: 支持认证的方法数量
	// METHODS: 对应NMETHODS，NMETHODS的值为多少，METHODS就有多少个字节。RFC预定义了一些值的含义，内容如下:
	// X’00’ NO AUTHENTICATION REQUIRED
	// X’02’ USERNAME/PASSWORD

	ver, err := reader.ReadByte()
	if err != nil {
		return fmt.Errorf("read ver failed:%w", err)
	}
	if ver != socks5Ver {
		return fmt.Errorf("not supported ver:%v", ver)
	}
	methodSize, err := reader.ReadByte()
	if err != nil {
		return fmt.Errorf("read methodSize failed:%w", err)
	}
	method := make([]byte, methodSize)
	_, err = io.ReadFull(reader, method)
	if err != nil {
		return fmt.Errorf("read method failed:%w", err)
	}

	// +----+--------+
	// |VER | METHOD |
	// +----+--------+
	// | 1  |   1    |
	// +----+--------+
	_, err = conn.Write([]byte{socks5Ver, 0x00})
	if err != nil {
		return fmt.Errorf("write failed:%w", err)
	}
	return nil
}

func connect(reader *bufio.Reader, conn net.Conn) (err error) {
	// +----+-----+-------+------+----------+----------+
	// |VER | CMD |  RSV  | ATYP | DST.ADDR | DST.PORT |
	// +----+-----+-------+------+----------+----------+
	// | 1  |  1  | X'00' |  1   | Variable |    2     |
	// +----+-----+-------+------+----------+----------+
	// VER 版本号，socks5的值为0x05
	// CMD 0x01表示CONNECT请求
	// RSV 保留字段，值为0x00
	// ATYP 目标地址类型，DST.ADDR的数据对应这个字段的类型。
	//   0x01表示IPv4地址，DST.ADDR为4个字节
	//   0x03表示域名，DST.ADDR是一个可变长度的域名
	// DST.ADDR 一个可变长度的值
	// DST.PORT 目标端口，固定2个字节

	buf := make([]byte, 4)
	_, err = io.ReadFull(reader, buf)
	if err != nil {
		return fmt.Errorf("read header failed:%w", err)
	}
	ver, cmd, atyp := buf[0], buf[1], buf[3]
	if ver != socks5Ver {
		return fmt.Errorf("not supported ver:%v", ver)
	}
	if cmd != cmdBind {
		return fmt.Errorf("not supported cmd:%v", ver)
	}
	addr := ""
	switch atyp {
	case atypIPV4:
		_, err = io.ReadFull(reader, buf)
		if err != nil {
			return fmt.Errorf("read atyp failed:%w", err)
		}
		addr = fmt.Sprintf("%d.%d.%d.%d", buf[0], buf[1], buf[2], buf[3])
	case atypeHOST:
		hostSize, err := reader.ReadByte()
		if err != nil {
			return fmt.Errorf("read hostSize failed:%w", err)
		}
		host := make([]byte, hostSize)
		_, err = io.ReadFull(reader, host)
		if err != nil {
			return fmt.Errorf("read host failed:%w", err)
		}
		addr = string(host)
	case atypeIPV6:
		return errors.New("IPv6: no supported yet")
	default:
		return errors.New("invalid atyp")
	}
	_, err = io.ReadFull(reader, buf[:2])
	if err != nil {
		return fmt.Errorf("read port failed:%w", err)
	}
	port := binary.BigEndian.Uint16(buf[:2])

	dest, err := net.Dial("tcp", fmt.Sprintf("%v:%v", addr, port))
	if err != nil {
		return fmt.Errorf("dial dst failed:%w", err)
	}
	defer dest.Close()
	log.Println("dial", addr, port)

	// +----+-----+-------+------+----------+----------+
	// |VER | REP |  RSV  | ATYP | BND.ADDR | BND.PORT |
	// +----+-----+-------+------+----------+----------+
	// | 1  |  1  | X'00' |  1   | Variable |    2     |
	// +----+-----+-------+------+----------+----------+
	// VER socks版本，这里为0x05
	// REP Relay field,内容取值如下 X’00’ succeeded
	// RSV 保留字段
	// ATYPE 地址类型
	// BND.ADDR 服务绑定的地址
	// BND.PORT 服务绑定的端口DST.PORT
	_, err = conn.Write([]byte{0x05, 0x00, 0x00, 0x01, 0, 0, 0, 0, 0, 0})
	if err != nil {
		return fmt.Errorf("write failed: %w", err)
	}
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	go func() {
		_, _ = io.Copy(dest, reader)
		cancel()
	}()
	go func() {
		_, _ = io.Copy(conn, dest)
		cancel()
	}()

	<-ctx.Done()
	return nil
}

四、课后个人总结

今天是字节青训营的day1，学了一些Go语言的基础语法，然后跟了这三个项目，明显感觉到后两个项目难度比较大，加上自己对Go语言并不熟悉，学起来会比较吃力，还要后面静下心来学慢慢体会。（好像这么多年来，每次学习一个新的语言都会被环境/IDE的配置安装给折磨痛苦，哭！！）希望今后的学习可以听+学结合起来，学会利用起论坛的各种教程，不会盲目学习，努力提升自己编码能力！

Go语言基本语法/项目实战 | 青训营笔记

Go 语言入门到初步进阶

一、Go 语言简介

基本用法：

二、 Go 的基础语法

1.Go程序基本结构

2.格式化字符串

3.变量声明

3.1 指定变量类型，如果没有初始化，则变量默认为零值。

3.2 根据值自行判定变量类型。

3.3 使用`:=`代替var

4.Go语言常量

（1）const

（2）iota

5.Go 语句条件语句

6.Go 语句循环语句

7.Go 语言函数

8.Go 语言数组

9.Go 语言指针

（1）指针的定义

（2）空指针

三、实践练习例子

（1）guessing-game

（2）simpledict

（3）proxy

四、课后个人总结

五、引用参考

Go语言基本语法/项目实战 | 青训营笔记

Go 语言入门到初步进阶

一、Go 语言简介

基本用法：

二、 Go 的基础语法

1.Go程序基本结构

2.格式化字符串

3.变量声明

3.1 指定变量类型，如果没有初始化，则变量默认为零值。

3.2 根据值自行判定变量类型。

3.3 使用:=代替var

4.Go语言常量

（1）const

（2）iota

5.Go 语句条件语句

6.Go 语句循环语句

7.Go 语言函数

8.Go 语言数组

9.Go 语言指针

（1）指针的定义

（2）空指针

三、实践练习例子

（1）guessing-game

（2）simpledict

（3）proxy

四、课后个人总结

五、引用参考

3.3 使用`:=`代替var