package bytes

Import Path
	bytes (on go.dev)

Dependency Relation
	imports 8 packages, and imported by 87 packages

Involved Source Files

	    buffer.go
	  d bytes.go
		Package bytes implements functions for the manipulation of byte slices.
		It is analogous to the facilities of the [strings] package.

	    iter.go
	    reader.go
Code Examples

	Buffer
		package main
		
		import (
			"bytes"
			"fmt"
			"os"
		)
		
		func main() {
			var b bytes.Buffer // A Buffer needs no initialization.
			b.Write([]byte("Hello "))
			fmt.Fprintf(&b, "world!")
			b.WriteTo(os.Stdout)
		}

	Buffer_AvailableBuffer
		package main
		
		import (
			"bytes"
			"os"
			"strconv"
		)
		
		func main() {
			var buf bytes.Buffer
			for i := 0; i < 4; i++ {
				b := buf.AvailableBuffer()
				b = strconv.AppendInt(b, int64(i), 10)
				b = append(b, ' ')
				buf.Write(b)
			}
			os.Stdout.Write(buf.Bytes())
		}

	Buffer_Bytes
		package main
		
		import (
			"bytes"
			"os"
		)
		
		func main() {
			buf := bytes.Buffer{}
			buf.Write([]byte{'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'})
			os.Stdout.Write(buf.Bytes())
		}

	Buffer_Cap
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			buf1 := bytes.NewBuffer(make([]byte, 10))
			buf2 := bytes.NewBuffer(make([]byte, 0, 10))
			fmt.Println(buf1.Cap())
			fmt.Println(buf2.Cap())
		}

	Buffer_Grow
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			var b bytes.Buffer
			b.Grow(64)
			bb := b.Bytes()
			b.Write([]byte("64 bytes or fewer"))
			fmt.Printf("%q", bb[:b.Len()])
		}

	Buffer_Len
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			var b bytes.Buffer
			b.Grow(64)
			b.Write([]byte("abcde"))
			fmt.Printf("%d", b.Len())
		}

	Buffer_Next
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			var b bytes.Buffer
			b.Grow(64)
			b.Write([]byte("abcde"))
			fmt.Printf("%s\n", b.Next(2))
			fmt.Printf("%s\n", b.Next(2))
			fmt.Printf("%s", b.Next(2))
		}

	Buffer_Read
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			var b bytes.Buffer
			b.Grow(64)
			b.Write([]byte("abcde"))
			rdbuf := make([]byte, 1)
			n, err := b.Read(rdbuf)
			if err != nil {
				panic(err)
			}
			fmt.Println(n)
			fmt.Println(b.String())
			fmt.Println(string(rdbuf))
		}

	Buffer_ReadByte
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			var b bytes.Buffer
			b.Grow(64)
			b.Write([]byte("abcde"))
			c, err := b.ReadByte()
			if err != nil {
				panic(err)
			}
			fmt.Println(c)
			fmt.Println(b.String())
		}

	Buffer_reader
		package main
		
		import (
			"bytes"
			"encoding/base64"
			"io"
			"os"
		)
		
		func main() {
			// A Buffer can turn a string or a []byte into an io.Reader.
			buf := bytes.NewBufferString("R29waGVycyBydWxlIQ==")
			dec := base64.NewDecoder(base64.StdEncoding, buf)
			io.Copy(os.Stdout, dec)
		}

	Clone
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			b := []byte("abc")
			clone := bytes.Clone(b)
			fmt.Printf("%s\n", clone)
			clone[0] = 'd'
			fmt.Printf("%s\n", b)
			fmt.Printf("%s\n", clone)
		}

	Compare
		package main
		
		import (
			"bytes"
		)
		
		func main() {
			// Interpret Compare's result by comparing it to zero.
			var a, b []byte
			if bytes.Compare(a, b) < 0 {
				// a less b
			}
			if bytes.Compare(a, b) <= 0 {
				// a less or equal b
			}
			if bytes.Compare(a, b) > 0 {
				// a greater b
			}
			if bytes.Compare(a, b) >= 0 {
				// a greater or equal b
			}
		
			// Prefer Equal to Compare for equality comparisons.
			if bytes.Equal(a, b) {
				// a equal b
			}
			if !bytes.Equal(a, b) {
				// a not equal b
			}
		}

	Compare_search
		package main
		
		import (
			"bytes"
			"slices"
		)
		
		func main() {
			// Binary search to find a matching byte slice.
			var needle []byte
			var haystack [][]byte // Assume sorted
			_, found := slices.BinarySearchFunc(haystack, needle, bytes.Compare)
			if found {
				// Found it!
			}
		}

	Contains
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Println(bytes.Contains([]byte("seafood"), []byte("foo")))
			fmt.Println(bytes.Contains([]byte("seafood"), []byte("bar")))
			fmt.Println(bytes.Contains([]byte("seafood"), []byte("")))
			fmt.Println(bytes.Contains([]byte(""), []byte("")))
		}

	ContainsAny
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Println(bytes.ContainsAny([]byte("I like seafood."), "fÄo!"))
			fmt.Println(bytes.ContainsAny([]byte("I like seafood."), "去是伟大的."))
			fmt.Println(bytes.ContainsAny([]byte("I like seafood."), ""))
			fmt.Println(bytes.ContainsAny([]byte(""), ""))
		}

	ContainsFunc
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			f := func(r rune) bool {
				return r >= 'a' && r <= 'z'
			}
			fmt.Println(bytes.ContainsFunc([]byte("HELLO"), f))
			fmt.Println(bytes.ContainsFunc([]byte("World"), f))
		}

	ContainsRune
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Println(bytes.ContainsRune([]byte("I like seafood."), 'f'))
			fmt.Println(bytes.ContainsRune([]byte("I like seafood."), 'ö'))
			fmt.Println(bytes.ContainsRune([]byte("去是伟大的!"), '大'))
			fmt.Println(bytes.ContainsRune([]byte("去是伟大的!"), '!'))
			fmt.Println(bytes.ContainsRune([]byte(""), '@'))
		}

	Count
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Println(bytes.Count([]byte("cheese"), []byte("e")))
			fmt.Println(bytes.Count([]byte("five"), []byte(""))) // before & after each rune
		}

	Cut
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			show := func(s, sep string) {
				before, after, found := bytes.Cut([]byte(s), []byte(sep))
				fmt.Printf("Cut(%q, %q) = %q, %q, %v\n", s, sep, before, after, found)
			}
			show("Gopher", "Go")
			show("Gopher", "ph")
			show("Gopher", "er")
			show("Gopher", "Badger")
		}

	CutPrefix
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			show := func(s, prefix string) {
				after, found := bytes.CutPrefix([]byte(s), []byte(prefix))
				fmt.Printf("CutPrefix(%q, %q) = %q, %v\n", s, prefix, after, found)
			}
			show("Gopher", "Go")
			show("Gopher", "ph")
		}

	CutSuffix
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			show := func(s, suffix string) {
				before, found := bytes.CutSuffix([]byte(s), []byte(suffix))
				fmt.Printf("CutSuffix(%q, %q) = %q, %v\n", s, suffix, before, found)
			}
			show("Gopher", "Go")
			show("Gopher", "er")
		}

	Equal
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Println(bytes.Equal([]byte("Go"), []byte("Go")))
			fmt.Println(bytes.Equal([]byte("Go"), []byte("C++")))
		}

	EqualFold
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Println(bytes.EqualFold([]byte("Go"), []byte("go")))
		}

	Fields
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Printf("Fields are: %q", bytes.Fields([]byte("  foo bar  baz   ")))
		}

	FieldsFunc
		package main
		
		import (
			"bytes"
			"fmt"
			"unicode"
		)
		
		func main() {
			f := func(c rune) bool {
				return !unicode.IsLetter(c) && !unicode.IsNumber(c)
			}
			fmt.Printf("Fields are: %q", bytes.FieldsFunc([]byte("  foo1;bar2,baz3..."), f))
		}

	FieldsFuncSeq
		package main
		
		import (
			"bytes"
			"fmt"
			"unicode"
		)
		
		func main() {
			text := []byte("The quick brown fox")
			fmt.Println("Split on whitespace(similar to FieldsSeq):")
			for word := range bytes.FieldsFuncSeq(text, unicode.IsSpace) {
				fmt.Printf("%q\n", word)
			}
		
			mixedText := []byte("abc123def456ghi")
			fmt.Println("\nSplit on digits:")
			for word := range bytes.FieldsFuncSeq(mixedText, unicode.IsDigit) {
				fmt.Printf("%q\n", word)
			}
		
		}

	FieldsSeq
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			text := []byte("The quick brown fox")
			fmt.Println("Split byte slice into fields:")
			for word := range bytes.FieldsSeq(text) {
				fmt.Printf("%q\n", word)
			}
		
			textWithSpaces := []byte("  lots   of   spaces  ")
			fmt.Println("\nSplit byte slice with multiple spaces:")
			for word := range bytes.FieldsSeq(textWithSpaces) {
				fmt.Printf("%q\n", word)
			}
		
		}

	HasPrefix
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Println(bytes.HasPrefix([]byte("Gopher"), []byte("Go")))
			fmt.Println(bytes.HasPrefix([]byte("Gopher"), []byte("C")))
			fmt.Println(bytes.HasPrefix([]byte("Gopher"), []byte("")))
		}

	HasSuffix
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Println(bytes.HasSuffix([]byte("Amigo"), []byte("go")))
			fmt.Println(bytes.HasSuffix([]byte("Amigo"), []byte("O")))
			fmt.Println(bytes.HasSuffix([]byte("Amigo"), []byte("Ami")))
			fmt.Println(bytes.HasSuffix([]byte("Amigo"), []byte("")))
		}

	Index
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Println(bytes.Index([]byte("chicken"), []byte("ken")))
			fmt.Println(bytes.Index([]byte("chicken"), []byte("dmr")))
		}

	IndexAny
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Println(bytes.IndexAny([]byte("chicken"), "aeiouy"))
			fmt.Println(bytes.IndexAny([]byte("crwth"), "aeiouy"))
		}

	IndexByte
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Println(bytes.IndexByte([]byte("chicken"), byte('k')))
			fmt.Println(bytes.IndexByte([]byte("chicken"), byte('g')))
		}

	IndexFunc
		package main
		
		import (
			"bytes"
			"fmt"
			"unicode"
		)
		
		func main() {
			f := func(c rune) bool {
				return unicode.Is(unicode.Han, c)
			}
			fmt.Println(bytes.IndexFunc([]byte("Hello, 世界"), f))
			fmt.Println(bytes.IndexFunc([]byte("Hello, world"), f))
		}

	IndexRune
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Println(bytes.IndexRune([]byte("chicken"), 'k'))
			fmt.Println(bytes.IndexRune([]byte("chicken"), 'd'))
		}

	Join
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			s := [][]byte{[]byte("foo"), []byte("bar"), []byte("baz")}
			fmt.Printf("%s", bytes.Join(s, []byte(", ")))
		}

	LastIndex
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Println(bytes.Index([]byte("go gopher"), []byte("go")))
			fmt.Println(bytes.LastIndex([]byte("go gopher"), []byte("go")))
			fmt.Println(bytes.LastIndex([]byte("go gopher"), []byte("rodent")))
		}

	LastIndexAny
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Println(bytes.LastIndexAny([]byte("go gopher"), "MüQp"))
			fmt.Println(bytes.LastIndexAny([]byte("go 地鼠"), "地大"))
			fmt.Println(bytes.LastIndexAny([]byte("go gopher"), "z,!."))
		}

	LastIndexByte
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Println(bytes.LastIndexByte([]byte("go gopher"), byte('g')))
			fmt.Println(bytes.LastIndexByte([]byte("go gopher"), byte('r')))
			fmt.Println(bytes.LastIndexByte([]byte("go gopher"), byte('z')))
		}

	LastIndexFunc
		package main
		
		import (
			"bytes"
			"fmt"
			"unicode"
		)
		
		func main() {
			fmt.Println(bytes.LastIndexFunc([]byte("go gopher!"), unicode.IsLetter))
			fmt.Println(bytes.LastIndexFunc([]byte("go gopher!"), unicode.IsPunct))
			fmt.Println(bytes.LastIndexFunc([]byte("go gopher!"), unicode.IsNumber))
		}

	Lines
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			text := []byte("Hello\nWorld\nGo Programming\n")
			for line := range bytes.Lines(text) {
				fmt.Printf("%q\n", line)
			}
		
		}

	Map
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			rot13 := func(r rune) rune {
				switch {
				case r >= 'A' && r <= 'Z':
					return 'A' + (r-'A'+13)%26
				case r >= 'a' && r <= 'z':
					return 'a' + (r-'a'+13)%26
				}
				return r
			}
			fmt.Printf("%s\n", bytes.Map(rot13, []byte("'Twas brillig and the slithy gopher...")))
		}

	Reader_Len
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Println(bytes.NewReader([]byte("Hi!")).Len())
			fmt.Println(bytes.NewReader([]byte("こんにちは!")).Len())
		}

	Repeat
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Printf("ba%s", bytes.Repeat([]byte("na"), 2))
		}

	Replace
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Printf("%s\n", bytes.Replace([]byte("oink oink oink"), []byte("k"), []byte("ky"), 2))
			fmt.Printf("%s\n", bytes.Replace([]byte("oink oink oink"), []byte("oink"), []byte("moo"), -1))
		}

	ReplaceAll
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Printf("%s\n", bytes.ReplaceAll([]byte("oink oink oink"), []byte("oink"), []byte("moo")))
		}

	Runes
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			rs := bytes.Runes([]byte("go gopher"))
			for _, r := range rs {
				fmt.Printf("%#U\n", r)
			}
		}

	Split
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Printf("%q\n", bytes.Split([]byte("a,b,c"), []byte(",")))
			fmt.Printf("%q\n", bytes.Split([]byte("a man a plan a canal panama"), []byte("a ")))
			fmt.Printf("%q\n", bytes.Split([]byte(" xyz "), []byte("")))
			fmt.Printf("%q\n", bytes.Split([]byte(""), []byte("Bernardo O'Higgins")))
		}

	SplitAfter
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Printf("%q\n", bytes.SplitAfter([]byte("a,b,c"), []byte(",")))
		}

	SplitAfterN
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Printf("%q\n", bytes.SplitAfterN([]byte("a,b,c"), []byte(","), 2))
		}

	SplitAfterSeq
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			s := []byte("a,b,c,d")
			for part := range bytes.SplitAfterSeq(s, []byte(",")) {
				fmt.Printf("%q\n", part)
			}
		
		}

	SplitN
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Printf("%q\n", bytes.SplitN([]byte("a,b,c"), []byte(","), 2))
			z := bytes.SplitN([]byte("a,b,c"), []byte(","), 0)
			fmt.Printf("%q (nil = %v)\n", z, z == nil)
		}

	SplitSeq
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			s := []byte("a,b,c,d")
			for part := range bytes.SplitSeq(s, []byte(",")) {
				fmt.Printf("%q\n", part)
			}
		
		}

	Title
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Printf("%s", bytes.Title([]byte("her royal highness")))
		}

	ToLower
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Printf("%s", bytes.ToLower([]byte("Gopher")))
		}

	ToLowerSpecial
		package main
		
		import (
			"bytes"
			"fmt"
			"unicode"
		)
		
		func main() {
			str := []byte("AHOJ VÝVOJÁRİ GOLANG")
			totitle := bytes.ToLowerSpecial(unicode.AzeriCase, str)
			fmt.Println("Original : " + string(str))
			fmt.Println("ToLower : " + string(totitle))
		}

	ToTitle
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Printf("%s\n", bytes.ToTitle([]byte("loud noises")))
			fmt.Printf("%s\n", bytes.ToTitle([]byte("брат")))
		}

	ToTitleSpecial
		package main
		
		import (
			"bytes"
			"fmt"
			"unicode"
		)
		
		func main() {
			str := []byte("ahoj vývojári golang")
			totitle := bytes.ToTitleSpecial(unicode.AzeriCase, str)
			fmt.Println("Original : " + string(str))
			fmt.Println("ToTitle : " + string(totitle))
		}

	ToUpper
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Printf("%s", bytes.ToUpper([]byte("Gopher")))
		}

	ToUpperSpecial
		package main
		
		import (
			"bytes"
			"fmt"
			"unicode"
		)
		
		func main() {
			str := []byte("ahoj vývojári golang")
			totitle := bytes.ToUpperSpecial(unicode.AzeriCase, str)
			fmt.Println("Original : " + string(str))
			fmt.Println("ToUpper : " + string(totitle))
		}

	ToValidUTF8
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Printf("%s\n", bytes.ToValidUTF8([]byte("abc"), []byte("\uFFFD")))
			fmt.Printf("%s\n", bytes.ToValidUTF8([]byte("a\xffb\xC0\xAFc\xff"), []byte("")))
			fmt.Printf("%s\n", bytes.ToValidUTF8([]byte("\xed\xa0\x80"), []byte("abc")))
		}

	Trim
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Printf("[%q]", bytes.Trim([]byte(" !!! Achtung! Achtung! !!! "), "! "))
		}

	TrimFunc
		package main
		
		import (
			"bytes"
			"fmt"
			"unicode"
		)
		
		func main() {
			fmt.Println(string(bytes.TrimFunc([]byte("go-gopher!"), unicode.IsLetter)))
			fmt.Println(string(bytes.TrimFunc([]byte("\"go-gopher!\""), unicode.IsLetter)))
			fmt.Println(string(bytes.TrimFunc([]byte("go-gopher!"), unicode.IsPunct)))
			fmt.Println(string(bytes.TrimFunc([]byte("1234go-gopher!567"), unicode.IsNumber)))
		}

	TrimLeft
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Print(string(bytes.TrimLeft([]byte("453gopher8257"), "0123456789")))
		}

	TrimLeftFunc
		package main
		
		import (
			"bytes"
			"fmt"
			"unicode"
		)
		
		func main() {
			fmt.Println(string(bytes.TrimLeftFunc([]byte("go-gopher"), unicode.IsLetter)))
			fmt.Println(string(bytes.TrimLeftFunc([]byte("go-gopher!"), unicode.IsPunct)))
			fmt.Println(string(bytes.TrimLeftFunc([]byte("1234go-gopher!567"), unicode.IsNumber)))
		}

	TrimPrefix
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			var b = []byte("Goodbye,, world!")
			b = bytes.TrimPrefix(b, []byte("Goodbye,"))
			b = bytes.TrimPrefix(b, []byte("See ya,"))
			fmt.Printf("Hello%s", b)
		}

	TrimRight
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Print(string(bytes.TrimRight([]byte("453gopher8257"), "0123456789")))
		}

	TrimRightFunc
		package main
		
		import (
			"bytes"
			"fmt"
			"unicode"
		)
		
		func main() {
			fmt.Println(string(bytes.TrimRightFunc([]byte("go-gopher"), unicode.IsLetter)))
			fmt.Println(string(bytes.TrimRightFunc([]byte("go-gopher!"), unicode.IsPunct)))
			fmt.Println(string(bytes.TrimRightFunc([]byte("1234go-gopher!567"), unicode.IsNumber)))
		}

	TrimSpace
		package main
		
		import (
			"bytes"
			"fmt"
		)
		
		func main() {
			fmt.Printf("%s", bytes.TrimSpace([]byte(" \t\n a lone gopher \n\t\r\n")))
		}

	TrimSuffix
		package main
		
		import (
			"bytes"
			"os"
		)
		
		func main() {
			var b = []byte("Hello, goodbye, etc!")
			b = bytes.TrimSuffix(b, []byte("goodbye, etc!"))
			b = bytes.TrimSuffix(b, []byte("gopher"))
			b = append(b, bytes.TrimSuffix([]byte("world!"), []byte("x!"))...)
			os.Stdout.Write(b)
		}


Package-Level Type Names (total 2)

	/* sort by: alphabet | popularity */
	 type Buffer (struct)
		A Buffer is a variable-sized buffer of bytes with [Buffer.Read] and [Buffer.Write] methods.
		The zero value for Buffer is an empty buffer ready to use.

		Methods (total 23)
			(*Buffer) Available() int
				Available returns how many bytes are unused in the buffer.

			(*Buffer) AvailableBuffer() []byte
				AvailableBuffer returns an empty buffer with b.Available() capacity.
				This buffer is intended to be appended to and
				passed to an immediately succeeding [Buffer.Write] call.
				The buffer is only valid until the next write operation on b.

			(*Buffer) Bytes() []byte
				Bytes returns a slice of length b.Len() holding the unread portion of the buffer.
				The slice is valid for use only until the next buffer modification (that is,
				only until the next call to a method like [Buffer.Read], [Buffer.Write], [Buffer.Reset], or [Buffer.Truncate]).
				The slice aliases the buffer content at least until the next buffer modification,
				so immediate changes to the slice will affect the result of future reads.

			(*Buffer) Cap() int
				Cap returns the capacity of the buffer's underlying byte slice, that is, the
				total space allocated for the buffer's data.

			(*Buffer) Grow(n int)
				Grow grows the buffer's capacity, if necessary, to guarantee space for
				another n bytes. After Grow(n), at least n bytes can be written to the
				buffer without another allocation.
				If n is negative, Grow will panic.
				If the buffer can't grow it will panic with [ErrTooLarge].

			(*Buffer) Len() int
				Len returns the number of bytes of the unread portion of the buffer;
				b.Len() == len(b.Bytes()).

			(*Buffer) Next(n int) []byte
				Next returns a slice containing the next n bytes from the buffer,
				advancing the buffer as if the bytes had been returned by [Buffer.Read].
				If there are fewer than n bytes in the buffer, Next returns the entire buffer.
				The slice is only valid until the next call to a read or write method.

			(*Buffer) Read(p []byte) (n int, err error)
				Read reads the next len(p) bytes from the buffer or until the buffer
				is drained. The return value n is the number of bytes read. If the
				buffer has no data to return, err is [io.EOF] (unless len(p) is zero);
				otherwise it is nil.

			(*Buffer) ReadByte() (byte, error)
				ReadByte reads and returns the next byte from the buffer.
				If no byte is available, it returns error [io.EOF].

			(*Buffer) ReadBytes(delim byte) (line []byte, err error)
				ReadBytes reads until the first occurrence of delim in the input,
				returning a slice containing the data up to and including the delimiter.
				If ReadBytes encounters an error before finding a delimiter,
				it returns the data read before the error and the error itself (often [io.EOF]).
				ReadBytes returns err != nil if and only if the returned data does not end in
				delim.

			(*Buffer) ReadFrom(r io.Reader) (n int64, err error)
				ReadFrom reads data from r until EOF and appends it to the buffer, growing
				the buffer as needed. The return value n is the number of bytes read. Any
				error except io.EOF encountered during the read is also returned. If the
				buffer becomes too large, ReadFrom will panic with [ErrTooLarge].

			(*Buffer) ReadRune() (r rune, size int, err error)
				ReadRune reads and returns the next UTF-8-encoded
				Unicode code point from the buffer.
				If no bytes are available, the error returned is io.EOF.
				If the bytes are an erroneous UTF-8 encoding, it
				consumes one byte and returns U+FFFD, 1.

			(*Buffer) ReadString(delim byte) (line string, err error)
				ReadString reads until the first occurrence of delim in the input,
				returning a string containing the data up to and including the delimiter.
				If ReadString encounters an error before finding a delimiter,
				it returns the data read before the error and the error itself (often [io.EOF]).
				ReadString returns err != nil if and only if the returned data does not end
				in delim.

			(*Buffer) Reset()
				Reset resets the buffer to be empty,
				but it retains the underlying storage for use by future writes.
				Reset is the same as [Buffer.Truncate](0).

			(*Buffer) String() string
				String returns the contents of the unread portion of the buffer
				as a string. If the [Buffer] is a nil pointer, it returns "<nil>".
				
				To build strings more efficiently, see the [strings.Builder] type.

			(*Buffer) Truncate(n int)
				Truncate discards all but the first n unread bytes from the buffer
				but continues to use the same allocated storage.
				It panics if n is negative or greater than the length of the buffer.

			(*Buffer) UnreadByte() error
				UnreadByte unreads the last byte returned by the most recent successful
				read operation that read at least one byte. If a write has happened since
				the last read, if the last read returned an error, or if the read read zero
				bytes, UnreadByte returns an error.

			(*Buffer) UnreadRune() error
				UnreadRune unreads the last rune returned by [Buffer.ReadRune].
				If the most recent read or write operation on the buffer was
				not a successful [Buffer.ReadRune], UnreadRune returns an error.  (In this regard
				it is stricter than [Buffer.UnreadByte], which will unread the last byte
				from any read operation.)

			(*Buffer) Write(p []byte) (n int, err error)
				Write appends the contents of p to the buffer, growing the buffer as
				needed. The return value n is the length of p; err is always nil. If the
				buffer becomes too large, Write will panic with [ErrTooLarge].

			(*Buffer) WriteByte(c byte) error
				WriteByte appends the byte c to the buffer, growing the buffer as needed.
				The returned error is always nil, but is included to match [bufio.Writer]'s
				WriteByte. If the buffer becomes too large, WriteByte will panic with
				[ErrTooLarge].

			(*Buffer) WriteRune(r rune) (n int, err error)
				WriteRune appends the UTF-8 encoding of Unicode code point r to the
				buffer, returning its length and an error, which is always nil but is
				included to match [bufio.Writer]'s WriteRune. The buffer is grown as needed;
				if it becomes too large, WriteRune will panic with [ErrTooLarge].

			(*Buffer) WriteString(s string) (n int, err error)
				WriteString appends the contents of s to the buffer, growing the buffer as
				needed. The return value n is the length of s; err is always nil. If the
				buffer becomes too large, WriteString will panic with [ErrTooLarge].

			(*Buffer) WriteTo(w io.Writer) (n int64, err error)
				WriteTo writes data to w until the buffer is drained or an error occurs.
				The return value n is the number of bytes written; it always fits into an
				int, but it is int64 to match the [io.WriterTo] interface. Any error
				encountered during the write is also returned.

		Implements (at least 16)
			*Buffer : compress/flate.Reader
			*Buffer : expvar.Var
			*Buffer : fmt.Stringer
			*Buffer : image/jpeg.Reader
			*Buffer : internal/bisect.Writer
			*Buffer : io.ByteReader
			*Buffer : io.ByteScanner
			*Buffer : io.ByteWriter
			*Buffer : io.Reader
			*Buffer : io.ReaderFrom
			*Buffer : io.ReadWriter
			*Buffer : io.RuneReader
			*Buffer : io.RuneScanner
			*Buffer : io.StringWriter
			*Buffer : io.Writer
			*Buffer : io.WriterTo
		As Outputs Of (at least 2)
			func NewBuffer(buf []byte) *Buffer
			func NewBufferString(s string) *Buffer
		As Inputs Of (at least 6)
			func encoding/json.Compact(dst *Buffer, src []byte) error
			func encoding/json.HTMLEscape(dst *Buffer, src []byte)
			func encoding/json.Indent(dst *Buffer, src []byte, prefix, indent string) error
			func go/types.WriteExpr(buf *Buffer, x ast.Expr)
			func go/types.WriteSignature(buf *Buffer, sig *types.Signature, qf types.Qualifier)
			func go/types.WriteType(buf *Buffer, typ types.Type, qf types.Qualifier)

	 type Reader (struct)
		A Reader implements the [io.Reader], [io.ReaderAt], [io.WriterTo], [io.Seeker],
		[io.ByteScanner], and [io.RuneScanner] interfaces by reading from
		a byte slice.
		Unlike a [Buffer], a Reader is read-only and supports seeking.
		The zero value for Reader operates like a Reader of an empty slice.

		Methods (total 11)
			(*Reader) Len() int
				Len returns the number of bytes of the unread portion of the
				slice.

			(*Reader) Read(b []byte) (n int, err error)
				Read implements the [io.Reader] interface.

			(*Reader) ReadAt(b []byte, off int64) (n int, err error)
				ReadAt implements the [io.ReaderAt] interface.

			(*Reader) ReadByte() (byte, error)
				ReadByte implements the [io.ByteReader] interface.

			(*Reader) ReadRune() (ch rune, size int, err error)
				ReadRune implements the [io.RuneReader] interface.

			(*Reader) Reset(b []byte)
				Reset resets the [Reader] to be reading from b.

			(*Reader) Seek(offset int64, whence int) (int64, error)
				Seek implements the [io.Seeker] interface.

			(*Reader) Size() int64
				Size returns the original length of the underlying byte slice.
				Size is the number of bytes available for reading via [Reader.ReadAt].
				The result is unaffected by any method calls except [Reader.Reset].

			(*Reader) UnreadByte() error
				UnreadByte complements [Reader.ReadByte] in implementing the [io.ByteScanner] interface.

			(*Reader) UnreadRune() error
				UnreadRune complements [Reader.ReadRune] in implementing the [io.RuneScanner] interface.

			(*Reader) WriteTo(w io.Writer) (n int64, err error)
				WriteTo implements the [io.WriterTo] interface.

		Implements (at least 11)
			*Reader : compress/flate.Reader
			*Reader : image/jpeg.Reader
			*Reader : io.ByteReader
			*Reader : io.ByteScanner
			*Reader : io.Reader
			*Reader : io.ReaderAt
			*Reader : io.ReadSeeker
			*Reader : io.RuneReader
			*Reader : io.RuneScanner
			*Reader : io.Seeker
			*Reader : io.WriterTo
		As Outputs Of (at least one exported)
			func NewReader(b []byte) *Reader


Package-Level Functions (total 60)

	 func Clone(b []byte) []byte
		Clone returns a copy of b[:len(b)].
		The result may have additional unused capacity.
		Clone(nil) returns nil.

	 func Compare(a, b []byte) int
		Compare returns an integer comparing two byte slices lexicographically.
		The result will be 0 if a == b, -1 if a < b, and +1 if a > b.
		A nil argument is equivalent to an empty slice.

	 func Contains(b, subslice []byte) bool
		Contains reports whether subslice is within b.

	 func ContainsAny(b []byte, chars string) bool
		ContainsAny reports whether any of the UTF-8-encoded code points in chars are within b.

	 func ContainsFunc(b []byte, f func(rune) bool) bool
		ContainsFunc reports whether any of the UTF-8-encoded code points r within b satisfy f(r).

	 func ContainsRune(b []byte, r rune) bool
		ContainsRune reports whether the rune is contained in the UTF-8-encoded byte slice b.

	 func Count(s, sep []byte) int
		Count counts the number of non-overlapping instances of sep in s.
		If sep is an empty slice, Count returns 1 + the number of UTF-8-encoded code points in s.

	 func Cut(s, sep []byte) (before, after []byte, found bool)
		Cut slices s around the first instance of sep,
		returning the text before and after sep.
		The found result reports whether sep appears in s.
		If sep does not appear in s, cut returns s, nil, false.
		
		Cut returns slices of the original slice s, not copies.

	 func CutPrefix(s, prefix []byte) (after []byte, found bool)
		CutPrefix returns s without the provided leading prefix byte slice
		and reports whether it found the prefix.
		If s doesn't start with prefix, CutPrefix returns s, false.
		If prefix is the empty byte slice, CutPrefix returns s, true.
		
		CutPrefix returns slices of the original slice s, not copies.

	 func CutSuffix(s, suffix []byte) (before []byte, found bool)
		CutSuffix returns s without the provided ending suffix byte slice
		and reports whether it found the suffix.
		If s doesn't end with suffix, CutSuffix returns s, false.
		If suffix is the empty byte slice, CutSuffix returns s, true.
		
		CutSuffix returns slices of the original slice s, not copies.

	 func Equal(a, b []byte) bool
		Equal reports whether a and b
		are the same length and contain the same bytes.
		A nil argument is equivalent to an empty slice.

	 func EqualFold(s, t []byte) bool
		EqualFold reports whether s and t, interpreted as UTF-8 strings,
		are equal under simple Unicode case-folding, which is a more general
		form of case-insensitivity.

	 func Fields(s []byte) [][]byte
		Fields interprets s as a sequence of UTF-8-encoded code points.
		It splits the slice s around each instance of one or more consecutive white space
		characters, as defined by [unicode.IsSpace], returning a slice of subslices of s or an
		empty slice if s contains only white space. Every element of the returned slice is
		non-empty. Unlike [Split], leading and trailing runs of white space characters
		are discarded.

	 func FieldsFunc(s []byte, f func(rune) bool) [][]byte
		FieldsFunc interprets s as a sequence of UTF-8-encoded code points.
		It splits the slice s at each run of code points c satisfying f(c) and
		returns a slice of subslices of s. If all code points in s satisfy f(c), or
		len(s) == 0, an empty slice is returned. Every element of the returned slice is
		non-empty. Unlike [SplitFunc], leading and trailing runs of code points
		satisfying f(c) are discarded.
		
		FieldsFunc makes no guarantees about the order in which it calls f(c)
		and assumes that f always returns the same value for a given c.

	 func FieldsFuncSeq(s []byte, f func(rune) bool) iter.Seq[[]byte]
		FieldsFuncSeq returns an iterator over subslices of s split around runs of
		Unicode code points satisfying f(c).
		The iterator yields the same subslices that would be returned by [FieldsFunc](s),
		but without constructing a new slice containing the subslices.

	 func FieldsSeq(s []byte) iter.Seq[[]byte]
		FieldsSeq returns an iterator over subslices of s split around runs of
		whitespace characters, as defined by [unicode.IsSpace].
		The iterator yields the same subslices that would be returned by [Fields](s),
		but without constructing a new slice containing the subslices.

	 func HasPrefix(s, prefix []byte) bool
		HasPrefix reports whether the byte slice s begins with prefix.

	 func HasSuffix(s, suffix []byte) bool
		HasSuffix reports whether the byte slice s ends with suffix.

	 func Index(s, sep []byte) int
		Index returns the index of the first instance of sep in s, or -1 if sep is not present in s.

	 func IndexAny(s []byte, chars string) int
		IndexAny interprets s as a sequence of UTF-8-encoded Unicode code points.
		It returns the byte index of the first occurrence in s of any of the Unicode
		code points in chars. It returns -1 if chars is empty or if there is no code
		point in common.

	 func IndexByte(b []byte, c byte) int
		IndexByte returns the index of the first instance of c in b, or -1 if c is not present in b.

	 func IndexFunc(s []byte, f func(r rune) bool) int
		IndexFunc interprets s as a sequence of UTF-8-encoded code points.
		It returns the byte index in s of the first Unicode
		code point satisfying f(c), or -1 if none do.

	 func IndexRune(s []byte, r rune) int
		IndexRune interprets s as a sequence of UTF-8-encoded code points.
		It returns the byte index of the first occurrence in s of the given rune.
		It returns -1 if rune is not present in s.
		If r is [utf8.RuneError], it returns the first instance of any
		invalid UTF-8 byte sequence.

	 func Join(s [][]byte, sep []byte) []byte
		Join concatenates the elements of s to create a new byte slice. The separator
		sep is placed between elements in the resulting slice.

	 func LastIndex(s, sep []byte) int
		LastIndex returns the index of the last instance of sep in s, or -1 if sep is not present in s.

	 func LastIndexAny(s []byte, chars string) int
		LastIndexAny interprets s as a sequence of UTF-8-encoded Unicode code
		points. It returns the byte index of the last occurrence in s of any of
		the Unicode code points in chars. It returns -1 if chars is empty or if
		there is no code point in common.

	 func LastIndexByte(s []byte, c byte) int
		LastIndexByte returns the index of the last instance of c in s, or -1 if c is not present in s.

	 func LastIndexFunc(s []byte, f func(r rune) bool) int
		LastIndexFunc interprets s as a sequence of UTF-8-encoded code points.
		It returns the byte index in s of the last Unicode
		code point satisfying f(c), or -1 if none do.

	 func Lines(s []byte) iter.Seq[[]byte]
		Lines returns an iterator over the newline-terminated lines in the byte slice s.
		The lines yielded by the iterator include their terminating newlines.
		If s is empty, the iterator yields no lines at all.
		If s does not end in a newline, the final yielded line will not end in a newline.
		It returns a single-use iterator.

	 func Map(mapping func(r rune) rune, s []byte) []byte
		Map returns a copy of the byte slice s with all its characters modified
		according to the mapping function. If mapping returns a negative value, the character is
		dropped from the byte slice with no replacement. The characters in s and the
		output are interpreted as UTF-8-encoded code points.

	 func NewBuffer(buf []byte) *Buffer
		NewBuffer creates and initializes a new [Buffer] using buf as its
		initial contents. The new [Buffer] takes ownership of buf, and the
		caller should not use buf after this call. NewBuffer is intended to
		prepare a [Buffer] to read existing data. It can also be used to set
		the initial size of the internal buffer for writing. To do that,
		buf should have the desired capacity but a length of zero.
		
		In most cases, new([Buffer]) (or just declaring a [Buffer] variable) is
		sufficient to initialize a [Buffer].

	 func NewBufferString(s string) *Buffer
		NewBufferString creates and initializes a new [Buffer] using string s as its
		initial contents. It is intended to prepare a buffer to read an existing
		string.
		
		In most cases, new([Buffer]) (or just declaring a [Buffer] variable) is
		sufficient to initialize a [Buffer].

	 func NewReader(b []byte) *Reader
		NewReader returns a new [Reader] reading from b.

	 func Repeat(b []byte, count int) []byte
		Repeat returns a new byte slice consisting of count copies of b.
		
		It panics if count is negative or if the result of (len(b) * count)
		overflows.

	 func Replace(s, old, new []byte, n int) []byte
		Replace returns a copy of the slice s with the first n
		non-overlapping instances of old replaced by new.
		If old is empty, it matches at the beginning of the slice
		and after each UTF-8 sequence, yielding up to k+1 replacements
		for a k-rune slice.
		If n < 0, there is no limit on the number of replacements.

	 func ReplaceAll(s, old, new []byte) []byte
		ReplaceAll returns a copy of the slice s with all
		non-overlapping instances of old replaced by new.
		If old is empty, it matches at the beginning of the slice
		and after each UTF-8 sequence, yielding up to k+1 replacements
		for a k-rune slice.

	 func Runes(s []byte) []rune
		Runes interprets s as a sequence of UTF-8-encoded code points.
		It returns a slice of runes (Unicode code points) equivalent to s.

	 func Split(s, sep []byte) [][]byte
		Split slices s into all subslices separated by sep and returns a slice of
		the subslices between those separators.
		If sep is empty, Split splits after each UTF-8 sequence.
		It is equivalent to SplitN with a count of -1.
		
		To split around the first instance of a separator, see [Cut].

	 func SplitAfter(s, sep []byte) [][]byte
		SplitAfter slices s into all subslices after each instance of sep and
		returns a slice of those subslices.
		If sep is empty, SplitAfter splits after each UTF-8 sequence.
		It is equivalent to SplitAfterN with a count of -1.

	 func SplitAfterN(s, sep []byte, n int) [][]byte
		SplitAfterN slices s into subslices after each instance of sep and
		returns a slice of those subslices.
		If sep is empty, SplitAfterN splits after each UTF-8 sequence.
		The count determines the number of subslices to return:
		  - n > 0: at most n subslices; the last subslice will be the unsplit remainder;
		  - n == 0: the result is nil (zero subslices);
		  - n < 0: all subslices.

	 func SplitAfterSeq(s, sep []byte) iter.Seq[[]byte]
		SplitAfterSeq returns an iterator over subslices of s split after each instance of sep.
		The iterator yields the same subslices that would be returned by [SplitAfter](s, sep),
		but without constructing a new slice containing the subslices.
		It returns a single-use iterator.

	 func SplitN(s, sep []byte, n int) [][]byte
		SplitN slices s into subslices separated by sep and returns a slice of
		the subslices between those separators.
		If sep is empty, SplitN splits after each UTF-8 sequence.
		The count determines the number of subslices to return:
		  - n > 0: at most n subslices; the last subslice will be the unsplit remainder;
		  - n == 0: the result is nil (zero subslices);
		  - n < 0: all subslices.
		
		To split around the first instance of a separator, see [Cut].

	 func SplitSeq(s, sep []byte) iter.Seq[[]byte]
		SplitSeq returns an iterator over all subslices of s separated by sep.
		The iterator yields the same subslices that would be returned by [Split](s, sep),
		but without constructing a new slice containing the subslices.
		It returns a single-use iterator.

	 func Title(s []byte) []byte
		Title treats s as UTF-8-encoded bytes and returns a copy with all Unicode letters that begin
		words mapped to their title case.
		
		Deprecated: The rule Title uses for word boundaries does not handle Unicode
		punctuation properly. Use golang.org/x/text/cases instead.

	 func ToLower(s []byte) []byte
		ToLower returns a copy of the byte slice s with all Unicode letters mapped to
		their lower case.

	 func ToLowerSpecial(c unicode.SpecialCase, s []byte) []byte
		ToLowerSpecial treats s as UTF-8-encoded bytes and returns a copy with all the Unicode letters mapped to their
		lower case, giving priority to the special casing rules.

	 func ToTitle(s []byte) []byte
		ToTitle treats s as UTF-8-encoded bytes and returns a copy with all the Unicode letters mapped to their title case.

	 func ToTitleSpecial(c unicode.SpecialCase, s []byte) []byte
		ToTitleSpecial treats s as UTF-8-encoded bytes and returns a copy with all the Unicode letters mapped to their
		title case, giving priority to the special casing rules.

	 func ToUpper(s []byte) []byte
		ToUpper returns a copy of the byte slice s with all Unicode letters mapped to
		their upper case.

	 func ToUpperSpecial(c unicode.SpecialCase, s []byte) []byte
		ToUpperSpecial treats s as UTF-8-encoded bytes and returns a copy with all the Unicode letters mapped to their
		upper case, giving priority to the special casing rules.

	 func ToValidUTF8(s, replacement []byte) []byte
		ToValidUTF8 treats s as UTF-8-encoded bytes and returns a copy with each run of bytes
		representing invalid UTF-8 replaced with the bytes in replacement, which may be empty.

	 func Trim(s []byte, cutset string) []byte
		Trim returns a subslice of s by slicing off all leading and
		trailing UTF-8-encoded code points contained in cutset.

	 func TrimFunc(s []byte, f func(r rune) bool) []byte
		TrimFunc returns a subslice of s by slicing off all leading and trailing
		UTF-8-encoded code points c that satisfy f(c).

	 func TrimLeft(s []byte, cutset string) []byte
		TrimLeft returns a subslice of s by slicing off all leading
		UTF-8-encoded code points contained in cutset.

	 func TrimLeftFunc(s []byte, f func(r rune) bool) []byte
		TrimLeftFunc treats s as UTF-8-encoded bytes and returns a subslice of s by slicing off
		all leading UTF-8-encoded code points c that satisfy f(c).

	 func TrimPrefix(s, prefix []byte) []byte
		TrimPrefix returns s without the provided leading prefix string.
		If s doesn't start with prefix, s is returned unchanged.

	 func TrimRight(s []byte, cutset string) []byte
		TrimRight returns a subslice of s by slicing off all trailing
		UTF-8-encoded code points that are contained in cutset.

	 func TrimRightFunc(s []byte, f func(r rune) bool) []byte
		TrimRightFunc returns a subslice of s by slicing off all trailing
		UTF-8-encoded code points c that satisfy f(c).

	 func TrimSpace(s []byte) []byte
		TrimSpace returns a subslice of s by slicing off all leading and
		trailing white space, as defined by Unicode.

	 func TrimSuffix(s, suffix []byte) []byte
		TrimSuffix returns s without the provided trailing suffix string.
		If s doesn't end with suffix, s is returned unchanged.


Package-Level Variables (only one)

	  var ErrTooLarge error
		ErrTooLarge is passed to panic if memory cannot be allocated to store data in a buffer.


Package-Level Constants (only one)

	const MinRead = 512
		MinRead is the minimum slice size passed to a [Buffer.Read] call by
		[Buffer.ReadFrom]. As long as the [Buffer] has at least MinRead bytes beyond
		what is required to hold the contents of r, [Buffer.ReadFrom] will not grow the
		underlying buffer.

The pages are generated with Golds v0.7.7-preview. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.