字符串

常用操作

包含

package main

import (
	"fmt"
	"strings"
)

func main() {
	var res bool

	// Contains 字符串A是否包含字符串B（相当于php中的strstr）
	str := "My name is Bob"
	res = strings.Contains(str, "name")
	fmt.Println(res) //true
}

拼接

package main

import (
	"fmt"
	"strings"
)

func main() {
	str := "My name is Bob"
	// Join 字符串组合（相当于php中的join和implode）
	strs := []string{"My", "name", "is", "Bob"}
	str = strings.Join(strs, "#")
	fmt.Println(str) //My#name#is#Bob
}

分割

package main

import (
	"fmt"
	"strings"
)

func main() {
	str := "My name is Bob"
	// Split 以指定分隔符拆分字符串（相当于php中的explode）
	strs2 := strings.Split(str, "#")
	fmt.Println(strs2) //[My name is Bob]
}

获取位置

package main

import (
	"fmt"
	"strings"
)

func main() {
	str := "My name is Bob"
	// Index（相当于php中的strpos）
	i := strings.Index(str, "name") // 不包含子串返回-1，（php中不包含返回false）
	fmt.Println(i)                  //3
}

重复拼接

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Repeat
	str2 := "Bob "
	str2 = strings.Repeat(str2, 4)
	fmt.Println(str2) //Bob Bob Bob Bob
}

去除空格

package main

import (
	"fmt"
	"strings"
)

func main() {
	str2 := "Bob "
	// Trim 去掉两头字符（相当于php中的trim，但没有默认的五空符）
	str2 = strings.Trim(str2, " ")
	fmt.Println(str2) // 字符串中最后的空格没有了  Bob
}

去除空格并分割转成切片

它主要用于将字符串按照空白字符分割成子字符串切片。

去除字符串首尾的所有空白字符（空格、制表符、换行符等）
按照一个或多个连续空白字符将字符串分割
返回一个包含所有非空子字符串的切片

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Fields 去掉空格之后，把元素放入切片中
	text := " Hello   world    this is   Go "
	words := strings.Fields(text)
	fmt.Printf("%#v , %T \n", words, words) //[]string{"Hello", "world", "this", "is", "Go"} , []string
}

字符串转换

Append

package main

import (
	"fmt"
	"strconv"
)

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

	fmt.Println(string(str)) //4567false"abcdefg"'单'
}

其他类型的转换为字符串

Format 系列函数把其他类型的转换为字符串。

package main

import (
	"fmt"
	"strconv"
)

func main() {
	a := strconv.FormatBool(false)
	b := strconv.FormatInt(1234, 10)
	c := strconv.FormatUint(12345, 10)
	d := strconv.Itoa(1023)

	fmt.Println(a, b, c, d) //false 1234 12345 1023
}

字符串转其他类型

package main

import (
	"fmt"
	"strconv"
)

func checkError(e error) {
	if e != nil {
		fmt.Println(e)
	}
}
func main() {
	a, err := strconv.ParseBool("false")
	checkError(err)
	b, err := strconv.ParseFloat("123.23", 64)
	checkError(err)
	c, err := strconv.ParseInt("1234", 10, 64)
	checkError(err)
	d, err := strconv.ParseUint("12345", 10, 64)
	checkError(err)
	e, err := strconv.Atoi("1023")
	checkError(err)
	fmt.Println(a, b, c, d, e) //false 123.23 1234 12345 1023
}

正则表达式

基本用法

其实也很简单，只不过有两种写法，一个是FindAllString , 一个是FindAllStringSubmatch , 后者比前者多了一个功能，就是当有组的概念的时候，切片第一个元素是匹配的全部内容，第二个元素是组内的内容。看个例子就知道。

package main

import (
	"fmt"
	"regexp"
)

func main() {
	context1 := "3.14 123123 .68 haha 1.0 abc 6.66 123."

	//MustCompile解析并返回一个正则表达式。如果成功返回，该Regexp就可用于匹配文本。
	// \d 匹配数字[0-9]，d+ 重复>=1次匹配d，越多越好（优先重复匹配d）
	exp1 := regexp.MustCompile(`\d+\.\d+`)
	
	//返回保管正则表达式所有不重叠的匹配结果的[]string切片。如果没有匹配到，会返回nil。-1表示匹配全部
	//result1 := exp1.FindAllString(context1, -1) //[3.14 1.0 6.66]
	result1 := exp1.FindAllStringSubmatch(context1, -1) //[[3.14] [1.0] [6.66]]

	fmt.Printf("%v\n", result1)
	fmt.Printf("\n------------------------------------\n\n")
	
	context2 := `
<title>标题</title>
<div>你过来啊</div>
<div>hello mike</div>
<div>你大爷</div>
<body>呵呵</body>
`
	//(.*?)被括起来的表达式作为分组
	//匹配<div>xxx</div>模式的所有子串
	exp2 := regexp.MustCompile(`<div>(.*?)</div>`)
	result2 := exp2.FindAllStringSubmatch(context2, -1)

	//[[<div>你过来啊</div> 你过来啊] [<div>hello mike</div> hello mike] [<div>你大爷</div> 你大爷]]
	fmt.Printf("%v\n", result2)
	fmt.Printf("\n------------------------------------\n\n")
}

json

格式化

注意，结构体的字段必须是大写的，否者json输出不认，艹，好难受啊

package main

import (
	"encoding/json"
	"fmt"
)

type IT struct {
	// 结构体变量一定要大写，否则获取不到
	Company  string
	Subjects []string
	IsOK     bool
	Score    float64
}

/*
*
结构体/map-=json.Marshal=>[]byte-=string()=>string
*/
func main() {
	s := IT{"itcast", []string{"Go", "C++", "Java"}, false, 6.4}
	//buf, err := json.Marshal(s);
	buf, err := json.MarshalIndent(s, "", "    ") // indent最好4个空格，累容
	// buf是byte类型
	if err != nil {
		fmt.Println("err =", err)
		return
	}
	fmt.Println("buf =", string(buf))
	/**
	buf = {
	    "Company": "itcast",
	    "Subjects": [
	        "Go",
	        "C++",
	        "Java"
	    ],
	    "IsOK": false,
	    "Score": 6.4
	}
	*/

	// 通过map生成json
	map1 := make(map[string]interface{}, 4)
	map1["Company"] = "q"
	map1["Subjects"] = 13
	map1["IsOK"] = IT{"itcast", []string{"Go", "C++", "Java"}, false, 6.4}
	map1["a"] = [...]int{1, 3, 6, 9}
	buf, err = json.Marshal(map1)
	if err != nil {
		fmt.Println("err =", err)
		return
	}
	fmt.Println("buf =", string(buf)) //buf = {"Company":"q","IsOK":{"Company":"itcast","Subjects":["Go","C++","Java"],"IsOK":false,"Score":6.4},"Subjects":13,"a":[1,3,6,9]}

}

struct tag

就是对字段特殊处理一下

package main

import (
	"encoding/json"
	"fmt"
)

type IT struct {
	// 结构体变量一定要大写，否则获取不到
	Company  string   `json:"-"`        // 此字段不会输出到屏幕
	Subjects []string `json:"subjects"` // 二次编码
	IsOK     bool     `json:",string"`  //
	Score    float64
}

func main() {
	s := IT{"itcast", []string{"Go", "C++", "Java"}, false, 6.4}
	//buf, err := json.Marshal(s);
	buf, err := json.MarshalIndent(s, "", "    ") // indent最好4个空格，累容
	if err != nil {
		fmt.Println("err =", err)
		return
	}
	fmt.Println("buf =", string(buf))

	/**
	buf = {
	    "subjects": [
	        "Go",
	        "C++",
	        "Java"
	    ],
	    "IsOK": "false",
	    "Score": 6.4
	}
	*/

	// 创建一个保存键值对的映射
	t1 := make(map[string]interface{})
	t1["company"] = "itcast"
	t1["subjects "] = []string{"Go", "C++", "Python", "Test"}
	t1["isok"] = true
	t1["price"] = 666.666

	b, err := json.Marshal(t1)
	//json.MarshalIndent(t1, "", "")
	if err != nil {
		fmt.Println("json err:", err)
	}
	fmt.Println(string(b))
	//输出结果：{"company":"itcast","isok":true,"price":666.666,"subjects ":["Go","C++","Python","Test"]}
}

json字符串转结构体

package main

import (
	"encoding/json"
	"fmt"
)

type IT struct {
	// 结构体变量一定要大写，否则获取不到
	Company  string
	Subjects []string
	IsOK     bool
	Score    float64
}

func main() {
	s := "{\"Company\": \"kakaluote\",\"Subjects\": [\"Go\",\"C++\",\"Java\"],\"IsOK\": false,\"Score\": 6.4}"

	// 解析到结构体
	var tmp IT
	fmt.Println("s =", s)
	err := json.Unmarshal([]byte(s), &tmp) // 只能传对象地址，指针还不行我去
	if err != nil {
		fmt.Println("err =", err)
		return
	}
	fmt.Println(tmp)

	// 解析到map
	map1 := make(map[string]interface{}, 4)
	err = json.Unmarshal([]byte(s), &map1)
	if err != nil {
		fmt.Println("err =", err)
		return
	}
	fmt.Println(map1)
	fmt.Println("str =", map1["Company"]) // 视频上说这里会报错，需要使用类型断言

	for key, value := range map1 {
		fmt.Printf("key = %v, value = %v...", key, value)
		switch value.(type) { // 类型断言的标准写法
		case string:
			fmt.Printf("the type of map[%s] is string", key)
			break
		case int:
			fmt.Printf("the type of map[%s] is int", key)
			break
		case []string: // 匹配不到
			fmt.Printf("the type of map[%s] is []string", key)
			break
		case []interface{}: // 这才能匹配到
			fmt.Printf("the type of map[%s] is []interface", key)
			break
		case bool:
			fmt.Printf("the type of map[%s] is bool", key)
			break
		case float64:
			fmt.Printf("the type of map[%s] is float64", key)
			break
		}
		fmt.Printf("\n")
	}

	/***
	s = {"Company": "kakaluote","Subjects": ["Go","C++","Java"],"IsOK": false,"Score": 6.4}
	{kakaluote [Go C++ Java] false 6.4}
	map[Company:kakaluote IsOK:false Score:6.4 Subjects:[Go C++ Java]]
	str = kakaluote
	key = Company, value = kakaluote...the type of map[Company] is string
	key = Subjects, value = [Go C++ Java]...the type of map[Subjects] is []interface
	key = IsOK, value = false...the type of map[IsOK] is bool
	key = Score, value = 6.4...the type of map[Score] is float64
	*/
}

字符串 ​

常用操作 ​

包含 ​

拼接 ​

分割 ​

获取位置 ​

重复拼接 ​

去除空格 ​

去除空格并分割转成切片 ​

字符串转换 ​

Append ​

其他类型的转换为字符串 ​

字符串转其他类型 ​

正则表达式 ​

基本用法 ​

json ​

格式化 ​

struct tag ​

json字符串转结构体 ​

字符串