Golang string 常用方法

判断字符串是否以某个字符串开头

strings.HasPrefix(a,b) 判断a是否以b开头

package main

import (
	"fmt"
	"strings"
)

func main() {
	//判断url是否以http开头
	fmt.Println(strings.HasPrefix("http://www.baidu.com", "http")) //true
	fmt.Println(strings.HasPrefix("dns://www.baidu.com","http")) //false
}

1
2
3
4
5
6
7
8
9
10
11
12
13

判断字符串是否以某个字符串结尾

strings.HasSuffix(a,b) 判断a是否以b结尾

package main

import (
	"fmt"
	"strings"
)

func main() {
	//判断url是否以com结尾
	fmt.Println(strings.HasSuffix("http://www.baidu.com", "com")) //true
	fmt.Println(strings.HasSuffix("dns://www.baidu.vip","com")) //false
}

1
2
3
4
5
6
7
8
9
10
11
12
13

字符比较

strings.Compare(p1, p2) 判断p1是否大于p2，大于:1,小于:-1,等于:0

package main

import (
	"fmt"
	"strings"
)

func main() {
	a := "a"
	b := "b"
	c := "a"

	// strings.Compare(p1, p2) 判断p1是否大于p2，大于:1,小于:-1,等于:0
	fmt.Println(strings.Compare(a, b)) //-1
	fmt.Println(strings.Compare(a, c)) //0
	fmt.Println(strings.Compare(b, a)) //1
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

字符串判断包含关系

1.strings.Contains(p1,p2) 判断p1字符串中是否包含p2
2.strings.ContainsAny(p1,p2) 判断p1是否包含字符串p2中的某个字符，包含就返回true

package main

import (
	"fmt"
	"strings"
)

func main() {
	a := "abac"

	//strings.Contains(p1,p2) 判断p1字符串中是否包含p2
	fmt.Println(strings.Contains(a, "ba")) //true
	fmt.Println(strings.Contains(a, "eb")) //false

	//strings.ContainsAny(p1,p2) 判断p1是否包含字符串p2中的某个字符，包含就返回true
	fmt.Println(strings.ContainsAny(a, "eb")) //true a中包含字符b
	fmt.Println(strings.ContainsAny(a, "e"))  //false
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

判断子串在字符串中出现的位置

1.strings.Index(p1,p2) p2在p1中第一次出现的位置,未出现返回-1
2.strings.LastIndex(p1,p2) p2在p1中最后一次出现的位置,未出现返回-1

package main

import (
	"fmt"
	"strings"
)

func main() {
   a := "abdeabf"
   //strings.Index(p1,p2) p2在p1中第一次出现的位置,未出现返回-1
   fmt.Println(strings.Index(a,"ab")) //0
   //strings.LastIndex(p1,p2) p2在p1中最后一次出现的位置,未出现返回-1
   fmt.Println(strings.LastIndex(a,"ab")) //4
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

判断子串在主串中出现的次数

strings.Count(p1,p2) 统计p2在p1中出现的次数,未出现返回0次

package main

import (
	"fmt"
	"strings"
)

func main() {
	a := "abcadef"

	//strings.Count(p1,p2) 统计p2在p1中出现的次数,未出现返回0次
	fmt.Println(strings.Count(a, "ab")) //1
	fmt.Println(strings.Count(a, "a"))  //2
	fmt.Println(strings.Count(a, "s"))  //0
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

分割字符串

1.strings.Fields(p1),使用空字符分割p1
2.strings.Split(p1,tag) 字符串在tag元素处切一刀(有几个切几刀)，获得切割后的切片
3.strings.Split(p1,tag,n) 和 Split功能一样，只不过能通过n指定切割后的元素个数

package main

import (
	"fmt"
	"strings"
)

func main() {
	a := "abcadefa"
	b := "a\tb\rc\ne h\fn l k"

	//strings.Fields(p1),使用空字符分割p1
	fmt.Println(strings.Fields(a)) //[abcadef]
	fmt.Println(strings.Fields(b)) //[a b c e h l k]

	//strings.Split(p1,tag) 字符串在tag元素处切一刀，获得切割后的切片
	fmt.Println(strings.Split(a,"")) //[a b c a d e f]
	//注意bc前，def后有个空字符,加起来一共四个元素(一个东西切三刀，刚好四个元素)
	fmt.Println(strings.Split(a,"a")) //[ bc def ]
	//strings.Split(p1,tag,n) 和 Split功能一样，只不过能通过n指定切割后的元素个数
    fmt.Println(strings.SplitN(a,"a", 2)) // [ bcdef]
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

切片拼接成字符串

strings.Join(s,sep) 使用sep将切片s拼接成字符串

package main

import (
	"fmt"
	"strings"
)

func main() {
	a := []string{"a", "b", "c"}
	// strings.Join(s,sep) 使用sep将切片s拼接成字符串
	fmt.Println(strings.Join(a, "-")) //a-b-c
}

1
2
3
4
5
6
7
8
9
10
11
12
13

重复字符串

strings.Repeat(p1,n) n个p1拼接得到新字符串

package main

import (
	"fmt"
	"strings"
)

func main() {
   a := "abc"
   // strings.Repeat(p1,n) n个p1拼接得到新字符串
   fmt.Println(strings.Repeat(a,3)) //abcabcabc
}

1
2
3
4
5
6
7
8
9
10
11
12
13

替换字符串

1.strings.Replace(p1,p2,p3,n) 将p1中的p2替换成p3，最多替换n个
2.strings.ReplaceAll(p1,p2,p3) 将p1中的所有p2替换成p3

package main

import (
	"fmt"
	"strings"
)

func main() {
	a := "abcabc"
	//strings.Replace(p1,p2,p3,n) 将p1中的p2替换成p3，最多替换n个
	fmt.Println(strings.Replace(a, "a", "s", 1)) //sbcabc
	//strings.ReplaceAll(p1,p2,p3) 将p1中的所有p2替换成p3
	fmt.Println(strings.ReplaceAll(a,"a","s")) //sbcsbc
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

大小写转换

1.strings.ToUpper(p1) 将p1中字符全部转为大写
2.strings.ToLower(p1) 将p1中的字符全部转为小写
3.strings.Title(p1) 将p1中的单词首字母大写

package main

import (
	"fmt"
	"strings"
)

func main() {
	a := "hello world"
	// strings.ToUpper(p1) 将p1中字符全部转为大写
	b := strings.ToUpper(a)
	fmt.Println(b) //HELLO WORLD
	// strings.ToLower(p1) 将p1中的字符全部转为小写
	c := strings.ToLower(b)
	fmt.Println(c) //hello world

	//strings.Title(p1) 将p1中的单词首字母大写
	fmt.Println(strings.Title(c)) //Hello Word

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

字符过滤

1.strings.Trim(p1,tag) 过滤p1左右两层tag
2.strings.TrimLeft(p1,tag) 过滤p1左侧tag
3.strings.TrimRight(p1,tag) 过滤p1右侧tag
4.strings.TrimSpace(p1) 过滤p1两侧空格

package main

import (
	"fmt"
	"strings"
)

func main() {
	 a := ":abc:"

	 //strings.Trim(p1,tag) 过滤p1左右两层tag
	 fmt.Println(strings.Trim(a,":")) //abc
	 //strings.TrimLeft(p1,tag) 过滤p1左侧tag
	 fmt.Println(strings.TrimLeft(a,":"))//abc:
	 //strings.TrimRight(p1,tag) 过滤p1右侧tag
	 fmt.Println(strings.TrimRight(a,":")) //:abc
	 b := "  a bc  "
	 //strings.TrimSpace(p1,tag) 过滤p1两侧空格
	 fmt.Println(strings.TrimSpace(b)) //a bc
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21