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