go語言字符串的處理與json轉換

1 字符串的處理

 能夠經過Go標準庫中的strings和strconv兩個包中的函數進行相應的操做

1 字符串的操做

1 func Contains(s, substr string) bool
2 字符串s中是否包含substr，返回bool值

package main

import (
    "fmt"
    "strings"
)
//1 func Contains(s, substr string) bool
//字符串s中是否包含substr，返回bool值
func main() {
    fmt.Println(strings.Contains("hello","llo"))
}
//2 func Join(a []string, sep string) string
//字符串連接，把slice a經過sep連接起來
func main() {
   s := []string{"abc", "456", "999"}
   fmt.Println(strings.Join(s, "** "))
}
//3 func Index(s, sep string) int
//在字符串s中查找sep所在的位置，返回位置值，找不到返回-1
func main() {
   fmt.Println(strings.Index("chicken", "ken"))
}
//4 func Repeat(s string, count int) string
//重複s字符串count次，最後返回重複的字符串
func main() {
   fmt.Println("ba" + strings.Repeat("na", 2))
}
//5 func Replace(s, old, new string, n int) string
//在s字符串中，把old字符串替換爲new字符串，n表示替換的次數，小於0表示所有替換
func main() {
   fmt.Println(strings.Replace("ok ok ok", "k", "ky", 2))
}
//6  func Split(s, sep string) []string
//把s字符串按照sep分割，返回slice
func main() {
   fmt.Printf("%q\n", strings.Split("a,b,c", ","))
}
//7 func Trim(s string, cutset string) string
//在s字符串的頭部和尾部去除cutset指定的字符串
func main() {
   fmt.Printf("[%q]", strings.Trim(" !哈!哈! ", "! "))
}
//8 func Fields(s string) []string
//去除s字符串的空格符，而且按照空格分割返回slice
func main() {
   fmt.Println( strings.Fields("  a b  c   "))
}

2. 字符串轉換

　　 Append系列函數：將整數等轉換爲字符串後，添加到現有的字節數組中

package main

import (
   "fmt"
   "strconv"
)

func main() {
   str := make([]byte, 0, 100)
   //以10進制方式追加
   str = strconv.AppendInt(str, 4567, 10)
   str = strconv.AppendBool(str, false)
   str = strconv.AppendQuote(str, "abcdefg")
   str = strconv.AppendQuoteRune(str, '單')
   fmt.Println(string(str))
}

　　Format系列函數：把其餘類型的轉換爲字符串

package main

import (
   "fmt"
   "strconv"
   "reflect"
)

func main() {
   a := strconv.FormatBool(false)
   b := strconv.FormatInt(-1234, 10)
   //Uint無符號
   c := strconv.FormatUint(1234, 10)
   //與FormatInt同樣，簡寫
   d := strconv.Itoa(-2234)
   fmt.Println(a, b, c, d)
   fmt.Println(reflect.TypeOf(a))
}

2 處理json

　　使用go語言內置的encoding/json 標準庫

　　1）編碼json 

func Marshal(v interface{}) ([]byte, error) 

　　2） 經過結構體生成json

package main

import (
   "encoding/json"
   "fmt"
)

type Person struct {
   Name  string
   Hobby string
}

func main() {
   //1.方式一
   p := Person{"Mr.Sun", "女"}
   b, err := json.Marshal(p)
   if err != nil {
      fmt.Println("json err:", err)
   }
   fmt.Println(string(b))

   //2.方式二：格式化
   //第二個參數：每行的前綴
   //第三個參數：每行的縮進格式
   b, err = json.MarshalIndent(p,"","    ")
   if err != nil {
      fmt.Println("json err:", err)
   }
   fmt.Println(string(b))
}

　　3） struct tag    　　tag用來給json字段起別名，也能夠隱藏字段

　　4）經過map生成json

package main

import (
   "encoding/json"
   "fmt"
)

func main() {
   //建立保存任意值的map
   mmp := make(map[string]interface{})
   mmp["name"] = "Mr.Sun"
   mmp["age"] = 18
   mmp["niubility"] = true

   //轉json
   json, err := json.Marshal(mmp)
   if err != nil {
      fmt.Println("json err:", err)
   }
   fmt.Println(string(json))
}

解碼json

　　 解析到結構體

 

package main

import (
   "encoding/json"
   "fmt"
)

type Person struct {
   Name  string `json:"name"`
   Hobby string `json:"hobby"`
}

func main() {
   //1.建立json數據
   b := []byte(`{"Name":"zhangsan","Hobby":"女"}`)
   //2.聲明結構體
   var p Person
   //3.json解析到結構體
   err := json.Unmarshal(b, &p)
   if err != nil {
      fmt.Println("json err:", err)
   }
   fmt.Println(p)
}

　　解析到interface

package main

import (
   "encoding/json"
   "fmt"
)

func main() {
   //1.建立json數據
   b := []byte(`{"Name":"zhangsan","Hobby":"女"}`)
   //2.聲明空interface
   var i interface{}
   //3.解析
   err := json.Unmarshal(b, &i)
   if err != nil {
      fmt.Println(err)
   }
   //默認轉成了map
   fmt.Println(i)
   //4.解析到interface的json能夠判斷類型
   m := i.(map[string]interface{})
   for k, v := range m {
      switch vv := v.(type) {
      case string:
         fmt.Println(k, "是string類型", vv)
      case int:
         fmt.Println(k, "是int類型", vv)
      default:
         fmt.Println("xxx")
      }
   }
}