Go 示例集合 記錄一下
Go 字典
//Go 字典
package main
import (
"fmt"
)
func main() {
dictionary := make(map[string]int)
dictionary["k1"] = 7
dictionary["k2"] = 10
//輸出字典
fmt.Println("map:", dictionary)
//獲取一個鍵的值
name := dictionary["k1"]
fmt.Println("name:", name)
//內建函式len 返回字典元素的個數
fmt.Println("len:", len(dictionary))
//內建函式delete 從字典刪除一個鍵對應的值
delete(dictionary, "k2")
fmt.Println("map:", dictionary)
// 根據鍵來獲取值有一個可選的返回值，這個返回值表示字典中是否
// 存在該鍵，如果存在為true，返回對應值，否則為false，返回零值
// 有的時候需要根據這個返回值來區分返回結果到底是存在的值還是零值
// 比如字典不存在鍵x對應的整型值，返回零值就是0，但是恰好字典中有
// 鍵y對應的值為0，這個時候需要那個可選返回值來判斷是否零值。
_, ok := dictionary["k2"]
fmt.Println("ok:", ok)
//可以使用 ":=" 同時定義和初始化一個字典
myMap := map[string]int{"foo": 1, "bar": 2}
fmt.Println("map:", myMap)
}
輸出 map: map[k1:7 k2:10]
name: 7
len: 2
map: map[k1:7]
ok: false
map: map[foo:1 bar:2]複製程式碼Go string操作函式
//Go 字串操作函式
package main
import (
"fmt"
s "strings"
)
var p = fmt.Println
func main() {
// 下面是strings包裡面提供的一些函式例項。注意這裡的函式並不是
// string物件所擁有的方法，這就是說使用這些字串操作函式的時候
// 你必須將字串物件作為第一個引數傳遞進去。
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"))
p()
//這兩個方法不是string包函式
//獲取字串長度
p("Len: ", len("hello"))
//獲取指定索引的字元
p("Char:", "hello"[1])
}
輸出:
Contains: true
Count: 2
HasPrefix: true
HasSuffix: true
Index: 1
Join: a-b
Repeat: aaaaa
Replace: f00
Replace: f0o
Split: [a b c d e]
ToLower: test
ToUpper: TEST
Len: 5
Char: 101複製程式碼Go 字串格式化
//Go 字串格式化
package main
import (
"fmt"
"os"
)
type point struct {
x, y int
}
func main() {
// Go提供了幾種列印格式，用來格式化一般的Go值，例如 下面的%v列印了一個point結構體的物件的值
p := point{1, 2}
fmt.Printf("%v\n", p)
// 如果所格式化的值是一個結構體物件，那麼`%+v`的格式化輸出將包括結構體的成員名稱和值
fmt.Printf("%+v\n", p)
// `%#v`格式化輸出將輸出一個值的Go語法表示方式。
fmt.Printf("%#v\n", p)
// 使用`%T`來輸出一個值的資料型別
fmt.Printf("%T\n", p)
// 格式化布林型變數
fmt.Printf("%t\n", true)
// 格式化布林型變數
fmt.Printf("%t\n", true)
// 有很多的方式可以格式化整型，使用`%d`是一種標準的以10進位制來輸出整型的方式
fmt.Printf("%d\n", 123)
// 這種方式輸出整型的二進位制表示方式
fmt.Printf("%b\n", 14)
// 這裡列印出該整型數值所對應的字元
fmt.Printf("%c\n", 33)
// 使用`%x`輸出一個值的16進製表示方式
fmt.Printf("%x\n", 456)
// 浮點型數值也有幾種格式化方法。最基本的一種是`%f`
fmt.Printf("%f\n", 78.9)
// `%e`和`%E`使用科學計數法來輸出整型
fmt.Printf("%e\n", 123400000.0)
fmt.Printf("%E\n", 123400000.0)
// 使用`%s`輸出基本的字串
fmt.Printf("%s\n", "\"string\"")
// 輸出像Go原始碼中那樣帶雙引號的字串，需使用`%q`
fmt.Printf("%q\n", "\"string\"")
// `%x`以16進位制輸出字串，每個字串的位元組用兩個字元輸出
fmt.Printf("%x\n", "hex this")
// 使用`%p`輸出一個指標的值
fmt.Printf("%p\n", &p)
// 當輸出數字的時候，經常需要去控制輸出的寬度和精度。
//可以使用一個位於%後面的數字來控制輸出的寬度，預設情況下輸出是右對齊的，左邊加上空格
fmt.Printf("|%6d|%6d|\n", 12, 345)
// 你也可以指定浮點數的輸出寬度，同時你還可以指定浮點數的輸出精度
fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45)
// To left-justify, use the `-` flag.
fmt.Printf("|%-6.2f|%-6.2f|\n", 1.2, 3.45)
// 你也可以指定輸出字串的寬度來保證它們輸出對齊。預設 // 情況下，輸出是右對齊的
fmt.Printf("|%6s|%6s|\n", "foo", "b")
// 為了使用左對齊你可以在寬度之前加上`-`號
fmt.Printf("|%-6s|%-6s|\n", "foo", "b")
// 可以用`Sprintf`來將格式化後的字串賦值給一個變數
s := fmt.Sprintf("a %s", "string")
fmt.Println(s)
// 也可以使用`Fprintf`來將格式化後的值輸出到`io.Writers`
fmt.Fprintf(os.Stderr, "an %s\n", "error")
}
輸出
{1 2}
{x:1 y:2}
main.point{x:1, y:2}
main.point
true
true
123
1110
!
1c8
78.900000
1.234000e+08
1.234000E+08
"string"
"\"string\""
6865782074686973
0xc42006e1a0
| 12| 345|
| 1.20| 3.45|
|1.20 |3.45 |
| foo| b|
|foo |b |
a string
an error複製程式碼Go Base64編碼
// Go Base64編碼
package main
import (
b64 "encoding/base64"
"fmt"
)
func main() {
// 這裡是我們用來演示編碼和解碼的字串
data := "abc123!?$*&()'-=@~"
// Go支援標準的和相容URL的base64編碼。
// 我們這裡使用標準的base64編碼，這個
// 函式需要一個`[]byte`引數，所以將這個字串轉換為位元組陣列
sEnc := b64.StdEncoding.EncodeToString([]byte(data))
fmt.Println(sEnc)
// 解碼一個base64編碼可能返回一個錯誤，
// 如果你不知道輸入是否是正確的base64編碼，你需要檢測一些解碼錯誤
sDec, _ := b64.StdEncoding.DecodeString(sEnc)
fmt.Println(string(sDec))
fmt.Println()
// 使用相容URL的base64編碼和解碼
uEnc := b64.URLEncoding.EncodeToString([]byte(data))
fmt.Println(uEnc)
uDec, _ := b64.URLEncoding.DecodeString(uEnc)
fmt.Println(string(uDec))
}
輸出
YWJjMTIzIT8kKiYoKSctPUB+
abc123!?$*&()'-=@~
YWJjMTIzIT8kKiYoKSctPUB-
abc123!?$*&()'-=@~
這兩種方法都將原資料編碼為base64編碼，區別在於標準的編碼後面是 + ，而相容URL的編碼方式後面 是-。複製程式碼Go range函式
//Go range
package main
import (
"fmt"
)
func main() {
// 這裡我們使用range來計算一個切片的所有元素和 // 這種方法對陣列也適用
nums := []int{2, 3, 4}
sum := 0
for _, num := range nums {
sum += num
}
fmt.Println("sum:", sum)
// range 用來遍歷陣列和切片的時候返回索引和元素值
// 如果我們不要關心索引可以使用一個下劃線(_)來忽略這個返回值 // 當然我們有的時候也需要這個索引
for i, num := range nums {
if num == 3 {
fmt.Println("index:", i)
}
}
// 使用range來遍歷字典的時候，返回鍵值對。
kvs := map[string]string{"a": "apple", "b": "banana"}
for k, v := range kvs {
fmt.Printf("%s -> %s\n", k, v)
}
// range函式用來遍歷字串時，返回Unicode程式碼點。
// 第一個返回值是每個字元的起始位元組的索引，第二個是字元程式碼點，
// 因為Go的字串是由位元組組成的，多個位元組組成一個rune型別字元。
for i, c := range "go" {
fmt.Println(i, c)
}
}
輸出
sum: 9
index: 1
a -> apple
b -> banana
0 103
1 111複製程式碼Go sha1 雜湊
SHA1雜湊經常用來計算二進位制或者大文字資料的短標識值
//Go sha1 雜湊
package main
import (
"crypto/sha1"
"fmt"
)
func main() {
s := "sha1 this string"
// 生成一個hash的模式是sha1.New()，sha1.Write(bytes)
// 然後是sha1.Sum([]byte{})
h := sha1.New()
// 寫入要hash的位元組，如果你的引數是字串，使用[]byte(s)
// 把它強制轉換為位元組陣列
h.Write([]byte(s))
// 這裡計算最終的hash值，Sum的引數是用來追加而外的位元組到要
// 計算的hash位元組裡面，一般來講，如果上面已經把需要hash的位元組都寫入了，這裡就設為nil就可以了
bs := h.Sum(nil)
// SHA1雜湊值經常以16進位制的方式輸出，例如git commit就是
// 這樣，所以可以使用`%x`來將雜湊結果格式化為16進位制的字串
fmt.Println(s)
fmt.Printf("%x\n", bs)
}
輸出
sha1 this string
cf23df2207d99a74fbe169e3eba035e633b65d94複製程式碼長期更新
github地址:github.com/sallenhando…