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