Пакет bytes

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

const MinRead = 512

Переменные

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

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

функция 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

функция 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!
}

функция 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

функция ContainsAny 1.7

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

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

Пример

Код:

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

функция ContainsFunc 1.21

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

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

Пример

Код:

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

функция ContainsRune 1.7

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

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

Пример

Код:

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

функция Count

func Count(s, sep []byte) int

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

Пример

Код:

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

Вывод:

3
5

функция 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

функция CutPrefix 1.20

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

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

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

Пример

Код:

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

Вывод:

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

функция CutSuffix 1.20

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

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

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

Пример

Код:

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

Вывод:

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

функция 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

функция EqualFold

func EqualFold(s, t []byte) bool

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

Пример

Код:

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

Вывод:

true

функция Fields

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

Fields интерпретирует s как последовательность UTF-8 кодовых точек. Она разделяет срез s вокруг каждой из одной или нескольких последовательных пробельных символов, как определено в unicode.IsSpace, возвращая срез подсрезами s или пустой срез, если s содержит только пробелы.

Пример

Код:

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

Вывод:

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

функция 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, возвращается пустой срез.

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

функция FieldsFuncSeq 1.24

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

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

func FieldsSeq 1.24

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

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

func HasPrefix

func HasPrefix(s, prefix []byte) bool

HasPrefix проверяет, начинается ли срез байтов s с префиксом.

Пример

Код:

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 суффиксом.

Пример

Код:

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 как последовательность UTF-8 кодовых точек. Он возвращает байтовый индекс первого вхождения в s любой из кодовых точек в 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 первой кодовой точки, удовлетворяющей 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. Возвращает -1, если rune отсутствует в s. Если 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 как последовательность UTF-8 кодовых точек. Возвращает байтовый индекс последнего вхождения любой из кодовых точек в chars. Возвращает -1, если chars пустой или нет совпадающих кодовых точек.

Пример

Код:

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 последней кодовой точки, удовлетворяющей 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 не заканчивается символом новой строки, последняя возвращаемая строка не будет заканчиваться символом новой строки. Возвращает одноразовый итератор.

func Map

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

Map возвращает копию среза байтов s со всеми символами, измененными в соответствии с функцией отображения. Если mapping возвращает отрицательное значение, символ удаляется из среза байтов без замены. Символы в 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), но без создания нового среза, содержащего эти подстроки. Возвращает одноразовый итератор.

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), но без создания нового среза, содержащего эти подстроки. Возвращает одноразовый итератор.

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 и возвращает копию со всеми буквами Юникода, преобразованными в нижний регистр, отдавая предпочтение правилам специального форматирования.

Пример

Код:

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 и возвращает копию со всеми буквами Юникода, преобразованными в заглавный регистр.

Пример

Код:

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 и возвращает копию со всеми буквами Юникода, преобразованными в заглавный регистр, отдавая предпочтение правилам специального форматирования.

Пример

Код:

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 со всеми буквами Юникода, преобразованными в верхний регистр.

Пример

Код:

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

Вывод:

GOPHER

func ToUpperSpecial

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

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

Пример

Код:

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 не начинается с префикса, 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, удаляя все ведущие и хвостовые пробелы, как определено Юникодом.

Пример

Код:

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 не заканчивается на суффикс, 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!

тип 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!

Пример (Reader)

Код:

// 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 должен иметь желаемую ёмкость, но длина должна быть равна нулю.

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

func NewBufferString

func NewBufferString(s string) *Buffer

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

В большинстве случаев достаточно new(Buffer) (или просто объявления переменной 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())

Вывод:

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) 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, но включена для соответствия bufio.Writer's WriteByte. Если буфер становится слишком большим, WriteByte вызовет панику с ErrTooLarge.

func (*Buffer) WriteRune

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

WriteRune добавляет UTF-8 кодирование Unicode символа r в буфер, возвращая его длину и ошибку, которая всегда равна nil, но включена для соответствия bufio.Writer's WriteRune. Буфер увеличивается по мере необходимости; если он становится слишком большим, 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.