Go语言 Day06 Summary part1

1.Regular Expressions

Go offers built-in support for regular expressions. Here are some examples of common regexp-related tasks in Go.

[maxwell@oracle-db-19c Day06]$ vim regular_expressions.go   
[maxwell@oracle-db-19c Day06]$ cat regular_expressions.go   
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))
}
[maxwell@oracle-db-19c Day06]$ go run regular_expressions.go
true
true
peach
idx: [0 5]
[peach ea]
[0 5 1 3]
[peach punch pinch]
all: [[0 5 1 3] [6 11 7 9] [12 17 13 15]]
[peach punch]
true
regexp: p([a-z]+)ch
a <fruit>
a PEACH
[maxwell@oracle-db-19c Day06]$ 

2.JSON

Go offers built-in support for JSON encoding and decoding, including to and from built-in and custom data types.

[maxwell@oracle-db-19c Day06]$ vim json.go   
[maxwell@oracle-db-19c Day06]$ cat json.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)
}
[maxwell@oracle-db-19c Day06]$ go run json.go
true
1
2.34
"gopher"
["apple","peach","pear"]
{"apple":5,"lettuce":7}
{"Page":1,"Fruits":["apple","peach","pear"]}
{"page":1,"fruits":["apple","peach","pear"]}
map[num:6.13 strs:[a b]]
6.13
a
{1 [apple peach]}
apple
{"apple":5,"lettuce":7}
[maxwell@oracle-db-19c Day06]$