go字符串常用20个函数,len()、Contains()、Count()、Index()

len()函数

len( arg )函数可以用于统计字符串arg的长度,注意,返回的是字节数,go语言的字符串是用UTF-8编码的,一个字符占据两个字节。

len()实例

var a string = "x1y1z1.com,大器编程,璞玉天成,大器晚成!"
fmt.Println(len(a))
b := "."
c := "1"
d := "x"
e := "大"
f := ","
fmt.Println(len(b))
fmt.Println(len(c))
fmt.Println(len(d))
fmt.Println(len(e))
fmt.Println(len(f)) //我们也可以将len()函数的返回值赋值给某个变量,如len_f = len(f)
————————————————————
代码输出:
58
1
1
1
3
3

代码解析

如上代码,可知,在go语言的字符串当中,英文字母,包括英文标点符号,以及阿拉伯数字的字节大小均为1字节,汉字及汉字的标点符号,则为3个字节。


[]rune()用于字符串的类型转换

[]rune(),返回的是一个切片序列,可以将字符串转换成可供for循环进行遍历的对象。for循环将在后面的章节中介绍,所以如果不想现在了解go语言中字符串的一些操作函数,可以跳过这一章节。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var a string = "璞玉天成,大器晚成!"
	b := []rune(a) //[]rune()将字符串转换成了一个slice切片序列
	c := make([]int32, 5) //声明创建一个数据类型为int32,元素个数为5,容量cap也为5的一个切片
	fmt.Println(reflect.TypeOf(b))
	fmt.Println(reflect.TypeOf(c))
	for index, value := range b {
		fmt.Printf("索引%d的位置上的字符是:%c\n", index, value)
	}
}
——————————————————————————————————
代码输出:
[]int32
[]int32
索引0的位置上的字符是:璞
索引1的位置上的字符是:玉
索引2的位置上的字符是:天
索引3的位置上的字符是:成
索引4的位置上的字符是:,
索引5的位置上的字符是:大
索引6的位置上的字符是:器
索引7的位置上的字符是:晚
索引8的位置上的字符是:成
索引9的位置上的字符是:!

代码解析

如上代码,从b和c的类型输出可知,[]rune()是将字符串转换成一个数据类型为rune的slice切片,之后便可用于for循环进行遍历。[]rune()的返回值的类型之所以和int32类型的切片一致,是因为rune是int32的别称。那是不是很奇怪,明明是字符类型的数据,怎么会变成数值类型的呢?那是因为每个字符都对应着唯一的Unicode编码值,而这编码值便是数值类型的数据。


[]byte()函数

[]byte()与[]rune()的作用差不多,而且byte类型是uint8的别称,不过,[]byte()函数常常用于修改字符串(其实并不是修改,而是重新赋值),如下代码:

[]byte()实例

	var a string = "Hello go!"
	b := []byte(a)
	b[6] = 'G'
	c := string(b) // 如果要重新赋值给变量a,则不能用“:”符号,直接用“=”,即a=string(b),string()函数将slice转换为字符串
	fmt.Println(c)
	fmt.Println(a)
	for index, value := range b {
		fmt.Printf("索引%d的位置上的字符是:%c\n", index, value)
	}
————————————————————————————————
代码输出:
Hello Go!
Hello go!
索引0的位置上的字符是:H
索引1的位置上的字符是:e
索引2的位置上的字符是:l
索引3的位置上的字符是:l
索引4的位置上的字符是:o
索引5的位置上的字符是: 
索引6的位置上的字符是:G
索引7的位置上的字符是:o
索引8的位置上的字符是:ï
索引9的位置上的字符是:¼
索引10的位置上的字符是:

代码解析

  • 如上代码,[]byte()通常用于“修改”字符串,但要通过重新赋值,所以,严格意义上来说,这并不是修改,而且从上面的输出我们可以看出,原字符串a并没有被修改。
  • 虽然经过[]byte()转换的数据也可以用于for循环的遍历,但会出现意想不到的问题,如上面的索引8、9、10的内容输出。

strcov.Atoi()函数

该函数可以将字符串转换成整数,注意,该字符串必须是整数型的字符串,比如“123”,否则即便是浮点数的也会发生错误,如下面实例代码:

strcov.Atoi()函数实例

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var a string = "123"
	b, err := strconv.Atoi(a)
	if err == nil {
		fmt.Printf("b的类型为%T,值为%d\n", b, b) //%T与Printf()函数配合,用于输出数据的类型,相当于reflect.TypeOf()函数
	} else {
		fmt.Println("转换错误!")
	}

	var c string = "123.5"
	d, err2 := strconv.Atoi(c)
	if err2 == nil {
		fmt.Printf("c的类型为%T,值为%d\n", d, d)
	} else {
		fmt.Println("转换错误")
	}

}
——————————————————————————————————
代码输出:
b的类型为int,值为123
转换错误

strconv.Itoa()函数

strconv.Itoa( num )将整数转换成字符串,实例跟上面的strconv.Atoi()的差不多,不同的是,strconv.Itoa()只有一个返回值。

strconv.Itoa()实例

package main

import (
	"fmt"
	"strconv"
)

func main() {
	a := 123  //如果a为浮点数,如123.5,那么使用strconv.Itoa(a)会引发错误
	b := strconv.Itoa(a)
	fmt.Printf("b的类型为%T,值为%s\n", b, b)
}
————————————————————————————————————
代码输出:
b的类型为string,值为123

strings.Contains()函数

strings.Contains(superstr, substr)函数可以用查找子串是否存在于指定的字符串中。

strings.Contains()实例

	a := "璞玉天成,大器晚成"
	b := strings.Contains(a, "大器")
	fmt.Printf("b的类型为%T,值为%v\n", b, b)
——————————————————————————
代码输出:
bd的类型为bool,值为true

strings.Count()函数

strings.Count( superstr, substr)函数可以用于统计子串在指定字符串中出现的次数。

strings.Count()实例

	a := "璞玉天成,大器晚成"
	b := strings.Count(a, "成")

	fmt.Printf("b的值为%v\n", b)
————————————————————————————
代码输出:
b的值为2

stirngs.Index()函数

strings.Index( superStr, subStr )函数,用于查找子串在字符串中第一次出现的索引值,如果没有,则返回-1。

strings.Index()实例

	a := "Hello, go"
	b := strings.Index(a, "l")
	c := strings.Index(a, "f")
	fmt.Printf("b的值为%v,c的值为%v\n", b, c)
————————————————————————————————
代码输出:
b的值为2,c的值为-1

strings.LastIndex()函数

strings.LastIndex( superStr, subStr )函数用于返回子串在字符串最后一次出现的索引,如果没有,就返回-1。例子与上面的几乎一样,就不列举了。


strings.Replace()函数

strings.Replace( superStr, subStr, replaceStr, n )函数用于将指定的子串替换成另外一个子串,n可以指定替换的个数,如果为-1,则表示全部替换。

strings.Replace()实例

	a := "abcdabcdefgabdcdefa"
	b := strings.Replace(a, "b", "B", -1)
	c := strings.Replace(a, "b", "B", 2)
	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)
——————————————————————————
代码输出:
abcdabcdefgabdcdefa  //由此也可知,go语言中的字符串是不能被修改的
aBcdaBcdefgaBdcdefa
aBcdaBcdefgabdcdefa

strings.Split()函数

strings.Split( superStr, subStr )用于拆分字符串,其中参数subStr又被称为分隔标识符,该函数返回一个string类型的切片。

strings.Split()实例

	a := "hello,world,hello,go"
	strs := strings.Split(a, ",")
	fmt.Println(strs)
	fmt.Printf("strs的类型是:%T", strs)
————————————————————————
代码输出:
[hello world hello go]
strs的类型是:[]string

strings.ToLower()函数

strings.ToLower( str )函数可以将字符串全部转换成小写,适用于字母字符串。

strings.ToLower()实例

	a := "Hello,World!"
	b := strings.ToLower(a)
	fmt.Println(b)
——————————————————————————
代码输出:
hello,world!

strings.ToUpper()函数

strings.ToUpper( str )函数将字符串全部转换成大写,实例与上面的类似。


strings.TrimSpace()函数

strings.TrimSpace( str )函数用于去掉字符串两边的空格。

strings.TrimSpace()实例

	a := " x1y1z1.com,大器编程 "
	b := strings.TrimSpace(a)
	fmt.Println(a)
	fmt.Println(b)
——————————————————————————————
代码输出:
 x1y1z1.com,大器编程 //注意这个输出的两边是有空格的
x1y1z1.com,大器编程

strings.Trim()函数

strings.Trim(superStr, subStr)函数将原字符串中左右两边指定的子串(subStr)去掉。

strings.Trim()实例

	a := "Hello, goo"
	b := strings.Trim(a, "o")
	fmt.Println(b)
——————————————————————————————
代码输出:
Hello, g

strings.TrimLeft()函数和strings.TrimRight()函数

strings.TrimLeft( superStr, subStr )用于去掉字符串左边指定的字符,strings.TrimRight( superStr, subStr )用于去掉字符串右边指定的字符,实例同上面的差不多。


strings.HasPrefix()函数

strings.HasPrefix( superStr, subStr )用于判断字符串是否以指定的子串开头。

strings.HasPrefix()实例

	a := "Hello, go"
	b := strings.HasPrefix(a, "H")
	fmt.Println(b)
——————————————————————————————————
代码输出:
true

strings.HasSuffix()函数

strings.HasSuffix( superStr, subStr )函数用于判断字符串是否以指定的子串结尾。用法同上面的实例。


strings.EqualFold()函数

strings.EqualFold( str1, str2 )函数可以用于在不区分大小写的前提条件下比较字符串,若相等,返回true,否则返回false。

strings.EqualFold()实例

	a := "Hello"
	b := "hELLo"
	c := "hi"
	d := strings.EqualFold(a, b)
	e := strings.EqualFold(b, c)
	fmt.Println(d)
	fmt.Println(e)
——————————————————————————————————
代码输出:
true
false

全栈后端 / go语法 :













Copyright © 2022-2024 笨鸟工具 x1y1z1.com All Rights Reserved.