Go示例集合

发表于

Go 示例集合 记录一下

Go 字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
复制代码//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操作函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
复制代码//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 字符串格式化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
复制代码//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编码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
复制代码// 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函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
复制代码//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散列经常用来计算二进制或者大文本数据的短标识值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
复制代码//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…

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%