Go源码学习：bytes包 - 1.2 - bytes.go -（4）

本文链接：https://blog.csdn.net/weixin_49015143/article/details/135998736

上一篇：
Go源码学习：bytes包 - 1.2 - bytes.go -（3）

31、ToTitle：转换为标题格式

这部分代码定义了 ToTitle 方法，用于将字符串转换为标题格式，即将所有的 Unicode 字母转换为它们的标题格式。

// ToTitle 将 s 视为 UTF-8 编码的字节，并返回一个副本，其中所有的 Unicode 字母都被转换为它们的标题格式。
func ToTitle(s []byte) []byte { return Map(unicode.ToTitle, s) }

解释：

ToTitle 方法是一个函数，接收一个字节数组 s，并返回一个字节数组。
它使用了 Map 函数，将 unicode.ToTitle 函数应用于输入字节的每个 Unicode 字母，并返回转换后的结果。

作用：

ToTitle 方法用于将字符串转换为标题格式，即将所有的 Unicode 字母转换为它们的标题格式。
这在处理文本时很有用，例如将标题标准化或处理特定格式的文本。

32、ToUpperSpecial：特殊规则转换为大写

这部分代码定义了 ToUpperSpecial 方法，用于将字符串转换为大写格式，优先考虑特殊的转换规则。

// ToUpperSpecial 将 s 视为 UTF-8 编码的字节，并返回一个副本，其中所有的 Unicode 字母都被转换为它们的大写格式，优先考虑特殊的转换规则。
func ToUpperSpecial(c unicode.SpecialCase, s []byte) []byte {
    return Map(c.ToUpper, s)
}

解释：

ToUpperSpecial 方法是一个函数，接收一个特殊规则 c 和一个字节数组 s，并返回一个字节数组。
它使用了 Map 函数，将特殊规则 c 中的大写转换函数应用于输入字节的每个 Unicode 字母，并返回转换后的结果。

作用：

ToUpperSpecial 方法用于将字符串转换为大写格式，优先考虑特殊的转换规则，这对于一些语言或特定文本处理场景很有用，因为它考虑了一些特殊的转换规则。

33、ToLowerSpecial：特殊规则转换为小写

这部分代码定义了 ToLowerSpecial 方法，用于将字符串转换为小写格式，优先考虑特殊的转换规则。

// ToLowerSpecial 将 s 视为 UTF-8 编码的字节，并返回一个副本，其中所有的 Unicode 字母都被转换为它们的小写格式，优先考虑特殊的转换规则。
func ToLowerSpecial(c unicode.SpecialCase, s []byte) []byte {
    return Map(c.ToLower, s)
}

解释：

ToLowerSpecial 方法是一个函数，接收一个特殊规则 c 和一个字节数组 s，并返回一个字节数组。
它使用了 Map 函数，将特殊规则 c 中的小写转换函数应用于输入字节的每个 Unicode 字母，并返回转换后的结果。

作用：

ToLowerSpecial 方法用于将字符串转换为小写格式，优先考虑特殊的转换规则，这对于一些语言或特定文本处理场景很有用，因为它考虑了一些特殊的转换规则。

34、ToTitleSpecial：特殊规则转换为标题格式

这部分代码定义了 ToTitleSpecial 方法，用于将字符串转换为标题格式，优先考虑特殊的转换规则。

// ToTitleSpecial 将 s 视为 UTF-8 编码的字节，并返回一个副本，其中所有的 Unicode 字母都被转换为它们的标题格式，优先考虑特殊的转换规则。
func ToTitleSpecial(c unicode.SpecialCase, s []byte) []byte {
    return Map(c.ToTitle, s)
}

解释：

ToTitleSpecial 方法是一个函数，接收一个特殊规则 c 和一个字节数组 s，并返回一个字节数组。
它使用了 Map 函数，将特殊规则 c 中的标题转换函数应用于输入字节的每个 Unicode 字母，并返回转换后的结果。

作用：

ToTitleSpecial 方法用于将字符串转换为标题格式，即将所有的 Unicode 字母转换为它们的标题格式。
与 ToTitle 不同的是，ToTitleSpecial 考虑了特殊的转换规则，这对于一些语言或特定文本处理场景很有用，因为它优先考虑了一些特殊的转换规则。

35、ToValidUTF8：替换无效的UTF-8序列

这部分代码定义了 ToValidUTF8 方法，用于将字符串视为UTF-8编码的字节，并返回一个副本，其中每个无效的UTF-8序列都被替换为指定的替代字节序列。

// ToValidUTF8 将 s 视为 UTF-8 编码的字节，并返回一个副本，其中每个无效的 UTF-8 序列都被替换为指定的替代字节序列，replacement 可以为空。
func ToValidUTF8(s, replacement []byte) []byte {
    b := make([]byte, 0, len(s)+len(replacement))
    invalid := false // 上一个字节来自无效的 UTF-8 序列
    for i := 0; i < len(s); {
        c := s[i]
        if c < utf8.RuneSelf {
            i++
            invalid = false
            b = append(b, c)
            continue
        }
        _, wid := utf8.DecodeRune(s[i:])
        if wid == 1 {
            i++
            if !invalid {
                invalid = true
                b = append(b, replacement...)
            }
            continue
        }
        invalid = false
        b = append(b, s[i:i+wid]...)
        i += wid
    }
    return b
}

解释：

ToValidUTF8 方法是一个函数，接收两个字节数组 s 和 replacement，并返回一个字节数组。
它通过迭代检查每个字节，将原始字节序列中的无效UTF-8序列替换为指定的替代字节序列。

作用：

ToValidUTF8 方法用于处理UTF-8编码的字节序列，将其中无效的UTF-8序列替换为指定的替代字节序列。
这对于清理或修复损坏的UTF-8数据很有用，确保数据在处理过程中是有效的UTF-8编码。

36、isSeparator：判断字符是否可作为单词边界

这部分代码定义了 isSeparator 函数，用于判断一个字符是否可以标记一个单词的边界。

// isSeparator 报告符文是否可以标记单词边界。
// TODO: 当 package unicode 捕获更多属性时进行更新。
func isSeparator(r rune) bool {
    // ASCII 字母数字和下划线不是分隔符
    if r <= 0x7F {
        switch {
        case '0' <= r && r <= '9':
            return false
        case 'a' <= r && r <= 'z':
            return false
        case 'A' <= r && r <= 'Z':
            return false
        case r == '_':
            return false
        }
        return true
    }
    // 字母和数字不是分隔符
    if unicode.IsLetter(r) || unicode.IsDigit(r) {
        return false
    }
    // 否则，目前我们只能将空格视为分隔符。
    return unicode.IsSpace(r)
}

解释：

isSeparator 函数用于判断给定的符文是否可以标记一个单词的边界。
对于 ASCII 字符，数字、小写字母、大写字母和下划线都不被视为分隔符。
对于非 ASCII 字符，除了字母和数字外，其他字符都被视为分隔符。空格也被视为分隔符。

作用：

isSeparator 函数用于在字符串处理中确定字符是否可以标记一个单词的边界。
这在一些文本处理场景中很有用，例如在处理单词时确定单词的开始和结束位置。

37、Title：将字符串中每个单词的首字母转换为标题格式

这部分代码定义了 Title 函数，用于将字符串视为UTF-8编码的字节，并返回一个副本，其中每个单词的首字母都被转换为标题格式。

// Title 将 s 视为 UTF-8 编码的字节，并返回一个副本，其中每个单词的首字母都被转换为标题格式。
//
// Deprecated: Title 用于单词边界的规则不能正确处理 Unicode 标点符号。请使用 golang.org/x/text/cases 代替。
func Title(s []byte) []byte {
    // 使用闭包在这里保持状态。
    // 有些巧妙但有效。依赖于 Map 按顺序扫描并在每个符文调用闭包一次。
    prev := ' '
    return Map(
        func(r rune) rune {
            if isSeparator(prev) {
                prev = r
                return unicode.ToTitle(r)
            }
            prev = r
            return r
        },
        s)
}

解释：

Title 函数是一个被弃用的函数，用于将字符串中每个单词的首字母转换为标题格式。
它使用了 Map 函数，对字符串进行遍历，对每个单词的首字母进行标题格式的转换。

作用：

Title 函数的作用是将字符串中每个单词的首字母转换为标题格式。
该函数已被弃用，因为其用于单词边界的规则不能正确处理 Unicode 标点符号，建议使用 golang.org/x/text/cases 包替代。

38、TrimLeftFunc：根据条件切割字节切片

这部分代码定义了 TrimLeftFunc 函数，用于将字节切片 s 视为UTF-8编码的字节，并返回一个子切片，通过切割掉所有满足条件 f(c) 的前导UTF-8编码码点 c。

// TrimLeftFunc 将 s 视为 UTF-8 编码的字节，并返回一个子切片，通过切割掉所有满足条件 f(c) 的前导 UTF-8 编码码点 c。
func TrimLeftFunc(s []byte, f func(r rune) bool) []byte {
    i := indexFunc(s, f, false)
    if i == -1 {
        return nil
    }
    return s[i:]
}

解释：

TrimLeftFunc 函数用于根据条件切割字节切片，将其视为UTF-8编码的字节。
使用 indexFunc 函数查找第一个不满足条件 f(c) 的UTF-8编码码点 c 的位置。
如果找不到符合条件的码点，返回空切片；否则，返回从找到位置开始的子切片。

作用：

TrimLeftFunc 用于去除字节切片前面满足指定条件的UTF-8编码码点，实现定制化的左侧修剪功能。

39、TrimRightFunc：根据条件切割字节切片

这部分代码定义了 TrimRightFunc 函数，用于返回字节切片 s 的子切片，通过切割掉所有满足条件 f(c) 的尾部UTF-8编码码点 c。

// TrimRightFunc 返回 s 的子切片，通过切割掉所有满足条件 f(c) 的尾部 UTF-8 编码码点 c。
func TrimRightFunc(s []byte, f func(r rune) bool) []byte {
    i := lastIndexFunc(s, f, false)
    if i >= 0 && s[i] >= utf8.RuneSelf {
        _, wid := utf8.DecodeRune(s[i:])
        i += wid
    } else {
        i++
    }
    return s[0:i]
}

解释：

TrimRightFunc 函数用于根据条件切割字节切片，将其视为UTF-8编码的字节。
使用 lastIndexFunc 函数查找最后一个不满足条件 f(c) 的UTF-8编码码点 c 的位置。
如果找到位置，并且码点 c 大于等于 utf8.RuneSelf，则根据码点宽度调整位置。
返回字节切片，截取到调整后的位置。

作用：

TrimRightFunc 用于去除字节切片尾部满足指定条件的UTF-8编码码点，实现定制化的右侧修剪功能。

40、TrimFunc：根据条件切割字节切片

这部分代码定义了 TrimFunc 函数，用于返回字节切片 s 的子切片，通过切割掉所有满足条件 f(c) 的前导和尾部UTF-8编码码点 c。

// TrimFunc 返回 s 的子切片，通过切割掉所有满足条件 f(c) 的前导和尾部 UTF-8 编码码点 c。
func TrimFunc(s []byte, f func(r rune) bool) []byte {
    return TrimRightFunc(TrimLeftFunc(s, f), f)
}