Rust 编程语言的字符串是使用 UTF-8 编码的,这种编码方式让每个字符有四种不同的宽度,例如 4 会被编码成 [52];ß 会被编码成 [195, 159];中 会被编码成 [228, 184, 173];𩸽 (ㄌㄨㄥˇ)会被编码成 [240, 169, 184, 189]。再加上 Rust 是标榜安全的编程语言,因此在切割字符串的时候会去做索引位置的检查,避免取到不正确的数据范围,不过这也因此让 Rust 的字符串处理多了不小的开支(overhead)。

先看看下面这个程序:

fn main() {
    let text = "abc";

    println!("{}", &text[0..2]);
}

以上程序的 text 变量是一个字符串切片(&str),&text[0..2] 可以取得一个新的字符串切片,数据为 text 变量的第一个字符和第二个字符。所以最终会输出 ab。

不过事实上,&text[0..2] 中的切片范围(0..2),是指保存 abc 这个字符串经 UTF-8 编码后的字节数组(u8 切片)之切片范围。把 abc 换成 中文字 试试看就知道了。

fn main() {
    let text = "中文字";

    println!("{}", &text[0..2]);
}

以上程序在运行的时候会于第 4 行发生 panic,因为 中文字 转成字节数组后的前两个字节并不是有效的 UTF-8 数据范围。

所以如果我们想要取得 中文 这个子字符串,切片的范围要怎么决定呢?……就只能根据字符的 UTF-8 宽度来决定啦!因为 中 和 文 这两个字都有 3 个字节,所以要将程序改写成:

fn main() {
    let text = "中文字";

    println!("{}", &text[0..6]);
}

如此一来程序才可以成功运行并印出 中文 这个子字符串。

不过在编译阶段无法确定被切片的字符串到底是什么的情况下,当然就无法预知要抓取的切片范围。此时可以使用字符串的 chars 方法来产生一个迭代器(iterator),一边将 UTF-8 数据解码,一边走访整个字符串。如下:

fn main() {
    let text = "中文字";
    
    for c in text.chars().take(2) {
        print!("{c}");
    }

    println!();
}

以上程序可以印出 中文字 的前两个字符,中 和 文。

chars 方法虽然感觉上挺方便的,但它却是性能杀手。例如我们要写一个程序,用来找出任意字符串中第一个全角句点 。,并将句点前,包含这个句点的字符串取出来处理。比较直觉的程序实作方式如下:

fn main() {
    let text = "昔人已乘黄鹤去,此地空余黄鹤楼。黄鹤一去不复返,白云千载空悠悠。";

    let mut first_sentence = String::new();

    for c in text.chars() {
        first_sentence.push(c);

        if c == '。' {
            break;
        }
    }

    println!("{first_sentence}");
}

以上代码看起来简洁易懂,但经不起推敲。因为 first_sentence 变量内的数据完全就是 text 变量内的数据之前面的部份,实在没有必要再另外拷贝一份出来。而且这个写法会让 String 结构体的 push 被调用数次,数据插入效率很糟,有点像是在实作一个文件拷贝功能,每次只拷贝一个字节那样。

不需要拷贝字符串的实作方式如下:

fn main() {
    let text = "昔人已乘黄鹤去,此地空余黄鹤楼。黄鹤一去不复返,白云千载空悠悠。";

    let mut length = 0;

    for c in text.chars() {
        length += c.len_utf8();

        if c == '。' {
            break;
        }
    }

    println!("{}", &text[..length]);
}

利用一个变量来保存已经看过的字节数量,最后再进行切片处理。字符的 len_utf8 方法可以用来计算这个字符在经过 UTF-8 编码后的字节数量。

虽然改写成这样让性能有了很大的提升,但 chars 方法产生的迭代器其实也会去计算字符宽度。而且它会回传字符,表示它有去进行 UTF-8 的解码,但在这个例子中显然不太需要。程序第 14 行,去取字符串切片的方式也是有点问题,那就是我们虽然能够 100% 确定 ..length 这个范围是 UTF-8 的正确数据范围,但程序在运行的时候还是需要从头再去验证一次……

最后那个问题很好解决,可以将字符串切片转成 u8 切片后再重新切片,最后再把新范围的 u8 切片转回 &str。代码如下:

use std::str::from_utf8_unchecked;

fn main() {
    let text = "昔人已乘黄鹤去,此地空余黄鹤楼。黄鹤一去不复返,白云千载空悠悠。";

    let mut length = 0;

    for c in text.chars() {
        length += c.len_utf8();

        if c == '。' {
            break;
        }
    }

    println!("{}", unsafe { from_utf8_unchecked(&text.as_bytes()[..length]) });
}

当然,也是可以直接使用切片提供的 get_unchecked 方法,但这个方法会连最基本的内存地址边界检查都舍弃掉,危险性十足,也不会让程序变得快多少(事实上有些案例显示会变得更慢),不是很建议使用。

fn main() {
    let text = "昔人已乘黄鹤去,此地空余黄鹤楼。黄鹤一去不复返,白云千载空悠悠。";

    let mut length = 0;

    for c in text.chars() {
        length += c.len_utf8();

        if c == '。' {
            break;
        }
    }

    println!("{}", unsafe { text.get_unchecked(..length) });
}

底下就来介绍能够以比较低级的方式替代 chars 方法的套件。

UTF-8 Width

「UTF-8 Width」是笔者开发的套件,可以利用字符经 UTF-8 编码后的第一个字节,来计算这个字符经 UTF-8 编码后的宽度。

Crates.io

Cargo.toml

utf8-width = "*"

使用方法

get_width 函数可以传入一个 UTF-8 编码后的字符之第一个字节(u8)的数值,并回传该字符的宽度。如果第一个字节不是有效的数值,会回传 0。

assert_eq!(1, utf8_width::get_width(b'1'));
assert_eq!(3, utf8_width::get_width("中".as_bytes()[0]));

如果可以确定传入的第一个字节一定是有效的数值(例如是从 Rust 字符串中取出来的字节数据。因为透过非 unsafe 的方式产生的 Rust 字符串,已经能确定它是一个正确的 UTF-8 数据),可以改用 get_width_assume_valid 函数,会算得更快。

另外这个套件还提供了第一个字节的宽度范围之常数,如果有需要的话还可以利用这些常数直接进行范围判断,连宽度都不用算。

改写上面的「第一句」程序

利用这个套件,可以将上面的「第一句」程序改写如下:

use std::str::from_utf8_unchecked;

fn main() {
    let text = "昔人已乘黄鹤去,此地空余黄鹤楼。黄鹤一去不复返,白云千载空悠悠。";
    let text_bytes = text.as_bytes();
    let text_length = text_bytes.len();

    let mut p = 0;

    while p < text_length {

        let e = text_bytes[p];

        let width = unsafe { utf8_width::get_width_assume_valid(e) };

        p += width;

        if e == 227 && text_bytes[p - 2] == 128 && text_bytes[p - 1] == 130 {
            break;
        }
    }

    println!("{}", unsafe { from_utf8_unchecked(&text_bytes[..p]) });
}

补充:字符 。 的 UTF-8 编码结果是 [227, 128, 130]。

改写之后,这个「第一句」程序仅会去计算一次 UTF-8 字符的宽度,而且不会去进行 UTF-8 字符的解码。

以上程序并不需要去判断 width 是否等于 3,因为不同宽度的 UTF-8 字符其第一个字节一定是不同的。事实上,在这个例子中,我们甚至也不一定要去计算宽度,因为输入的 Rust 字符串一定是一个正确的 UTF-8 数据,而 UTF-8 还有一个特性就是非第一个字节的数值范围并不会和第一个字节重叠。

所以「第一句」程序其实还可以有如下的实作方式:

use std::str::from_utf8_unchecked;

fn main() {
    let text = "昔人已乘黄鹤去,此地空余黄鹤楼。黄鹤一去不复返,白云千载空悠悠。";

    let length = text.find("。").map(|length| length + 3).unwrap_or(text.len());

    println!("{}", unsafe { from_utf8_unchecked(&text.as_bytes()[..length]) });
}

Rust 字符串内置的 find 方法不会浪费性能去进行 UTF-8 相关的处理,可以安心使用。

利用第一个字节取得 UTF-8 字符宽度的方式

利用第一个字节取得 UTF-8 字符宽度的方式大致上有三种。

第一种是利用遮罩去进行计算。宽度为 1 的字符,其第一个字节之最大比特(MSB, Most Significant Bit)一定是 0;宽度为 2 的字符,其第一个字节最大的三个比特一定是 110;宽度为 3 的字符,其第一个字节最大的四个比特一定是 1110;宽度为 4 的字符,其第一个字节最大的五个比特一定是 11110。

第二种是利用第一个字节的范围来判断。宽度为 1 的字符,其第一个字节的范围是 0x00~0x7F;宽度为 2 的字符,其第一个字节的范围是 0xC2~0xDF;宽度为 3 的字符,其第一个字节的范围是 0xE0~0xEF;宽度为 4 的字符,其第一个字节的范围是 0xF0~0xF4。这种方式是上面介绍的「UTF-8 Width」套件选择使用的方式。

第三种是查表,表格如下:

static UTF8_CHAR_WIDTH: [usize; 256] = [
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x1F
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x3F
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x5F
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x7F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x9F
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xBF
    0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // 0xDF
    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 0xEF
    4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xFF
];

这三种方式的性能差不多,但第三种通常不会比较快,而且会占用额外的内存空间。