@

基礎(chǔ)標(biāo)準(zhǔn)庫

簡述

Go語言的標(biāo)準(zhǔn)庫覆蓋網(wǎng)絡(luò)、系統(tǒng)、加密、編碼、圖形等各個(gè)方面，可以直接使用標(biāo)準(zhǔn)庫的 http 包進(jìn)行 HTTP 協(xié)議的收發(fā)處理；網(wǎng)絡(luò)庫基于高性能的操作系統(tǒng)通信模型（Linux 的 epoll、Windows 的 IOCP）；所有的加密、編碼都內(nèi)建支持，無需要再從第三方開發(fā)者處獲??；Go 語言的編譯器也是標(biāo)準(zhǔn)庫的一部分，通過詞法器掃描源碼，使用語法樹獲得源碼邏輯分支等；Go 語言的周邊工具也是建立在這些標(biāo)準(zhǔn)庫上。在標(biāo)準(zhǔn)庫上可以完成幾乎大部分的需求，Go 語言的標(biāo)準(zhǔn)庫以包的方式提供支持，下表是 Go 語言標(biāo)準(zhǔn)庫中常見的包及其功能。

字符串-string

底層結(jié)構(gòu)

標(biāo)準(zhǔn)庫的strings包提供了許多有用的與字符串相關(guān)的函數(shù)。Go字符串底層的數(shù)據(jù)結(jié)構(gòu)在runtime/strings.go中定義如下:

從上面的stringStruct結(jié)構(gòu)體得知其包含兩個(gè)字段，一個(gè)是8個(gè)字節(jié)的萬能指針，指向一個(gè)數(shù)組，數(shù)組里面存儲就是實(shí)際的字符，另一個(gè)則是一個(gè)8個(gè)字節(jié)表示其長度，因此不管anyStrings多長通過unsafe.Sizeof("anyStrings")最終獲取大小都是固定的16個(gè)字節(jié)。

函數(shù)

下面是一些常見函數(shù)舉例，可以到strings包文檔中找到更多的函數(shù)

package main

import (
	"fmt"
	s "strings"
	"unsafe"
)

var p = fmt.Println

func main() {
	p(unsafe.Sizeof("anyStrings"))
	p(unsafe.Sizeof("anyStringsMoreThenLength"))
	p("Contains:  ", s.Contains("test", "es"))
	p("Count:     ", s.Count("test", "t"))
	p("HasPrefix: ", s.HasPrefix("test", "te"))
	p("HasSuffix: ", s.HasSuffix("test", "st"))
	p("Index:     ", s.Index("test", "e"))
	p("Join:      ", s.Join([]string{"a", "b"}, "-"))
	p("Repeat:    ", s.Repeat("a", 5))
	p("Replace:   ", s.Replace("foo", "o", "0", -1))
	p("Replace:   ", s.Replace("foo", "o", "0", 1))
	p("Split:     ", s.Split("a-b-c-d-e", "-"))
	p("ToLower:   ", s.ToLower("TEST"))
	p("ToUpper:   ", s.ToUpper("test"))
}

長度

• Go 語言的內(nèi)建函數(shù) len()，可以用來獲取切片、字符串、通道（channel）等的長度，
• Go 語言的字符串都以 UTF-8 格式保存，每個(gè)中文占用 3 個(gè)字節(jié)，因此使用 len() 獲得兩個(gè)中文文字對應(yīng)的 6 個(gè)字節(jié)；
• 針對ASCII 字符串長度使用 len() 函數(shù)，Unicode 字符串長度使用 utf8.RuneCountInString() 函數(shù)。如果沒有使用 Unicode，漢字則顯示為亂碼。
• ASCII 字符串遍歷直接使用下標(biāo)；Unicode 字符串遍歷用 for range。
• bytes.Buffer實(shí)現(xiàn)字符串拼接。

package main

import (
	"bytes"
	"fmt"
	"unicode/utf8"
)

var p = fmt.Println

func main() {
	str1 := "Hello World!"
	str2 := "你好"
	fmt.Println(len(str1))                          // 12
	fmt.Println(len(str2))                          // 6
	fmt.Println(utf8.RuneCountInString(str2))       // 2
	fmt.Println(utf8.RuneCountInString("你好,world")) // 8

	// 聲明字節(jié)緩沖
	var stringBuilder bytes.Buffer
	// 把字符串寫入緩沖
	stringBuilder.WriteString(str1)
	stringBuilder.WriteString(str2)
	// 將緩沖以字符串形式輸出
	fmt.Println(stringBuilder.String())

	theme := "狙擊 start"
	for i := 0; i < len(theme); i++ {
		fmt.Printf("ascii: %c  %d\n", theme[i], theme[i])
	}

	for _, s := range theme {
		fmt.Printf("Unicode: %c  %d\n", s, s)
	}
}

格式化輸出

Go為傳統(tǒng)的printf字符串格式化提供了很好的支持，Go提供了若干個(gè)打印“動詞”，用于格式化一般Go值，下面是一些常見的字符串格式化任務(wù)的示例。

package main

import (
	"fmt"
	"os"
)

type point struct {
	x, y int
}

func main() {

	p := point{1, 2}
	fmt.Printf("struct1: %v\n", p)

	fmt.Printf("struct2: %+v\n", p)

	fmt.Printf("struct3: %#v\n", p)

	fmt.Printf("type: %T\n", p)

	fmt.Printf("bool: %t\n", true)

	fmt.Printf("int: %d\n", 123)

	fmt.Printf("bin: %b\n", 14)

	fmt.Printf("char: %c\n", 33)

	fmt.Printf("hex: %x\n", 456)

	fmt.Printf("float1: %f\n", 78.9)

	fmt.Printf("float2: %e\n", 123400000.0)
	fmt.Printf("float3: %E\n", 123400000.0)

	fmt.Printf("str1: %s\n", "\"string\"")

	fmt.Printf("str2: %q\n", "\"string\"")

	fmt.Printf("str3: %x\n", "hex this")

	fmt.Printf("pointer: %p\n", &p)

	fmt.Printf("width1: |%6d|%6d|\n", 12, 345)

	fmt.Printf("width2: |%6.2f|%6.2f|\n", 1.2, 3.45)

	fmt.Printf("width3: |%-6.2f|%-6.2f|\n", 1.2, 3.45)

	fmt.Printf("width4: |%6s|%6s|\n", "foo", "b")

	fmt.Printf("width5: |%-6s|%-6s|\n", "foo", "b")

	s := fmt.Sprintf("sprintf: a %s", "string")
	fmt.Println(s)

	fmt.Fprintf(os.Stderr, "io: an %s\n", "error")
}

模版-template

text/template

Golang中的標(biāo)準(zhǔn)庫template就像是一個(gè)“腳本語言解析器”，其中涉及到變量賦值、函數(shù)/方法調(diào)用和各種條件/循環(huán)控制結(jié)構(gòu)等。template包實(shí)現(xiàn)了數(shù)據(jù)驅(qū)動的用于生成文本輸出的模板，簡單來說就是將一組文本嵌入另一組文本模版中，返回一個(gè)期望的文本。Go為模板操作提供了豐富的支持。嵌套模板，導(dǎo)入函數(shù)，表示變量，迭代數(shù)據(jù)等等都很簡單。如果需要比CSV數(shù)據(jù)格式更復(fù)雜的東西，模板可能是一個(gè)不錯(cuò)的解決方案。模板的另一個(gè)應(yīng)用是網(wǎng)站的頁面渲染；當(dāng)我們想要將服務(wù)器端數(shù)據(jù)呈現(xiàn)給客戶端時(shí)，模板可以很好地滿足要求。

Go提供了text/template和html/template這兩個(gè)模板包，這兩個(gè)包的部分函數(shù)看起來非常相似，實(shí)際功能也確實(shí)如此

package main

import (
	"os"
	"text/template"
)

type Inventory struct {
	Username string
	Phone    uint
	Tag      bool
	Sex      string
}

func main() {
	t1 := template.New("t1")
	t1, err := t1.Parse("Value is {{.}}\n")
	if err != nil {
		panic(err)
	}

	t1 = template.Must(t1.Parse("Value: {{.}}\n"))

	t1.Execute(os.Stdout, "some text")
	t1.Execute(os.Stdout, 5)
	t1.Execute(os.Stdout, []string{
		"Go",
		"Rust",
		"C++",
		"C#",
	})

	Create := func(name, t string) *template.Template {
		return template.Must(template.New(name).Parse(t))
	}

	t2 := Create("t2", "Name: {{.Name}}\n")

	t2.Execute(os.Stdout, struct {
		Name string
	}{"Jane Doe"})

	t2.Execute(os.Stdout, map[string]string{
		"Name": "Mickey Mouse",
	})

	t3 := Create("t3",
		"{{if . -}} yes {{else -}} no {{end}}\n")
	t3.Execute(os.Stdout, "not empty")
	t3.Execute(os.Stdout, "")

	t4 := Create("t4",
		"Range: {{range .}}{{.}} {{end}}\n")
	t4.Execute(os.Stdout,
		[]string{
			"Go",
			"Rust",
			"C++",
			"C#",
		})

	sweaters := Inventory{"移動", 10086, false, "難"}

	content := `{{.Phone}} of {{.Username}} {{if .Tag }} tag=true {{else}}   tag=false {{end}}`
	tmpl, err := template.New("test").Parse(content)
	//{{.Phone}}獲取的是struct對象中的Phone字段的值
	if err != nil {
		panic(err)
	}
	err = tmpl.Execute(os.Stdout, sweaters) // 10086 of 移動  tag=true
	if err != nil {
		panic(err)
	}
}

html/template

使用html/template來呈現(xiàn)網(wǎng)站，模板是純文本，但變量和函數(shù)可以在大括號塊內(nèi)使用，模板包還提供了處理文件的便捷方法。html/template包是對text/template包的包裝，因此能同于text/template基本都對html/template包同樣適用，除了import語句無需其他任何修改。HTML模板提供了上下文感知安全性的額外好處，也可以防止諸如JavaScript注入之類的事情。如果要生成HTML格式的輸出，參見html/template包，該包提供了和本包相同的接口，但會自動將輸出轉(zhuǎn)化為安全的HTML格式輸出，可以抵抗一些網(wǎng)絡(luò)攻擊。

package main

import (
	"html/template"
	"net/http"
)

func tmpl(w http.ResponseWriter, r *http.Request) {
	t1, err := template.ParseFiles("test.html")
	if err != nil {
		panic(err)
	}
	t1.Execute(w, "hello world")
}

func main() {
	server := http.Server{
		Addr: "127.0.0.1:8080",
	}
	http.HandleFunc("/tmpl", tmpl)
	server.ListenAndServe()
}

創(chuàng)建test.html

<!DOCTYPE html>
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>Go Web</title>
</head>
<body>
{{ . }}
</body>
</html>

訪問測試地址http://localhost:8080/tmpl

正則表達(dá)式-regexp

Go提供了對正則表達(dá)式的內(nèi)置支持，其由regexp包實(shí)現(xiàn)了正則表達(dá)式搜索；Go標(biāo)準(zhǔn)庫使用RE2語法，RE2語法也是Python、C和Perl使用的正則表達(dá)式語法，常見函數(shù)：

• MatchString：regexp.MatchString()用來匹配子字符串。下面這個(gè)例子是檢查字符串是否以Golang開頭。我們使用^來匹配字符串中以文本的開始。我們使用^Golang作為正則表達(dá)式進(jìn)行匹配。
• Compile：Compile() 或者 MustCompile()創(chuàng)建一個(gè)編譯好的正則表達(dá)式對象。假如正則表達(dá)式非法，那么Compile()方法會返回error,而MustCompile()編譯非法正則表達(dá)式時(shí)不會返回error，而是會panic。如果你想要很好的性能，不要在使用的時(shí)候才調(diào)用Compile()臨時(shí)進(jìn)行編譯，而是預(yù)先調(diào)用Compile()編譯好正則表達(dá)式對象。
• FindString：FindString()用來返回第一個(gè)匹配的結(jié)果。如果沒有匹配的字符串，那么它會返回一個(gè)空的字符串，當(dāng)然如果你的正則表達(dá)式就是要匹配空字符串的話，它也會返回空字符串。使用 FindStringIndex 或者 FindStringSubmatch可以區(qū)分這兩種情況。
  • FindStringIndex：FindStringIndex()可以得到匹配的字符串在整體字符串中的索引位置。如果沒有匹配的字符串，它會返回nil值。
  • FindStringSubmatch：FindStringSubmatch() 除了返回匹配的字符串外，還會返回子表達(dá)式的匹配項(xiàng)。如果沒有匹配項(xiàng)，則返回nil值。
• FindAllString：FindString方法的All版本，它返回所有匹配的字符串的slice。如果返回nil值代表沒有匹配的字符串。
• ReplaceAllString ：用來替換所有匹配的字符串，返回一個(gè)源字符串的拷貝。

Go中與regexp相關(guān)的一些常見示例

package main

import (
	"bytes"
	"fmt"
	"regexp"
)

func main() {

	match, _ := regexp.MatchString("p([a-z]+)ch", "peach")
	fmt.Println(match)

	r, _ := regexp.Compile("p([a-z]+)ch")

	fmt.Println(r.MatchString("peach"))

	fmt.Println(r.FindString("peach punch"))

	fmt.Println("idx:", r.FindStringIndex("peach punch"))

	fmt.Println(r.FindStringSubmatch("peach punch"))

	fmt.Println(r.FindStringSubmatchIndex("peach punch"))

	fmt.Println(r.FindAllString("peach punch pinch", -1))

	fmt.Println("all:", r.FindAllStringSubmatchIndex(
		"peach punch pinch", -1))

	fmt.Println(r.FindAllString("peach punch pinch", 2))

	fmt.Println(r.Match([]byte("peach")))

	r = regexp.MustCompile("p([a-z]+)ch")
	fmt.Println("regexp:", r)

	fmt.Println(r.ReplaceAllString("a peach", "<fruit>"))

	in := []byte("a peach")
	out := r.ReplaceAllFunc(in, bytes.ToUpper)
	fmt.Println(string(out))
}

編碼-encoding

encoding 包是 Go 標(biāo)準(zhǔn)庫中的一個(gè)重要包，主要用于數(shù)據(jù)編碼和解碼。encoding 包中包含了許多常用的數(shù)據(jù)編碼和解碼算法，如 JSON、XML、CSV、Base64 等，這些算法可以幫助我們將數(shù)據(jù)從一種格式轉(zhuǎn)換為另一種格式，便于在不同的系統(tǒng)之間傳輸和處理。

Base64

Go提供對base64編碼/解碼的內(nèi)置支持。

package main

import (
	b64 "encoding/base64"
	"fmt"
)

func main() {

	data := "abc123!?$*&()'-=@~"

	sEnc := b64.StdEncoding.EncodeToString([]byte(data))
	fmt.Println(sEnc)

	sDec, _ := b64.StdEncoding.DecodeString(sEnc)
	fmt.Println(string(sDec))
	fmt.Println()

	uEnc := b64.URLEncoding.EncodeToString([]byte(data))
	fmt.Println(uEnc)
	uDec, _ := b64.URLEncoding.DecodeString(uEnc)
	fmt.Println(string(uDec))
}

JSON

Go提供了對JSON編碼和解碼的內(nèi)置支持，包括來自內(nèi)置和自定義數(shù)據(jù)類型的支持。需要使用encoding/json包進(jìn)行json實(shí)現(xiàn)序列化與反序列化，go的json解析主要是編碼和解碼兩個(gè)函數(shù)，序列化也就是由結(jié)構(gòu)體轉(zhuǎn)化為json string字符串，使用json.Marshal函數(shù)；反序列化就是將json string字符串轉(zhuǎn)化為結(jié)構(gòu)體，使用函數(shù)json.Unmarshal函數(shù)完成。

~~~go
package main

import (
	"encoding/json"
	"fmt"
	"os"
)

type response1 struct {
	Page   int
	Fruits []string
}

type response2 struct {
	Page   int      `json:"page"`
	Fruits []string `json:"fruits"`
}

func main() {

	bolB, _ := json.Marshal(true)
	fmt.Println(string(bolB))

	intB, _ := json.Marshal(1)
	fmt.Println(string(intB))

	fltB, _ := json.Marshal(2.34)
	fmt.Println(string(fltB))

	strB, _ := json.Marshal("gopher")
	fmt.Println(string(strB))

	slcD := []string{"apple", "peach", "pear"}
	slcB, _ := json.Marshal(slcD)
	fmt.Println(string(slcB))

	mapD := map[string]int{"apple": 5, "lettuce": 7}
	mapB, _ := json.Marshal(mapD)
	fmt.Println(string(mapB))

	res1D := &response1{
		Page:   1,
		Fruits: []string{"apple", "peach", "pear"}}
	res1B, _ := json.Marshal(res1D)
	fmt.Println(string(res1B))

	res2D := &response2{
		Page:   1,
		Fruits: []string{"apple", "peach", "pear"}}
	res2B, _ := json.Marshal(res2D)
	fmt.Println(string(res2B))

	byt := []byte(`{"num":6.13,"strs":["a","b"]}`)

	var dat map[string]interface{}

	if err := json.Unmarshal(byt, &dat); err != nil {
		panic(err)
	}
	fmt.Println(dat)

	num := dat["num"].(float64)
	fmt.Println(num)

	strs := dat["strs"].([]interface{})
	str1 := strs[0].(string)
	fmt.Println(str1)

	str := `{"page": 1, "fruits": ["apple", "peach"]}`
	res := response2{}
	json.Unmarshal([]byte(str), &res)
	fmt.Println(res)
	fmt.Println(res.Fruits[0])

	enc := json.NewEncoder(os.Stdout)
	d := map[string]int{"apple": 5, "lettuce": 7}
	enc.Encode(d)
}

XML

Go通過encoding.xml包提供了對XML和類XML格式的內(nèi)置支持。Go語言內(nèi)置的 encoding/xml 包可以用在結(jié)構(gòu)體和 XML 格式之間進(jìn)行編解碼，其方式跟 encoding/json 包類似；然而與 JSON 相比 XML 的編碼和解碼在功能上更苛刻得多，這是由于 encoding/xml 包要求結(jié)構(gòu)體的字段包含格式合理的標(biāo)簽，而 JSON 格式卻不需要。

package main

import (
	"encoding/xml"
	"fmt"
)

type Plant struct {
	XMLName xml.Name `xml:"plant"`
	Id      int      `xml:"id,attr"`
	Name    string   `xml:"name"`
	Origin  []string `xml:"origin"`
}

func (p Plant) String() string {
	return fmt.Sprintf("Plant id=%v, name=%v, origin=%v",
		p.Id, p.Name, p.Origin)
}

func main() {
	coffee := &Plant{Id: 27, Name: "Coffee"}
	coffee.Origin = []string{"Ethiopia", "Brazil"}

	out, _ := xml.MarshalIndent(coffee, " ", "  ")
	fmt.Println(string(out))

	fmt.Println(xml.Header + string(out))

	var p Plant
	if err := xml.Unmarshal(out, &p); err != nil {
		panic(err)
	}
	fmt.Println(p)

	tomato := &Plant{Id: 81, Name: "Tomato"}
	tomato.Origin = []string{"Mexico", "California"}

	type Nesting struct {
		XMLName xml.Name `xml:"nesting"`
		Plants  []*Plant `xml:"parent>child>plant"`
	}

	nesting := &Nesting{}
	nesting.Plants = []*Plant{coffee, tomato}

	out, _ = xml.MarshalIndent(nesting, " ", "  ")
	fmt.Println(string(out))
}

時(shí)間-time

在編程中經(jīng)常會遭遇八小時(shí)時(shí)間差問題，這是由時(shí)區(qū)差異引起的，為了能更好地解決它們，需要先理解幾個(gè)時(shí)間定義標(biāo)準(zhǔn)。

• GMT（Greenwich Mean Time）：格林威治時(shí)間；GMT 根據(jù)地球的自轉(zhuǎn)和公轉(zhuǎn)來計(jì)算時(shí)間，它規(guī)定太陽每天經(jīng)過位于英國倫敦郊區(qū)的皇家格林威治天文臺的時(shí)間為中午12點(diǎn)；GMT 是前世界標(biāo)準(zhǔn)時(shí)。
• UTC（Coordinated Universal Time），協(xié)調(diào)世界時(shí)間，又稱世界統(tǒng)一時(shí)間；UTC 比 GMT 更精準(zhǔn)，它根據(jù)原子鐘來計(jì)算時(shí)間，適應(yīng)現(xiàn)代社會的精確計(jì)時(shí)。在不需要精確到秒的情況下，可以認(rèn)為 UTC=GMT；UTC 是現(xiàn)世界標(biāo)準(zhǔn)時(shí)。

適應(yīng)現(xiàn)代社會的精確計(jì)時(shí)從格林威治本初子午線起，往東為正，往西為負(fù)，全球共劃分為 24 個(gè)標(biāo)準(zhǔn)時(shí)區(qū)，相鄰時(shí)區(qū)相差一個(gè)小時(shí)；如何獲取自Unix紀(jì)元以來的秒數(shù)、毫秒數(shù)或納秒數(shù)和時(shí)間格式化。

package main

import (
	"fmt"
	"time"
)

func main() {
	p := fmt.Println

	now := time.Now()
	p(now)

	then := time.Date(
		2009, 11, 17, 20, 34, 58, 651387237, time.UTC)
	p(then)

	p(then.Year())
	p(then.Month())
	p(then.Day())
	p(then.Hour())
	p(then.Minute())
	p(then.Second())
	p(then.Nanosecond())
	p(then.Location())

	p(then.Weekday())

	p(then.Before(now))
	p(then.After(now))
	p(then.Equal(now))

	diff := now.Sub(then)
	p(diff)

	p(diff.Hours())
	p(diff.Minutes())
	p(diff.Seconds())
	p(diff.Nanoseconds())

	p(then.Add(diff))
	p(then.Add(-diff))
	p("-----------------------")
	fmt.Println(now.Unix())
	fmt.Println(now.UnixMilli())
	fmt.Println(now.UnixNano())

	fmt.Println(time.Unix(now.Unix(), 0))
	fmt.Println(time.Unix(0, now.UnixNano()))
	p("-----------------------")
	t := time.Now()
	p(t.Format(time.RFC3339))

	t1, e := time.Parse(
		time.RFC3339,
		"2012-11-01T22:08:41+00:00")
	p(t1)

	p(t.Format("3:04PM"))
	p(t.Format("Mon Jan _2 15:04:05 2006"))
	p(t.Format("2006-01-02T15:04:05.999999-07:00"))
	form := "3 04 PM"
	t2, e := time.Parse(form, "8 41 PM")
	p(t2)

	fmt.Printf("%d-%02d-%02dT%02d:%02d:%02d-00:00\n",
		t.Year(), t.Month(), t.Day(),
		t.Hour(), t.Minute(), t.Second())

	ansic := "Mon Jan _2 15:04:05 2006"
	_, e = time.Parse(ansic, "8:41PM")
	p(e)
}

網(wǎng)絡(luò)-net

網(wǎng)絡(luò)編程是go語言使用的一個(gè)核心模塊；golang的網(wǎng)絡(luò)封裝使用對于底層socket或者上層的http，甚至是web服務(wù)都很友好。net包提供了可移植的網(wǎng)絡(luò)I/O接口，包括TCP/IP、UDP、域名解析和Unix域socket等方式的通信。其中每一種通信方式都使用 xxConn 結(jié)構(gòu)體來表示，諸如IPConn、TCPConn等，這些結(jié)構(gòu)體都實(shí)現(xiàn)了Conn接口，Conn接口實(shí)現(xiàn)了基本的讀、寫、關(guān)閉、獲取遠(yuǎn)程和本地地址、設(shè)置timeout等功能。

URL

url提供了一種統(tǒng)一的方式來定位資源，Go中解析url需要使用到其net包。

• URL格式：??/:

  @:

  /

  :

  ?#

• scheme : 方案是如何訪問指定資源的主要標(biāo)識符，他會告訴負(fù)責(zé)解析 URL 應(yīng)用程序應(yīng)該使用什么協(xié)議；
• user ：用戶名；
• password ：密碼；
• host : 主機(jī)組件標(biāo)識了因特網(wǎng)上能夠訪問資源的宿主機(jī)器，可以有主機(jī)名或者是 IP 地址來表示；
• port : 端口標(biāo)識了服務(wù)器正在監(jiān)聽的網(wǎng)絡(luò)端口。默認(rèn)端口號是 80；
• path : URL 的路徑組件說明了資源位于服務(wù)器的什么地方；
• params : URL 中通過協(xié)議參數(shù)來訪問資源，比名值對列表，分號分割來進(jìn)行訪問；
• query : 字符串是通過提問問題或進(jìn)行查詢來縮小請求資源類的范圍；
• frag : 為了引用部分資源或資源的一個(gè)片段，比如 URL 指定 HTML 文檔中一個(gè)圖片或一個(gè)小節(jié)；

package main

import (
    "fmt"
    "net"
    "net/url"
)

func main() {

    s := "postgres://user:pass@host.com:5432/path?k=v#f"

    u, err := url.Parse(s)
    if err != nil {
        panic(err)
    }

    fmt.Println(u.Scheme)

    fmt.Println(u.User)
    fmt.Println(u.User.Username())
    p, _ := u.User.Password()
    fmt.Println(p)

    fmt.Println(u.Host)
    host, port, _ := net.SplitHostPort(u.Host)
    fmt.Println(host)
    fmt.Println(port)

    fmt.Println(u.Path)
    fmt.Println(u.Fragment)

    fmt.Println(u.RawQuery)
    m, _ := url.ParseQuery(u.RawQuery)
    fmt.Println(m)
    fmt.Println(m["k"][0])
}

HTTP客戶端和服務(wù)端

Go語言提供了一個(gè)功能豐富的net/http包，它提供了客戶端和服務(wù)端的實(shí)現(xiàn)，使得我們可以比較輕易的創(chuàng)建http服務(wù)。

• 作為客戶端發(fā)送http請求

package main

import (
    "bufio"
    "fmt"
    "net/http"
)

func main() {

    resp, err := http.Get("https://gobyexample.com")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    fmt.Println("Response status:", resp.Status)

    scanner := bufio.NewScanner(resp.Body)
    for i := 0; scanner.Scan() && i < 5; i++ {
        fmt.Println(scanner.Text())
    }

    if err := scanner.Err(); err != nil {
        panic(err)
    }
}

• 作為服務(wù)端監(jiān)聽HTTP請求

package main

import (
    "fmt"
    "net/http"
)

func hello(w http.ResponseWriter, req *http.Request) {

    fmt.Fprintf(w, "hello\n")
}

func headers(w http.ResponseWriter, req *http.Request) {

    for name, headers := range req.Header {
        for _, h := range headers {
            fmt.Fprintf(w, "%v: %v\n", name, h)
        }
    }
}

func main() {

    http.HandleFunc("/hello", hello)
    http.HandleFunc("/headers", headers)

    http.ListenAndServe(":8090", nil)
}

訪問測試頁面:http://localhost:8090/hello和http://localhost:8090/headers

加密

crypto是go的加密庫，包含了常用的各種密碼算法，AES，DES，Cipher，DSA，ecdsa，elliptic，HMAC，MD5，特別用于加密的隨機(jī)數(shù)生成器rand，RC4，RSA，SHA1，SHA256，SHA384，SHA512，tls1.2，tls1.3，X.509；如SHA256哈希經(jīng)常用于計(jì)算二進(jìn)制或文本blob的短身份，TLS/SSL證書常使用SHA256來計(jì)算證書的簽名；md5算法屬于hash算法的一種。

package main

import (
	"crypto/md5"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
)

func main() {
	s := "sha256 this string"

	h := sha256.New()

	h.Write([]byte(s))

	bs := h.Sum(nil)

	fmt.Println(s)
	fmt.Printf("%x\n", bs)

	has := md5.New()
	has.Write([]byte("abc123"))
	b := has.Sum(nil)
	fmt.Println(b)
	fmt.Println(hex.EncodeToString(b))
	fmt.Printf("%x", b)

	c := md5.Sum([]byte("abc123"))
	fmt.Printf("%x", c)
}

IO操作

io包提供了對I/O原語的基本接口。該包的基本任務(wù)是包裝這些原語已有的實(shí)現(xiàn)（如os包里的原語），使之成為共享的公共接口，這些公共接口抽象出了泛用的函數(shù)并附加了一些相關(guān)的原語的操作。

讀寫文件

讀寫文件在Go程序是常見的功能，bufio包實(shí)現(xiàn)了帶緩沖區(qū)的讀寫，是對文件讀寫的封裝.其中的讀寫文件在Go程序是常見的功能Go語言里使用io.Reader和io.Writer兩個(gè) interface 來抽象I/O。io.Reader 接口代表一個(gè)可以從中讀取字節(jié)流的實(shí)體，而io.Writer則代表一個(gè)可以向其寫入字節(jié)流的實(shí)體。io.Reader/Writer 常用的幾種實(shí)現(xiàn)：

• net.Conn: 表示網(wǎng)絡(luò)連接。
• os.Stdin, os.Stdout, os.Stderr: 標(biāo)準(zhǔn)輸入、輸出和錯(cuò)誤。
• os.File: 網(wǎng)絡(luò),標(biāo)準(zhǔn)輸入輸出,文件的流讀取。
• strings.Reader: 字符串抽象成 io.Reader 的實(shí)現(xiàn)。
• bytes.Reader: []byte抽象成 io.Reader 的實(shí)現(xiàn)。
• bytes.Buffer: []byte抽象成 io.Reader 和 io.Writer 的實(shí)現(xiàn)。
• bufio.Reader/Writer: 帶緩沖的流讀取和寫入（比如按行讀寫）。

package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
)

func check(e error) {
	if e != nil {
		panic(e)
	}
}

func main() {
	writeDemo()
	readDemo()
}

func writeDemo() {

	d1 := []byte("hello\ngo\n")
	err := os.WriteFile("/tmp/dat1", d1, 0644)
	check(err)

	f, err := os.Create("/tmp/dat2")
	check(err)

	defer f.Close()

	d2 := []byte{115, 111, 109, 101, 10}
	n2, err := f.Write(d2)
	check(err)
	fmt.Printf("wrote %d bytes\n", n2)

	n3, err := f.WriteString("writes\n")
	check(err)
	fmt.Printf("wrote %d bytes\n", n3)

	f.Sync()

	w := bufio.NewWriter(f)
	n4, err := w.WriteString("buffered\n")
	check(err)
	fmt.Printf("wrote %d bytes\n", n4)

	w.Flush()

}
func readDemo() {
	dat, err := os.ReadFile("/tmp/dat1")
	check(err)
	fmt.Print(string(dat))

	f, err := os.Open("/tmp/dat1")
	check(err)

	b1 := make([]byte, 5)
	n1, err := f.Read(b1)
	check(err)
	fmt.Printf("%d bytes: %s\n", n1, string(b1[:n1]))

	o2, err := f.Seek(6, 0)
	check(err)
	b2 := make([]byte, 2)
	n2, err := f.Read(b2)
	check(err)
	fmt.Printf("%d bytes @ %d: ", n2, o2)
	fmt.Printf("%v\n", string(b2[:n2]))

	o3, err := f.Seek(6, 0)
	check(err)
	b3 := make([]byte, 2)
	n3, err := io.ReadAtLeast(f, b3, 2)
	check(err)
	fmt.Printf("%d bytes @ %d: %s\n", n3, o3, string(b3))

	_, err = f.Seek(0, 0)
	check(err)

	r4 := bufio.NewReader(f)
	b4, err := r4.Peek(5)
	check(err)
	fmt.Printf("5 bytes: %s\n", string(b4))

	f.Close()
}

環(huán)境變量

環(huán)境變量是向Unix程序傳遞配置信息的通用機(jī)制。

package main

import (
	"fmt"
	"os"
	"strings"
)

func main() {

	os.Setenv("FOO", "1")
	fmt.Println("FOO:", os.Getenv("FOO"))
	fmt.Println("BAR:", os.Getenv("BAR"))

	fmt.Println()
	for _, e := range os.Environ() {
		pair := strings.SplitN(e, "=", 2)
		fmt.Println(pair[0])
	}
}

命令行

• 命令行參數(shù)：程序執(zhí)行參數(shù)化的常用方法。例如，運(yùn)行hello。Go使用run和hello。Go程序的參數(shù)。

package main

import (
	"fmt"
	"os"
)

func main() {

	argsWithProg := os.Args
	argsWithoutProg := os.Args[1:]

	arg := os.Args[3]

	fmt.Println(argsWithProg)
	fmt.Println(argsWithoutProg)
	fmt.Println(arg)
}

go run demo.go a b c d
[./demo.exe a b c d]
[a b c d]
c

• 命令行標(biāo)記：為命令行程序指定選項(xiàng)的常用方法。例如，在wc -l中，-l是命令行標(biāo)志。

package main

import (
	"flag"
	"fmt"
)

func main() {

	wordPtr := flag.String("word", "foo", "a string")

	numbPtr := flag.Int("numb", 42, "an int")
	forkPtr := flag.Bool("fork", false, "a bool")

	var svar string
	flag.StringVar(&svar, "svar", "bar", "a string var")

	flag.Parse()

	fmt.Println("word:", *wordPtr)
	fmt.Println("numb:", *numbPtr)
	fmt.Println("fork:", *forkPtr)
	fmt.Println("svar:", svar)
	fmt.Println("tail:", flag.Args())
}

go run demo.go -word=opt -numb=7 -fork -svar=flag
word: opt
numb: 7
fork: true
svar: flag
tail: []

• 命令行子命令：一些命令行工具如go工具或git有許多子命令，每個(gè)子命令都有自己的一組標(biāo)志；例如go build和go get是go工具的兩個(gè)不同的子命令；flag包允許我們輕松地定義具有自己標(biāo)志的簡單子命令。

package main

import (
    "flag"
    "fmt"
    "os"
)

func main() {

    fooCmd := flag.NewFlagSet("foo", flag.ExitOnError)
    fooEnable := fooCmd.Bool("enable", false, "enable")
    fooName := fooCmd.String("name", "", "name")

    barCmd := flag.NewFlagSet("bar", flag.ExitOnError)
    barLevel := barCmd.Int("level", 0, "level")

    if len(os.Args) < 2 {
        fmt.Println("expected 'foo' or 'bar' subcommands")
        os.Exit(1)
    }

    switch os.Args[1] {

    case "foo":
        fooCmd.Parse(os.Args[2:])
        fmt.Println("subcommand 'foo'")
        fmt.Println("  enable:", *fooEnable)
        fmt.Println("  name:", *fooName)
        fmt.Println("  tail:", fooCmd.Args())
    case "bar":
        barCmd.Parse(os.Args[2:])
        fmt.Println("subcommand 'bar'")
        fmt.Println("  level:", *barLevel)
        fmt.Println("  tail:", barCmd.Args())
    default:
        fmt.Println("expected 'foo' or 'bar' subcommands")
        os.Exit(1)
    }
}

go run demo.go foo -enable -name=joe a1 a2
subcommand 'foo'
  enable: true
  name: joe
  tail: [a1 a2]

數(shù)據(jù)庫

在Go中使用SQL或類SQL數(shù)據(jù)庫通過database/sql包，它為面向行的數(shù)據(jù)庫提供了一個(gè)輕量級接口；也即是在Go 的標(biāo)準(zhǔn)庫中是沒有數(shù)據(jù)庫驅(qū)動，只提供了驅(qū)動接口，但有很多第三方實(shí)現(xiàn)了驅(qū)動，建議選擇 go-sql-driver 這個(gè)實(shí)現(xiàn)是目前使用最多的，其github 地址是：https://github.com/go-sql-driver/mysql

# 命令行安裝三方庫 
go get github.com/go-sql-driver/mysql

package main

import (
	"database/sql"
	_ "github.com/go-sql-driver/mysql"
	"log"
)

func main() {
	db, err := sql.Open("mysql", "root:123456@tcp(mysqlserver:3306)/test")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	var (
		id   int
		name string
	)
	rows, err := db.Query("select id, name from test_data where id = ?", 1)
	if err != nil {
		log.Fatal(err)
	}
	defer rows.Close()
	for rows.Next() {
		err := rows.Scan(&id, &name)
		if err != nil {
			log.Fatal(err)
		}
		log.Println(id, name)
	}
	err = rows.Err()
	if err != nil {
		log.Fatal(err)
	}
}

上面是匿名加載mysql驅(qū)動的，將它的包限定符別名為_，所以它導(dǎo)出的名稱對我們的代碼是不可見的；在底層，驅(qū)動程序?qū)⒆约鹤詾閐atabase/sql包可用。

排序-sort

• Go的sort包實(shí)現(xiàn)了對內(nèi)置和用戶定義類型的排序，實(shí)現(xiàn)了包括插入排序 、 堆排序 、 快排 和 歸并排序4種排序方法 ，但是并沒有暴露給用戶接口。sort包會根據(jù)數(shù)據(jù)選擇最優(yōu)的排序方法(其實(shí)只使用了3種， 歸并排序 除外)。用戶需要實(shí)現(xiàn)以下接口才能使用sort包的排序功能。對于常用的類型( 整型切片 、 float64切片 、 String切片 )，sort包提供了內(nèi)置的接口實(shí)現(xiàn)；如經(jīng)常用到的 int32、int64、float32、bool 類型并沒有由 sort 包實(shí)現(xiàn)，使用時(shí)依然需要開發(fā)者自己編寫。

• 除了基本類型的排序，也可以對結(jié)構(gòu)體進(jìn)行排序。 結(jié)構(gòu)體比基本類型更為復(fù)雜，排序時(shí)不能像數(shù)值和字符串一樣擁有一些固定的單一原則；可以自定義排序接口，比如想要按自然順序以外的方式對集合進(jìn)行排序;例如希望按字符串的長度而不是按字母順序排序。

• Go 的 sort 包中所有的排序算法在最壞的情況下會做 n log n 次 比較，n 是被排序序列的長度，所以排序的時(shí)間復(fù)雜度是 O ( n log n*)。 其大多數(shù)的函數(shù)都是用改良后的快速排序算法實(shí)現(xiàn)的。

package main

import (
	"fmt"
	"sort"
)

type byLength []string

func (s byLength) Len() int {
	return len(s)
}
func (s byLength) Swap(i, j int) {
	s[i], s[j] = s[j], s[i]
}
func (s byLength) Less(i, j int) bool {
	return len(s[i]) < len(s[j])
}

func main() {

	strs := []string{"c", "a", "b"}
	sort.Strings(strs)
	fmt.Println("Strings:", strs)

	ints := []int{7, 2, 4}
	sort.Ints(ints)
	fmt.Println("Ints:   ", ints)

	s := sort.IntsAreSorted(ints)
	fmt.Println("Sorted: ", s)

	fruits := []string{"peach", "banana", "kiwi"}
	sort.Sort(byLength(fruits))
	fmt.Println(fruits)
}

測試和基準(zhǔn)測試

單元測試是編寫Go程序的重要組成部分，testing包提供了編寫單元測試所需的工具，通過go test命令運(yùn)行測試。

package main

import (
    "fmt"
    "testing"
)

func IntMin(a, b int) int {
    if a < b {
        return a
    }
    return b
}

func TestIntMinBasic(t *testing.T) {
    ans := IntMin(2, -2)
    if ans != -2 {
        t.Errorf("IntMin(2, -2) = %d; want -2", ans)
    }
}

func TestIntMinTableDriven(t *testing.T) {
    var tests = []struct {
        a, b int
        want int
    }{
        {0, 1, 0},
        {1, 0, 0},
        {2, -2, -2},
        {0, -1, -1},
        {-1, 0, -1},
    }

    for _, tt := range tests {

        testname := fmt.Sprintf("%d,%d", tt.a, tt.b)
        t.Run(testname, func(t *testing.T) {
            ans := IntMin(tt.a, tt.b)
            if ans != tt.want {
                t.Errorf("got %d, want %d", ans, tt.want)
            }
        })
    }
}

func BenchmarkIntMin(b *testing.B) {
    for i := 0; i < b.N; i++ {
        IntMin(1, 2)
    }
}

命令行執(zhí)行g(shù)o test -v

命令行執(zhí)行g(shù)o test -bench=.

文章來源地址http://www.zghlxwxcb.cn/news/detail-434476.html

• 本人博客網(wǎng)站IT小神 www.itxiaoshen.com

到了這里，關(guān)于云原生時(shí)代崛起的編程語言Go常用標(biāo)準(zhǔn)庫實(shí)戰(zhàn)的文章就介紹完了。如果您還想了解更多內(nèi)容，請?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！