go字符串和字节(28)

8.字符串和字节

字符串和字节切片

• 区别

bytes： 将buffer对象转换为字节切片

String： 将buffer对象转化为字符串

• 转换

可以将string通过函数byte[]转化为字节切片，同时也可通过

8.1strings包介绍

strings包提供操作UFT-8字符串常用函数

• a).常用函数

Compare： 比较字符串

Contains：是否包含子字符串

Count： 字符串出现次数

EqualFold： 不区分大小写比较

Fields： 按空白符分割字符串

Split： 分割字符串为切片

Join: 将字符串切片链接

LastIndex： 获取字符串最后一次出现的位置

Hasprefix: 是否以字符串作为某个字符串开头

HasSuffix: 是否以字符串作为某个字符串结尾

Index: 获取字符串首次出现

等

8.2strings常用操作

• 比较字符串

package main
import (
    "fmt"
    "strings"
)
func main(){
    fmt.Println(strings.Compare("abc","bac"))
}

不相等则是-1,否则是0

[root@www.linuxea.com /opt/Golang/work2]# go run string.go 
-1

• 是否包含某字符串

abc是否包含bc，包含则为true

fmt.Println(strings.Contains("abc","bc"))

运行

[root@www.linuxea.com /opt/Golang/work2]# go run string.go 
true

• 只要包含一个字符就为ture

abcdsadasdasdas只要包含一个b就为true

fmt.Println(strings.Contains("abcdsadasdasdas","b"))

[root@www.linuxea.com /opt/Golang/work2]# go run string.go 
true

• 获取字符串出现的次数

获取abcdsadasdasdas中a出现的次数

fmt.Println(strings.Count("abcdsadasdasdas","a"))

[root@www.linuxea.com /opt/Golang/work2]# go run string.go 
5

• 分割

按空白字符分割

    fmt.Println(strings.Fields("abc defn eeee"))
    fmt.Printf("%qn",strings.Fields("abc defn eeee"))

[root@www.linuxea.com /opt/Golang/work2]# go run string.go 
[abc def eeee]
["abc" "def" "eeee"]

• 以什么结尾和开头

HasPrefix是以什么开头，如果是就为true

HasSuffix是以什么结尾，如果是就为true

    fmt.Println(strings.HasPrefix("abcd","ab"))
    fmt.Println(strings.HasSuffix("abcd","cd"))

[root@www.linuxea.com /opt/Golang/work2]# go run string.go 
true
true

• 索引位置

cd在abcd中的索引位置，如果存在则打印索引位置，如果不存在就等于-1

fmt.Println(strings.Index("abcd","cd"))

[root@www.linuxea.com /opt/Golang/work2]# go run string.go 
2

这里还有Lastindex，就是最后出现的索引位置

    fmt.Println(strings.LastIndex("abcdaasxcd","cd"))

[root@www.linuxea.com /opt/Golang/work2]# go run string.go
8

• 分隔符

fmt.Println(strings.Split("adbcdef;abcd;abcd3edsa",";"))

以;进行分割

[root@www.linuxea.com /opt/Golang/work2]# go run string.go
[adbcdef abcd abcd3edsa]

• 连接符

fmt.Println(strings.Join([]string{"adb","abcd","abcd3edsa"},"~"))

以~进行链接

[root@www.linuxea.com /opt/Golang/work2]# go run string.go
adb~abcd~abcd3edsa

• 重复N份

fmt.Println(strings.Repeat("abc",3))

将acb重复三次

[root@www.linuxea.com /opt/Golang/work2]# go run string.go
abcabcabc

• 替换

将abcabcabcabc中的a替换成1，1表示替换一次

    fmt.Println(strings.Replace("abcabcabcabc","a","1",1))

将abcabcabcabc中的a替换成1，-1表示全部替换

    fmt.Println(strings.Replace("abcabcabcabc","a","1",-1))

将abcabcabcabc中的a替换成1，ReplaceAll不需要指定替换多少次，默认替换全部

    fmt.Println(strings.ReplaceAll("abcabcabcabc","a","1"))

运行

[root@www.linuxea.com /opt/Golang/work2]# go run string.go
1bcabcabcabc
1bc1bc1bc1bc
1bc1bc1bc1bc

• 大小写转换

ToLower转换小写，ToUpper转换大写

    fmt.Println(strings.ToLower("abcABC"))
    fmt.Println(strings.ToUpper("abcABC"))

运行

[root@www.linuxea.com /opt/Golang/work2]# go run string.go
abcabc
ABCABC

• 首字母大写

fmt.Println(strings.Title("hello"))

将hello首字母大写

[root@www.linuxea.com /opt/Golang/work2]# go run string.go
Hello

• 前后字符去掉

fmt.Println(strings.Trim("xhelloxz","xz"))

去掉xhelloxz前后包括xz或者前后包含x,z的字符

[root@www.linuxea.com /opt/Golang/work2]# go run string.go
hello

• 去除空白字符

fmt.Println(strings.TrimSpace(" hello n r "))

[root@www.linuxea.com /opt/Golang/work2]# go run string.go
hello

8.3定义字节切片

byte是无符号的uint8类型。

package main
import (
    "fmt"
)
func main(){
    var bytes []byte = []byte{'a','b','c'}
    fmt.Printf("%T,%#vn",bytes,bytes)
}

[root@www.linuxea.com /opt/Golang/work2]# go run byte.go 
[]uint8,[]byte{0x61, 0x62, 0x63}

这里a,b,c的ASCII分别是0x61, 0x62, 0x63

8.4字节转换字符串

直接使用string转换即可

package main
import (
    "fmt"
)
func main(){
    var bytes []byte = []byte{'a','b','c'}
    fmt.Printf("%T,%#vn",bytes,bytes)
    
    sb := string(bytes)
    fmt.Printf("%T %vn",sb,sb)
}

将定义的bytes转换成字符串

[root@www.linuxea.com /opt/Golang/work2]# go run byte.go 
[]uint8,[]byte{0x61, 0x62, 0x63}
string abc

8.5字符串转字节

将转换过的字符串再转回字节

package main
import (
    "fmt"
)
func main(){
    var bytes []byte = []byte{'a','b','c'}
    fmt.Printf("%T,%#vn",bytes,bytes)
    
    sb := string(bytes)
    fmt.Printf("%T %vn",sb,sb)


    bs := []byte(sb)
    fmt.Printf("%T %#vn",bs,bs)
}

如下

[root@www.linuxea.com /opt/Golang/work2]# go run byte.go 
[]uint8,[]byte{0x61, 0x62, 0x63}
string abc
[]uint8 []byte{0x61, 0x62, 0x63}

8.6bytes包

bytes包与strings包基本上一样

• Compare 比较

按照直接数组进行比较

fmt.Println(bytes.Compare([]byte("abc"),[]byte("def")))

运行

[root@www.linuxea.com /opt/Golang/work2]# go run byte.go
-1

• Index索引位置

bytes.Index索引位置

计算字节def在abcdef的索引位置

fmt.Println(bytes.Index([]byte("abcdef"),[]byte("def")))

运行

[root@www.linuxea.com /opt/Golang/work2]# go run byte.go
3

• bytes.Contains

字节abcdef是否包含def，如果包含则为true，否则false

fmt.Println(bytes.Contains([]byte("abcdef"),[]byte("def")))

运行

[root@www.linuxea.com /opt/Golang/work2]# go run byte.go
true

8.7计算unicode

当使用len计算字符串是可以的，但是遇到中文字符就需要unicode/utf8模块计算。如下:

[root@www.linuxea.com /opt/Golang/work2]# cat byte1.go
package main
import (
    "fmt"
    "unicode/utf8"
)
func main(){
    s := "这是一个测试"
    fmt.Println(s)
    fmt.Println(utf8.RuneCountInString(s))
}

运行

[root@www.linuxea.com /opt/Golang/work2]# go run byte1.go
这是一个测试
6