1、时间格式化
基于模式的布局进行时间格式化和解析
1 package main
2
3 import "fmt"
4 import "time"
5
6 func main() {
7 p := fmt.Println
8
9 t := time.Now()
10 p(t.Format(time.RFC3339))
11
12 t1, e := time.Parse(
13 time.RFC3339,
14 "2012-11-01T22:08:41+00:00")
15 p(t1)
16
17 p(t.Format("3:04PM"))
18 p(t.Format("Mon Jan _2 15:04:05 2006"))
19 p(t.Format("2006-01-02T15:04:05.999999-07:00"))
20 form := "3 04 PM"
21 t2, e := time.Parse(form, "8 41 PM")
22 p(t2)
23
24 fmt.Printf("%d-%02d-%02dT%02d:%02d:%02d-00:00\n",
25 t.Year(), t.Month(), t.Day(),
26 t.Hour(), t.Minute(), t.Second())
27
28 ansic := "Mon Jan _2 15:04:05 2006"
29 _, e = time.Parse(ansic, "8:41PM")
30 p(e)
31 }
执行上面代码，将得到以下输出结果
1 2017-03-23T11:41:52+08:00 2 2012-11-01 22:08:41 +0000 +0000 3 11:41AM 4 Thu Mar 23 11:41:52 2017 5 2017-03-23T11:41:52.246508+08:00 6 0000-01-01 20:41:00 +0000 UTC 7 2017-03-23T11:41:52-00:00 8 parsing time "8:41PM" as "Mon Jan _2 15:04:05 2006": cannot parse "8:41PM" as "Mon"
2、字符串格式化
1 package main
2
3 import "fmt"
4 import "os"
5
6 type point struct {
7 x, y int
8 }
9
10 func main() {
11 p := point{1, 2}
12 fmt.Printf("%v\n", p)
13
14 fmt.Printf("%+v\n", p)
15
16 fmt.Printf("%#v\n", p)
17
18 fmt.Printf("%T\n", p)
19
20 fmt.Printf("%t\n", true)
21
22 fmt.Printf("%d\n", 123)
23
24 fmt.Printf("%b\n", 14)
25
26 fmt.Printf("%c\n", 33)
27
28 fmt.Printf("%x\n", 456)
29
30 fmt.Printf("%f\n", 78.9)
31
32 fmt.Printf("%e\n", 123400000.0)
33 fmt.Printf("%E\n", 123400000.0)
34
35 fmt.Printf("%s\n", "\"string\"")
36
37 fmt.Printf("%q\n", "\"string\"")
38
39 fmt.Printf("%x\n", "hex this")
40
41 fmt.Printf("%p\n", &p)
42
43 fmt.Printf("|%6d|%6d|\n", 12, 345)
44
45 fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45)
46
47 fmt.Printf("|%-6.2f|%-6.2f|\n", 1.2, 3.45)
48
49 fmt.Printf("|%6s|%6s|\n", "foo", "b")
50
51 fmt.Printf("|%-6s|%-6s|\n", "foo", "b")
52
53 s := fmt.Sprintf("a %s", "string")
54 fmt.Println(s)
55
56 fmt.Fprintf(os.Stderr, "an %s\n", "error")
57 }
1 {1 2}
2 {x:1 y:2}
3 main.point{x:1, y:2}
4 main.point
5 true
6 123
7 1110
8 !
9 1c8
10 78.900000
11 1.234000e+08
12 1.234000E+08
13 "string"
14 "\"string\""
15 6865782074686973
16 0xc042004280
17 | 12| 345|
18 | 1.20| 3.45|
19 |1.20 |3.45 |
20 | foo| b|
21 |foo |b |
22 a string
23 an error
3、正则表达式
1 package main
2
3 import "bytes"
4 import "fmt"
5 import "regexp"
6
7 func main() {
8
9 // This tests whether a pattern matches a string.
10 match, _ := regexp.MatchString("p([a-z]+)ch", "peach")
11 fmt.Println(match)
12
13 // Above we used a string pattern directly, but for
14 // other regexp tasks you‘ll need to `Compile` an
15 // optimized `Regexp` struct.
16 r, _ := regexp.Compile("p([a-z]+)ch")
17
18 // Many methods are available on these structs. Here‘s
19 // a match test like we saw earlier.
20 fmt.Println(r.MatchString("peach"))
21
22 // This finds the match for the regexp.
23 fmt.Println(r.FindString("peach punch"))
24
25 // This also finds the first match but returns the
26 // start and end indexes for the match instead of the
27 // matching text.
28 fmt.Println(r.FindStringIndex("peach punch"))
29
30 // The `Submatch` variants include information about
31 // both the whole-pattern matches and the submatches
32 // within those matches. For example this will return
33 // information for both `p([a-z]+)ch` and `([a-z]+)`.
34 fmt.Println(r.FindStringSubmatch("peach punch"))
35
36 // Similarly this will return information about the
37 // indexes of matches and submatches.
38 fmt.Println(r.FindStringSubmatchIndex("peach punch"))
39
40 // The `All` variants of these functions apply to all
41 // matches in the input, not just the first. For
42 // example to find all matches for a regexp.
43 fmt.Println(r.FindAllString("peach punch pinch", -1))
44
45 // These `All` variants are available for the other
46 // functions we saw above as well.
47 fmt.Println(r.FindAllStringSubmatchIndex(
48 "peach punch pinch", -1))
49
50 // Providing a non-negative integer as the second
51 // argument to these functions will limit the number
52 // of matches.
53 fmt.Println(r.FindAllString("peach punch pinch", 2))
54
55 // Our examples above had string arguments and used
56 // names like `MatchString`. We can also provide
57 // `[]byte` arguments and drop `String` from the
58 // function name.
59 fmt.Println(r.Match([]byte("peach")))
60
61 // When creating constants with regular expressions
62 // you can use the `MustCompile` variation of
63 // `Compile`. A plain `Compile` won‘t work for
64 // constants because it has 2 return values.
65 r = regexp.MustCompile("p([a-z]+)ch")
66 fmt.Println(r)
67
68 // The `regexp` package can also be used to replace
69 // subsets of strings with other values.
70 fmt.Println(r.ReplaceAllString("a peach", "<fruit>"))
71
72 // The `Func` variant allows you to transform matched
73 // text with a given function.
74 in := []byte("a peach")
75 out := r.ReplaceAllFunc(in, bytes.ToUpper)
76 fmt.Println(string(out))
77 }
执行上面代码，将得到以下输出结果
1 true 2 true 3 peach 4 [0 5] 5 [peach ea] 6 [0 5 1 3] 7 [peach punch pinch] 8 [[0 5 1 3] [6 11 7 9] [12 17 13 15]] 9 [peach punch] 10 true 11 p([a-z]+)ch 12 a <fruit> 13 a PEACH
4、Json
1 package main
2
3 import "encoding/json"
4 import "fmt"
5 import "os"
6
7 // We‘ll use these two structs to demonstrate encoding and
8 // decoding of custom types below.
9 type Response1 struct {
10 Page int
11 Fruits []string
12 }
13 type Response2 struct {
14 Page int `json:"page"`
15 Fruits []string `json:"fruits"`
16 }
17
18 func main() {
19
20 // First we‘ll look at encoding basic data types to
21 // JSON strings. Here are some examples for atomic
22 // values.
23 bolB, _ := json.Marshal(true)
24 fmt.Println(string(bolB))
25
26 intB, _ := json.Marshal(1)
27 fmt.Println(string(intB))
28
29 fltB, _ := json.Marshal(2.34)
30 fmt.Println(string(fltB))
31
32 strB, _ := json.Marshal("gopher")
33 fmt.Println(string(strB))
34
35 // And here are some for slices and maps, which encode
36 // to JSON arrays and objects as you‘d expect.
37 slcD := []string{"apple", "peach", "pear"}
38 slcB, _ := json.Marshal(slcD)
39 fmt.Println(string(slcB))
40
41 mapD := map[string]int{"apple": 5, "lettuce": 7}
42 mapB, _ := json.Marshal(mapD)
43 fmt.Println(string(mapB))
44
45 // The JSON package can automatically encode your
46 // custom data types. It will only include exported
47 // fields in the encoded output and will by default
48 // use those names as the JSON keys.
49 res1D := &Response1{
50 Page: 1,
51 Fruits: []string{"apple", "peach", "pear"}}
52 res1B, _ := json.Marshal(res1D)
53 fmt.Println(string(res1B))
54
55 // You can use tags on struct field declarations
56 // to customize the encoded JSON key names. Check the
57 // definition of `Response2` above to see an example
58 // of such tags.
59 res2D := &Response2{
60 Page: 1,
61 Fruits: []string{"apple", "peach", "pear"}}
62 res2B, _ := json.Marshal(res2D)
63 fmt.Println(string(res2B))
64
65 // Now let‘s look at decoding JSON data into Go
66 // values. Here‘s an example for a generic data
67 // structure.
68 byt := []byte(`{"num":6.13,"strs":["a","b"]}`)
69
70 // We need to provide a variable where the JSON
71 // package can put the decoded data. This
72 // `map[string]interface{}` will hold a map of strings
73 // to arbitrary data types.
74 var dat map[string]interface{}
75
76 // Here‘s the actual decoding, and a check for
77 // associated errors.
78 if err := json.Unmarshal(byt, &dat); err != nil {
79 panic(err)
80 }
81 fmt.Println(dat)
82
83 // In order to use the values in the decoded map,
84 // we‘ll need to cast them to their appropriate type.
85 // For example here we cast the value in `num` to
86 // the expected `float64` type.
87 num := dat["num"].(float64)
88 fmt.Println(num)
89
90 // Accessing nested data requires a series of
91 // casts.
92 strs := dat["strs"].([]interface{})
93 str1 := strs[0].(string)
94 fmt.Println(str1)
95
96 // We can also decode JSON into custom data types.
97 // This has the advantages of adding additional
98 // type-safety to our programs and eliminating the
99 // need for type assertions when accessing the decoded
100 // data.
101 str := `{"page": 1, "fruits": ["apple", "peach"]}`
102 res := Response2{}
103 json.Unmarshal([]byte(str), &res)
104 fmt.Println(res)
105 fmt.Println(res.Fruits[0])
106
107 // In the examples above we always used bytes and
108 // strings as intermediates between the data and
109 // JSON representation on standard out. We can also
110 // stream JSON encodings directly to `os.Writer`s like
111 // `os.Stdout` or even HTTP response bodies.
112 enc := json.NewEncoder(os.Stdout)
113 d := map[string]int{"apple": 5, "lettuce": 7}
114 enc.Encode(d)
115 }
执行上面代码，将得到以下输出结果
1 true
2 1
3 2.34
4 "gopher"
5 ["apple","peach","pear"]
6 {"apple":5,"lettuce":7}
7 {"Page":1,"Fruits":["apple","peach","pear"]}
8 {"page":1,"fruits":["apple","peach","pear"]}
9 map[num:6.13 strs:[a b]]
10 6.13
11 a
12 {1 [apple peach]}
13 apple
14 {"apple":5,"lettuce":7}
5、数字解析
1 package main
2
3 // The built-in package `strconv` provides the number
4 // parsing.
5 import "strconv"
6 import "fmt"
7
8 func main() {
9
10 // With `ParseFloat`, this `64` tells how many bits of
11 // precision to parse.
12 f, _ := strconv.ParseFloat("1.234", 64)
13 fmt.Println(f)
14
15 // For `ParseInt`, the `0` means infer the base from
16 // the string. `64` requires that the result fit in 64
17 // bits.
18 i, _ := strconv.ParseInt("123", 0, 64)
19 fmt.Println(i)
20
21 // `ParseInt` will recognize hex-formatted numbers.
22 d, _ := strconv.ParseInt("0x1c8", 0, 64)
23 fmt.Println(d)
24
25 // A `ParseUint` is also available.
26 u, _ := strconv.ParseUint("789", 0, 64)
27 fmt.Println(u)
28
29 // `Atoi` is a convenience function for basic base-10
30 // `int` parsing.
31 k, _ := strconv.Atoi("135")
32 fmt.Println(k)
33
34 // Parse functions return an error on bad input.
35 _, e := strconv.Atoi("wat")
36 fmt.Println(e)
37 }
执行上面代码，将得到以下输出结果
1 1.234 2 123 3 456 4 789 5 135 6 strconv.ParseInt: parsing "wat": invalid syntax
6、Url解析
1 package main
2
3 import "fmt"
4 import "net"
5 import "net/url"
6
7 func main() {
8
9 s := "postgres://user:[email protected]:5432/path?k=v#f"
10
11 u, err := url.Parse(s)
12 if err != nil {
13 panic(err)
14 }
15
16 fmt.Println(u.Scheme)
17
18 fmt.Println(u.User)
19 fmt.Println(u.User.Username())
20 p, _ := u.User.Password()
21 fmt.Println(p)
22
23 fmt.Println(u.Host)
24 host, port, _ := net.SplitHostPort(u.Host)
25 fmt.Println(host)
26 fmt.Println(port)
27
28 fmt.Println(u.Path)
29 fmt.Println(u.Fragment)
30
31 fmt.Println(u.RawQuery)
32 m, _ := url.ParseQuery(u.RawQuery)
33 fmt.Println(m)
34 fmt.Println(m["k"][0])
35 }
执行上面代码，将得到以下输出结果
1 postgres 2 user:pass 3 user 4 pass 5 host.com:5432 6 host.com 7 5432 8 /path 9 f 10 k=v 11 map[k:[v]] 12 v
7、SHA1哈希
package main
// Go implements several hash functions in various
// `crypto/*` packages.
import "crypto/sha1"
import "fmt"
func main() {
s := "sha1 this string"//原始字符串
h := sha1.New()//加密对象
h.Write([]byte(s))//将原始字符串转换成字节切片传给加密对象
bs := h.Sum(nil)//哈希结果追加和片段 可以不需要
fmt.Println(s)//打印原始字符串
fmt.Printf("%x\n", bs)//输出哈希结果
}
执行上面代码，将得到以下输出结果
1 sha1 this string 2 cf23df2207d99a74fbe169e3eba035e633b65d94
8、Base64编码
Go提供对base64编码/解码的内置支持。导入带有b64名称的encoding/base64软件包，而不是默认的base64。它会节省我们一些空间。编码器需要一个[]byte，所以将字符串转换为该类型。
1 import b64 "encoding/base64"
2 import "fmt"
3
4 func main() {
5 data := "abc123!?$*&()‘[email protected]~"
6
7 sEnc := b64.StdEncoding.EncodeToString([]byte(data))
8 fmt.Println(sEnc)
9
10
11 sDec, _ := b64.StdEncoding.DecodeString(sEnc)
12 fmt.Println(string(sDec))
13 fmt.Println()
14
15 uEnc := b64.URLEncoding.EncodeToString([]byte(data))
16 fmt.Println(uEnc)
17 uDec, _ := b64.URLEncoding.DecodeString(uEnc)
18 fmt.Println(string(uDec))
19 }
执行上面代码，将得到以下输出结果
1 YWJjMTIzIT8kKiYoKSctPUB+ 2 abc123!?$*&()‘[email protected]~ 3 4 YWJjMTIzIT8kKiYoKSctPUB- 5 abc123!?$*&()‘[email protected]~
9、文件读写
读取和写入文件是许多Go程序所需的基本任务。
1、读取文件
1 package main
2
3 import (
4 "bufio"
5 "fmt"
6 "io"
7 "io/ioutil"
8 "os"
9 )
10 //检查error状态 如果包含错误信息 则使用panic中断
11 func check(e error) {
12 if e != nil {
13 panic(e)
14 }
15 }
16
17 func main() {
18
19 dat, err := ioutil.ReadFile("/tmp/dat")//直接读取文件内容到内存
20 check(err)
21 fmt.Print(string(dat))
22
23 //使用os.Open打开文件 以获取文件的更多操作
24 f, err := os.Open("/tmp/dat")
25 check(err)
26
27 b1 := make([]byte, 5)
28 n1, err := f.Read(b1)//读取5个字节
29 check(err)
30 fmt.Printf("%d bytes: %s\n", n1, string(b1))
31
32 o2, err := f.Seek(6, 0)//定位到文件开头6个字符后
33 check(err)
34 b2 := make([]byte, 2)
35 n2, err := f.Read(b2)//读取2个字节
36 check(err)
37 fmt.Printf("%d bytes @ %d: %s\n", n2, o2, string(b2))
38
39 o3, err := f.Seek(6, 0)
40 check(err)
41 b3 := make([]byte, 2)
42 n3, err := io.ReadAtLeast(f, b3, 2)//使用io对象读取
43 check(err)
44 fmt.Printf("%d bytes @ %d: %s\n", n3, o3, string(b3))
45
46 _, err = f.Seek(0, 0)//定位到文件开始位置
47 check(err)
48
49 r4 := bufio.NewReader(f)//bufio先读取到缓存
50 b4, err := r4.Peek(5)//然后从缓存中拿字节 比较高效
51 check(err)
52 fmt.Printf("5 bytes: %s\n", string(b4))
53
54 f.Close()
55 }
执行上面代码，将得到以下输出结果
1 abcdfawef!@ 2 cawfe 3 awefawef 4 5 awefaf 6 5 bytes: abcdf 7 2 bytes @ 6: we 8 2 bytes @ 6: we 9 5 bytes: abcdf
2、文件写入
1 package main
2
3 import (
4 "bufio"
5 "fmt"
6 "io/ioutil"
7 "os"
8 )
9
10 func check(e error) {
11 if e != nil {
12 panic(e)
13 }
14 }
15
16 func main() {
17 d1 := []byte("hello\ngo\n")
18 err := ioutil.WriteFile("dat1.txt", d1, 0644)
19 check(err)
20
21 f, err := os.Create("dat2.txt")
22 check(err)
23
24 defer f.Close()//延迟关闭文件操作(f超出作用域)
25
26 d2 := []byte{115, 111, 109, 101, 10}
27 n2, err := f.Write(d2)
28 check(err)
29 fmt.Printf("wrote %d bytes\n", n2)
30
31 n3, err := f.WriteString("writes\n")
32 fmt.Printf("wrote %d bytes\n", n3)
33
34 f.Sync()
35
36 w := bufio.NewWriter(f)
37 n4, err := w.WriteString("buffered\n")
38 fmt.Printf("wrote %d bytes\n", n4)
39
40 w.Flush()
41 }
10、行过滤器
1 package main
2
3 import (
4 "bufio"//读写
5 "fmt"//格式化输出
6 "os"//操作系统
7 "strings"//字符串
8 )
9
10 func main() {
11 scanner := bufio.NewScanner(os.Stdin)//扫描标准输入
12
13 for scanner.Scan() {
14 ucl := strings.ToUpper(scanner.Text())//标
15 fmt.Println(ucl)
16 }
17
18 if err := scanner.Err(); err != nil {//发送错误 退出
19 fmt.Fprintln(os.Stderr, "error:", err)
20 os.Exit(1)
21 }
22 }
11、环境变量
通过os包获取和设置环境变量
1 package main
2
3 import "os"
4 import "strings"
5 import "fmt"
6
7 func main() {
8
9 // To set a key/value pair, use `os.Setenv`. To get a
10 // value for a key, use `os.Getenv`. This will return
11 // an empty string if the key isn‘t present in the
12 // environment.
13 os.Setenv("FOO", "1")
14 fmt.Println("FOO:", os.Getenv("FOO"))
15 fmt.Println("BAR:", os.Getenv("BAR"))
16
17 // Use `os.Environ` to list all key/value pairs in the
18 // environment. This returns a slice of strings in the
19 // form `KEY=value`. You can `strings.Split` them to
20 // get the key and value. Here we print all the keys.
21 fmt.Println()
22 for _, e := range os.Environ() {
23 pair := strings.Split(e, "=")
24 fmt.Println(pair[0])
25 }
26 }
12、信号
信号通知通过在通道上发送os.Signal值来工作。
1 package main
2
3 import "fmt"
4 import "os"
5 import "os/signal"
6 import "syscall"
7
8 func main() {
9
10 sigs := make(chan os.Signal, 1)//信号通道
11 done := make(chan bool, 1)
12
13 signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
14
15 go func() {
16 sig := <-sigs//等待信号
17 fmt.Println()
18 fmt.Println(sig)
19 done <- true//发送给done通道
20 }()
21
22 fmt.Println("awaiting signal")
23 <-done//收到匿名函数发送的true值后 退出程序
24 fmt.Println("exiting")
25 }
执行上面代码，将得到以下输出结果
1 awaiting signal 2 [Ctl+C] 3 interrupt 4 exiting
时间： 2024-10-08 09:05:49