• 字符串
    • 索引（Indexing）
    • 切片（Slicing）
    • 连接（Concatenation）

    字符串

    strings.md


    commit 23a7a7bdb6a6a43cd7efdd9176b1d3f75d9d0e70

    对于每一个程序，字符串都是需要掌握的重要内容。由于Rust主要着眼于系统编程，所以它的字符串处理系统与其它语言有些许区别。每当你碰到一个可变大小的数据结构时，情况都会变得很微妙，而字符串正是可变大小的数据结构。这也就是说，Rust的字符串与一些像C这样的系统编程语言也不相同。

    让我们进一步了解一下。一个字符串是一串UTF-8字节编码的Unicode量级值的序列。所有的字符串都确保是有效编码的UTF-8序列。另外，字符串并不以null结尾并且可以包含null字节。

    Rust有两种主要的字符串类型：&str和String。让我们先看看&str。这叫做字符串片段（string slices）。字符串常量是&'static str类型的：

    1. let greeting = "Hello there."; // greeting: &'static str

    "Hello there."是一个字符串常量而它的类型是&'static str。字符串常量是静态分配的字符串切片，也就是说它储存在我们编译好的程序中，并且整个程序的运行过程中一直存在。这个greeting绑定了一个静态分配的字符串的引用。任何接受一个字符串切片的函数也接受一个字符串常量。

    字符串常量可以跨多行。有两种形式。第一种会包含新行符和之前的空格：

    1. let s = "foo
    2.     bar";
    4. assert_eq!("foo\n    bar", s);

    第二种，带有\，会去掉空格和新行符：

    1. let s = "foo\
    2.     bar";
    4. assert_eq!("foobar", s);

    注意通常你不能直接访问一个str，只能通过&str引用。这是因为str是一个不定长类型，它需要额外的运行时信息才能使用。关于更多请查看不定长类型章节。

    Rust 当然不仅仅只有&str。一个String，是一个在堆上分配的字符串。这个字符串可以增长，并且也保证是UTF-8编码的。String通常通过一个字符串片段调用to_string方法转换而来。

    1. let mut s = "Hello".to_string(); // mut s: String
    2. println!("{}", s);
    4. s.push_str(", world.");
    5. println!("{}", s);

    String可以通过一个&强制转换为&str：

    1. fn takes_slice(slice: &str) {
    2.     println!("Got: {}", slice);
    3. }
    5. fn main() {
    6.     let s = "Hello".to_string();
    7.     takes_slice(&s);
    8. }

    这种强制转换并不发生在接受&str的trait而不是&str本身作为参数的函数上。例如，TcpStream::connect，有一个ToSocketAddrs类型的参数。&str可以不用转换不过String必须使用&*显式转换。

    1. use std::net::TcpStream;
    3. TcpStream::connect("192.168.0.1:3000"); // Parameter is of type &str.
    5. let addr_string = "192.168.0.1:3000".to_string();
    6. TcpStream::connect(&*addr_string); // Convert `addr_string` to &str.

    把String转换为&str的代价很小，不过从&str转换到String涉及到分配内存。除非必要，没有理由这样做！

    索引（Indexing）

    因为字符串是有效 UTF-8 编码的，它不支持索引：

    1. let s = "hello";
    3. println!("The first letter of s is {}", s[0]); // ERROR!!!

    通常，用[]访问一个数组是非常快的。不过，字符串中每个UTF-8编码的字符可以是多个字节，你必须遍历字符串来找到字符串的第N个字符。这个操作的代价相当高，而且我们不想误导读者。更进一步来讲，Unicode实际上并没有定义什么“字符”。我们可以选择把字符串看作一个串独立的字节，或者代码点（codepoints）：

    1. let hachiko = "忠犬ハチ公";
    3. for b in hachiko.as_bytes() {
    4.     print!("{}, ", b);
    5. }
    7. println!("");
    9. for c in hachiko.chars() {
    10.     print!("{}, ", c);
    11. }
    13. println!("");

    这会打印出：

    1. 229, 191, 160, 231, 138, 172, 227, 131, 143, 227, 131, 129, 229, 133, 172,
    2. 忠, 犬, ハ, チ, 公,

    如你所见，这有比char更多的字节。

    你可以这样来获取跟索引相似的东西：

    1. # let hachiko = "忠犬ハチ公";
    2. let dog = hachiko.chars().nth(1); // Kinda like `hachiko[1]`.

    这强调了我们不得不遍历整个char的列表。

    切片（Slicing）

    你可以使用切片语法来获取一个字符串的切片：

    1. let dog = "hachiko";
    2. let hachi = &dog[0..5];

    注意这里是字节偏移，而不是字符偏移。所以如下代码在运行时会失败：

    1. let dog = "忠犬ハチ公";
    2. let hachi = &dog[0..2];

    给出如下错误：

    1. thread 'main' panicked at 'byte index 2 is not a char boundary; it is inside '忠'
    2. (bytes 0..3) of `忠犬ハチ公`'

    连接（Concatenation）

    如果你有一个String，你可以在它后面接上一个&str：

    1. let hello = "Hello ".to_string();
    2. let world = "world!";
    4. let hello_world = hello + world;

    不过如果你有两个String，你需要一个&：

    1. let hello = "Hello ".to_string();
    2. let world = "world!".to_string();
    4. let hello_world = hello + &world;

    这是因为&String可以自动转换为一个&str。这个功能叫做Deref转换。