Source file src/strings/example_test.go

Documentation: strings

     1  // Copyright 2012 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package strings_test
     6  
     7  import (
     8  	"fmt"
     9  	"strings"
    10  	"unicode"
    11  )
    12  
    13  func ExampleFields() {
    14  	fmt.Printf("Fields are: %q", strings.Fields("  foo bar  baz   "))
    15  	// Output: Fields are: ["foo" "bar" "baz"]
    16  }
    17  
    18  func ExampleFieldsFunc() {
    19  	f := func(c rune) bool {
    20  		return !unicode.IsLetter(c) && !unicode.IsNumber(c)
    21  	}
    22  	fmt.Printf("Fields are: %q", strings.FieldsFunc("  foo1;bar2,baz3...", f))
    23  	// Output: Fields are: ["foo1" "bar2" "baz3"]
    24  }
    25  
    26  func ExampleCompare() {
    27  	fmt.Println(strings.Compare("a", "b"))
    28  	fmt.Println(strings.Compare("a", "a"))
    29  	fmt.Println(strings.Compare("b", "a"))
    30  	// Output:
    31  	// -1
    32  	// 0
    33  	// 1
    34  }
    35  
    36  func ExampleContains() {
    37  	fmt.Println(strings.Contains("seafood", "foo"))
    38  	fmt.Println(strings.Contains("seafood", "bar"))
    39  	fmt.Println(strings.Contains("seafood", ""))
    40  	fmt.Println(strings.Contains("", ""))
    41  	// Output:
    42  	// true
    43  	// false
    44  	// true
    45  	// true
    46  }
    47  
    48  func ExampleContainsAny() {
    49  	fmt.Println(strings.ContainsAny("team", "i"))
    50  	fmt.Println(strings.ContainsAny("fail", "ui"))
    51  	fmt.Println(strings.ContainsAny("ure", "ui"))
    52  	fmt.Println(strings.ContainsAny("failure", "ui"))
    53  	fmt.Println(strings.ContainsAny("foo", ""))
    54  	fmt.Println(strings.ContainsAny("", ""))
    55  	// Output:
    56  	// false
    57  	// true
    58  	// true
    59  	// true
    60  	// false
    61  	// false
    62  }
    63  
    64  func ExampleContainsRune() {
    65  	// Finds whether a string contains a particular Unicode code point.
    66  	// The code point for the lowercase letter "a", for example, is 97.
    67  	fmt.Println(strings.ContainsRune("aardvark", 97))
    68  	fmt.Println(strings.ContainsRune("timeout", 97))
    69  	// Output:
    70  	// true
    71  	// false
    72  }
    73  
    74  func ExampleCount() {
    75  	fmt.Println(strings.Count("cheese", "e"))
    76  	fmt.Println(strings.Count("five", "")) // before & after each rune
    77  	// Output:
    78  	// 3
    79  	// 5
    80  }
    81  
    82  func ExampleEqualFold() {
    83  	fmt.Println(strings.EqualFold("Go", "go"))
    84  	// Output: true
    85  }
    86  
    87  func ExampleHasPrefix() {
    88  	fmt.Println(strings.HasPrefix("Gopher", "Go"))
    89  	fmt.Println(strings.HasPrefix("Gopher", "C"))
    90  	fmt.Println(strings.HasPrefix("Gopher", ""))
    91  	// Output:
    92  	// true
    93  	// false
    94  	// true
    95  }
    96  
    97  func ExampleHasSuffix() {
    98  	fmt.Println(strings.HasSuffix("Amigo", "go"))
    99  	fmt.Println(strings.HasSuffix("Amigo", "O"))
   100  	fmt.Println(strings.HasSuffix("Amigo", "Ami"))
   101  	fmt.Println(strings.HasSuffix("Amigo", ""))
   102  	// Output:
   103  	// true
   104  	// false
   105  	// false
   106  	// true
   107  }
   108  
   109  func ExampleIndex() {
   110  	fmt.Println(strings.Index("chicken", "ken"))
   111  	fmt.Println(strings.Index("chicken", "dmr"))
   112  	// Output:
   113  	// 4
   114  	// -1
   115  }
   116  
   117  func ExampleIndexFunc() {
   118  	f := func(c rune) bool {
   119  		return unicode.Is(unicode.Han, c)
   120  	}
   121  	fmt.Println(strings.IndexFunc("Hello, 世界", f))
   122  	fmt.Println(strings.IndexFunc("Hello, world", f))
   123  	// Output:
   124  	// 7
   125  	// -1
   126  }
   127  
   128  func ExampleIndexAny() {
   129  	fmt.Println(strings.IndexAny("chicken", "aeiouy"))
   130  	fmt.Println(strings.IndexAny("crwth", "aeiouy"))
   131  	// Output:
   132  	// 2
   133  	// -1
   134  }
   135  
   136  func ExampleIndexByte() {
   137  	fmt.Println(strings.IndexByte("golang", 'g'))
   138  	fmt.Println(strings.IndexByte("gophers", 'h'))
   139  	fmt.Println(strings.IndexByte("golang", 'x'))
   140  	// Output:
   141  	// 0
   142  	// 3
   143  	// -1
   144  }
   145  func ExampleIndexRune() {
   146  	fmt.Println(strings.IndexRune("chicken", 'k'))
   147  	fmt.Println(strings.IndexRune("chicken", 'd'))
   148  	// Output:
   149  	// 4
   150  	// -1
   151  }
   152  
   153  func ExampleLastIndex() {
   154  	fmt.Println(strings.Index("go gopher", "go"))
   155  	fmt.Println(strings.LastIndex("go gopher", "go"))
   156  	fmt.Println(strings.LastIndex("go gopher", "rodent"))
   157  	// Output:
   158  	// 0
   159  	// 3
   160  	// -1
   161  }
   162  
   163  func ExampleLastIndexAny() {
   164  	fmt.Println(strings.LastIndexAny("go gopher", "go"))
   165  	fmt.Println(strings.LastIndexAny("go gopher", "rodent"))
   166  	fmt.Println(strings.LastIndexAny("go gopher", "fail"))
   167  	// Output:
   168  	// 4
   169  	// 8
   170  	// -1
   171  }
   172  
   173  func ExampleLastIndexByte() {
   174  	fmt.Println(strings.LastIndexByte("Hello, world", 'l'))
   175  	fmt.Println(strings.LastIndexByte("Hello, world", 'o'))
   176  	fmt.Println(strings.LastIndexByte("Hello, world", 'x'))
   177  	// Output:
   178  	// 10
   179  	// 8
   180  	// -1
   181  }
   182  
   183  func ExampleLastIndexFunc() {
   184  	fmt.Println(strings.LastIndexFunc("go 123", unicode.IsNumber))
   185  	fmt.Println(strings.LastIndexFunc("123 go", unicode.IsNumber))
   186  	fmt.Println(strings.LastIndexFunc("go", unicode.IsNumber))
   187  	// Output:
   188  	// 5
   189  	// 2
   190  	// -1
   191  }
   192  
   193  func ExampleJoin() {
   194  	s := []string{"foo", "bar", "baz"}
   195  	fmt.Println(strings.Join(s, ", "))
   196  	// Output: foo, bar, baz
   197  }
   198  
   199  func ExampleRepeat() {
   200  	fmt.Println("ba" + strings.Repeat("na", 2))
   201  	// Output: banana
   202  }
   203  
   204  func ExampleReplace() {
   205  	fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2))
   206  	fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1))
   207  	// Output:
   208  	// oinky oinky oink
   209  	// moo moo moo
   210  }
   211  
   212  func ExampleReplaceAll() {
   213  	fmt.Println(strings.ReplaceAll("oink oink oink", "oink", "moo"))
   214  	// Output:
   215  	// moo moo moo
   216  }
   217  
   218  func ExampleSplit() {
   219  	fmt.Printf("%q\n", strings.Split("a,b,c", ","))
   220  	fmt.Printf("%q\n", strings.Split("a man a plan a canal panama", "a "))
   221  	fmt.Printf("%q\n", strings.Split(" xyz ", ""))
   222  	fmt.Printf("%q\n", strings.Split("", "Bernardo O'Higgins"))
   223  	// Output:
   224  	// ["a" "b" "c"]
   225  	// ["" "man " "plan " "canal panama"]
   226  	// [" " "x" "y" "z" " "]
   227  	// [""]
   228  }
   229  
   230  func ExampleSplitN() {
   231  	fmt.Printf("%q\n", strings.SplitN("a,b,c", ",", 2))
   232  	z := strings.SplitN("a,b,c", ",", 0)
   233  	fmt.Printf("%q (nil = %v)\n", z, z == nil)
   234  	// Output:
   235  	// ["a" "b,c"]
   236  	// [] (nil = true)
   237  }
   238  
   239  func ExampleSplitAfter() {
   240  	fmt.Printf("%q\n", strings.SplitAfter("a,b,c", ","))
   241  	// Output: ["a," "b," "c"]
   242  }
   243  
   244  func ExampleSplitAfterN() {
   245  	fmt.Printf("%q\n", strings.SplitAfterN("a,b,c", ",", 2))
   246  	// Output: ["a," "b,c"]
   247  }
   248  
   249  func ExampleTitle() {
   250  	// Compare this example to the ToTitle example.
   251  	fmt.Println(strings.Title("her royal highness"))
   252  	fmt.Println(strings.Title("loud noises"))
   253  	fmt.Println(strings.Title("хлеб"))
   254  	// Output:
   255  	// Her Royal Highness
   256  	// Loud Noises
   257  	// Хлеб
   258  }
   259  
   260  func ExampleToTitle() {
   261  	// Compare this example to the Title example.
   262  	fmt.Println(strings.ToTitle("her royal highness"))
   263  	fmt.Println(strings.ToTitle("loud noises"))
   264  	fmt.Println(strings.ToTitle("хлеб"))
   265  	// Output:
   266  	// HER ROYAL HIGHNESS
   267  	// LOUD NOISES
   268  	// ХЛЕБ
   269  }
   270  
   271  func ExampleToTitleSpecial() {
   272  	fmt.Println(strings.ToTitleSpecial(unicode.TurkishCase, "dünyanın ilk borsa yapısı Aizonai kabul edilir"))
   273  	// Output:
   274  	// DÜNYANIN İLK BORSA YAPISI AİZONAİ KABUL EDİLİR
   275  }
   276  
   277  func ExampleMap() {
   278  	rot13 := func(r rune) rune {
   279  		switch {
   280  		case r >= 'A' && r <= 'Z':
   281  			return 'A' + (r-'A'+13)%26
   282  		case r >= 'a' && r <= 'z':
   283  			return 'a' + (r-'a'+13)%26
   284  		}
   285  		return r
   286  	}
   287  	fmt.Println(strings.Map(rot13, "'Twas brillig and the slithy gopher..."))
   288  	// Output: 'Gjnf oevyyvt naq gur fyvgul tbcure...
   289  }
   290  
   291  func ExampleNewReplacer() {
   292  	r := strings.NewReplacer("<", "&lt;", ">", "&gt;")
   293  	fmt.Println(r.Replace("This is <b>HTML</b>!"))
   294  	// Output: This is &lt;b&gt;HTML&lt;/b&gt;!
   295  }
   296  
   297  func ExampleToUpper() {
   298  	fmt.Println(strings.ToUpper("Gopher"))
   299  	// Output: GOPHER
   300  }
   301  
   302  func ExampleToUpperSpecial() {
   303  	fmt.Println(strings.ToUpperSpecial(unicode.TurkishCase, "örnek iş"))
   304  	// Output: ÖRNEK İŞ
   305  }
   306  
   307  func ExampleToLower() {
   308  	fmt.Println(strings.ToLower("Gopher"))
   309  	// Output: gopher
   310  }
   311  
   312  func ExampleToLowerSpecial() {
   313  	fmt.Println(strings.ToLowerSpecial(unicode.TurkishCase, "Önnek İş"))
   314  	// Output: önnek iş
   315  }
   316  
   317  func ExampleTrim() {
   318  	fmt.Print(strings.Trim("¡¡¡Hello, Gophers!!!", "!¡"))
   319  	// Output: Hello, Gophers
   320  }
   321  
   322  func ExampleTrimSpace() {
   323  	fmt.Println(strings.TrimSpace(" \t\n Hello, Gophers \n\t\r\n"))
   324  	// Output: Hello, Gophers
   325  }
   326  
   327  func ExampleTrimPrefix() {
   328  	var s = "¡¡¡Hello, Gophers!!!"
   329  	s = strings.TrimPrefix(s, "¡¡¡Hello, ")
   330  	s = strings.TrimPrefix(s, "¡¡¡Howdy, ")
   331  	fmt.Print(s)
   332  	// Output: Gophers!!!
   333  }
   334  
   335  func ExampleTrimSuffix() {
   336  	var s = "¡¡¡Hello, Gophers!!!"
   337  	s = strings.TrimSuffix(s, ", Gophers!!!")
   338  	s = strings.TrimSuffix(s, ", Marmots!!!")
   339  	fmt.Print(s)
   340  	// Output: ¡¡¡Hello
   341  }
   342  
   343  func ExampleTrimFunc() {
   344  	fmt.Print(strings.TrimFunc("¡¡¡Hello, Gophers!!!", func(r rune) bool {
   345  		return !unicode.IsLetter(r) && !unicode.IsNumber(r)
   346  	}))
   347  	// Output: Hello, Gophers
   348  }
   349  
   350  func ExampleTrimLeft() {
   351  	fmt.Print(strings.TrimLeft("¡¡¡Hello, Gophers!!!", "!¡"))
   352  	// Output: Hello, Gophers!!!
   353  }
   354  
   355  func ExampleTrimLeftFunc() {
   356  	fmt.Print(strings.TrimLeftFunc("¡¡¡Hello, Gophers!!!", func(r rune) bool {
   357  		return !unicode.IsLetter(r) && !unicode.IsNumber(r)
   358  	}))
   359  	// Output: Hello, Gophers!!!
   360  }
   361  
   362  func ExampleTrimRight() {
   363  	fmt.Print(strings.TrimRight("¡¡¡Hello, Gophers!!!", "!¡"))
   364  	// Output: ¡¡¡Hello, Gophers
   365  }
   366  
   367  func ExampleTrimRightFunc() {
   368  	fmt.Print(strings.TrimRightFunc("¡¡¡Hello, Gophers!!!", func(r rune) bool {
   369  		return !unicode.IsLetter(r) && !unicode.IsNumber(r)
   370  	}))
   371  	// Output: ¡¡¡Hello, Gophers
   372  }
   373  
   374  func ExampleBuilder() {
   375  	var b strings.Builder
   376  	for i := 3; i >= 1; i-- {
   377  		fmt.Fprintf(&b, "%d...", i)
   378  	}
   379  	b.WriteString("ignition")
   380  	fmt.Println(b.String())
   381  
   382  	// Output: 3...2...1...ignition
   383  }
   384  

View as plain text