github.com/geraldss/go/src@v0.0.0-20210511222824-ac7d0ebfc235/bytes/example_test.go (about)

     1  // Copyright 2011 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 bytes_test
     6  
     7  import (
     8  	"bytes"
     9  	"encoding/base64"
    10  	"fmt"
    11  	"io"
    12  	"os"
    13  	"sort"
    14  	"unicode"
    15  )
    16  
    17  func ExampleBuffer() {
    18  	var b bytes.Buffer // A Buffer needs no initialization.
    19  	b.Write([]byte("Hello "))
    20  	fmt.Fprintf(&b, "world!")
    21  	b.WriteTo(os.Stdout)
    22  	// Output: Hello world!
    23  }
    24  
    25  func ExampleBuffer_reader() {
    26  	// A Buffer can turn a string or a []byte into an io.Reader.
    27  	buf := bytes.NewBufferString("R29waGVycyBydWxlIQ==")
    28  	dec := base64.NewDecoder(base64.StdEncoding, buf)
    29  	io.Copy(os.Stdout, dec)
    30  	// Output: Gophers rule!
    31  }
    32  
    33  func ExampleBuffer_Bytes() {
    34  	buf := bytes.Buffer{}
    35  	buf.Write([]byte{'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'})
    36  	os.Stdout.Write(buf.Bytes())
    37  	// Output: hello world
    38  }
    39  
    40  func ExampleBuffer_Grow() {
    41  	var b bytes.Buffer
    42  	b.Grow(64)
    43  	bb := b.Bytes()
    44  	b.Write([]byte("64 bytes or fewer"))
    45  	fmt.Printf("%q", bb[:b.Len()])
    46  	// Output: "64 bytes or fewer"
    47  }
    48  
    49  func ExampleBuffer_Len() {
    50  	var b bytes.Buffer
    51  	b.Grow(64)
    52  	b.Write([]byte("abcde"))
    53  	fmt.Printf("%d", b.Len())
    54  	// Output: 5
    55  }
    56  
    57  func ExampleCompare() {
    58  	// Interpret Compare's result by comparing it to zero.
    59  	var a, b []byte
    60  	if bytes.Compare(a, b) < 0 {
    61  		// a less b
    62  	}
    63  	if bytes.Compare(a, b) <= 0 {
    64  		// a less or equal b
    65  	}
    66  	if bytes.Compare(a, b) > 0 {
    67  		// a greater b
    68  	}
    69  	if bytes.Compare(a, b) >= 0 {
    70  		// a greater or equal b
    71  	}
    72  
    73  	// Prefer Equal to Compare for equality comparisons.
    74  	if bytes.Equal(a, b) {
    75  		// a equal b
    76  	}
    77  	if !bytes.Equal(a, b) {
    78  		// a not equal b
    79  	}
    80  }
    81  
    82  func ExampleCompare_search() {
    83  	// Binary search to find a matching byte slice.
    84  	var needle []byte
    85  	var haystack [][]byte // Assume sorted
    86  	i := sort.Search(len(haystack), func(i int) bool {
    87  		// Return haystack[i] >= needle.
    88  		return bytes.Compare(haystack[i], needle) >= 0
    89  	})
    90  	if i < len(haystack) && bytes.Equal(haystack[i], needle) {
    91  		// Found it!
    92  	}
    93  }
    94  
    95  func ExampleTrimSuffix() {
    96  	var b = []byte("Hello, goodbye, etc!")
    97  	b = bytes.TrimSuffix(b, []byte("goodbye, etc!"))
    98  	b = bytes.TrimSuffix(b, []byte("gopher"))
    99  	b = append(b, bytes.TrimSuffix([]byte("world!"), []byte("x!"))...)
   100  	os.Stdout.Write(b)
   101  	// Output: Hello, world!
   102  }
   103  
   104  func ExampleTrimPrefix() {
   105  	var b = []byte("Goodbye,, world!")
   106  	b = bytes.TrimPrefix(b, []byte("Goodbye,"))
   107  	b = bytes.TrimPrefix(b, []byte("See ya,"))
   108  	fmt.Printf("Hello%s", b)
   109  	// Output: Hello, world!
   110  }
   111  
   112  func ExampleFields() {
   113  	fmt.Printf("Fields are: %q", bytes.Fields([]byte("  foo bar  baz   ")))
   114  	// Output: Fields are: ["foo" "bar" "baz"]
   115  }
   116  
   117  func ExampleFieldsFunc() {
   118  	f := func(c rune) bool {
   119  		return !unicode.IsLetter(c) && !unicode.IsNumber(c)
   120  	}
   121  	fmt.Printf("Fields are: %q", bytes.FieldsFunc([]byte("  foo1;bar2,baz3..."), f))
   122  	// Output: Fields are: ["foo1" "bar2" "baz3"]
   123  }
   124  
   125  func ExampleContains() {
   126  	fmt.Println(bytes.Contains([]byte("seafood"), []byte("foo")))
   127  	fmt.Println(bytes.Contains([]byte("seafood"), []byte("bar")))
   128  	fmt.Println(bytes.Contains([]byte("seafood"), []byte("")))
   129  	fmt.Println(bytes.Contains([]byte(""), []byte("")))
   130  	// Output:
   131  	// true
   132  	// false
   133  	// true
   134  	// true
   135  }
   136  
   137  func ExampleContainsAny() {
   138  	fmt.Println(bytes.ContainsAny([]byte("I like seafood."), "fÄo!"))
   139  	fmt.Println(bytes.ContainsAny([]byte("I like seafood."), "去是伟大的."))
   140  	fmt.Println(bytes.ContainsAny([]byte("I like seafood."), ""))
   141  	fmt.Println(bytes.ContainsAny([]byte(""), ""))
   142  	// Output:
   143  	// true
   144  	// true
   145  	// false
   146  	// false
   147  }
   148  
   149  func ExampleContainsRune() {
   150  	fmt.Println(bytes.ContainsRune([]byte("I like seafood."), 'f'))
   151  	fmt.Println(bytes.ContainsRune([]byte("I like seafood."), 'ö'))
   152  	fmt.Println(bytes.ContainsRune([]byte("去是伟大的!"), '大'))
   153  	fmt.Println(bytes.ContainsRune([]byte("去是伟大的!"), '!'))
   154  	fmt.Println(bytes.ContainsRune([]byte(""), '@'))
   155  	// Output:
   156  	// true
   157  	// false
   158  	// true
   159  	// true
   160  	// false
   161  }
   162  
   163  func ExampleCount() {
   164  	fmt.Println(bytes.Count([]byte("cheese"), []byte("e")))
   165  	fmt.Println(bytes.Count([]byte("five"), []byte(""))) // before & after each rune
   166  	// Output:
   167  	// 3
   168  	// 5
   169  }
   170  
   171  func ExampleEqual() {
   172  	fmt.Println(bytes.Equal([]byte("Go"), []byte("Go")))
   173  	fmt.Println(bytes.Equal([]byte("Go"), []byte("C++")))
   174  	// Output:
   175  	// true
   176  	// false
   177  }
   178  
   179  func ExampleEqualFold() {
   180  	fmt.Println(bytes.EqualFold([]byte("Go"), []byte("go")))
   181  	// Output: true
   182  }
   183  
   184  func ExampleHasPrefix() {
   185  	fmt.Println(bytes.HasPrefix([]byte("Gopher"), []byte("Go")))
   186  	fmt.Println(bytes.HasPrefix([]byte("Gopher"), []byte("C")))
   187  	fmt.Println(bytes.HasPrefix([]byte("Gopher"), []byte("")))
   188  	// Output:
   189  	// true
   190  	// false
   191  	// true
   192  }
   193  
   194  func ExampleHasSuffix() {
   195  	fmt.Println(bytes.HasSuffix([]byte("Amigo"), []byte("go")))
   196  	fmt.Println(bytes.HasSuffix([]byte("Amigo"), []byte("O")))
   197  	fmt.Println(bytes.HasSuffix([]byte("Amigo"), []byte("Ami")))
   198  	fmt.Println(bytes.HasSuffix([]byte("Amigo"), []byte("")))
   199  	// Output:
   200  	// true
   201  	// false
   202  	// false
   203  	// true
   204  }
   205  
   206  func ExampleIndex() {
   207  	fmt.Println(bytes.Index([]byte("chicken"), []byte("ken")))
   208  	fmt.Println(bytes.Index([]byte("chicken"), []byte("dmr")))
   209  	// Output:
   210  	// 4
   211  	// -1
   212  }
   213  
   214  func ExampleIndexByte() {
   215  	fmt.Println(bytes.IndexByte([]byte("chicken"), byte('k')))
   216  	fmt.Println(bytes.IndexByte([]byte("chicken"), byte('g')))
   217  	// Output:
   218  	// 4
   219  	// -1
   220  }
   221  
   222  func ExampleIndexFunc() {
   223  	f := func(c rune) bool {
   224  		return unicode.Is(unicode.Han, c)
   225  	}
   226  	fmt.Println(bytes.IndexFunc([]byte("Hello, 世界"), f))
   227  	fmt.Println(bytes.IndexFunc([]byte("Hello, world"), f))
   228  	// Output:
   229  	// 7
   230  	// -1
   231  }
   232  
   233  func ExampleIndexAny() {
   234  	fmt.Println(bytes.IndexAny([]byte("chicken"), "aeiouy"))
   235  	fmt.Println(bytes.IndexAny([]byte("crwth"), "aeiouy"))
   236  	// Output:
   237  	// 2
   238  	// -1
   239  }
   240  
   241  func ExampleIndexRune() {
   242  	fmt.Println(bytes.IndexRune([]byte("chicken"), 'k'))
   243  	fmt.Println(bytes.IndexRune([]byte("chicken"), 'd'))
   244  	// Output:
   245  	// 4
   246  	// -1
   247  }
   248  
   249  func ExampleLastIndex() {
   250  	fmt.Println(bytes.Index([]byte("go gopher"), []byte("go")))
   251  	fmt.Println(bytes.LastIndex([]byte("go gopher"), []byte("go")))
   252  	fmt.Println(bytes.LastIndex([]byte("go gopher"), []byte("rodent")))
   253  	// Output:
   254  	// 0
   255  	// 3
   256  	// -1
   257  }
   258  
   259  func ExampleLastIndexAny() {
   260  	fmt.Println(bytes.LastIndexAny([]byte("go gopher"), "MüQp"))
   261  	fmt.Println(bytes.LastIndexAny([]byte("go 地鼠"), "地大"))
   262  	fmt.Println(bytes.LastIndexAny([]byte("go gopher"), "z,!."))
   263  	// Output:
   264  	// 5
   265  	// 3
   266  	// -1
   267  }
   268  
   269  func ExampleLastIndexByte() {
   270  	fmt.Println(bytes.LastIndexByte([]byte("go gopher"), byte('g')))
   271  	fmt.Println(bytes.LastIndexByte([]byte("go gopher"), byte('r')))
   272  	fmt.Println(bytes.LastIndexByte([]byte("go gopher"), byte('z')))
   273  	// Output:
   274  	// 3
   275  	// 8
   276  	// -1
   277  }
   278  
   279  func ExampleLastIndexFunc() {
   280  	fmt.Println(bytes.LastIndexFunc([]byte("go gopher!"), unicode.IsLetter))
   281  	fmt.Println(bytes.LastIndexFunc([]byte("go gopher!"), unicode.IsPunct))
   282  	fmt.Println(bytes.LastIndexFunc([]byte("go gopher!"), unicode.IsNumber))
   283  	// Output:
   284  	// 8
   285  	// 9
   286  	// -1
   287  }
   288  
   289  func ExampleJoin() {
   290  	s := [][]byte{[]byte("foo"), []byte("bar"), []byte("baz")}
   291  	fmt.Printf("%s", bytes.Join(s, []byte(", ")))
   292  	// Output: foo, bar, baz
   293  }
   294  
   295  func ExampleRepeat() {
   296  	fmt.Printf("ba%s", bytes.Repeat([]byte("na"), 2))
   297  	// Output: banana
   298  }
   299  
   300  func ExampleReplace() {
   301  	fmt.Printf("%s\n", bytes.Replace([]byte("oink oink oink"), []byte("k"), []byte("ky"), 2))
   302  	fmt.Printf("%s\n", bytes.Replace([]byte("oink oink oink"), []byte("oink"), []byte("moo"), -1))
   303  	// Output:
   304  	// oinky oinky oink
   305  	// moo moo moo
   306  }
   307  
   308  func ExampleReplaceAll() {
   309  	fmt.Printf("%s\n", bytes.ReplaceAll([]byte("oink oink oink"), []byte("oink"), []byte("moo")))
   310  	// Output:
   311  	// moo moo moo
   312  }
   313  
   314  func ExampleRunes() {
   315  	rs := bytes.Runes([]byte("go gopher"))
   316  	for _, r := range rs {
   317  		fmt.Printf("%#U\n", r)
   318  	}
   319  	// Output:
   320  	// U+0067 'g'
   321  	// U+006F 'o'
   322  	// U+0020 ' '
   323  	// U+0067 'g'
   324  	// U+006F 'o'
   325  	// U+0070 'p'
   326  	// U+0068 'h'
   327  	// U+0065 'e'
   328  	// U+0072 'r'
   329  }
   330  
   331  func ExampleSplit() {
   332  	fmt.Printf("%q\n", bytes.Split([]byte("a,b,c"), []byte(",")))
   333  	fmt.Printf("%q\n", bytes.Split([]byte("a man a plan a canal panama"), []byte("a ")))
   334  	fmt.Printf("%q\n", bytes.Split([]byte(" xyz "), []byte("")))
   335  	fmt.Printf("%q\n", bytes.Split([]byte(""), []byte("Bernardo O'Higgins")))
   336  	// Output:
   337  	// ["a" "b" "c"]
   338  	// ["" "man " "plan " "canal panama"]
   339  	// [" " "x" "y" "z" " "]
   340  	// [""]
   341  }
   342  
   343  func ExampleSplitN() {
   344  	fmt.Printf("%q\n", bytes.SplitN([]byte("a,b,c"), []byte(","), 2))
   345  	z := bytes.SplitN([]byte("a,b,c"), []byte(","), 0)
   346  	fmt.Printf("%q (nil = %v)\n", z, z == nil)
   347  	// Output:
   348  	// ["a" "b,c"]
   349  	// [] (nil = true)
   350  }
   351  
   352  func ExampleSplitAfter() {
   353  	fmt.Printf("%q\n", bytes.SplitAfter([]byte("a,b,c"), []byte(",")))
   354  	// Output: ["a," "b," "c"]
   355  }
   356  
   357  func ExampleSplitAfterN() {
   358  	fmt.Printf("%q\n", bytes.SplitAfterN([]byte("a,b,c"), []byte(","), 2))
   359  	// Output: ["a," "b,c"]
   360  }
   361  
   362  func ExampleTitle() {
   363  	fmt.Printf("%s", bytes.Title([]byte("her royal highness")))
   364  	// Output: Her Royal Highness
   365  }
   366  
   367  func ExampleToTitle() {
   368  	fmt.Printf("%s\n", bytes.ToTitle([]byte("loud noises")))
   369  	fmt.Printf("%s\n", bytes.ToTitle([]byte("хлеб")))
   370  	// Output:
   371  	// LOUD NOISES
   372  	// ХЛЕБ
   373  }
   374  
   375  func ExampleToTitleSpecial() {
   376  	str := []byte("ahoj vývojári golang")
   377  	totitle := bytes.ToTitleSpecial(unicode.AzeriCase, str)
   378  	fmt.Println("Original : " + string(str))
   379  	fmt.Println("ToTitle : " + string(totitle))
   380  	// Output:
   381  	// Original : ahoj vývojári golang
   382  	// ToTitle : AHOJ VÝVOJÁRİ GOLANG
   383  }
   384  
   385  func ExampleTrim() {
   386  	fmt.Printf("[%q]", bytes.Trim([]byte(" !!! Achtung! Achtung! !!! "), "! "))
   387  	// Output: ["Achtung! Achtung"]
   388  }
   389  
   390  func ExampleTrimFunc() {
   391  	fmt.Println(string(bytes.TrimFunc([]byte("go-gopher!"), unicode.IsLetter)))
   392  	fmt.Println(string(bytes.TrimFunc([]byte("\"go-gopher!\""), unicode.IsLetter)))
   393  	fmt.Println(string(bytes.TrimFunc([]byte("go-gopher!"), unicode.IsPunct)))
   394  	fmt.Println(string(bytes.TrimFunc([]byte("1234go-gopher!567"), unicode.IsNumber)))
   395  	// Output:
   396  	// -gopher!
   397  	// "go-gopher!"
   398  	// go-gopher
   399  	// go-gopher!
   400  }
   401  
   402  func ExampleMap() {
   403  	rot13 := func(r rune) rune {
   404  		switch {
   405  		case r >= 'A' && r <= 'Z':
   406  			return 'A' + (r-'A'+13)%26
   407  		case r >= 'a' && r <= 'z':
   408  			return 'a' + (r-'a'+13)%26
   409  		}
   410  		return r
   411  	}
   412  	fmt.Printf("%s", bytes.Map(rot13, []byte("'Twas brillig and the slithy gopher...")))
   413  	// Output: 'Gjnf oevyyvt naq gur fyvgul tbcure...
   414  }
   415  
   416  func ExampleTrimLeft() {
   417  	fmt.Print(string(bytes.TrimLeft([]byte("453gopher8257"), "0123456789")))
   418  	// Output:
   419  	// gopher8257
   420  }
   421  
   422  func ExampleTrimLeftFunc() {
   423  	fmt.Println(string(bytes.TrimLeftFunc([]byte("go-gopher"), unicode.IsLetter)))
   424  	fmt.Println(string(bytes.TrimLeftFunc([]byte("go-gopher!"), unicode.IsPunct)))
   425  	fmt.Println(string(bytes.TrimLeftFunc([]byte("1234go-gopher!567"), unicode.IsNumber)))
   426  	// Output:
   427  	// -gopher
   428  	// go-gopher!
   429  	// go-gopher!567
   430  }
   431  
   432  func ExampleTrimSpace() {
   433  	fmt.Printf("%s", bytes.TrimSpace([]byte(" \t\n a lone gopher \n\t\r\n")))
   434  	// Output: a lone gopher
   435  }
   436  
   437  func ExampleTrimRight() {
   438  	fmt.Print(string(bytes.TrimRight([]byte("453gopher8257"), "0123456789")))
   439  	// Output:
   440  	// 453gopher
   441  }
   442  
   443  func ExampleTrimRightFunc() {
   444  	fmt.Println(string(bytes.TrimRightFunc([]byte("go-gopher"), unicode.IsLetter)))
   445  	fmt.Println(string(bytes.TrimRightFunc([]byte("go-gopher!"), unicode.IsPunct)))
   446  	fmt.Println(string(bytes.TrimRightFunc([]byte("1234go-gopher!567"), unicode.IsNumber)))
   447  	// Output:
   448  	// go-
   449  	// go-gopher
   450  	// 1234go-gopher!
   451  }
   452  
   453  func ExampleToUpper() {
   454  	fmt.Printf("%s", bytes.ToUpper([]byte("Gopher")))
   455  	// Output: GOPHER
   456  }
   457  
   458  func ExampleToUpperSpecial() {
   459  	str := []byte("ahoj vývojári golang")
   460  	totitle := bytes.ToUpperSpecial(unicode.AzeriCase, str)
   461  	fmt.Println("Original : " + string(str))
   462  	fmt.Println("ToUpper : " + string(totitle))
   463  	// Output:
   464  	// Original : ahoj vývojári golang
   465  	// ToUpper : AHOJ VÝVOJÁRİ GOLANG
   466  }
   467  
   468  func ExampleToLower() {
   469  	fmt.Printf("%s", bytes.ToLower([]byte("Gopher")))
   470  	// Output: gopher
   471  }
   472  
   473  func ExampleToLowerSpecial() {
   474  	str := []byte("AHOJ VÝVOJÁRİ GOLANG")
   475  	totitle := bytes.ToLowerSpecial(unicode.AzeriCase, str)
   476  	fmt.Println("Original : " + string(str))
   477  	fmt.Println("ToLower : " + string(totitle))
   478  	// Output:
   479  	// Original : AHOJ VÝVOJÁRİ GOLANG
   480  	// ToLower : ahoj vývojári golang
   481  }
   482  
   483  func ExampleReader_Len() {
   484  	fmt.Println(bytes.NewReader([]byte("Hi!")).Len())
   485  	fmt.Println(bytes.NewReader([]byte("こんにちは!")).Len())
   486  	// Output:
   487  	// 3
   488  	// 16
   489  }