// Equal reports whether a and b // are the same length and contain the same bytes. // A nil argument is equivalent to an empty slice. func Equal(a, b []byte) bool { … } // Compare returns an integer comparing two byte slices lexicographically. // The result will be 0 if a == b, -1 if a < b, and +1 if a > b. // A nil argument is equivalent to an empty slice. func Compare(a, b []byte) int { … } // explode splits s into a slice of UTF-8 sequences, one per Unicode code point (still slices of bytes), // up to a maximum of n byte slices. Invalid UTF-8 sequences are chopped into individual bytes. func explode(s []byte, n int) [][]byte { … } // Count counts the number of non-overlapping instances of sep in s. // If sep is an empty slice, Count returns 1 + the number of UTF-8-encoded code points in s. func Count(s, sep []byte) int { … } // Contains reports whether subslice is within b. func Contains(b, subslice []byte) bool { … } // ContainsAny reports whether any of the UTF-8-encoded code points in chars are within b. func ContainsAny(b []byte, chars string) bool { … } // ContainsRune reports whether the rune is contained in the UTF-8-encoded byte slice b. func ContainsRune(b []byte, r rune) bool { … } // ContainsFunc reports whether any of the UTF-8-encoded code points r within b satisfy f(r). func ContainsFunc(b []byte, f func(rune) bool) bool { … } // IndexByte returns the index of the first instance of c in b, or -1 if c is not present in b. func IndexByte(b []byte, c byte) int { … } func indexBytePortable(s []byte, c byte) int { … } // LastIndex returns the index of the last instance of sep in s, or -1 if sep is not present in s. func LastIndex(s, sep []byte) int { … } // LastIndexByte returns the index of the last instance of c in s, or -1 if c is not present in s. func LastIndexByte(s []byte, c byte) int { … } // IndexRune interprets s as a sequence of UTF-8-encoded code points. // It returns the byte index of the first occurrence in s of the given rune. // It returns -1 if rune is not present in s. // If r is [utf8.RuneError], it returns the first instance of any // invalid UTF-8 byte sequence. func IndexRune(s []byte, r rune) int { … } // IndexAny interprets s as a sequence of UTF-8-encoded Unicode code points. // It returns the byte index of the first occurrence in s of any of the Unicode // code points in chars. It returns -1 if chars is empty or if there is no code // point in common. func IndexAny(s []byte, chars string) int { … } // LastIndexAny interprets s as a sequence of UTF-8-encoded Unicode code // points. It returns the byte index of the last occurrence in s of any of // the Unicode code points in chars. It returns -1 if chars is empty or if // there is no code point in common. func LastIndexAny(s []byte, chars string) int { … } // Generic split: splits after each instance of sep, // including sepSave bytes of sep in the subslices. func genSplit(s, sep []byte, sepSave, n int) [][]byte { … } // SplitN slices s into subslices separated by sep and returns a slice of // the subslices between those separators. // If sep is empty, SplitN splits after each UTF-8 sequence. // The count determines the number of subslices to return: // - n > 0: at most n subslices; the last subslice will be the unsplit remainder; // - n == 0: the result is nil (zero subslices); // - n < 0: all subslices. // // To split around the first instance of a separator, see [Cut]. func SplitN(s, sep []byte, n int) [][]byte { … } // SplitAfterN slices s into subslices after each instance of sep and // returns a slice of those subslices. // If sep is empty, SplitAfterN splits after each UTF-8 sequence. // The count determines the number of subslices to return: // - n > 0: at most n subslices; the last subslice will be the unsplit remainder; // - n == 0: the result is nil (zero subslices); // - n < 0: all subslices. func SplitAfterN(s, sep []byte, n int) [][]byte { … } // Split slices s into all subslices separated by sep and returns a slice of // the subslices between those separators. // If sep is empty, Split splits after each UTF-8 sequence. // It is equivalent to SplitN with a count of -1. // // To split around the first instance of a separator, see [Cut]. func Split(s, sep []byte) [][]byte { … } // SplitAfter slices s into all subslices after each instance of sep and // returns a slice of those subslices. // If sep is empty, SplitAfter splits after each UTF-8 sequence. // It is equivalent to SplitAfterN with a count of -1. func SplitAfter(s, sep []byte) [][]byte { … } var asciiSpace … // Fields interprets s as a sequence of UTF-8-encoded code points. // It splits the slice s around each instance of one or more consecutive white space // characters, as defined by [unicode.IsSpace], returning a slice of subslices of s or an // empty slice if s contains only white space. func Fields(s []byte) [][]byte { … } // FieldsFunc interprets s as a sequence of UTF-8-encoded code points. // It splits the slice s at each run of code points c satisfying f(c) and // returns a slice of subslices of s. If all code points in s satisfy f(c), or // len(s) == 0, an empty slice is returned. // // FieldsFunc makes no guarantees about the order in which it calls f(c) // and assumes that f always returns the same value for a given c. func FieldsFunc(s []byte, f func(rune) bool) [][]byte { … } // Join concatenates the elements of s to create a new byte slice. The separator // sep is placed between elements in the resulting slice. func Join(s [][]byte, sep []byte) []byte { … } // HasPrefix reports whether the byte slice s begins with prefix. func HasPrefix(s, prefix []byte) bool { … } // HasSuffix reports whether the byte slice s ends with suffix. func HasSuffix(s, suffix []byte) bool { … } // Map returns a copy of the byte slice s with all its characters modified // according to the mapping function. If mapping returns a negative value, the character is // dropped from the byte slice with no replacement. The characters in s and the // output are interpreted as UTF-8-encoded code points. func Map(mapping func(r rune) rune, s []byte) []byte { … } // Repeat returns a new byte slice consisting of count copies of b. // // It panics if count is negative or if the result of (len(b) * count) // overflows. func Repeat(b []byte, count int) []byte { … } // ToUpper returns a copy of the byte slice s with all Unicode letters mapped to // their upper case. func ToUpper(s []byte) []byte { … } // ToLower returns a copy of the byte slice s with all Unicode letters mapped to // their lower case. func ToLower(s []byte) []byte { … } // ToTitle treats s as UTF-8-encoded bytes and returns a copy with all the Unicode letters mapped to their title case. func ToTitle(s []byte) []byte { … } // ToUpperSpecial treats s as UTF-8-encoded bytes and returns a copy with all the Unicode letters mapped to their // upper case, giving priority to the special casing rules. func ToUpperSpecial(c unicode.SpecialCase, s []byte) []byte { … } // ToLowerSpecial treats s as UTF-8-encoded bytes and returns a copy with all the Unicode letters mapped to their // lower case, giving priority to the special casing rules. func ToLowerSpecial(c unicode.SpecialCase, s []byte) []byte { … } // ToTitleSpecial treats s as UTF-8-encoded bytes and returns a copy with all the Unicode letters mapped to their // title case, giving priority to the special casing rules. func ToTitleSpecial(c unicode.SpecialCase, s []byte) []byte { … } // ToValidUTF8 treats s as UTF-8-encoded bytes and returns a copy with each run of bytes // representing invalid UTF-8 replaced with the bytes in replacement, which may be empty. func ToValidUTF8(s, replacement []byte) []byte { … } // isSeparator reports whether the rune could mark a word boundary. // TODO: update when package unicode captures more of the properties. func isSeparator(r rune) bool { … } // Title treats s as UTF-8-encoded bytes and returns a copy with all Unicode letters that begin // words mapped to their title case. // // Deprecated: The rule Title uses for word boundaries does not handle Unicode // punctuation properly. Use golang.org/x/text/cases instead. func Title(s []byte) []byte { … } // TrimLeftFunc treats s as UTF-8-encoded bytes and returns a subslice of s by slicing off // all leading UTF-8-encoded code points c that satisfy f(c). func TrimLeftFunc(s []byte, f func(r rune) bool) []byte { … } // TrimRightFunc returns a subslice of s by slicing off all trailing // UTF-8-encoded code points c that satisfy f(c). func TrimRightFunc(s []byte, f func(r rune) bool) []byte { … } // TrimFunc returns a subslice of s by slicing off all leading and trailing // UTF-8-encoded code points c that satisfy f(c). func TrimFunc(s []byte, f func(r rune) bool) []byte { … } // TrimPrefix returns s without the provided leading prefix string. // If s doesn't start with prefix, s is returned unchanged. func TrimPrefix(s, prefix []byte) []byte { … } // TrimSuffix returns s without the provided trailing suffix string. // If s doesn't end with suffix, s is returned unchanged. func TrimSuffix(s, suffix []byte) []byte { … } // IndexFunc interprets s as a sequence of UTF-8-encoded code points. // It returns the byte index in s of the first Unicode // code point satisfying f(c), or -1 if none do. func IndexFunc(s []byte, f func(r rune) bool) int { … } // LastIndexFunc interprets s as a sequence of UTF-8-encoded code points. // It returns the byte index in s of the last Unicode // code point satisfying f(c), or -1 if none do. func LastIndexFunc(s []byte, f func(r rune) bool) int { … } // indexFunc is the same as IndexFunc except that if // truth==false, the sense of the predicate function is // inverted. func indexFunc(s []byte, f func(r rune) bool, truth bool) int { … } // lastIndexFunc is the same as LastIndexFunc except that if // truth==false, the sense of the predicate function is // inverted. func lastIndexFunc(s []byte, f func(r rune) bool, truth bool) int { … } type asciiSet … // makeASCIISet creates a set of ASCII characters and reports whether all // characters in chars are ASCII. func makeASCIISet(chars string) (as asciiSet, ok bool) { … } // contains reports whether c is inside the set. func (as *asciiSet) contains(c byte) bool { … } // containsRune is a simplified version of strings.ContainsRune // to avoid importing the strings package. // We avoid bytes.ContainsRune to avoid allocating a temporary copy of s. func containsRune(s string, r rune) bool { … } // Trim returns a subslice of s by slicing off all leading and // trailing UTF-8-encoded code points contained in cutset. func Trim(s []byte, cutset string) []byte { … } // TrimLeft returns a subslice of s by slicing off all leading // UTF-8-encoded code points contained in cutset. func TrimLeft(s []byte, cutset string) []byte { … } func trimLeftByte(s []byte, c byte) []byte { … } func trimLeftASCII(s []byte, as *asciiSet) []byte { … } func trimLeftUnicode(s []byte, cutset string) []byte { … } // TrimRight returns a subslice of s by slicing off all trailing // UTF-8-encoded code points that are contained in cutset. func TrimRight(s []byte, cutset string) []byte { … } func trimRightByte(s []byte, c byte) []byte { … } func trimRightASCII(s []byte, as *asciiSet) []byte { … } func trimRightUnicode(s []byte, cutset string) []byte { … } // TrimSpace returns a subslice of s by slicing off all leading and // trailing white space, as defined by Unicode. func TrimSpace(s []byte) []byte { … } // Runes interprets s as a sequence of UTF-8-encoded code points. // It returns a slice of runes (Unicode code points) equivalent to s. func Runes(s []byte) []rune { … } // Replace returns a copy of the slice s with the first n // non-overlapping instances of old replaced by new. // If old is empty, it matches at the beginning of the slice // and after each UTF-8 sequence, yielding up to k+1 replacements // for a k-rune slice. // If n < 0, there is no limit on the number of replacements. func Replace(s, old, new []byte, n int) []byte { … } // ReplaceAll returns a copy of the slice s with all // non-overlapping instances of old replaced by new. // If old is empty, it matches at the beginning of the slice // and after each UTF-8 sequence, yielding up to k+1 replacements // for a k-rune slice. func ReplaceAll(s, old, new []byte) []byte { … } // EqualFold reports whether s and t, interpreted as UTF-8 strings, // are equal under simple Unicode case-folding, which is a more general // form of case-insensitivity. func EqualFold(s, t []byte) bool { … } // Index returns the index of the first instance of sep in s, or -1 if sep is not present in s. func Index(s, sep []byte) int { … } // Cut slices s around the first instance of sep, // returning the text before and after sep. // The found result reports whether sep appears in s. // If sep does not appear in s, cut returns s, nil, false. // // Cut returns slices of the original slice s, not copies. func Cut(s, sep []byte) (before, after []byte, found bool) { … } // Clone returns a copy of b[:len(b)]. // The result may have additional unused capacity. // Clone(nil) returns nil. func Clone(b []byte) []byte { … } // CutPrefix returns s without the provided leading prefix byte slice // and reports whether it found the prefix. // If s doesn't start with prefix, CutPrefix returns s, false. // If prefix is the empty byte slice, CutPrefix returns s, true. // // CutPrefix returns slices of the original slice s, not copies. func CutPrefix(s, prefix []byte) (after []byte, found bool) { … } // CutSuffix returns s without the provided ending suffix byte slice // and reports whether it found the suffix. // If s doesn't end with suffix, CutSuffix returns s, false. // If suffix is the empty byte slice, CutSuffix returns s, true. // // CutSuffix returns slices of the original slice s, not copies. func CutSuffix(s, suffix []byte) (before []byte, found bool) { … }
Codebase Browser
go