Go 语言字符串常见操作

2022-04-27 391

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： 1. 字节数组2. 头尾处理3. 位置索引4. 替换5. 统计次数6. 重复7. 大小写8. 去除字符9. 字符串切片处理10. 数值处理

1. 字节数组

字节与字符的区别

字节(Byte) 是计量单位，表示数据量多少，是计算机信息技术用于计量存储容量的一种计量单位，通常情况下一字节等于八位

字符(Character) 是计算机中使用的字母、数字、字和符号，比如'A'、'B'、'$'、'&'等

一般在英文状态下一个字母或字符占用一个字节，一个汉字用两个字节表示

通俗点来说，人的语言就是字符，而字节是机器的语言

示例

package main
import "fmt"
func main() {
  var (
    str1 = "hello"
    str2 = "world"
  )
  str3 := str1 + " " + str2
  //字符串转换成字节数组
  tmp := []byte(str3)
  fmt.Printf("数据: %s,长度: %d,数据类型: %T\n", str3, len(str3), str3)
  fmt.Println("字节数组:", tmp)
  fmt.Printf("数据: %s,长度: %d,数据类型: %T\n", tmp, len(tmp), tmp)
  //字节数组转字符串
  fmt.Println("字节数组转字符串:", string(tmp))
  //反转函数调用
  fmt.Println("反转: ", Reverse(str3))
}
//反转函数
func Reverse(str string) string {
  var (
    result string
    leng   int = len(str)
  )
  for i := 0; i < leng; i++ {
    //sprintf转换数据类型为string,使用+进行拼接
    result = result + fmt.Sprintf("%c", str[leng-i-1])
  }
  return result
}
//输出结果如下
数据: hello world,长度: 11,数据类型: string
字节数组: [104 101 108 108 111 32 119 111 114 108 100]
数据: hello world,长度: 11,数据类型: []uint8
字节数组转字符串: hello world
反转:  dlrow olleh

Sprintf的作用

package main
import "fmt"
func main() {
  var a = 88
  fmt.Printf("a的数值: %d , 类型: %T\n", a, a)
  b := fmt.Sprintf("%d", a)
  fmt.Printf("b的数值: %s , 类型: %T\n", b, b)
}
//输出结果如下
a的数值: 88 , 类型: int
b的数值: 88 , 类型: string

2. 头尾处理

prefix()函数判断前缀

suffix()函数判断后缀

使用prefix函数判断URL是否是以http://为开头，如果不是，则加上http://

使用suffix函数判断路径是否以/结尾，如果不是，则加上/为结尾

package main
import (
  "fmt"
  "strings"
)
func main() {
  var (
    url  string
    path string
  )
  fmt.Println("请输入URL和路径:")
  fmt.Scanf("%s%s", &url, &path)
  fmt.Printf("URL: %s\n", urlProcess(url))
  fmt.Printf("路径: %s", pathProcess(path))
}
//字符串头部处理
func urlProcess(url string) string {
  //判断是否以http://开头，返回布尔类型赋予result
  result := strings.HasPrefix(url, "http://")
  if !result {
    url = fmt.Sprintf("http://%s", url)
  }
  return url
}
//字符串尾部处理
func pathProcess(path string) string {
  //判断是否以/结尾，返回布尔类型赋予result
  result := strings.HasSuffix(path, "/")
  if !result {
    path = fmt.Sprintf("%s/", path)
  }
  return path
}

终端输入如下：
PS D:\goproject\src\test\main> go run .\main.go
请输入URL和路径:
www.google.com /opt/conf/k8s
URL: http://www.google.com
路径: /opt/conf/k8s/

3. 位置索引

Index()函数判断出现在前面的位置

LastIndex()函数判断出现在末尾的位置

判断子字符串在字符串中首次出现的位置和在末尾出现的位置

package main
import (
  "fmt"
  "strings"
)
func main() {
  var (
    a   = "abbaabcddccd"
    str = "cd"
  )
  //判断str在a中首次出现的位置
  head := strings.Index(a, str)
  tail := strings.LastIndex(a, str)
  fmt.Printf("首次出现的位置:%d\n最后出现的位置:%d\n", head, tail)
}
//输出结果如下
首次出现的位置:6
最后出现的位置:10

4. 替换

Replace()函数格式如下：Replace(原字符串,原字段,新字符串,新字段,替换次数)-1表示全部替换，0表示不替换 Replace()函数格式如下：Replace(原字符串,原字段,新字符串,新字段,替换次数)-1表示全部替换，0表示不替换Replace()函数格式如下：Replace(原字符串,原字段,新字符串,新字段,替换次数)-1表示全部替换，0表示不替换

package main
import (
  "fmt"
  "strings"
)
func main() {
  var (
    a = "abbaabcddccd"
  )
  //把cd替换成CD，-1表示全部替换，0表示不替换
  result := strings.Replace(a, "cd", "CD", -1)
  fmt.Printf("替换前: %v\n", a)
  fmt.Printf("全部替换后: %v\n", result)
  result1 := strings.Replace(a, "cd", "CD", 0)
  fmt.Printf("不进行替换: %v\n", result1)
}
//输出结果如下
替换前: abbaabcddccd
全部替换后: abbaabCDdcCD
不进行替换: abbaabcddccd

5. 统计次数

Count()函数 统计次数

package main
import (
  "fmt"
  "strings"
)
func main() {
  var a = "abbcddcedsca"
  count := strings.Count(a, "cd")
  fmt.Printf("count: %v\n", count)
}
//输出结果如下
count: 1

6. 重复

Repeat()函数 重复输出多次

package main
import (
  "fmt"
  "strings"
)
func main() {
  var a = "加油~"
  result := strings.Repeat(a, 3)
  fmt.Printf("result: %v\n", result)
}
//输出结果如下
result: 加油~加油~加油~

7. 大小写

ToUpper()函数 转换大写

ToLower()函数转换小写

package main
import (
  "fmt"
  "strings"
)
func main() {
  var a = "hello"
  //转换大写
  result1 := strings.ToUpper(a)
  fmt.Printf("大写: %v\n", result1)
  //把上面转换的大写给转成小写
  result2 := strings.ToLower(result1)
  fmt.Printf("小写: %v\n", result2)
}
//输出结果如下
大写: HELLO
小写: hello

8. 去除字符

TrimSpace()函数去除空白字符

TrimLeft()从左往右删除

TrimRight()从右往左删除

去除首尾空白字符

package main
import (
  "fmt"
  "strings"
)
func main() {
  var a = " abc "
  fmt.Println("长度:", len(a))
  //去除首位空白的字符
  result1 := strings.TrimSpace(a)
  fmt.Println("去除首尾空白字符:", result1, "\n长度:", len(result1))
}
//输出结果如下
长度: 5
去除首尾空白字符: abc 
长度: 3

去除指定位置字符

package main
import (
  "fmt"
  "strings"
)
func main() {
  var a = "this is test web"
  //去掉字符串首尾部web字符
  result1 := strings.Trim(a, "web")
  fmt.Println("尾部去除:", result1)
  //从左往右删除所有指定的字符，直到遇到不包含在指定的字符为止
  result2 := strings.TrimLeft(a, "this")
  //空格也需匹配删除，直到没有指定的字符可以匹配为止
  result3 := strings.TrimLeft(a, "this ")
  //从右往左删除所有指定的字符，直到遇到不包含在内的字符为止
  result4 := strings.TrimRight(a, "web")
  fmt.Println("从左往右删除:", result2)
  fmt.Println("从左往右删除,有空格:", result3)
  fmt.Println("从右往左删除:", result4)
}
//输出结果如下
尾部去除: this is test 
从左往右删除:  is test web
从左往右删除,有空格: est web
从右往左删除: this is test

9. 字符串切片处理

Fields()函数

Split()函数

默认识别空格进行切片处理

package main
import (
  "fmt"
  "strings"
)
func main() {
  var str string = "abc def ghi"
  //Fields函数默认识别的符号是空格
  result1 := strings.Fields(str)
  fmt.Printf("数据类型: %T , 数据格式: %v\n", result1, result1)
  for i := 0; i < len(result1); i++ {
    fmt.Println(result1[i])
  }
}
//输出结果如下
数据类型: []string , 数据格式: [abc def ghi]
abc
def
ghi

识别其他符号分隔成切片

package main
import (
  "fmt"
  "strings"
)
func main() {
  var str string = "abc,def,ghi"
  //识别逗号进行分隔切片
  result := strings.Split(str, ",")
  fmt.Printf("数据类型: %T , 数据格式: %v\n", result, result)
}
//输出结果如下
数据类型: []string , 数据格式: [abc def ghi]

推荐使用Split()函数进行分隔

因为fields()函数默认只能识别空格，不能识别其他符号，而Split()函数则均可以识别

把切片按指定分隔符进行转换成字符串

Join()函数

package main
import (
  "fmt"
  "strings"
)
func main() {
  //定义切片
  var slice = []string{"123", "456", "789"}
  fmt.Printf("切片: %v\n", slice)
  //切片转换成字符串
  result := strings.Join(slice, ":")
  fmt.Printf("数据结构: %v , 数据类型: %T", result, result)
}
//输出结果如下
切片: [123 456 789]
数据结构: 123:456:789 , 数据类型: string

10. 数值处理

使用strconv.Itoa()函数将数值转换成字符串

package main
import (
  "fmt"
  "strconv"
)
func main() {
  var num int = 12345678
  fmt.Printf("初始数据类型: %T\n", num)
  fmt.Printf("初始值: %d\n", num)
  //转换成字符串
  result := strconv.Itoa(num)
  fmt.Printf("转换后数据类型: %T\n", result)
  fmt.Printf("转换后值为: %s", result)
}
//输出结果如下
初始数据类型: int
初始值: 12345678
转换后数据类型: string
转换后值为: 12345678

使用Sprintf()函数将整数转换成字符串

package main
import (
  "fmt"
)
func main() {
  var num int = 12345678
  fmt.Printf("初始数据类型: %T\n", num)
  //使用Sprintf()转换成字符串，可以实现多类型的转换
  result := fmt.Sprintf("%d", num)
  fmt.Printf("转换后数据类型:%T\n", result)
}
//输出结果如下
初始数据类型: int
转换后数据类型:string

使用strconv.Atoi()函数进行字符串转换整数

package main
import (
  "fmt"
  "strconv"
)
func main() {
  var str string = "12345678"
  //字符串转整数
  result, err := strconv.Atoi(str)
  //如果有转换过程中有错，就抛出错误，没有错就返回数据类型
  if err == nil {
    fmt.Printf("数据类型: %T\n", result)
  } else {
    fmt.Println(err)
  }
}
//输出结果
数据类型: int