basic/compound-type/string-slice

[giscus[bot]]

basic/compound-type/string-slice

https://course.rs/basic/compound-type/string-slice.html

[AldenClark]

可以补充一下字符串转义方面的内容吗？

[sunface]

可以看一下课后练习，里面比较全，书中篇幅得控制下 🤣

[jimbaMe]

fn main() {
let mut s = String::from("hello world"); //1
let word = first_word(&s); //2
s.clear(); // error! //3
println!("the first word is: {}", word); //4
}

fn first_word(s: &String) -> &str {
&s[..1]
}

关于这一段不是很理解，按照上一讲的说法，&s只在 //2 出现，之后就没有再使用了，范围应该是只在//2，&mut s的范围在 //3，这里报错是因为rust知道word是s的不可变引用，所以&s的范围是从 //2到 //4吗？rust是怎么知道的

[zhaochaobo]

let word = first_word(&s); //2 这一行产生了两次借用，&s借用是发生在函数调用的时候，函数返回会释放。
在函数里面返回只是对s的第一个字符产生了借用，并绑定给了word. word借用到最后才会释放。而调用s.clear()会会将s自身作为可变借用传入clear函数。因此发生冲突。

[totwoto]

@zhaochaobo 我感觉只有你解释的对了, &s 在first_word函数结束后,声明周期结束, 而 first_word内把 s的第一个元素的不可变引用返回了,赋给了word, 所以后面操作s.clear()会报错

[xiaoyunfei0816]

@zhaochaobo 你说的是对的，不论 &s 还是 word 获得的对 s 的首字母的引用，都是同一块堆内存，clear()要清空这块堆内存，而 printLn 又用到了这块堆内存，所以不能先清空再引用， 把 clear()放到 printLn 之后执行就没问题

[xiaoyunfei0816]

问了下 monica ，monica 如是说：
是的，你的理解是正确的。在 Rust 中，word 的生命周期与 s 相关联。当你调用 first_word(&s) 时，word 获取了对 s 字符串的一部分的引用。

在你的代码中，s.clear() 会清空 s 的内容，这意味着 s 的内存空间被释放了。此时，word 仍然是一个指向已释放内存的引用，这会导致悬空引用（dangling reference），从而在编译时产生错误。

[hdn1998]

fn main() {
    let mut s = String::from("hello world"); //1
    let word: &str = first_word(&s); //2
    String::clear(&mut s); // error! //3
    println!("the first word is: {}", word); //4
}

fn first_word(s: &String) -> &str {
    &s[..1]
}

代码//4行中word是s 的不可变借用切片：&str，而冲突在于//3行clear函数要求传入的是s 的可变借用变量：&mut String，那么//3行出现了 既要 s的不可变借用，又要s的可变借用的情况，违背了**"同一时刻，你只能拥有要么一个可变引用，要么任意多个不可变引用"**

[Nanbert]

”+ 和 += 都是返回一个新的字符串。所以变量声明可以不需要 mut 关键字修饰。“，但是代码里就是用了mut,而且result还变了？这写错了？

[underwoodnoble]

应该这样理解，比如let s = String::from("I like dogs")，这里并不代表String不能修改，而是s是String的一个不可变的绑定，你可以尝试下后面可以用let mut s1 = s，这个时候s1是String的一个可变的绑定，s1获取了s的所有权，函数调用的使用也是这样，因为获取的是所有权，在获取所有权时你可以决定是可变的绑定(s1)还是不可变的绑定(s)，因为你就是数据的拥有者了，可以自己决定改还是不改。这一点与接受引用的函数是不同的，接受引用其实就是借用，你不能说你是不可变的借用，然后又想要修改数据，所有者不会同意的。

[Ethkuil]

作者目前还没修复这个问题，我就发了个 PR。

[preoge]

1楼说的挺对的，因为 += 这个操作和 a=a+b 这个差不多，所以要求a是存在的，再加上这个过程会对a修改，所以a需要是可变的。这个也是函数作者将其输入定义为可变的原因。

[upWooStream]

let result = string_append + &string_rust;
let mut result = result + "!";
result += "!!!";

第2行之所以加mut是因为第3行+=对result做了修改，如果没有第3行，则写成

let result = string_append + &string_rust;
let result = result + "!";

也是没有问题的，这里虽然看着对result做了修改，其实是覆盖声明，两个result是不同变量

[hdn1998]

+= 可是不会创建新字符串是直接在原字符串追加内容，所以result是需要可变的；
+ 会创建新的字符串，并复制原内容，所以+左侧会丢失所有权。

操作符	所有权转移	原字符是否可变	适用场景
+	转移左侧操作数	否	创建新字符串
+=	不转移	是	原地修改字符串

[jyutjyu]

少了一个“节“：
string_remove 占 18 个字

[sunface]

是的，少了，谢谢哈～

[walikaka2020]

"数组切片和字符串切片的工作方式是一样的",有一些具体的细节还是没讲清楚:
比如(1)字符串切片的类型是&str,数组的切片类型是&[T].
(2)字符串切片是按照字节进行索引的,数组切片是按照元素进行索引的.

[sunface]

好的，感谢建议

[tcqiuyu]

这里的add方法其实是代表了字符串之间的加法运算么？一开始一直在找哪里调用了这个方法

[tcqiuyu]

留错位置了😅

[791045873]

关于字符串连接的第一个代码示例中的注释——” &string_rust会自动解引用为&str“。
是否应当是——”会自动解引用为*str“。
& -> *

[sunface]

额。。这不是 C 语言🤣，&str 代表字符串切片的引用

[791045873]

感谢，是我误解了

[li2rn]

remove()函数返回的不是字符串，是字符类型。

[giveahug]

为什么String可变，声明的时候还要加mut呢

[sunface]

汽车能开，为何还需要汽油和司机呢？🤣

原因是 String 可变只是描述这个数据结构的特点，但是在使用中是否可变，取决于我们是否允许它变化

[bluecode2017]

我理解“String可变” 是指初始赋值可以大可小长度不定。 但是若不加mut，赋值后，值就不能改了

[tabris233]

r###"xxxx"### 这种写法 看着就好麻烦啊

[zhwei820]

习惯就好

[macran]

显然没有 JavaScript 里面的 好用。这个应该跟rust 提一下嘛。太恶心了。解决 #的歧义为什么必须用# 去一对一的拼命？用一个 原子弹(``)不就好了吗。

[ahuigo]

原子弹(``) 也不能解决歧义呀。只能用转义

[chanhsiaoyu]

为啥内部同时要弄utf8和unicode两种编码。。

[jinliming2]

我觉得这里不应该说是“UTF-8 和 Unicode 两种编码”，Unicode 是字符集，UTF-8 是 Unicode 的一种编码格式。Rust 里的字符是存的 Unicode 代码点（一个整数），而非 UTF-8 这种字符编码（也不是 UTF-32 编码）。

字符串用 UTF-8 应该是因为它是变长编码，每个字符占用 1 到 4 个字节，这样可以节省存储空间。

而字符类型因为是属于基本类型，在栈上分配，所以长度需要固定，而如果长度固定了，如果这是个可变的变量，那么在字符变量被修改的时候就要确保内存空间是足够的，所以用 Unicode 的最大容量 4 个字节来存储单个字符，而且存的是个 Unicode 代码点整数，而非任何编码。

[Hccake]

字符集中的码点是字符的序列号，字符编码是用来控制这个序列号的存储方式的。
比如码点 1，可以用一个字节存储为 ‘0x01’，也可以用两个字节存储为 '0x00 0x01'。
而 rust 中的字符使用 4 个字节的二进制存储，'0x00 0x00 0x00 0x01' , 也就是 UTF32 编码方式

[polluxliu]

unicode是一种字符集，为世界上所有字符分配了一个唯一的编号，但是没有规定如何存储和传输，这需要具体的编码方式来实现，比如 UTF-8。

[ramonli]

fn main() {
    let s1 = String::from("hello,");
    let s2 = String::from("world!");
    // 在下句中，s1的所有权被转移走了，因此后面不能再使用s1
    let s3 = s1 + &s2;
    assert_eq!(s3,"hello,world!");
    // 下面的语句如果去掉注释，就会报错
    // println!("{}",s1);
}

这里s1的所有权是被转移到了add方法的self? 理解起来有点怪。

[ramonli]

@sunface

[ramonli]

impl Add<&str> for String {
    type Output = String;

    #[inline]
    fn add(mut self, other: &str) -> String {
        self.push_str(other);
        self
    }
}

[qianxiaoming]

这个感觉确实比较奇怪，字符串+另外一个串返回一个新的串后，结果自己失效了...

[soraclub]

+两边的两个值类型是不一样的，这个感觉更奇怪

[SingleKey]

因为String::from是在堆区创建字符串，相当于是全局的，会导致修改了一个地方，其他地方也会跟着变，所以需要转移所有权，不然会出现问题

[x931890193]

我又一个不成熟的问题、前文提到过，字符串切片是非常危险的操作，因为切片的索引是通过字节来进行，但是字符串又是 UTF-8 编码，因此你无法保证索引的字节刚好落在字符的边界上, 那么操作字符串的方法中 带索引参数的是不是也很危险、

[xiaohongxiedaima]

是的

[ZYFZYF]

既然不支持索引，为什么要支持切片呢（切片的错误发生在run time，索引直接就在compile time了，也放到run time不好么，或者统一放到compile time）

[P2Tree]

有同样的疑惑，既然切片也是下标运算，也会遇到切到非字符对齐位置，切到时就报 runtime error，为什么下标索引却直接在编译期禁止了？

[iegad]

有个问题想请教一下, 如果定义一个字符串引用, 例如
let ss = "Hello world";
那么这个 值"hello world"在编译期间是会出现在栈上还是堆上, 还是和c++一样出现在储存全局数据的内存中???

[Young-Flash]

硬编码到可执行文件中，应该是在 .data 段

[791045873]

既然String是可变的，那对String的不可变引用&str是不是把原来存在堆上的数据重新copy了一份到栈上？
之后再对&str做操作就都是对一个固定大小的栈进行了？
还是说只是我们将其声明为可变或不可变，这种声明不改变其存在形式？

[fenglea]

原文中的切片数据图有指针和长度组成，所以应该是复制了数据到栈上的吧

[fenglea]

小白一个，说错的话请见谅

[thethinking]

具体的字符串数据是在堆上，而 String 和 &str 都是在栈上的一种符合结构，String包含起始指针，长度，容量。&str包含起始指针，长度。

[Libtiger]

我理解&str和String都是栈上的复合类型：
1、let s: &str = "hello";
这个时候，hello是字面量，存储在静态数据区，栈上的&str指向静态数据区；
2、let s1: String = String::from("hello");
let s2: &str = s2[0..1];
这个时候hello是在堆上创建的，栈上的String类型中的指针指向堆上的数据；切片之后栈上的&str中的指针也指向堆上的数据；

[YiuTerran]

最后一个String的联系链接404了

[huangfengya]

很奇怪啊，rust中pop的实现：```rust
pub fn pop(&mut self) -> Option {
let ch = self.chars().rev().next()?;
let newlen = self.len() - ch.len_utf8();
unsafe {
self.vec.set_len(newlen);
}
Some(ch)
}

字符串pop就能做 utf8 转义，为啥不在字符串索引的时候也做同样处理？

[crosscap]

最后一个练习的链接似乎需要从大写S改成小写s。

[Veng0923]

切片后的字符串是什么类型呢? 内存是怎么管理的, 是跟原字符串共用的一片内存吗? 因为我原先是学习C的, C里面\0表示字符串结束, 那么在这里如果共用的话, rust是字符串是有自己的逻辑来判断字符串的终止?

[qiyuewuyi2333]

无论且的是字面值还是String， 字符串切片的类型是&str， 也就是说是对字面值的借用。自身不占内存，不可修改。
rust的字符串内部实现是vec，没有\0

[Treagzhao]

String的课后作业页面Page Not Found 了

[LancelotSaki]

rust的字符串比js、java复杂太多了。

[SWZ128]

感觉主要是两个方面导致：

1. 因为要求内存安全并且性能优异，所以难免复杂
2. Rust 的 UTF-8 强制要求

[PengHuir]

insert的第一个参数是字节位置，如果字符串中是中文，会崩溃！！！
let mut s = String::from("你好世界");
s.insert(1, '不');
println!("{}", s);

insert说明
Inserts a character into this String at a byte position.
This is an O(n) operation as it requires copying every element in the buffer.
Panics
Panics if idx is larger than the String's length, or if it does not lie on a char boundary.

[qiyuewuyi2333]

fn string_add() -> () {
    let test_add = String::from("qqq123");
    let str_rht = String::from("rust");
    let test_add = test_add + str_rht.as_str();

    println!("test_add: {}", test_add);
}

请容许我借这段代码向您讲解一下，rust的mut机制。
一个变量是否允许修改，不仅要看其是否被标记为mut，还要看它是否在被释放或转移所有权之前被使用。
如上面那段代码，虽然第一个test_add不可更改，但是我们通过+运算符，也就是add函数，使得第一个test_add不再保留对String的所有权，将其转交给了第二个test_add，从而可以通过编译。
接下来我们再来看两个例子：

fn string_add() -> () {
    let test_add = String::from("qqq123");
    let str_rht = String::from("rust");
    let test_add = test_add + str_rht.as_str();
    str_rht.push_str("dsad");

    println!("test_add: {}", test_add);
}

我们新增了一个str_rht.push_str， 请你判断这个函数是否能够被成功编译？
答案是不能，因为它并没有发生所有权的转移，并且str_rht在这一句中得到了使用。这可能会有些难以理解，但如果我把这一句等效为 str_rht = str_rht + "dsad"; 是否就豁然开朗了呢。

那么根据我上面所讲述的，请你改写这一句使可以通过编译吧。

[musoulee]

刚学到这里，字符串删除方法中说truncate无返回值，我查了查文档，感觉是不是应该说返回单元类型()？

[B41dr]

"A b A b A b A b A" -> "A b A b B b B b A"

rust 大牛们能给个 replace 函数不支持索引的理由吗？这种场景真就不 care 吗？

[happyfeetw]

`fn replace_a_with_b(input: &str) -> String {
let mut count = 0;
input
.split_whitespace()
.map(|s| {
if s == "A" {
count += 1;
if count == 3 || count == 4 {
return "B";
}
}
s
})
.collect::<Vec<_>>()
.join(" ")
}

fn main() {
let input = "A b A b A b A b A";
let output = replace_a_with_b(input);
println!("{}", output); // "A b A b B b B b A"
}`

[happyfeetw]

额没有排版不好意思，大概就是自己写一个函数去遍历然后精准替换就行。
或者找找看第三方的crates里有没有这种字符串操作的工具吧。
rust内建的replace确实没有按索引替换的api。

[soraclub]

明确都是ascii字符的话，用 as_bytes_mut拿到底层byte数组，然后修改。。

[Irelia5]

初学rust，在char, str, &str, String, &String中迷惑。
如果能更精确解释名称可能更好理解，比如：

• str 是字符串切片，动态大小类型；
• &str 是字符串切片引用，是对str的不可变引用；
• String 是堆分配字符串，封装了底层的str；
• &String 是堆分配字符串的引用。

[YoungPeak]

truncate方法的解释有误，应该是从开始截取指定长度的字符串

[YoungPeak]

忽略，两种解释方式都可以。我是看源码中第二个参数名是new_len，所以产生了另外一种想法

[meifu2027]

我开始赞同 Rust 为什么反内卷了，光是一个字符串的增删改已经把大部分人劝退了。希望我能坚持下来，不要被别人卷走。

[Mesono-xian]

内容很扎实，学到了！

[bryarrow]

既然做了切片是否落在字符边界的运行时检查，为什么不干脆切片以Unicode码点为单位呢……这样也顺便支持了下标访问