四时宝库

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")
      }
   }
}