strings包用法

package stringTest

import (
   "fmt"
   "strings"
   "unicode"
)

/*StringTest is testing code for package strings*/
/*https://studygolang.com/articles/5769*/
func Test() {
   fmt.Println("---------------------------String start-----------------------------")
   jordan := "I can accept failure,but i can not accept not trying"
   jordan1 := "I,can,accept,failure,but,i,can,not,accept,not,trying陈"
   kobe := "The second is the first loser"
   /*
      strings.Compare(a string,b string) int

      按照unicode字典顺序比较a,b大小
      a == b ; return 0
      a > b ; return 1
      a < b ; return -1
      尽量不使用该方法进行字符串比较，用内置的 ==,>,<符号进行字符串比较
   */
   fmt.Println(strings.Compare(jordan, kobe))
   /*
      strings.Contains(s string, substr string) bool
      strings.ContainsAny(s string, chars string) bool
      strings.ContainsRune(s string, r rune) bool

      Contains: s包含substr返回true,否则返回false
      ContainsAny： s包含chars中任意一个字符返回true,否则返回false
      ContainsRune: s包含值等于r的字符返回true，否则返回false
   */
   fmt.Println(strings.Contains(jordan, jordan[:6]))
   fmt.Println(strings.ContainsAny(jordan, "abcd"))
   fmt.Println(strings.ContainsRune(jordan1, '陈'))
   //strings.Count(s string, substr string) int
   /*
      返回substr在s中的非重叠个数,如果substr是空的话,则返回s的unicode字符数量(并不是字节数) + 1
      非重叠意思是substr之间不能有重叠，str := "aaaaaa"只能计算str[:2],str[2:4],str[4:],而不能计算str[1:3]
      因为str[1:3]和str[:2]和str[2:4]有重叠的部分
   */
   fmt.Println(strings.Count("aaaaaa", "aa"))
   /*
      strings.EqualFold(s string, t string) bool
      不区分大小写比较字符串
   */
   fmt.Println(strings.EqualFold(jordan, strings.ToUpper(jordan)))
   /*
      strings.Fields(s string) []string
      把string转换成[]string的切片
      满足unicode.IsSpace()都可以作为分隔符，如\t,' ',\n,\f,\v等
   */
   fmt.Println(strings.Fields(jordan))
   /*
      strings.FieldsFunc(s string,f func(r rune) bool) []string
      功能同上，只是s的分割符是满足函数f的rune值
   */
   fmt.Println(strings.FieldsFunc(jordan1, func(r rune) bool {
      if r == rune(',') {
         return true
      }
      return false
   }))
   /*
      strings.HasPrefix(s string,prefix string) bool
      strings.HasSuffix(s string,suffix string) bool
      HasPrefix: s以prefix开头返回true
      HasSuffix: s以suffix结尾返回true
   */
   fmt.Println(strings.HasPrefix(jordan, jordan[:2]))
   fmt.Println(strings.HasSuffix(jordan, jordan[5:]))
   /*
      strings.Index(s string, substr string) int
      strings.IndexAny(s string, chars string) int
      strings.IndexFunc(s string,f func(rune) bool) int
      strings.IndexRune(s string,r rune) int
      strings.IndexByte(s string,c byte) int
      以上函数返回s中第一个子串,字符,满足函数f,r,c的位置,如果没有则返回-1
      strings.LastIndex(s string,substr string) int
      strings.LastIndexAny(s string, chars string) int
      strings.LastIndexFunc(s string,f func(rune) bool) int
      strings.LastIndexByte(s string,c byte) int
      以上函数返回s中最后一个子串,字符,满足函数f,c的位置,如果没有则返回-1
   */
   fmt.Println(strings.Index(jordan, "accept"))
   fmt.Println(strings.IndexAny(jordan, jordan[3:5]))
   fmt.Println(strings.IndexByte(jordan, 'c'))
   fmt.Println(strings.IndexFunc(jordan, func(r rune) bool {
      if r == rune(' ') {
         return true
      }
      return false
   }))
   fmt.Println(strings.IndexRune(jordan, rune('a')))
   fmt.Println(strings.LastIndex(jordan, "accept"))
   fmt.Println(strings.LastIndexAny(jordan, "accept"))
   fmt.Println(strings.LastIndexByte(jordan, 'c'))
   fmt.Println(strings.LastIndexFunc(jordan, func(r rune) bool {
      if r >= rune('x') {
         return true
      }
      return false
   }))
   /*
      strings.Join(s []string,sep string) string
      把[]string的切片合并成一个string,并且以sep为分隔符
   */
   fmt.Println(strings.Join(strings.Fields(jordan), ":"))
   /*
      strings.Map(maping f(rune)rune, s string) string
      s中满足mapping函数的字符被替换成mapping函数的返回值,如果mapping返回负数,那么对应的字节被删除
      如下是把小写a~z替换成大写A~Z,不再a-z范围的抛弃
   */
   fmt.Println(strings.Map(func(r rune) rune {
      if r >= 'a' && r <= 'z' {
         return r - ('a' - 'A')
      }
      return r
   }, jordan))
   readbuf := make([]byte, len(jordan))
   r := strings.NewReader(jordan)
   _, _ = r.Read(readbuf)
   fmt.Printf("%c", readbuf)
   fmt.Println()
   /*
   *  NewReplacer(s ...string) *Replacer,通过输入参数生成一个*Replacer对象,参数必须成对出现
   *  第1个参数替换第2个,第3个替换第4个....,当参数列表中有重复的替换规则,则重复的部分被忽略
   *
   **/
   jordan3 := strings.Join(strings.Fields(jordan), ":")
   replacer := strings.NewReplacer("hello", "你好", "world", "世界", "!", "!", "hello", "你好")
   helloworld := "hello world hello world!!"
   fmt.Println(replacer.Replace(helloworld)) //你好 世界 你好 世界 !!
   /*把string分隔成[]string切片,并且以sep为分隔符,如果s中不存在sep分隔符,则返回一整个字符串*/
   fmt.Println(strings.Split(jordan3, ":"))
   /*把string分隔成[]string切片,并且以sep为分隔符,如果s中包含sep分隔符,则返回一整个字符串*/
   fmt.Println(strings.SplitAfter(jordan3, ":"))
   /*把string分隔成[]string切片,并且以sep为分隔符,如果s中包含sep分隔符,则返回一整个字符串
   *  n=0,返回nil
   *   n < 0 全部切片,和SplitAfter()一样
   *  n > 0 表示最多切片成n个字符串,超出部分不再切片
   **/
   fmt.Println(strings.SplitAfterN(jordan3, ":", -1))
   fmt.Println(strings.SplitAfterN(jordan3, ":", 3))
   fmt.Println(strings.SplitAfterN(jordan3, ":", 0))

   /*和SplitAfterN一样,只是结果中不包含分隔符sep*/
   fmt.Println(strings.SplitN(jordan3, ":", -1))
   fmt.Println(strings.SplitN(jordan3, ":", 3))
   fmt.Println(strings.SplitN(jordan3, ":", 0))
   /*将字符串的首字母转换成title格式,大部分字符的title格式都是其大写字母,少数是特殊字符*/
   fmt.Println(strings.Title("hello world"))
   fmt.Println(strings.ToTitle("hello world"))
   // fmt.Println(strings.ToTitleSpecial())
   fmt.Println(strings.ToLower(strings.ToTitle("hello world")))
   fmt.Println(strings.ToUpper("chenyanpeng"))
   //删除s首尾中连续出现在cutset中的字符
   fmt.Println(strings.Trim(jordan3, "I:tpecairtyng"))
   fmt.Println(strings.TrimFunc(jordan3, func(r rune) bool {
      if r == 'I' || r == ':' || (r >= 'a' && r <= 'z') {
         return true
      }
      return false
   }))
   /*删除首部连续出现在cutset中的字符*/
   fmt.Println(strings.TrimLeft(jordan3, "Iacdcn:"))
   fmt.Println(strings.TrimLeftFunc(jordan3, func(r rune) bool {
      return false
   }))
   /*删除尾部连续出现在cutset中的字符*/
   fmt.Println(strings.TrimRight(jordan3, "ynigrt"))
   fmt.Println(strings.TrimRightFunc(jordan3, func(r rune) bool {
      return false
   }))
   /*删除首尾连续出现的空白字符*/
   fmt.Println(strings.TrimSpace("             afafaadfab              "))
   fmt.Println(strings.TrimPrefix(jordan, jordan[:4]))
   fmt.Println(strings.TrimSuffix(jordan, jordan[4:]))

   /*
   *  'a','c'表示a-c,就是abc三个字符
   *  ToUpperSpecial表示a-c每个字符都加上'你'-'a'
   *  ToLowerSpecial表示a-c每个字符都加上'好'-'b'
   *  ToTitleSpecial表示a-c每个字符都加上'吗'-'c'
   **/
   var _mycase = unicode.SpecialCase{
      unicode.CaseRange{Lo: 'a', Hi: 'c', Delta: [unicode.MaxCase]rune{'x' - 'a', 'y' - 'b', 'z' - 'c'}},
      // unicode.CaseRange{'a', 'b', [unicode.MaxCase]rune{}},
      // unicode.CaseRange{'a', 'b', [unicode.MaxCase]rune{}},
   }
   fmt.Println(strings.ToUpperSpecial(_mycase, "aaaaaaabnijbijbsfbsbgjsb"))
   fmt.Println(strings.ToLowerSpecial(_mycase, "bbbbbbbFGKNSGJSNGNSGSGSG"))
   fmt.Println(strings.ToTitleSpecial(_mycase, "cccccccoijoipkppkoopkkpo"))
   fmt.Println("---------------------------String end-----------------------------")
}