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-----------------------------")
}