Пакет bytes

• import "bytes"
• Обзор
• Указатель
• Примеры

Обзор

Пакет bytes реализует функции для работы с байтовыми срезами. Он аналогичен возможностям пакета strings.

Указатель

• Константы
• Переменные
• func Clone(b []byte) []byte
• func Compare(a, b []byte) int
• func Contains(b, subslice []byte) bool
• func ContainsAny(b []byte, chars string) bool
• func ContainsFunc(b []byte, f func(rune) bool) bool
• func ContainsRune(b []byte, r rune) bool
• func Count(s, sep []byte) int
• func Cut(s, sep []byte) (before, after []byte, found bool)
• func CutLast(s, sep []byte) (before, after []byte, found bool)
• func CutPrefix(s, prefix []byte) (after []byte, found bool)
• func CutSuffix(s, suffix []byte) (before []byte, found bool)
• func Equal(a, b []byte) bool
• func EqualFold(s, t []byte) bool
• func Fields(s []byte) [][]byte
• func FieldsFunc(s []byte, f func(rune) bool) [][]byte
• func FieldsFuncSeq(s []byte, f func(rune) bool) iter.Seq[[]byte]
• func FieldsSeq(s []byte) iter.Seq[[]byte]
• func HasPrefix(s, prefix []byte) bool
• func HasSuffix(s, suffix []byte) bool
• func Index(s, sep []byte) int
• func IndexAny(s []byte, chars string) int
• func IndexByte(b []byte, c byte) int
• func IndexFunc(s []byte, f func(rune) bool) int
• func IndexRune(s []byte, r rune) int
• func Join(s [][]byte, sep []byte) []byte
• func LastIndex(s, sep []byte) int
• func LastIndexAny(s []byte, chars string) int
• func LastIndexByte(s []byte, c byte) int
• func LastIndexFunc(s []byte, f func(rune) bool) int
• func Lines(s []byte) iter.Seq[[]byte]
• func Map(mapping func(rune) rune, s []byte) []byte
• func Repeat(b []byte, count int) []byte
• func Replace(s, old, new []byte, n int) []byte
• func ReplaceAll(s, old, new []byte) []byte
• func Runes(s []byte) []rune
• func Split(s, sep []byte) [][]byte
• func SplitAfter(s, sep []byte) [][]byte
• func SplitAfterN(s, sep []byte, n int) [][]byte
• func SplitAfterSeq(s, sep []byte) iter.Seq[[]byte]
• func SplitN(s, sep []byte, n int) [][]byte
• func SplitSeq(s, sep []byte) iter.Seq[[]byte]
• func Title(s []byte) []byte
• func ToLower(s []byte) []byte
• func ToLowerSpecial(c unicode.SpecialCase, s []byte) []byte
• func ToTitle(s []byte) []byte
• func ToTitleSpecial(c unicode.SpecialCase, s []byte) []byte
• func ToUpper(s []byte) []byte
• func ToUpperSpecial(c unicode.SpecialCase, s []byte) []byte
• func ToValidUTF8(s, replacement []byte) []byte
• func Trim(s []byte, cutset string) []byte
• func TrimFunc(s []byte, f func(rune) bool) []byte
• func TrimLeft(s []byte, cutset string) []byte
• func TrimLeftFunc(s []byte, f func(rune) bool) []byte
• func TrimPrefix(s, prefix []byte) []byte
• func TrimRight(s []byte, cutset string) []byte
• func TrimRightFunc(s []byte, f func(rune) bool) []byte
• func TrimSpace(s []byte) []byte
• func TrimSuffix(s, suffix []byte) []byte
• type Buffer
• func NewBuffer(buf []byte) *Buffer
• func NewBufferString(s string) *Buffer
• func (b *Buffer) Available() int
• func (b *Buffer) AvailableBuffer() []byte
• func (b *Buffer) Bytes() []byte
• func (b *Buffer) Cap() int
• func (b *Buffer) Grow(n int)
• func (b *Buffer) Len() int
• func (b *Buffer) Next(n int) []byte
• func (b *Buffer) Peek(n int) ([]byte, error)
• func (b *Buffer) Read(p []byte) (n int, err error)
• func (b *Buffer) ReadByte() (byte, error)
• func (b *Buffer) ReadBytes(delim byte) (line []byte, err error)
• func (b *Buffer) ReadFrom(r io.Reader) (n int64, err error)
• func (b *Buffer) ReadRune() (r rune, size int, err error)
• func (b *Buffer) ReadString(delim byte) (line string, err error)
• func (b *Buffer) Reset()
• func (b *Buffer) String() string
• func (b *Buffer) Truncate(n int)
• func (b *Buffer) UnreadByte() error
• func (b *Buffer) UnreadRune() error
• func (b *Buffer) Write(p []byte) (n int, err error)
• func (b *Buffer) WriteByte(c byte) error
• func (b *Buffer) WriteRune(r rune) (n int, err error)
• func (b *Buffer) WriteString(s string) (n int, err error)
• func (b *Buffer) WriteTo(w io.Writer) (n int64, err error)
• type Reader
• func NewReader(b []byte) *Reader
• func (r *Reader) Len() int
• func (r *Reader) Read(b []byte) (n int, err error)
• func (r *Reader) ReadAt(b []byte, off int64) (n int, err error)
• func (r *Reader) ReadByte() (byte, error)
• func (r *Reader) ReadRune() (ch rune, size int, err error)
• func (r *Reader) Reset(b []byte)
• func (r *Reader) Seek(offset int64, whence int) (int64, error)
• func (r *Reader) Size() int64
• func (r *Reader) UnreadByte() error
• func (r *Reader) UnreadRune() error
• func (r *Reader) WriteTo(w io.Writer) (n int64, err error)

Файлы пакета

buffer.go bytes.go iter.go reader.go

Константы

MinRead — минимальный размер среза, передаваемого вызову Buffer.Read функцией Buffer.ReadFrom. Пока у Buffer есть как минимум MinRead байт сверх объёма, необходимого для хранения содержимого r, функция Buffer.ReadFrom не будет увеличивать базовый буфер.

const MinRead = 512

Переменные

ErrTooLarge передаётся в panic, если не удаётся выделить память для хранения данных в буфере.

var ErrTooLarge = errors.New("bytes.Buffer: too large")

func Clone 1.20

func Clone(b []byte) []byte

Clone возвращает копию b[:len(b)]. У результата может быть дополнительная неиспользуемая ёмкость. Clone(nil) возвращает nil.

Пример

Код:

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)

Вывод:

abc
abc
dbc

func Compare

func Compare(a, b []byte) int

Compare возвращает целое число, сравнивающее два байтовых среза лексикографически. Результат равен 0, если a == b, -1, если a < b, и +1, если a > b. Аргумент nil эквивалентен пустому срезу.

Пример

Код:

// 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
}

Пример (поиск)

Код:

// 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!
}

func Contains

func Contains(b, subslice []byte) bool

Contains сообщает, содержится ли подсрез в b.

Пример

Код:

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("")))

Вывод:

true
false
true
true

func ContainsAny 1.7

func ContainsAny(b []byte, chars string) bool

ContainsAny сообщает, содержится ли в b хотя бы одна из кодовых точек chars, закодированных в UTF-8.

Пример

Код:

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(""), ""))

Вывод:

true
true
false
false

func ContainsFunc 1.21

func ContainsFunc(b []byte, f func(rune) bool) bool

ContainsFunc сообщает, удовлетворяет ли хотя бы одна из кодовых точек r, закодированных в UTF-8 и содержащихся в b, условию f(r). Функция останавливается, как только вызов f возвращает true.

Пример

Код:

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

Вывод:

false
true

func ContainsRune 1.7

func ContainsRune(b []byte, r rune) bool

ContainsRune сообщает, содержится ли руна в байтовом срезе b, закодированном в UTF-8.

Пример

Код:

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(""), '@'))

Вывод:

true
false
true
true
false

func Count

func Count(s, sep []byte) int

Count подсчитывает количество неперекрывающихся вхождений sep в s. Если sep — пустой срез, Count возвращает 1 + количество кодовых точек в s, закодированных в UTF-8.

Пример

Код:

fmt.Println(bytes.Count([]byte("cheese"), []byte("e")))
fmt.Println(bytes.Count([]byte("five"), []byte(""))) // before & after each rune

Вывод:

3
5

func Cut 1.18

func Cut(s, sep []byte) (before, after []byte, found bool)

Cut разделяет s вокруг первого вхождения sep и возвращает текст до и после sep. Результат found указывает, встречается ли sep в s. Если sep не встречается в s, Cut возвращает s, nil, false.

Cut возвращает срезы исходного среза s, а не копии.

Пример

Код:

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")

Вывод:

Cut("Gopher", "Go") = "", "pher", true
Cut("Gopher", "ph") = "Go", "er", true
Cut("Gopher", "er") = "Goph", "", true
Cut("Gopher", "Badger") = "Gopher", "", false

func CutLast 1.27

func CutLast(s, sep []byte) (before, after []byte, found bool)

CutLast разделяет s вокруг последнего вхождения sep и возвращает текст до и после sep. Результат found указывает, встречается ли sep в s. Если sep не встречается в s, CutLast возвращает s, nil, false.

CutLast возвращает срезы исходного среза s, а не копии.

func CutPrefix 1.20

func CutPrefix(s, prefix []byte) (after []byte, found bool)

CutPrefix возвращает s без указанного начального байтового среза prefix и сообщает, найден ли этот префикс. Если s не начинается с prefix, CutPrefix возвращает s, false. Если prefix — пустой байтовый срез, CutPrefix возвращает s, true.

CutPrefix возвращает срезы исходного среза s, а не копии.

Пример

Код:

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")

Вывод:

CutPrefix("Gopher", "Go") = "pher", true
CutPrefix("Gopher", "ph") = "Gopher", false

func CutSuffix 1.20

func CutSuffix(s, suffix []byte) (before []byte, found bool)

CutSuffix возвращает s без указанного конечного байтового среза suffix и сообщает, найден ли этот суффикс. Если s не заканчивается на suffix, CutSuffix возвращает s, false. Если suffix — пустой байтовый срез, CutSuffix возвращает s, true.

CutSuffix возвращает срезы исходного среза s, а не копии.

Пример

Код:

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")

Вывод:

CutSuffix("Gopher", "Go") = "Gopher", false
CutSuffix("Gopher", "er") = "Goph", true

func Equal

func Equal(a, b []byte) bool

Equal сообщает, имеют ли a и b одинаковую длину и содержат ли одинаковые байты. Аргумент nil эквивалентен пустому срезу.

Пример

Код:

fmt.Println(bytes.Equal([]byte("Go"), []byte("Go")))
fmt.Println(bytes.Equal([]byte("Go"), []byte("C++")))

Вывод:

true
false

func EqualFold

func EqualFold(s, t []byte) bool

EqualFold сообщает, равны ли s и t, рассматриваемые как строки в кодировке UTF-8, с учётом простого Unicode-преобразования регистра, которое представляет собой более общий вариант сравнения без учёта регистра.

Пример

Код:

fmt.Println(bytes.EqualFold([]byte("Go"), []byte("go")))

Вывод:

true

func Fields

func Fields(s []byte) [][]byte

Fields рассматривает s как последовательность кодовых точек, закодированных в UTF-8. Функция разделяет срез s по каждому вхождению одной или нескольких подряд идущих пробельных символов, определяемых функцией unicode.IsSpace, и возвращает срез подсрезов s или пустой срез, если s содержит только пробельные символы. Каждый элемент возвращённого среза непустой. В отличие от Split, начальные и конечные последовательности пробельных символов отбрасываются.

Пример

Код:

fmt.Printf("Fields are: %q", bytes.Fields([]byte("  foo bar  baz   ")))

Вывод:

Fields are: ["foo" "bar" "baz"]

func FieldsFunc

func FieldsFunc(s []byte, f func(rune) bool) [][]byte

FieldsFunc рассматривает s как последовательность кодовых точек, закодированных в UTF-8. Функция разделяет срез s в каждой последовательности кодовых точек c, удовлетворяющих условию f(c), и возвращает срез подсрезов s. Если все кодовые точки в s удовлетворяют условию f(c) или len(s) == 0, возвращается пустой срез. Каждый элемент возвращённого среза непустой. В отличие от Split, начальные и конечные последовательности кодовых точек, удовлетворяющих условию f(c), отбрасываются.

FieldsFunc не гарантирует порядок вызова f(c) и предполагает, что f всегда возвращает одно и то же значение для заданного c.

Пример

Код:

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

Вывод:

Fields are: ["foo1" "bar2" "baz3"]

func FieldsFuncSeq 1.24

func FieldsFuncSeq(s []byte, f func(rune) bool) iter.Seq[[]byte]

FieldsFuncSeq возвращает итератор по подсрезам s, разделённым последовательностями кодовых точек Unicode, удовлетворяющих условию f(c). Итератор выдаёт те же подсрезы, что и FieldsFunc(s), но не создаёт новый срез, содержащий эти подсрезы.

Пример

Код:

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)
}

Вывод:

Split on whitespace(similar to FieldsSeq):
"The"
"quick"
"brown"
"fox"

Split on digits:
"abc"
"def"
"ghi"

func FieldsSeq 1.24

func FieldsSeq(s []byte) iter.Seq[[]byte]

FieldsSeq возвращает итератор по подсрезам s, разделённым последовательностями пробельных символов, определяемых функцией unicode.IsSpace. Итератор выдаёт те же подсрезы, что и Fields(s), но не создаёт новый срез, содержащий эти подсрезы.

Пример

Код:

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)
}

Вывод:

Split byte slice into fields:
"The"
"quick"
"brown"
"fox"

Split byte slice with multiple spaces:
"lots"
"of"
"spaces"

func HasPrefix

func HasPrefix(s, prefix []byte) bool

HasPrefix сообщает, начинается ли байтовый срез s с prefix.

Пример

Код:

fmt.Println(bytes.HasPrefix([]byte("Gopher"), []byte("Go")))
fmt.Println(bytes.HasPrefix([]byte("Gopher"), []byte("C")))
fmt.Println(bytes.HasPrefix([]byte("Gopher"), []byte("")))

Вывод:

true
false
true

func HasSuffix

func HasSuffix(s, suffix []byte) bool

HasSuffix сообщает, заканчивается ли байтовый срез s на suffix.

Пример

Код:

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("")))

Вывод:

true
false
false
true

func Index

func Index(s, sep []byte) int

Index возвращает индекс первого вхождения sep в s или -1, если sep отсутствует в s.

Пример

Код:

fmt.Println(bytes.Index([]byte("chicken"), []byte("ken")))
fmt.Println(bytes.Index([]byte("chicken"), []byte("dmr")))

Вывод:

4
-1

func IndexAny

func IndexAny(s []byte, chars string) int

IndexAny рассматривает s как последовательность кодовых точек Unicode, закодированных в UTF-8. Функция возвращает байтовый индекс первого вхождения в s любой из кодовых точек Unicode из chars. Возвращается -1, если chars пуст или если нет общих кодовых точек.

Пример

Код:

fmt.Println(bytes.IndexAny([]byte("chicken"), "aeiouy"))
fmt.Println(bytes.IndexAny([]byte("crwth"), "aeiouy"))

Вывод:

2
-1

func IndexByte

func IndexByte(b []byte, c byte) int

IndexByte возвращает индекс первого вхождения c в b или -1, если c отсутствует в b.

Пример

Код:

fmt.Println(bytes.IndexByte([]byte("chicken"), byte('k')))
fmt.Println(bytes.IndexByte([]byte("chicken"), byte('g')))

Вывод:

4
-1

func IndexFunc

func IndexFunc(s []byte, f func(r rune) bool) int

IndexFunc рассматривает s как последовательность кодовых точек, закодированных в UTF-8. Функция возвращает байтовый индекс в s первой кодовой точки Unicode, удовлетворяющей условию f(c), или -1, если таких кодовых точек нет.

Пример

Код:

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))

Вывод:

7
-1

func IndexRune

func IndexRune(s []byte, r rune) int

IndexRune рассматривает s как последовательность кодовых точек в кодировке UTF-8. Она возвращает байтовый индекс первого вхождения заданной руны в s. Если rune отсутствует в s, возвращается -1. Если r — это utf8.RuneError, возвращается первое вхождение любой недопустимой последовательности байтов UTF-8.

Пример

Код:

fmt.Println(bytes.IndexRune([]byte("chicken"), 'k'))
fmt.Println(bytes.IndexRune([]byte("chicken"), 'd'))

Вывод:

4
-1

func Join

func Join(s [][]byte, sep []byte) []byte

Join объединяет элементы s в новый байтовый срез. В результирующем срезе между элементами помещается разделитель sep.

Пример

Код:

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

Вывод:

foo, bar, baz

func LastIndex

func LastIndex(s, sep []byte) int

LastIndex возвращает индекс последнего вхождения sep в s или -1, если sep отсутствует в s.

Пример

Код:

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")))

Вывод:

0
3
-1

func LastIndexAny

func LastIndexAny(s []byte, chars string) int

LastIndexAny рассматривает s как последовательность кодовых точек Unicode в кодировке UTF-8. Она возвращает байтовый индекс последнего вхождения в s любой из кодовых точек Unicode, содержащихся в chars. Если chars пуст или нет общих кодовых точек, возвращается -1.

Пример

Код:

fmt.Println(bytes.LastIndexAny([]byte("go gopher"), "MüQp"))
fmt.Println(bytes.LastIndexAny([]byte("go 地鼠"), "地大"))
fmt.Println(bytes.LastIndexAny([]byte("go gopher"), "z,!."))

Вывод:

5
3
-1

func LastIndexByte 1.5

func LastIndexByte(s []byte, c byte) int

LastIndexByte возвращает индекс последнего вхождения c в s или -1, если c отсутствует в s.

Пример

Код:

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')))

Вывод:

3
8
-1

func LastIndexFunc

func LastIndexFunc(s []byte, f func(r rune) bool) int

LastIndexFunc рассматривает s как последовательность кодовых точек в кодировке UTF-8. Она возвращает байтовый индекс в s последней кодовой точки Unicode, удовлетворяющей условию f(c), или -1, если таких точек нет.

Пример

Код:

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))

Вывод:

8
9
-1

func Lines 1.24

func Lines(s []byte) iter.Seq[[]byte]

Lines возвращает итератор по строкам байтового среза s, заканчивающимся символом новой строки. Строки, выдаваемые итератором, включают завершающие символы новой строки. Если s пуст, итератор не выдаёт ни одной строки. Если s не заканчивается символом новой строки, последняя выданная строка не будет им заканчиваться. Возвращается одноразовый итератор.

Пример

Код:

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

Вывод:

"Hello\n"
"World\n"
"Go Programming\n"

func Map

func Map(mapping func(r rune) rune, s []byte) []byte

Map возвращает копию байтового среза s, в которой все символы изменены согласно функции отображения. Если функция отображения возвращает отрицательное значение, символ удаляется из байтового среза без замены. Символы в s и результирующем срезе рассматриваются как кодовые точки в кодировке UTF-8.

Пример

Код:

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...")))

Вывод:

'Gjnf oevyyvt naq gur fyvgul tbcure...

func Repeat

func Repeat(b []byte, count int) []byte

Repeat возвращает новый байтовый срез, состоящий из count копий b.

Функция вызывает панику, если count отрицателен или если результат вычисления (len(b) * count) переполняется.

Пример

Код:

fmt.Printf("ba%s", bytes.Repeat([]byte("na"), 2))

Вывод:

banana

func Replace

func Replace(s, old, new []byte, n int) []byte

Replace возвращает копию среза s, в которой первые n неперекрывающихся вхождений old заменены на new. Если old пуст, совпадение находится в начале среза и после каждой последовательности UTF-8, что даёт до k+1 замен для среза из k рун. Если n < 0, количество замен не ограничено.

Пример

Код:

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))

Вывод:

oinky oinky oink
moo moo moo

func ReplaceAll 1.12

func ReplaceAll(s, old, new []byte) []byte

ReplaceAll возвращает копию среза s, в которой все неперекрывающиеся вхождения old заменены на new. Если old пуст, совпадение находится в начале среза и после каждой последовательности UTF-8, что даёт до k+1 замен для среза из k рун.

Пример

Код:

fmt.Printf("%s\n", bytes.ReplaceAll([]byte("oink oink oink"), []byte("oink"), []byte("moo")))

Вывод:

moo moo moo

func Runes

func Runes(s []byte) []rune

Runes рассматривает s как последовательность кодовых точек в кодировке UTF-8. Она возвращает срез рун (кодовых точек Unicode), эквивалентный s.

Пример

Код:

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

Вывод:

U+0067 'g'
U+006F 'o'
U+0020 ' '
U+0067 'g'
U+006F 'o'
U+0070 'p'
U+0068 'h'
U+0065 'e'
U+0072 'r'

func Split

func Split(s, sep []byte) [][]byte

Split разделяет s на все подсрезы, отделённые sep, и возвращает срез подсрезов, расположенных между этими разделителями. Если sep пуст, Split разделяет после каждой последовательности UTF-8. Функция эквивалентна SplitN со значением count -1.

Чтобы разделить строку по первому вхождению разделителя, см. Cut.

Пример

Код:

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")))

Вывод:

["a" "b" "c"]
["" "man " "plan " "canal panama"]
[" " "x" "y" "z" " "]
[""]

func SplitAfter

func SplitAfter(s, sep []byte) [][]byte

SplitAfter разделяет s на все подсрезы после каждого вхождения sep и возвращает срез этих подсрезов. Если sep пуст, SplitAfter разделяет после каждой последовательности UTF-8. Функция эквивалентна SplitAfterN со значением count -1.

Пример

Код:

fmt.Printf("%q\n", bytes.SplitAfter([]byte("a,b,c"), []byte(",")))

Вывод:

["a," "b," "c"]

func SplitAfterN

func SplitAfterN(s, sep []byte, n int) [][]byte

SplitAfterN разделяет s на подсрезы после каждого вхождения sep и возвращает срез этих подсрезов. Если sep пуст, SplitAfterN разделяет после каждой последовательности UTF-8. Значение count определяет количество возвращаемых подсрезов:

• n > 0: не более n подсрезов; последний подсрез будет оставшейся неразделённой частью;
• n == 0: результат — nil (ноль подсрезов);
• n < 0: все подсрезы.

Пример

Код:

fmt.Printf("%q\n", bytes.SplitAfterN([]byte("a,b,c"), []byte(","), 2))

Вывод:

["a," "b,c"]

func SplitAfterSeq 1.24

func SplitAfterSeq(s, sep []byte) iter.Seq[[]byte]

SplitAfterSeq возвращает итератор по подсрезам s, разделённым после каждого вхождения sep. Итератор выдаёт те же подсрезы, что и SplitAfter(s, sep), но без создания нового среза, содержащего эти подсрезы. Возвращается одноразовый итератор.

Пример

Код:

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

Вывод:

"a,"
"b,"
"c,"
"d"

func SplitN

func SplitN(s, sep []byte, n int) [][]byte

SplitN разделяет s на подсрезы, отделённые sep, и возвращает срез подсрезов, расположенных между этими разделителями. Если sep пуст, SplitN разделяет после каждой последовательности UTF-8. Значение count определяет количество возвращаемых подсрезов:

• n > 0: не более n подсрезов; последний подсрез будет несегментированным остатком;
• n == 0: результат — nil (ноль подсрезов);
• n < 0: все подсрезы.

Чтобы разделить строку вокруг первого вхождения разделителя, см. Cut.

Пример

Код:

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)

Вывод:

["a" "b,c"]
[] (nil = true)

func SplitSeq 1.24

func SplitSeq(s, sep []byte) iter.Seq[[]byte]

SplitSeq возвращает итератор по всем подсрезам s, разделённым sep. Итератор выдаёт те же подсрезы, что и Split(s, sep), но не создаёт новый срез, содержащий подсрезы. Возвращается одноразовый итератор.

Пример

Код:

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

Вывод:

"a"
"b"
"c"
"d"

func Title

func Title(s []byte) []byte

Title рассматривает s как байты в кодировке UTF-8 и возвращает копию, в которой все буквы Unicode, начинающие слова, преобразованы в заглавный регистр.

Устарело: правило, используемое Title для определения границ слов, некорректно обрабатывает знаки пунктуации Unicode. Вместо него используйте golang.org/x/text/cases.

Пример

Код:

fmt.Printf("%s", bytes.Title([]byte("her royal highness")))

Вывод:

Her Royal Highness

func ToLower

func ToLower(s []byte) []byte

ToLower возвращает копию среза байтов s, в которой все буквы Unicode преобразованы в нижний регистр.

Пример

Код:

fmt.Printf("%s", bytes.ToLower([]byte("Gopher")))

Вывод:

gopher

func ToLowerSpecial

func ToLowerSpecial(c unicode.SpecialCase, s []byte) []byte

ToLowerSpecial рассматривает s как байты в кодировке UTF-8 и возвращает копию, в которой все буквы Unicode преобразованы в нижний регистр с приоритетом особых правил изменения регистра.

Пример

Код:

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

Вывод:

Original : AHOJ VÝVOJÁRİ GOLANG
ToLower : ahoj vývojári golang

func ToTitle

func ToTitle(s []byte) []byte

ToTitle рассматривает s как байты в кодировке UTF-8 и возвращает копию, в которой все буквы Unicode преобразованы в заглавный регистр.

Пример

Код:

fmt.Printf("%s\n", bytes.ToTitle([]byte("loud noises")))
fmt.Printf("%s\n", bytes.ToTitle([]byte("брат")))

Вывод:

LOUD NOISES
БРАТ

func ToTitleSpecial

func ToTitleSpecial(c unicode.SpecialCase, s []byte) []byte

ToTitleSpecial рассматривает s как байты в кодировке UTF-8 и возвращает копию, в которой все буквы Unicode преобразованы в заглавный регистр с приоритетом особых правил изменения регистра.

Пример

Код:

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

Вывод:

Original : ahoj vývojári golang
ToTitle : AHOJ VÝVOJÁRİ GOLANG

func ToUpper

func ToUpper(s []byte) []byte

ToUpper возвращает копию среза байтов s, в которой все буквы Unicode преобразованы в верхний регистр.

Пример

Код:

fmt.Printf("%s", bytes.ToUpper([]byte("Gopher")))

Вывод:

GOPHER

func ToUpperSpecial

func ToUpperSpecial(c unicode.SpecialCase, s []byte) []byte

ToUpperSpecial рассматривает s как байты в кодировке UTF-8 и возвращает копию, в которой все буквы Unicode преобразованы в верхний регистр с приоритетом особых правил изменения регистра.

Пример

Код:

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

Вывод:

Original : ahoj vývojári golang
ToUpper : AHOJ VÝVOJÁRİ GOLANG

func ToValidUTF8 1.13

func ToValidUTF8(s, replacement []byte) []byte

ToValidUTF8 рассматривает s как байты в кодировке UTF-8 и возвращает копию, в которой каждая последовательность байтов, представляющая некорректный UTF-8, заменена байтами replacement, который может быть пустым.

Пример

Код:

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")))

Вывод:

abc
abc
abc

func Trim

func Trim(s []byte, cutset string) []byte

Trim возвращает подсрез s, удаляя все начальные и конечные кодовые точки UTF-8, содержащиеся в cutset.

Пример

Код:

fmt.Printf("[%q]", bytes.Trim([]byte(" !!! Achtung! Achtung! !!! "), "! "))

Вывод:

["Achtung! Achtung"]

func TrimFunc

func TrimFunc(s []byte, f func(r rune) bool) []byte

TrimFunc возвращает подсрез s, удаляя все начальные и конечные кодовые точки UTF-8 c, для которых выполняется f(c).

Пример

Код:

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)))

Вывод:

-gopher!
"go-gopher!"
go-gopher
go-gopher!

func TrimLeft

func TrimLeft(s []byte, cutset string) []byte

TrimLeft возвращает подсрез s, удаляя все начальные кодовые точки UTF-8, содержащиеся в cutset.

Пример

Код:

fmt.Print(string(bytes.TrimLeft([]byte("453gopher8257"), "0123456789")))

Вывод:

gopher8257

func TrimLeftFunc

func TrimLeftFunc(s []byte, f func(r rune) bool) []byte

TrimLeftFunc рассматривает s как байты в кодировке UTF-8 и возвращает подсрез s, удаляя все начальные кодовые точки UTF-8 c, для которых выполняется f(c).

Пример

Код:

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)))

Вывод:

-gopher
go-gopher!
go-gopher!567

func TrimPrefix 1.1

func TrimPrefix(s, prefix []byte) []byte

TrimPrefix возвращает s без указанного префикса в начале строки. Если s не начинается с prefix, возвращается s без изменений.

Пример

Код:

var b = []byte("Goodbye,, world!")
b = bytes.TrimPrefix(b, []byte("Goodbye,"))
b = bytes.TrimPrefix(b, []byte("See ya,"))
fmt.Printf("Hello%s", b)

Вывод:

Hello, world!

func TrimRight

func TrimRight(s []byte, cutset string) []byte

TrimRight возвращает подсрез s, удаляя все конечные кодовые точки UTF-8, содержащиеся в cutset.

Пример

Код:

fmt.Print(string(bytes.TrimRight([]byte("453gopher8257"), "0123456789")))

Вывод:

453gopher

func TrimRightFunc

func TrimRightFunc(s []byte, f func(r rune) bool) []byte

TrimRightFunc возвращает подсрез s, удаляя все конечные кодовые точки UTF-8 c, для которых выполняется f(c).

Пример

Код:

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)))

Вывод:

go-
go-gopher
1234go-gopher!

func TrimSpace

func TrimSpace(s []byte) []byte

TrimSpace возвращает подсрез s, удаляя все начальные и конечные пробельные символы согласно определению Unicode.

Пример

Код:

fmt.Printf("%s", bytes.TrimSpace([]byte(" \t\n a lone gopher \n\t\r\n")))

Вывод:

a lone gopher

func TrimSuffix 1.1

func TrimSuffix(s, suffix []byte) []byte

TrimSuffix возвращает s без указанного суффикса в конце строки. Если s не заканчивается на suffix, возвращается s без изменений.

Пример

Код:

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)

Вывод:

Hello, world!

type Buffer

Buffer — это буфер байтов переменного размера с методами Buffer.Read и Buffer.Write. Нулевое значение Buffer — пустой буфер, готовый к использованию.

type Buffer struct {
    // contains filtered or unexported fields
}

Пример

Код:

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

Вывод:

Hello world!

Пример (читатель)

Код:

// 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)

Вывод:

Gophers rule!

func NewBuffer

func NewBuffer(buf []byte) *Buffer

NewBuffer создает и инициализирует новый Buffer, используя buf в качестве исходного содержимого. Новый Buffer получает владение buf, и вызывающий код не должен использовать buf после этого вызова. NewBuffer предназначен для подготовки Buffer к чтению существующих данных. Его также можно использовать, чтобы задать начальный размер внутреннего буфера для записи. Для этого buf должен иметь желаемую емкость, но нулевую длину.

В большинстве случаев для инициализации Buffer достаточно new(Buffer) (или просто объявления переменной типа Buffer).

func NewBufferString

func NewBufferString(s string) *Buffer

NewBufferString создает и инициализирует новый Buffer, используя строку s в качестве исходного содержимого. Он предназначен для подготовки буфера к чтению существующей строки.

В большинстве случаев для инициализации Buffer достаточно new(Buffer) (или просто объявления переменной типа Buffer).

func (*Buffer) Available 1.21

func (b *Buffer) Available() int

Available возвращает количество неиспользуемых байтов в буфере.

func (*Buffer) AvailableBuffer 1.21

func (b *Buffer) AvailableBuffer() []byte

AvailableBuffer возвращает пустой буфер емкостью b.Available(). Предполагается, что в этот буфер будут добавлены данные, после чего он будет передан в непосредственно следующий вызов Buffer.Write. Буфер действителен только до следующей операции записи в b.

Пример

Код:

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())

Вывод:

0 1 2 3

func (*Buffer) Bytes

func (b *Buffer) Bytes() []byte

Bytes возвращает срез длины b.Len(), содержащий непрочитанную часть буфера. Срез действителен только до следующего изменения буфера (то есть только до следующего вызова метода, такого как Buffer.Read, Buffer.Write, Buffer.Reset или Buffer.Truncate). Срез ссылается на содержимое буфера как минимум до следующего изменения буфера, поэтому немедленные изменения среза повлияют на результат последующих операций чтения.

Пример

Код:

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

Вывод:

hello world

func (*Buffer) Cap 1.5

func (b *Buffer) Cap() int

Cap возвращает емкость базового среза байтов буфера, то есть общий объем памяти, выделенный для данных буфера.

Пример

Код:

buf1 := bytes.NewBuffer(make([]byte, 10))
buf2 := bytes.NewBuffer(make([]byte, 0, 10))
fmt.Println(buf1.Cap())
fmt.Println(buf2.Cap())

Вывод:

10
10

func (*Buffer) Grow 1.1

func (b *Buffer) Grow(n int)

Grow увеличивает емкость буфера, если необходимо, чтобы гарантировать место еще для n байтов. После вызова Grow(n) в буфер можно записать как минимум n байтов без повторного выделения памяти. Если n отрицательно, Grow вызовет панику. Если емкость буфера нельзя увеличить, будет вызвана паника с ErrTooLarge.

Пример

Код:

var b bytes.Buffer
b.Grow(64)
bb := b.Bytes()
b.Write([]byte("64 bytes or fewer"))
fmt.Printf("%q", bb[:b.Len()])

Вывод:

"64 bytes or fewer"

func (*Buffer) Len

func (b *Buffer) Len() int

Len возвращает количество байтов в непрочитанной части буфера; b.Len() == len(b.Bytes()).

Пример

Код:

var b bytes.Buffer
b.Grow(64)
b.Write([]byte("abcde"))
fmt.Printf("%d", b.Len())

Вывод:

5

func (*Buffer) Next

func (b *Buffer) Next(n int) []byte

Next возвращает срез, содержащий следующие n байтов из буфера, и сдвигает позицию в буфере так, как если бы эти байты были возвращены методом Buffer.Read. Если в буфере меньше n байтов, Next возвращает весь буфер. Срез действителен только до следующего вызова метода чтения или записи.

Пример

Код:

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))

Вывод:

ab
cd
e

func (*Buffer) Peek 1.26

func (b *Buffer) Peek(n int) ([]byte, error)

Peek возвращает следующие n байтов, не сдвигая позицию в буфере. Если Peek возвращает меньше n байтов, он также возвращает io.EOF. Срез действителен только до следующего вызова метода чтения или записи. Срез ссылается на содержимое буфера как минимум до следующего изменения буфера, поэтому немедленные изменения среза повлияют на результат последующих операций чтения.

func (*Buffer) Read

func (b *Buffer) Read(p []byte) (n int, err error)

Read считывает из буфера следующие len(p) байтов или до тех пор, пока буфер не опустеет. Возвращаемое значение n — количество считанных байтов. Если в буфере нет данных для возврата, err равен io.EOF (если только len(p) не равен нулю); в противном случае он равен nil.

Пример

Код:

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))

Вывод:

1
bcde
a

func (*Buffer) ReadByte

func (b *Buffer) ReadByte() (byte, error)

ReadByte считывает и возвращает следующий байт из буфера. Если байтов нет, возвращается ошибка io.EOF.

Пример

Код:

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())

Вывод:

97
bcde

func (*Buffer) ReadBytes

func (b *Buffer) ReadBytes(delim byte) (line []byte, err error)

ReadBytes считывает данные до первого вхождения delim во входных данных и возвращает срез, содержащий данные вплоть до разделителя включительно. Если ReadBytes встречает ошибку до обнаружения разделителя, он возвращает данные, считанные до ошибки, и саму ошибку (часто io.EOF). ReadBytes возвращает err != nil тогда и только тогда, когда возвращенные данные не заканчиваются на delim.

func (*Buffer) ReadFrom

func (b *Buffer) ReadFrom(r io.Reader) (n int64, err error)

ReadFrom считывает данные из r до EOF и добавляет их в буфер, увеличивая его размер по мере необходимости. Возвращаемое значение n — количество считанных байтов. Также возвращается любая ошибка, кроме io.EOF, возникшая при чтении. Если буфер становится слишком большим, ReadFrom вызовет панику с ErrTooLarge.

func (*Buffer) ReadRune

func (b *Buffer) ReadRune() (r rune, size int, err error)

ReadRune считывает и возвращает следующую кодовую точку Unicode в кодировке UTF-8 из буфера. Если байтов нет, возвращается ошибка io.EOF. Если байты содержат некорректную последовательность UTF-8, метод потребляет один байт и возвращает U+FFFD, 1.

func (*Buffer) ReadString

func (b *Buffer) ReadString(delim byte) (line string, err error)

ReadString считывает данные до первого вхождения delim во входных данных и возвращает строку, содержащую данные вплоть до разделителя включительно. Если ReadString встречает ошибку до обнаружения разделителя, он возвращает данные, считанные до ошибки, и саму ошибку (часто io.EOF). ReadString возвращает err != nil тогда и только тогда, когда возвращенные данные не заканчиваются на delim.

func (*Buffer) Reset

func (b *Buffer) Reset()

Reset очищает буфер, но сохраняет базовое хранилище для последующих операций записи. Reset эквивалентен вызову Buffer.Truncate(0).

func (*Buffer) String

func (b *Buffer) String() string

String возвращает содержимое непрочитанной части буфера в виде строки. Если Buffer — nil-указатель, возвращается "<nil>".

Для более эффективного создания строк см. тип strings.Builder.

func (*Buffer) Truncate

func (b *Buffer) Truncate(n int)

Truncate отбрасывает все байты буфера, кроме первых n непрочитанных, но продолжает использовать то же выделенное хранилище. Вызывает панику, если n отрицательно или превышает длину буфера.

func (*Buffer) UnreadByte

func (b *Buffer) UnreadByte() error

UnreadByte возвращает последний байт, полученный при последней успешной операции чтения, которая прочитала хотя бы один байт. Если после последнего чтения была выполнена запись, последнее чтение завершилось ошибкой или прочитало ноль байтов, UnreadByte возвращает ошибку.

func (*Buffer) UnreadRune

func (b *Buffer) UnreadRune() error

UnreadRune возвращает последнюю руну, полученную вызовом Buffer.ReadRune. Если последняя операция чтения или записи буфера не была успешным вызовом Buffer.ReadRune, UnreadRune возвращает ошибку. (В этом отношении метод строже, чем Buffer.UnreadByte, который возвращает последний байт, полученный при любой операции чтения.)

func (*Buffer) Write

func (b *Buffer) Write(p []byte) (n int, err error)

Write добавляет содержимое p в буфер, при необходимости увеличивая его размер. Возвращаемое значение n — длина p; err всегда равно nil. Если буфер становится слишком большим, Write вызывает панику с ErrTooLarge.

func (*Buffer) WriteByte

func (b *Buffer) WriteByte(c byte) error

WriteByte добавляет байт c в буфер, при необходимости увеличивая его размер. Возвращаемая ошибка всегда равна nil, но включена для соответствия методу WriteByte типа bufio.Writer. Если буфер становится слишком большим, WriteByte вызывает панику с ErrTooLarge.

func (*Buffer) WriteRune

func (b *Buffer) WriteRune(r rune) (n int, err error)

WriteRune добавляет в буфер UTF-8-кодировку кодовой точки Unicode r и возвращает количество записанных байтов и nil в качестве ошибки. Ошибка nil включена для соответствия методу WriteRune типа bufio.Writer. Размер буфера увеличивается при необходимости; если он становится слишком большим, WriteRune вызывает панику с ErrTooLarge.

func (*Buffer) WriteString

func (b *Buffer) WriteString(s string) (n int, err error)

WriteString добавляет содержимое s в буфер, при необходимости увеличивая его размер. Возвращаемое значение n — длина s; err всегда равно nil. Если буфер становится слишком большим, WriteString вызывает панику с ErrTooLarge.

func (*Buffer) WriteTo

func (b *Buffer) WriteTo(w io.Writer) (n int64, err error)

WriteTo записывает данные в w, пока буфер не опустеет или не возникнет ошибка. Возвращаемое значение n — количество записанных байтов; оно всегда помещается в int, но имеет тип int64 для соответствия интерфейсу io.WriterTo. Также возвращается любая ошибка, возникшая при записи.

type Reader

Reader реализует интерфейсы io.Reader, io.ReaderAt, io.WriterTo, io.Seeker, io.ByteScanner и io.RuneScanner, читая данные из среза байтов. В отличие от Buffer, Reader доступен только для чтения и поддерживает перемещение по данным. Нулевое значение Reader работает как Reader пустого среза.

type Reader struct {
    // contains filtered or unexported fields
}

func NewReader

func NewReader(b []byte) *Reader

NewReader возвращает новый Reader, читающий данные из b.

func (*Reader) Len

func (r *Reader) Len() int

Len возвращает количество байтов в непрочитанной части среза.

Пример

Код:

fmt.Println(bytes.NewReader([]byte("Hi!")).Len())
fmt.Println(bytes.NewReader([]byte("こんにちは!")).Len())

Результат:

3
16

func (*Reader) Read

func (r *Reader) Read(b []byte) (n int, err error)

Read реализует интерфейс io.Reader.

func (*Reader) ReadAt

func (r *Reader) ReadAt(b []byte, off int64) (n int, err error)

ReadAt реализует интерфейс io.ReaderAt.

func (*Reader) ReadByte

func (r *Reader) ReadByte() (byte, error)

ReadByte реализует интерфейс io.ByteReader.

func (*Reader) ReadRune

func (r *Reader) ReadRune() (ch rune, size int, err error)

ReadRune реализует интерфейс io.RuneReader.

func (*Reader) Reset 1.7

func (r *Reader) Reset(b []byte)

Reset перенастраивает Reader для чтения данных из b.

func (*Reader) Seek

func (r *Reader) Seek(offset int64, whence int) (int64, error)

Seek реализует интерфейс io.Seeker.

func (*Reader) Size 1.5

func (r *Reader) Size() int64

Size возвращает исходную длину базового среза байтов. Size — это количество байтов, доступных для чтения с помощью Reader.ReadAt. Результат не зависит от вызовов каких-либо методов, кроме Reader.Reset.

func (*Reader) UnreadByte

func (r *Reader) UnreadByte() error

UnreadByte дополняет Reader.ReadByte при реализации интерфейса io.ByteScanner.

func (*Reader) UnreadRune

func (r *Reader) UnreadRune() error

UnreadRune дополняет Reader.ReadRune при реализации интерфейса io.RuneScanner.

func (*Reader) WriteTo 1.1

func (r *Reader) WriteTo(w io.Writer) (n int64, err error)

WriteTo реализует интерфейс io.WriterTo.