玩转Go语言之字符串操作

1.字符串长度:

func main() {
   /*
   1.获取字符串长度
   我们已知字符串在Go语言中的本质是一个切片, 如果想要获取切片的长度, 可以通过len()函数来获取
   所以字符串也可以通过len()函数来获取字符串的长度

   2.注意点:
   2.1len()函数获取字符串长度的时候, 获取的是字节数
   在Go语言中中文是按照UTF-8编码的, 所以一个中文占用3个字节
   2.2如果想要获取的是中文的个数, 而不是字节数, 那么需要将字符串转换为rune类型的切片才行
    */
    //str := "lnj"
    //len := len(str)
    //fmt.Println(len)

   //str := "李南江"
   //len := len(str)
   //fmt.Println(len)

   //str1 := "李南江"
   //var str2 []rune = []rune(str1)
   //len := len(str2)
   //fmt.Println(len)


   str1 := "lnj李南江"
   var str2 []rune = []rune(str1)
   len := len(str2)
   fmt.Println(len)

}

2.字符串查找:

func main() {
   /*
   查找子串在字符串中出现的位置
   1.从左至右查找
   func IndexByte(s string, c byte) int
   func IndexRune(s string, r rune) int
   func IndexAny(s, chars string) int
   func Index(s, sep string) int
   func IndexFunc(s string, f func(rune) bool) int
   2.从右至左查找
   func LastIndex(s, sep string) int
   func LastIndexByte(s string, c byte) int
   func LastIndexAny(s, chars string) int
   func LastIndexFunc(s string, f func(rune) bool) int
    */

    // IndexByte
    /*
    // 1.定义一个字符串
    //str := "www.it666.com"
    str := "www.知播渔.com"
    // 2.查找指定字符在字符串中的位置
    // 注意点: 从左至右的查找, 一旦找到了, 就不会继续查找的
    //         只能查找字符, 不能查找中文
    //         如果找到了就返回字符在字符串中的位置, 如果没有找到就会-1
    //index := strings.IndexByte(str, '6')
    //index := strings.IndexByte(str, 'p')
    index := strings.IndexByte(str, '知')
    // 3.打印查找到的位置
    fmt.Println(index)
    */

    // IndexRune
    /*
   // 1.定义一个字符串
   str := "www.知播渔.com"
   // 2.查找指定字符在字符串中的位置
   // 注意点: 从左至右的查找, 一旦找到了, 就不会继续查找的
   //         可以查找字符, 也可以查找中文
   //         如果找到了就返回字符在字符串中的位置, 如果没有找到就会-1
   //         在返回找到的索引的时候, 如果前面有中文, 那么一个中文按照3个索引计算
   //index := strings.IndexRune(str, '知') // 4
   //index := strings.IndexRune(str, '播') // 7
   index := strings.IndexRune(str, 'w')
   // 3.打印查找到的位置
   fmt.Println(index)
    */

    // IndexAny
    /*
   // 1.定义一个字符串
   //str := "www.it666.com"
   str := "www.李南江.com"
   // 2.查找指定字符在字符串中的位置
   // 注意点: 从左至右的查找, 一旦找到了, 就不会继续查找的
   //         查找时不是将第二个参数当做一个整体查找, 是拆开来查找, 返回找到的最前面一个值
   //index := strings.IndexAny(str, "6ic")
   index := strings.IndexAny(str, "江南")
   // 3.打印查找到的位置
   fmt.Println(index)
    */

    // Index
    /*
   // 1.定义一个字符串
   //str := "www.it666.it"
   str := "www.江南666.江南"
   // 2.查找指定字符在字符串中的位置
   // 注意点: 从左至右的查找, 一旦找到了, 就不会继续查找的
   //         查找时会将第二个参数当做一个整体查找
   //index := strings.Index(str, "it")
   index := strings.Index(str, "江南")
   // 3.打印查找到的位置
   fmt.Println(index)
    */

    // IndexFunc
    /*
   // 1.定义一个字符串
   //str := "www.it666.it.com"
   str := "www.江南666.江南.com"
   // 2.查找指定字符在字符串中的位置
   // 注意点: 从左至右的查找, 一旦找到了, 就不会继续查找的
   // IndexFunc方法会将字符串转换成一个[]rune, 然后遍历切片,
   // 逐个将切片中的元素传递给自定义的函数, 只要自定义函数返回true就代表找到了
   index := strings.IndexFunc(str, custom)
   // 3.打印查找到的位置
   fmt.Println(index)
    */


    // LastIndex
   // 1.定义一个字符串
   str := "www.it666.it.com"
   // 2.查找指定字符在字符串中的位置
   // 注意点: 从右至左的查找, 一旦找到了, 就不会继续查找的
   index := strings.LastIndex(str, "it")
   // 3.打印查找到的位置
   fmt.Println(index)
}
func custom(ch rune) bool {
   if ch == '江'{
      // 一旦return的是true就代表告诉IndexFunc方法, 找到了我们需要查找的字符
      return true
   }
   return false
}

3.字符串包含:

func main() {
   /*
   字符串包含
   func Contains(s, substr string) bool
   func ContainsRune(s string, r rune) bool
   func ContainsAny(s, chars string) bool
   func HasPrefix(s, prefix string) bool
   func HasSuffix(s, suffix string) bool
    */

   // Contains
   /*
   // 作用: 判断字符串中是否包含指定的子串
   // 如果包含返回true, 如果不包含返回false
   str := "www.it666.江南.com"
   //res := strings.Contains(str, "66")
   //res := strings.Contains(str, "mm")
   res := strings.Contains(str, "江南")
   fmt.Println(res)
   */

   // ContainsRune
   /*
   // 作用: 判断字符串中是否包含指定的字符
   // 如果包含返回true, 如果不包含返回false
   str := "www.it666.江南.com"
   //res := strings.ContainsRune(str, 't')
   //res := strings.ContainsRune(str, 'p')
   res := strings.ContainsRune(str, '江')
   fmt.Println(res)
   */

   // ContainsAny
   /*
   // 作用: 判断字符串中是否包含指定的子串中任意一个字符
   // 如果包含返回true, 如果不包含返回false
   str := "www.it666.江南.com"
   res := strings.ContainsAny(str, "p江e")
   fmt.Println(res)
   */

   // HasPrefix
   // 作用: 判断字符串是否以指定字符串开头
   str := "01-够浪HtlloWorld.mp4"
   //res := strings.HasPrefix(str, "01")
   // HasSuffix
   // 作用: 判断字符串是否以指定字符串结尾
   res := strings.HasSuffix(str, ".mp4")
   fmt.Println(res)
}

4.字符串比较:

func main() {
   /*
   字符串比较
   func Compare(a, b string) int
   func EqualFold(s, t string) bool
    */

    // Compare
    /*
    //str1 := "123"
    //str2 := "126"
   str1 := "李南江"
   str2 := "李江南"
    // Compare作用:
    // 比较两个字符串
    // 如果两个字符串相等, 那么返回0
    // 如果两个字符串不相等
    // 第一个字符串 > 第二个字符串 返回 1
    // 第一个字符串 < 第二个字符串 返回 -1
    res := strings.Compare(str1, str2)
    fmt.Println(res)

   bytes1 := []byte(str1)
   fmt.Println(bytes1)
   bytes2 := []byte(str2)
   fmt.Println(bytes2)
   */

    // EqualFold
    /*
    // EqualFold作用:
    // 比较两个字符串是否相等, 相等返回true, 不相等返回false
   str1 := "123"
   str2 := "124"
   res := strings.EqualFold(str1, str2)
   fmt.Println(res)
    */

}

5.字符串转换:

func main() {
   /*
   字符串转换
   unc ToUpper(s string) string
   func ToLower(s string) string
   func ToTitle(s string) string
   func ToUpperSpecial(_case unicode.SpecialCase, s string) string
   func ToLowerSpecial(_case unicode.SpecialCase, s string) string
   func ToTitleSpecial(_case unicode.SpecialCase, s string) string
   func Title(s string) string
    */

    // ToUpper
    /*
    // 作用: 将指定字符串中所有的小写字母转换成大写
    // 注意点: 会生成一个新的字符串, 不会影响原有的字符串
    str1 := "www.it666.com"
    str2 := strings.ToUpper(str1)
    fmt.Println(str1)
    fmt.Println(str2)
    */

    // ToLower
    /*
   // 作用: 将指定字符串中所有的大写字母转换成小写
   // 注意点: 会生成一个新的字符串, 不会影响原有的字符串
   str1 := "WWW.IT666.COM"
   str2 := strings.ToLower(str1)
   fmt.Println(str1)
   fmt.Println(str2)
    */

    // ToTitle 和 ToUpper 会将小写转换为大写
    /*
   str1 := "hello world"
   str2 := strings.ToTitle(str1)
   fmt.Println(str1)
   fmt.Println(str2)
    */


    // Title
    // 作用: 将单词的首字母大写, 单词之间用空格或者-隔开
   //str1 := "hello world"
   //str1 := "helloworld"
   str1 := "hello-world"
   str2 := strings.Title(str1)
   fmt.Println(str1)
   fmt.Println(str2)
}

6:字符串截取:

func main() {
   /*
   字符串拆合
   1.字符串切割
   func Split(s, sep string) []string
   func SplitN(s, sep string, n int) []string
   func SplitAfter(s, sep string) []string
   func SplitAfterN(s, sep string, n int) []string
   2.按照空格切割字符串
   func Fields(s string) []string
   func FieldsFunc(s string, f func(rune) bool) []string
   3.字符串合并
   func Join(a []string, sep string) string

   4.重复生成字符串
   func Repeat(s string, count int) string

   5.替换字符串
   func Replace(s, old, new string, n int) string
    */

    // Split
    /*
    // 作用: 按照指定字符串切割原有字符串
    // 注意点: 切割之后的结果, 不包含指定的字符串
    str := "abc,def,123,456"
    sce := strings.Split(str, ",")
    fmt.Println(sce)
    */

    // SplitN
    /*
   // 作用: 按照指定字符串切割原有字符串, 切割为指定的份数
   // 注意点: 切割之后的结果, 不包含指定的字符串
   str := "abc,def,123,456"
   //sce := strings.SplitN(str, ",", 2)
   sce := strings.SplitN(str, ",", 0)
   fmt.Println(len(sce))
   fmt.Println(sce)
    */

    // SplitAfter
    /*
   // 作用: 按照指定字符串切割原有字符串
   // 注意点: 切割之后的结果, 包含指定的字符串
   str := "abc,def,123,456"
   sce := strings.SplitAfter(str, ",")
   fmt.Println(len(sce))
   fmt.Println(sce)
    */

    // SplitAfterN
    /*
   // 作用: 按照指定字符串切割原有字符串, 切割为指定的份数
   // 注意点: 切割之后的结果, 包含指定的字符串
   str := "abc,def,123,456"
   sce := strings.SplitAfterN(str, ",", 2)
   fmt.Println(len(sce))
   fmt.Println(sce)
    */

    // Fields
    /*
   // 作用: 按照空格切割原有字符串
   // 注意点: 连续的多个空格会按照一个空格来处理
   str := "abc def        123 456"
   sce := strings.Fields(str)
   fmt.Println(len(sce))
   fmt.Println(sce)
    */

    // FieldsFunc
    /*
    // 作用: 函数返回true就切片, 返回false就不切割
   //str := "abc def       123 456"
   str := "abc-def-123-456"
   sce := strings.FieldsFunc(str, custom)
   fmt.Println(len(sce))
   fmt.Println(sce)
    */

   // Join
   /*
   // 作用: 按照指定字符连接切片中的元素
   sce := []string{"www", "it666", "com"}
   str := strings.Join(sce, ".")
   fmt.Println(str)
   */

   // Repeat
   /*
   // 作用: 将原有字符串重复指定次数后生成一个新的字符串
   str1 := "123"
   str2 := strings.Repeat(str1, 2)
   fmt.Println(str2)
   */

   // Replace
   // 作用: 将原有字符串中的, 指定字符串替换为新的字符串
   //      最后一个参数用于指定替换多少个, 如果传入-1全部都替换
   str1 := "abc123abc456def"
   //str2 := strings.Replace(str1,"abc","www", 1)
   //str2 := strings.Replace(str1,"abc","www", 2)
   str2 := strings.Replace(str1,"abc","www", -1)
   fmt.Println(str2)
}
func custom(ch rune) bool{
   //if ch == ' '{
   // return true
   //}
   if ch == '-'{
      return true
   }
   return false
}

7.字符串过滤:

func main() {
   /*
   字符串清理
   func Trim(s string, cutset string) string
   func TrimLeft(s string, cutset string) string
   func TrimRight(s string, cutset string) string
   func TrimFunc(s string, f func(rune) bool) string
   func TrimLeftFunc(s string, f func(rune) bool) string
   func TrimRightFunc(s string, f func(rune) bool) string
   func TrimSpace(s string) string
   func TrimPrefix(s, prefix string) string
   func TrimSuffix(s, suffix string) string
    */

    // Trim
    /*
    // 作用: 返回字符串前后两端去掉指定字符串之后的新字符串
    //str1 := "123www.it123.com123"
    str1 := "     www.it123.com "
    str2 := strings.Trim(str1, " ")
    fmt.Println(str2)
    */

    // TrimLeft 只去除左边的
    // TrimRight 只去除右边的
    /*
   str1 := "123www.it123.com123"
   str2 := strings.TrimLeft(str1, "123")
   fmt.Println(str2)
   str3 := strings.TrimRight(str1, "123")
   fmt.Println(str3)
    */

    // TrimFunc
    /*
   str1 := "  www.it123.com   "
   str2 := strings.TrimFunc(str1, custom)
   fmt.Println(str2)
    */

    // TrimSpace
    /*
    // 作用: 去除两端的空格
   str1 := "  www.it123.com   "
   str2 := strings.TrimSpace(str1)
   fmt.Println(str2)
    */
   str1 := "01-HelloWorld.mp4"
   str2 := strings.TrimSuffix(str1, ".mp4")
   fmt.Println(str2)

}
func custom(ch rune) bool{
   if ch == ' '{
      return true
   }
   return false
}

代码:https://github.com/codeXiaoQiang/Go-language