fmt包

package main

import "fmt"

func main() {
        type Person struct {
                Name string
        }
        var people = Person{Name: "mark"}

        //1.普通占位符
        //%v(相應值的默認格式)
        fmt.Printf("%v", people) //{mark}

        //%+v(打印結構體時，會添加字段名)
        fmt.Printf("%+v", people) //{Name:mark}

        //%#v(相應值的Go語法表示)
        fmt.Printf("%#v", people) //main.Person{Name:"mark"}

        //%T(相應值的類型的Go語法表示)
        fmt.Printf("%T", people) //main.Person

        //%%(字面上的百分號，並非值的占位符)
        fmt.Printf("%%") //%

        //2.布爾占位符
        //%t(true 或 false)
        fmt.Printf("%t", true) //true

        //3.整數占位符
        //%b(二進制表示)
        fmt.Printf("%b", 5) //101

        //%c(相應Unicode碼點所表示的字符)
        fmt.Printf("%c", 0x4E2D) //中

        //%d(十進制表示)
        fmt.Printf("%d", 0x12) //18

        //%o(八進制表示)
        fmt.Printf("%o", 10) //12

        //%q(單引號圍繞的字符字面值，由Go語法安全地轉義)
        fmt.Printf("%q", 0x4E2D) //'中'

        //%x(十六進制表示，字母形式為小寫a-f)
        fmt.Printf("%x", 13) //d

        //%X(十六進制表示，字母形式為小寫A-F)
        fmt.Printf("%X", 13) //D

        //%U(Unicode格式：U+1234，等同於 "U+%04X")
        fmt.Printf("%U", 0x4E2D) //U+4E2D

        //4.浮點數和覆數的組成部分
        //%b(無小數部分的，指數為二的冪的科學計數法)
        fmt.Printf("%b", 10.2) //5742089524897382p-49

        //%e(科學計數法,例如 -1234.456e+78)
        fmt.Printf("%e", 10.2) //1.020000e+01

        //%E(科學計數法,例如 -1234.456E+78)
        fmt.Printf("%E", 10.2) //1.020000E+01

        //%f(有小數點而無指數，例如123.456)
        fmt.Printf("%f", 10.2) //10.200000

        //%g(根據情況選擇%e或%f以產生更緊湊的(無末尾的0))
        fmt.Printf("%g", 10.20) //10.2

        //%G(根據情況選擇%E或%f以產生更緊湊的(無末尾的0))
        fmt.Printf("%G", 10.20+2i) //(10.2+2i)

        //5.字符串與字節切片
        //%s(輸出字符串表示(string類型或[]byte))
        fmt.Printf("%s", []byte("Go語言")) //Go語言

        //%q(雙引號圍繞的字符串，由Go語法安全地轉義)
        fmt.Printf("%q", "Go語言") //"Go語言"

        //%x(十六進制，小寫字母，每字節兩個字符)
        fmt.Printf("%x", "golang") //676f6c616e67

        //%X(十六進制，大寫字母，每字節兩個字符)
        fmt.Printf("%X", "golang") //676F6C616E67

        //6.指針
        //%p(十六進制表示，前綴0x)
        fmt.Printf("%p", &people) //0xc0420421d0
}

strings包

package main

import (
        "bytes"
        "fmt"
        "strings"
)

func main() {
        s := "Hello,World!!!!!"

        //Count計算字符串sep在s中的非重疊個數：2
        //func Count(s, sep string) int
        strings.Count(s, "!!")

        //Contains判斷字符串s中是否包含子串substr：true
        //func Contains(s, substr string) bool
        strings.Contains(s, "Hello")

        //ContainsAny判斷字符串s中是否包含chars中的任何一個字符：true
        //func ContainsAny(s, chars string) bool
        strings.ContainsAny(s, "HJK")

        //ContainsRune判斷字符串s中是否包含字符r：true
        //Go語言的單引號一般用來表示「rune literal」，即碼點字面量
        //func ContainsRune(s string, r rune) bool
        strings.ContainsRune(s, 'H')

        //Index返回子串sep在字符串s中第一次出現的位置,如果找不到，則返回-1：6
        //func Index(s, sep string) int
        strings.Index(s, "W")

        //LastIndex返回子串sep在字符串s中最後一次出現的位置,如果找不到，則返回-1：9
        //func LastIndex(s, sep string) int
        strings.LastIndex(s, "l")

        //IndexRune返回字符r在字符串s中第一次出現的位置,如果找不到，則返回-1：6
        //func IndexRune(s string, r rune) int
        strings.IndexRune(s, 'W')

        //IndexAny返回字符串chars中的任何一個字符在字符串s中第一次出現的位置：8
        //如果找不到，則返回-1
        //func IndexAny(s, chars string) int
        strings.IndexAny(s, "rd")

        //LastIndexAny返回字符串chars中的任何一個字符在字符串s中最後一次出現的位置：10
        //如果找不到，則返回-1
        //func LastIndexAny(s, chars string) int
        strings.LastIndexAny(s, "rd")

        //Split以sep為分隔符，將s切分成多個子切片：[Hello World!!!!!]
        //func Split(s, sep string) []string
        strings.Split(s, ",")

        //Join將a中的子串連接成一個字符串，用sep分隔：Monday|Tuesday|Wednesday
        //func Join(a []string, sep string) string
        ss := []string{"Monday", "Tuesday", "Wednesday"}
        strings.Join(ss, "|")

        //HasPrefix判斷字符串s是否以prefix開頭：true
        //func HasPrefix(s, prefix string) bool
        strings.HasPrefix(s, "He")

        //HasSuffix判斷字符串s是否以prefix結尾：true
        //func HasSuffix(s, suffix string) bool
        strings.HasSuffix(s, "!!")

        //Repeat將count個字符串s連接成一個新的字符串
        //func Repeat(s string, count int) string
        strings.Repeat(s, 2)

        //ToUpper將s中的所有字符修改為其大寫格式：HELLO,WORLD!!!!!
        //func ToUpper(s string) string
        strings.ToUpper(s)

        //ToLower將s中的所有字符修改為其小寫格式：hello,world!!!!!
        //func ToLower(s string) string
        strings.ToLower(s)

        //Trim將刪除s首尾連續的包含在cutset中的字符：世界
        //func Trim(s string, cutset string) string
        sss := " Hello 世界! "
        strings.Trim(sss, " Helo!")

        //TrimLeft將刪除s頭部連續的包含在cutset中的字符：世界！
        //func TrimLeft(s string, cutset string) string
        strings.TrimLeft(sss, " Helo")

        //TrimRight將刪除s尾部連續的包含在cutset中的字符： Hello
        //func TrimRight(s string, cutset string) string
        strings.TrimRight(sss, " 世界!")

        //TrimSpace將刪除s首尾連續的的空白字符：Hello 世界!
        //func TrimSpace(s string) string
        strings.TrimSpace(sss)

        //TrimPrefix刪除s頭部的prefix字符串：,World!!!!!
        //func TrimPrefix(s, prefix string) string
        strings.TrimPrefix(s, "Hello")

        //TrimSuffix刪除s尾部的suffix字符串：Hello,World!
        //func TrimSuffix(s, suffix string) string
        strings.TrimSuffix(s, "!!!!")

        //Replace返回s的副本，並將副本中的old字符串替換為new字符串
        //替換次數為 n 次，如果 n 為 -1，則全部替換
        //func Replace(s, old, new string, n int) string
        strings.Replace(s, "!", "|", -1)

        //EqualFold判斷s和t是否相等。忽略大小寫，同時它還會對特殊字符進行轉換：true
        //比如將“ϕ”轉換為“Φ”、將“DŽ”轉換為“Dž”等，然後再進行比較
        //func EqualFold(s, t string) bool
        s1 := "Hello 世界! ϕ DŽ"
        s2 := "hello 世界! Φ Dž"
        strings.EqualFold(s1, s2)

        //通過字符串s創建strings.Reader對象
        //func NewReader(s string) *Reader { return &Reader{s, 0, -1} }
        r := strings.NewReader(s)

        //Len返回r.i之後的所有數據的字節長度:16
        //func (r *Reader) Len() int
        r.Len()

        //Read將r.i之後的所有數據寫入到b中（如果b的容量足夠大）
        //func (r *Reader) Read(b []byte) (n int, err error)
        b := make([]byte, 5)
        for n, _ := r.Read(b); n > 0; n, _ = r.Read(b) {
                fmt.Println(string(b[:n])) //"Hello", ",Worl", "d!!!!", "!",
        }

        //ReadAt將off之後的所有數據寫入到b中（如果 b 的容量足夠大）
        //func (r *Reader) ReadAt(b []byte, off int64) (n int, err error)
        n, _ := r.ReadAt(b, 6)
        fmt.Println(string(b[:n])) //World

        //ReadByte將r.i之後的一個字節寫入到返回值b中
        //func (r *Reader) ReadByte() (b byte, err error)
        r.ReadByte()

        //Seek用來移動r中的索引位置，offset：要移動的偏移量，負數表示反向移動
        //whence：從那裏開始移動，0：起始位置，1：當前位置，2：結尾位置
        //func (r *Reader) Seek(offset int64, whence int) (int64, error)
        r1 := strings.NewReader(s)
        b1 := make([]byte, 5)
        r1.Seek(6, 0) // 移動索引位置到第7個字節
        r1.Read(b1)   // 開始讀取
        fmt.Printf("%q\n", b1)
        r1.Seek(-5, 1) // 將索引位置移回去
        r1.Read(b1)    // 繼續讀取
        fmt.Printf("%q\n", b1)

        //WriteTo 將 r.i 之後的數據寫入接口 w 中
        //func (r *Reader) WriteTo(w io.Writer) (n int64, err error)
        r2 := strings.NewReader(s)
        buf := bytes.NewBuffer(nil)
        r2.WriteTo(buf)
        fmt.Printf("%q\n", buf) //"Hello,World!!!!!"

        //NewReplacer 通過“替換列表”創建一個 Replacer 對象。
        //按照“替換列表”中的順序進行替換，只替換非重疊部分。
        //如果參數的個數不是偶數，則拋出異常。
        //func NewReplacer(oldnew ...string) *Replacer

        //Replace 返回對 s 進行“查找和替換”後的結果
        //Replace 使用的是 Boyer-Moore 算法，速度很快
        //func (r *Replacer) Replace(s string) string
        srp := strings.NewReplacer("Hello", "你好", "World", "世界", "!", "！")
        s = "Hello World!Hello World!hello world!"
        rst := srp.Replace(s)
        fmt.Print(rst) //你好 世界！你好 世界！hello world！

time包

package main

import (
        "fmt"
        "time"
)

func main(){
        //time.Time代表一個納秒精度的時間點
        var t time.Time

        //返回當前時間：2017-10-23 19:16:25.3599073 +0800 CST
        t = time.Now()
        fmt.Printf("%v\n", t)

        //返回所在時區：Local
        fmt.Printf("%v\n", t.Location())

        //返回UTC時間和UTC時區：2017-10-23 11:16:25.3599073 +0000 UTC UTC
        fmt.Printf("%v %v\n", t.UTC(), t.UTC().Location())

        //同上，In()返回指定時區的時間：2017-10-23 11:16:25.3599073 +0000 UTC UTC
        fmt.Printf("%v %v\n", t.In(time.UTC), t.In(time.UTC).Location())

        //返回當地時區的時間：2017-10-23 19:16:25.3599073 +0800 CST Local
        fmt.Printf("%v %v\n", t.Local(), t.Local().Location())

        //根據時間戳返回本地時間，參數分別表示秒數和納秒數
        //2017-02-23 00:13:30 +0800 CST
        t2 := time.Unix(1487780010, 0)
        fmt.Println(t2)

        //根據指定時間返回time.Time，分別指定年，月，日，時，分，秒，納秒，時區
        //2017-05-26 15:30:20 +0800 CST
        t3 := time.Date(2017, time.Month(5), 26, 15, 30, 20, 0, t.Location())
        fmt.Println(t3)

        //格式化輸出時間：2017-10-23 19:16:25
        t4 := time.Now()
        fmt.Println(t4.Format("2006-01-02 15:04:05"))

        //獲取時間信息：2017 October 23
        t5 := time.Now()

        //返回日期：2017 October 23
        fmt.Println(t5.Date())

        //返回年：2017
        fmt.Println(t5.Year())

        //返回月：October
        fmt.Println(t5.Month())

        //返回日：23
        fmt.Println(t5.Day())

        //返回星期：Monday
        fmt.Println(t5.Weekday())

        //返回ISO 9601標準下的年份和星期編號：2017 43
        fmt.Println(t5.ISOWeek())

        //返回時分秒：19 16 25
        fmt.Println(t5.Clock())

        //返回小時：19
        fmt.Println(t5.Hour())

        //返回分鐘：16
        fmt.Println(t5.Minute())

        //返回秒：25
        fmt.Println(t5.Second())

        //返回納秒：381921400
        fmt.Println(t5.Nanosecond())

        //返回一年中對應的天：296
        fmt.Println(t5.YearDay())

        //返回時區的規範名,時區相對於UTC的時間偏移量(秒)：CST 28800
        fmt.Println(t5.Zone())

        //返回時間戳：1508757385
        fmt.Println(t5.Unix())

        //返回納秒時間戳：1508757385381921400
        fmt.Println(t5.UnixNano())

        //時間的比較與計算
        t6 := time.Now()

        //是否零時時間：false
        fmt.Println(t6.IsZero())

        //t6時間在t5時間之後，返回真：true
        fmt.Println(t6.After(t5))

        //t5時間在t6時間之前，返回真：true
        fmt.Println(t5.Before(t6))

        //時間是否相同：true
        fmt.Println(t6.Equal(t6))

        //返回t6加上納秒的時間：2017-10-23 19:16:25.383933 +0800 CST
        fmt.Println(t6.Add(10000))

        //返回兩個時間之差的納秒數：2.0016ms
        fmt.Println(t6.Sub(t5))

        //返回t6加1年，1月，1天的時間：2018-11-24 19:16:25.383923 +0800 CST
        fmt.Println(t6.AddDate(1, 1, 1))

        //時間的序列化
        t7 := time.Now()

        //序列化二進制
        bin, _ := t7.MarshalBinary()

        //反序列化二進制：2017-10-23 19:16:25.383923 +0800 CST
        t7.UnmarshalBinary(bin)
        fmt.Println(t7)

        //序列化json："2017-10-23T19:16:25.383923+08:00"
        json, _ := t7.MarshalJSON()
        fmt.Println(string(json))

        //反序列化json：2017-10-23 19:16:25.383923 +0800 CST
        t7.UnmarshalJSON(json)
        fmt.Println(t7)

        //序列化文本：2017-10-23T19:16:25.383923+08:00
        txt, _ := t7.MarshalText()
        fmt.Println(string(txt))

        //反序列化文本：2017-10-23 19:16:25.383923 +0800 CST
        t7.UnmarshalText(txt)
        fmt.Println(t7)

        //gob編碼：2017-10-23 19:16:25.383923 +0800 CST
        gob, _ := t7.GobEncode()
        t7.GobDecode(gob)
        fmt.Println(t7)

        //時間段time.Duration
        dur := time.Duration(6666666600000)

        //返回字符串表示：1h51m6.6666s
        fmt.Println(dur.String())

        //返回小時表示：1.8518518333333334
        fmt.Println(dur.Hours())

        //返回分鐘表示：111.11111
        fmt.Println(dur.Minutes())

        //返回秒表示：6666.6666
        fmt.Println(dur.Seconds())

        //返回納秒表示：6666666600000
        fmt.Println(dur.Nanoseconds())

        //時區time.Location，返回時區名：local
        fmt.Println(time.Local.String())

        //通過地點名和時間偏移量返回時區：Shanghai
        fmt.Println(time.FixedZone("Shanghai", 800))

        //通過給定時區名稱，返回時區：Asia/Shanghai
        loc, _ := time.LoadLocation("Asia/Shanghai")
        fmt.Println(loc)

        //阻塞當前進程3秒
        time.Sleep(time.Second * 3)

        //定時器time.Timer，創建一個1秒後觸發定時器
        timer1 := time.NewTimer(time.Second * 1)
        <-timer1.C
        fmt.Println("timer1 end")

        //1秒後運行函數
        time.AfterFunc(time.Second * 1, func() {
                fmt.Println("wait 1 second")
        })
        time.Sleep(time.Second * 3)

        //打點器time.Ticker，創建一個打點器，在固定1秒內重覆執行
        ticker := time.NewTicker(time.Second)
        num := 1
        for {
                if num > 5 {
                        ticker.Stop()
                        break
                }
                select {
                        case <-ticker.C:
                                num++
                                fmt.Println("1 second...")
                }
        }
}