String是动态堆字符串类型，如Vec：当您需要拥有或修改字符串数据时使用它。

str是内存中某个动态长度的UTF-8字节的一个不可更改的1序列。由于大小未知，只能在指针后面处理。这意味着str最常见的形式是&str：对一些UTF-8数据的引用，通常称为“字符串切片”或“切片”。切片只是一些数据的视图，这些数据可以在任何地方，例如。

在静态存储中：字符串“foo”是一个&‘静态字符串。数据被硬编码到可执行文件中，并在程序运行时加载到内存中。在堆分配的String:String中，取消对String数据的&str视图的引用。在堆栈上：例如，下面创建一个堆栈分配的字节数组，然后以&str的形式获取该数据的视图：使用std:：str；设x:&[u8]=&[b'a'，b'b'，b'c']；让stack_str:&str=str:：from_utf8（x）.unwrap（）；

总之，如果您需要自己的字符串数据（比如将字符串传递给其他线程，或者在运行时构建它们），请使用String；如果您只需要字符串的视图，请使用&str。

这与向量Vec<T>和切片&[T]之间的关系相同，并且与一般类型的按值T和按引用&T之间的关系相似。

1 A str为固定长度；不能写入超出结尾的字节，或留下尾随无效字节。由于UTF-8是一种可变宽度编码，因此在许多情况下，这有效地迫使所有str都是不可变的。一般来说，突变需要比以前写更多或更少的字节（例如，用ä（2+字节）替换a（1字节）将需要在str中腾出更多空间）。有一些特定的方法可以就地修改&mut str，大多数方法只处理ASCII字符，如make_ASCII_capital。

2自Rust 1.2以来，动态大小的类型允许Rc＜str＞等引用计数的UTF-8字节序列。Rust 1.21允许轻松创建这些类型。

在这三种不同类型中let面条=“面条”.to_string（）；let oodles=面条[1..]；让贵宾犬=“ಠ_ಠ“；//这是字符串文本字符串有一个可调整大小的缓冲区，用于保存UTF-8文本。缓冲区是在堆上分配的，因此它可以根据需要调整缓冲区的大小，或者请求。在示例中，“面条”是一个字符串，它拥有八字节缓冲器，其中七个正在使用。你可以想到字符串作为Vec，保证保持格式良好的UTF-8；在里面事实上，这就是String的实现方式。&str是对其他人拥有的UTF-8文本的引用：它“借用”了文本。在示例中，oodles是一个&str参考属于“面条”的文本的最后六个字节，因此它表示文本“oodles”。与其他切片引用一样，&str是一个胖指针，包含实际数据的地址和其长度。你可以把&str看作是&[u8]，保证保持格式良好的UTF-8。字符串文字是一个&str，它引用预先分配的文本，通常与程序的机器一起存储在只读存储器中密码在前面的示例中，贵宾犬是一个字符串文本，指向到程序开始执行时创建的七个字节，以及直到它退出。这就是它们在内存中的存储方式

参考资料：Jim Blandy、Jason Orendorff、Leonora F。S.廷德尔

str，仅用作&str，是一个字符串片段，是对UTF-8字节数组的引用。

字符串过去是~str，一个可增长的、拥有的UTF-8字节数组。

std：：字符串只是u8的向量。您可以在源代码中找到它的定义。它是堆分配的，可以生长。

#[derive(PartialOrd, Eq, Ord)]
#[stable(feature = "rust1", since = "1.0.0")]
pub struct String {
    vec: Vec<u8>,
}

str是一种原始类型，也称为字符串切片。字符串切片具有固定大小。像let test=“hello world”这样的文本字符串具有&‘static str类型。test是对这个静态分配字符串的引用。&str不能被修改，

let mut word = "hello world";
word[0] = 's';
word.push('\n');

str确实具有可变切片&mut str，例如：pub-fn-split_at_mut（&mut自身，mid:usize）->（&mut字符串，&mut字符串）

let mut s = "Per Martin-Löf".to_string();
{
    let (first, last) = s.split_at_mut(3);
    first.make_ascii_uppercase();
    assert_eq!("PER", first);
    assert_eq!(" Martin-Löf", last);
}
assert_eq!("PER Martin-Löf", s);

但是，对UTF-8的一个小改动可以改变它的字节长度，并且一个切片不能重新分配它的引用。

简单地说，String是存储在堆上的数据类型（就像Vec一样），您可以访问该位置。

&str是一种切片类型。这意味着它只是对堆中某个已经存在的String的引用。

&str在运行时不进行任何分配。因此，出于内存原因，可以在字符串上使用&str。但是，请记住，在使用&str时，您可能需要处理显式的生存期。

锈蚀和字符串（&S）

字符串：

Rust拥有String类型，字符串本身存在于堆中，因此是可变的，可以更改其大小和内容。因为当拥有字符串的变量超出范围时，String是被拥有的，所以堆上的内存将被释放。String类型的变量是胖指针（指针+相关元数据）fat指针长度为3*8字节（字大小），由以下3个元素组成：指向堆上实际数据的指针，它指向第一个字符字符串长度（字符数）堆上字符串的容量

&字符串：

Rust非拥有的String类型，默认情况下是不可变的。字符串本身位于内存中的其他位置，通常位于堆或“静态内存”中。因为当&str变量超出范围时，字符串是非所有的，所以字符串的内存不会被释放。&str类型的变量是胖指针（指针+相关元数据）fat指针长度为2*8字节（字大小），由以下2个元素组成：指向堆上实际数据的指针，它指向第一个字符字符串长度（字符数）

例子：

use std::mem;

fn main() {
    // on 64 bit architecture:
    println!("{}", mem::size_of::<&str>()); // 16
    println!("{}", mem::size_of::<String>()); // 24

    let string1: &'static str = "abc";
    // string will point to `static memory which lives through the whole program

    let ptr = string1.as_ptr();
    let len = string1.len();

    println!("{}, {}", unsafe { *ptr as char }, len); // a, 3
    // len is 3 characters long so 3
    // pointer to the first character points to letter a

    {
        let mut string2: String = "def".to_string();

        let ptr = string2.as_ptr();
        let len = string2.len();
        let capacity = string2.capacity();
        println!("{}, {}, {}", unsafe { *ptr as char }, len, capacity); // d, 3, 3
        // pointer to the first character points to letter d
        // len is 3 characters long so 3
        // string has now 3 bytes of space on the heap

        string2.push_str("ghijk"); // we can mutate String type, capacity and length will aslo change
        println!("{}, {}", string2, string2.capacity()); // defghijk, 8

    } // memory of string2 on the heap will be freed here because owner goes out of scope

}