bytes

bytes 패키지는 바이트 슬라이스를 조작하기 위한 함수들을 구현하고 있다.

문자열 패키지와 유사한 기능이 많다.

상수

const MinRead = 512

MinRead 는 Buffer.ReadFrom 에 의해 Read 호출에 전달된 슬라이스의 최소 크키이다.

변수

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

버퍼에 데이터를 저장하기 위해 메모리를 할당할 수 없을 경우 ErrTooLarge 가 패닉 상태로 전달된다.

함수

func Compare(a, b []byte) int

두 바이트 슬라이스를 사전식으로 비교하는 정수를 반환한다.

결과는 a==b 이면 0, a < b 이면 -1, a>b 이면 1 이다.

nil 인수는 빈 슬라이스와 같다.

func Contains(b, subslice []byte) bool
func ContainsAny(b []byte, chars string) bool
func ContainsRune(b []byte, r rune) bool

Contains 는 subslice 가 b 내에 있는지 여부를 반환한다.

ContainsAny 는 UTF-8 로 인코딩된 문자 내에 b 가 있는지 여부를 반환한다.

ContainsRune 은 룬이 UTF-8 로 인코딩된 바이트 슬라이스에 포함되어 있는지 여부를 반환한다.

func Count(s, seq []byte) int

Count 는 s 에서 seq 의 겹치지 않는 인스턴스 수를 계산한다.

seq 가 빈 슬라이스면 1 + s 의 UTF-8 인코딩 포인트 수를 반환한다.

func Equal(a, b []byte) bool
func EqualFold(s, t[]byte) bool

Equal 은 a 와 b 가 동일한 길이고 동일한 바이트를 포함하는지 여부를 반환한다.

nil 인수는 빈 슬라이스와 같다.

EqualFold 는 UTF-8 문자열로 해석되는 s 및 t 가 보다 일반적인 대소문자 구분없는 형식인 유니코드 대소문자 구분에서 동일한지 여부를 반환한다.

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

Fields 는 s 를 UTF-8로 인코딩된 포인트의 시퀀스로 해석한다.

unicode.IsSpace 에 의해 정의된대로 하나 이상의 연속 공백 문자의 각 인스턴스 주위로 슬라이스 s 를 분할하여 s 의 부분 슬라이스 또는 s 에 공백만 포함된 경우 빈 슬라이스를 반환한다.

FieldsFunc 는 s 를 UTF-8 로 인코딩된 포인트의 시퀀스를 해석한다.

f(c) 를 만족하는 포인트 c 의 각 실행에서 슬라이스 s 를 분할하고 s 의 부분 슬라이스를 반환한다.

s 의 모든 코드 포인트가 f(c) 또는 len(s) == 0 을 충족하면 빈 슬라이스를 반환된다.

그리고 f(c) 를 호출하는 순서에 대해 보장하지 않고 f 가 주어진 c 에 대해 상상 동일한 값을 반환한다고 가정한다.

func HasPrefix(s, prefix []byte) bool
func HasSuffix(s, suffix []byte) bool

각각 바이트 슬라이스가 [접두사|접미사] 로 끝나는지 여부를 테스트한다.

func Index(s, seq []byte) int
func IndexAny(s []byte, chars string) int
func IndexByte(b []byte, c byte) int
func IndexFunc(s []byte, f func(r rune) bool) int
func IndexRune(s []byte, r rune) int

Index 는 s 에서 seq 의 첫 번째 인스턴스의 인덱스를 반환하거나 seq 가 s 에 없으면 -1 을 반환한다.

IndexAny 는 s 를 UTF-8 로 인코딩된 유니코드 포인트의 시퀀스로 해석한다.

문자로 된 유니코드 포인트의 s 에서 첫 번째 발생의 바이트 인덱스를 반환한다.

chars 가 비어 있거나 공통 코드 포인트가 없으면 -1 을 반환한다.

IndexByte 는 b 에서 c 의 첫 번째 인스턴스의 인덱스를 반환하거나 b 에 c 가 없으면 -1 을 반환한다.

IndexFunc 는 s 를 UTF-8 로 인코딩된 코드 포인트의 시퀀스로 해석한다.

f(c) 를 만족하는 첫 번째 유니코드 포인트의 s 에 있는 바이트 인덱스를 반환한다. 그렇지 않으면 -1 을 반환한다.

IndexRune 은 s 를 UTF-8 로 인코딩된 코드 포인트의 시퀀스로 해석한다.

주어진 룬의 s 에서 처음 발견되는 바이트 인덱스를 반환한다.

s 에 룬이 없으면 -1 을 반환한다. r 이 utf8.RuneError 이면 유효하지 않은 UTF-8 바이트 시퀀스의 첫 번째 인스턴스를 반환한다.

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

s 의 요소를 연결하여 새 바이트 슬라이스를 만든다.

구분자 seq 는 결과 조각의 요소 사이에 배치된다.

func LastIndex(s, seq[] byte) int
func LastIndexAny(s []byte, chars string) int
func LastIndexByte(s []byte, c byte) int
func LastIndexFunc(s []byte, f func(r rune) bool) int

LastIndex 는 s 에서 seq 의 마지막 인스턴스의 인덱스를 반환하거나 seq 가 s 에 없으면 -1 을 반환한다.

LastIndexAny 는 UTF-8 로 인코딩된 유니코드 포인트의 시퀀스로 해석한다.

LastIndexByte 는 s 에 있는 c 의 마지막 인스턴스 인덱스를 반환하고, s 에 c 가 없으면 -1 을 반환한다.

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

매핑 함수에 따라 모든 문자가 수정된 바이트 슬라이스의 복사본을 반환한다.

매핑이 음수 값을 반환하면 문자는 대체없이 바이트 조각에서 삭제된다.

s 및 출력의 문자는 UTF-8 로 인코딩된 코드 포인트로 해석된다.

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

b 의 복사본 개수로 구성된 새 바이트 조각을 반환한다.

count 가 음수거나 (len (b) *count) 의 결과가 오버플로되면 패닉이 발생한다.

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

Replace 는 겹치지 않는 처음 n 개의 인스턴스를 new 로 교체한 슬라이스 s 의 복사본을 반환한다.

old 가 비어 있으면 슬라이스의 시작 부분과 각 UTF-8 시퀀스 이후에 일치하여 k 룬 슬라이스에 대해 최대 k + 1 개의 대체를 생성한다.

n < 0 이면 교체 횟수에 제한이 없다.

ReplaceAll 은 겹치지 않는 모든 인스턴스가 new 로 교체된 슬라이스의 복사본을 반환한다.

old 가 비어 있으면 슬라이스의 시작 부분과 각 UTF-8 시퀀스 이후에 일치하여 k 룬 슬라이스에 대해 최대 k + 1 개의 대체를 생성한다.

func Runes(s []byte) []rune

s 를 UTF-8 로 인코딩된 코드 포인트의 시퀀스로 해석한다.

s 에 해당하는 룬 조각을 반환한다.

func Split(s, seq []byte) [][]byte
func SplitAfter(s, seq []byte) [][]byte
func SplitAfterN(s, seq []byte, n int) [][]byte
func SplitN(s, seq []byte, n int) [][]byte

Split 은 s 를 seq 로 구분된 모든 하위 슬라이스로 분할하고 해당 구분 기호 사이의 하위 슬라이스를 반환한다.

seq 가 비어있으면 각 UTF-8 시퀀스 후에 분할한다.

개수가 -1 인 SplitN 과 동일한다.

SplitAfter 는 seq 의 각 인스턴스 후에 모든 하위 슬라이스로 분할되고 해당 하위 슬라이스의 슬라이스를 반환한다.

seq 가 비어 있다면 SplitAfter 는 각 UTF-8 시퀀스 후에 분할된다.

개수가 -1 인 SplitAfterN 과 동일하다.

SplitAfterN 은 seq 의 각 인스턴스 후에 s 를 하위 슬라이스로 분할하고 해당 하위 슬라이스의 슬라이스를 반환한다.

seq 가 비어 있으면 SplitAfterN 은 각 UTF-8 시퀀스 후에 분할된다.

이 개수는 반환할 하위 슬라이스의 수를 결정한다.

n > 0 : 최대 n 개의 서브 슬라이스. 마지막 부분은 분할되지 않은 나머지 부분이 된다.
n == 0 : 결과가 nil (서브 슬라이스 0개)
n < 0 : 모든 서브 슬라이스

SplitN 는 seq 로 구분된 하위 슬라이스로 s 로 분할하고 해당 구분자 사이에 하위 슬라이스를 반환한다.

seq 가 비어 있으면 UTF-8 시퀀스 후에 분할된다.

이 개수는 반환할 하위 조각의 수를 결정한다.

n > 0 : 최대 n 개의 서브 슬라이스. 마지막 부분은 분할되지 않은 나머지 부분이 된다.
n == 0 : 결과가 nil (서브 슬라이스 0개)
n < 0 : 모든 서브 슬라이스

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

Title 은 s 를 UTF-8 로 인코딩된 바이트로 취급하고 단어를 시작하는 모든 유니 코드 문자가 제목 대소 문자에 매핑된 사본을 반환한다.

ToTitle 은 s 를 UTF-8 로 인코딩된 바이트로 취급하고 모든 유니코드 문자가 제목 케이스에 매핑된 복사본을 반환한다.

ToTitleSpecial 은 s 를 UTF-8 로 인코딩된 바이트로 취급하고 모든 유니코드 문자가 제목 케이스에 매핑된 복사본을 반환하여 특수 대/소문자 규칙에 우선 순위를 부여한다.

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

To[Lower|Upper] 는 모든 유니 코드 문자가 [대|소]문자로 매핑된 바이트 슬라이스의 복사본을 반환한다.

To[Lower|Upper]Special 은 s 를 UTF-8 로 인코딩된 바이트로 취급하고 모든 유니코드 문자가 소문자로 매핑된 복사본을 반환하여 특수 대/소문자 규칙에 우선 순위를 부여한다.

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

s 는 UTF-8 로 인코딩된 바이트로 취급하고 유효하지 않은 UTF-8 을 나타내는 각 바이트 실행이 비어있을 수 있는 대체 바이트로 대체된 복사본을 반환한다.

func Trim(s []byte, cutset string) []byte
func TrimFunc(s []byte, f func(r rune) bool) []byte
func TrimLeft(s []byte, curset string) []byte
func TrimLeftFunc(s []byte, f func(r rune) bool) []byte
func TrimRight(s []byte, curset string) []byte
func TrimRightFunc(s []byte, f func(r rune) bool) []byte
func TrimPrefix(s, prefix []byte) []byte
func TrimSuffix(s, suffix []byte) []byte
func TrimSpace(s []byte) []byte

Trim 은 cutset 에 포함된 모든 선행 및 후행 UTF-8 인코딩 코드 포인트를 잘라내어 s 의 서브 슬라이스를 반환한다.

TrimFunc 는 f(c) 를 충족하는 모든 선행 및 후행 UTF-8 인코딩 코드 포인트 c 를 슬라이스하여 s 의 서브 슬라이스를 반환한다.

Trim[Left|Right] 는 cutset 에 포함된 모든 [선행|후행] UTF-8 인코딩 코드 포인트를 슬라이스하여 s 의 서브 슬라이스를 반환한다.

Trim[Left|Right]Func 는 s 를 UTF-8 로 인코딩된 바이트로 취급하고 f(c) 를 충족하는 모든 [선행|후행] UTF-8 로 인코딩된 코드 포인트를 c 를 슬라이스하여 s 의 서브 슬라이스를 반환한다.

Trim[Prefix|Suffix] 는 [선행|후행] 접미사 문자열 없이 반환한다.

s 가 접미사로 끝나지 않으면 s 는 변경되지 않고 반환된다.

TrimSpace 는 유니 코드에 정의 된대로 모든 선행 및 후행 공백을 잘라내어 s 의 하위 슬라이스를 반환한다.

타입

Buffer

type Buffer struct {
	buf      []byte // buf[off : len(buf)] 바이트 버퍼
	off      int    // off 부터 읽고 buf 부터 씀
	lastRead readOp // 마지막으로 읽은 곳에서 작업을 수행
}

버퍼는 읽기 및 쓰기 메소드가 있는 가변 크기 바이트 버퍼이다.

Buffer 의 제로 값은 사용할 준비가 된 버퍼이다.

func NewBuffer(buf []byte) *Buffer
func NewBufferString(s string) *Buffer

NewBuffer 는 buf 를 초기 내용으로 사용하여 새 Buffer 를 만들고 초기화한다.

NewBufferString 은 문자열 s 를 초기 내용으로 사용하여 새 버퍼를 만들고 초기화한다.

func (b *Buffer) Cap() int

버퍼의 기본 바이트 슬라이스 용량.

func (b *Buffer) Grow(n int)

필요한 경우 버퍼의 용량을 증가시켜 다른 n 바이트 공간을 보장한다.

n 이 음수일 경우 패닉이 발생한다.

버퍼가 커지지 않으면 ErrTooLarge 와 함께 패닉 상태가 된다.

func (b *Buffer) Len() int

버퍼에서 읽지 않은 부분의 바이트 수를 반환한다.

b.Len() == len(b.Bytes())

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

버퍼에서 다음 n 바이트를 포함하는 슬라이스를 반환하여 마치 Read 에 의해 바이트가 반환된 것처럼 버퍼를 전진시킨다.

버퍼에 n 바이트 미만이 있으면 전체를 반환한다.

슬라이스는 다음에 읽기 또는 쓰기 메소드를 호출할 때까지만 유효하다.

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)

Read 는 버퍼가 비워질 때까지 다음 len(p) 바이트를 읽는다.

반환 값 n 은 읽은 바이트 수이다.

버퍼에 반환할 데이터가 없으면 err 은 io.EOF 이다.

그렇지 않으면 nil 이다.

ReadByte 는 버퍼에서 다음 바이트를 읽고 반환한다.

사용 가능한 바이트가 없으면 오류 io.EOF 를 반환한다.

ReadBytes 는 입력에서 delim 이 처음 나타날 때까지 읽고 구분 기호까지 포함하는 데이터를 포함하는 슬라이스를 반환한다.

오류가 발생하면 오류 전에 읽은 데이터와 오류 자체 (종종 io.EOF)를 반환한다.

반환된 데이터가 delim 으로 끝나지 않는 경우에만 err!=nil 을 반환한다.

ReadFrom 은 r 에서 EOF 까지 데이터를 읽고 버퍼에 추가하여 필요에 따라 버퍼를 늘린다.

반환 값 n 은 읽은 바이트 수이다. 읽는 동안 발생한 io.EOF 를 제외한 모든 오류도 반환된다.

버퍼가 커지면 ErrTooLarge 와 함께 패닉상태가 된다.

ReaderRune 은 버퍼에서 UTF-8 로 인코딩된 다음 유니코드 포인트를 읽고 반환한다.

사용 가능한 바이트가 없는 경우 반환되는 오류는 io.EOF 이다.

잘못된 UTF-8 인 경우 1 바이트를 소비하고 U+FFFD, 1 을 반환한다.

ReadString 은 입력에서 delim 이 처음 나타날 때까지 읽고 구분 기호까지 포함하는 데이터를 포함하는 문자열을 반환한다.

오류가 발생하면 오류 전에 읽은 데이터와 오류 자체 (종종 io.EOF)를 반환한다.

반환된 데이터가 delim 으로 끝나지 않는 경우에만 err!=nil 을 반환한다.

func (b *Buffer) Reset()

버퍼를 비워두도록 재설정하지만 향후 쓰기에 사용할 수 있도록 기본 스토리지를 유지한다.

재설정은 Truncate(0) 과 동일하다.

func (b *Buffer) String() string

버퍼에서 읽지 않은 부분의 내용을 문자열로 반환한다.

버퍼가 nil 포인터인 경우 "<nil>" 을 리턴한다.

func (b *Buffer) Truncate(n int)

버퍼에서 읽지 않은 처음 n 바이트를 제외한 모든 바이트를 버리지만 동일한 할당된 스토리지를 계속 사용한다.

n 이 음수거나 버퍼 길이보다 크면 패닉이 발생한다.

func (b *Buffer) UnreadByte() error
func (b *Buffer) UnreadRune() error

UnreadByte 는 최소 1 바이트를 읽은 가장 최근에 성공한 읽기 작업에서 반환된 마지막 바이트를 읽지 않는다.

마지막 읽기 이후 쓰기가 발생한 경우, 마지막 읽기에서 오류가 반환된 경우 또는 읽기에서 0 바이트를 읽은 경우 오류를 반환한다.

UnreadRune 은 ReadRune 이 반환한 마지막 룬을 읽지 않는다.

최근의 읽기 또는 쓰기 작업을 성공적인 ReadRune 이 아닌 경우 오류를 반환한다.

func (b *Buffer) Write(p []byte) (n int, err error)
func (b *Buffer) WriteByte(c byte) (n int, err 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)

Write 는 p 의 내용을 버퍼에 추가하여 필요에 따라 버퍼를 늘린다.

반환 값 n 은 p 의 길이이다. err 는 항상 nil 이다.

버퍼에 너무 커지면 ErrTooLarge 와 함께 패닉 상태가 된다.

WriteByte 는 버퍼에 c 바이트를 추가하여 필요에 따라 버퍼를 늘린다.

반환된 오류는 항상 nil 이며 버퍼가 너무 커지면 ErrTooLarge 와 함께 패닉 상태가 된다.

WriteRune 은 유니코드 포인트 r 의 UTF-8 인코딩을 버퍼에 추가하여 길이와 오류를 반환한다.

반환된 오류는 항상 nil 이며 버퍼가 너무 커지면 ErrTooLarge 와 함께 패닉 상태가 된다.

WriteTo 는 버퍼가 비워지거나 오류를 발생할 때까지 w 에 데이터를 쓴다.

반환 값 n 은 바이트 수이며 쓰기 중 발생한 오류도 반환된다.

Reader

type Reader struct {
	s        []byte
	i        int64 // 최근에 읽은 인덱스
	prevRune int   // 이전 룬의 인덱스 또는 < 0
}

리더는 바이트 슬라이스에 읽어 io.Reader, io.ReaderAt, io.WriterTo, io.Seeker, io.ByteScanner 및 io.RuneScanner 인터페이스를 구현한다.

버퍼와 달리 읽기 전용이며 검색을 지원한다.

Reader 의 제로값은 빈 슬라이스의 Reader 처럼 작동한다.

func NewReader(b []byte) *Reader

b 에서 읽은 새 Reader 를 반환한다.

func (r *Reader) Len() int

슬라이스에서 읽지 않은 부분의 바이트 수를 반환한다.

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

io.Reader 인터페이스를 구현한다.

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

io.ReaderAt 인터페이스를 구현한다.

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

io.ByteReader 인터페이스를 구현한다.

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

io.RuneReader 인터페이스를 구현한다.

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

리더가 b 에서 읽도록 재설정한다.

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

io.Seeker 인터페이스를 구현한다.

func (r *Reader) Size() int64

기본 문자열의 원래 길이를 반환한다.

func (r *Reader) UnreadByte() error

io.ByteScanner 인터페이스를 구현한다.

func (r *Reader) UnreadRune() error

io.RuneScanner 인터페이스를 구현한다.

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

io.WriteTo 인터페이스를 구현한다.