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是怎么知道的

[lincyyaran]

感觉规范就是
变量A开始
变量B开始
todo...
变量B结束
变量A结束

相互交错不行

[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），从而在编译时产生错误。

[Nanbert]

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

[thethinking]

代码中的 let mut result=result+"!"; 一句，必须使用 mut 的原因是后面要修改该变量，即： result+="!!!" ，如果没有后面的修改，可以去除 mut ，因为这里遮蔽了原变量 result ，尽管原变量 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是不同变量

[SifungLei]

少了一个“节“：
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 编码方式

[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]

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

[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包含起始指针，长度。

[lilhammer111]

fn main() {
    let mut s = String::from("hello world");

    let word = first_word(&s);

    s.clear(); // error!

    println!("the first word is: {}", word);
}
fn first_word(s: &String) -> &str {
    &s[..1]
}

这段代码看似简单实则不简单，这里面蕴含了两个值得思考的地方：

1. 哪些类型可以被切片？
   在first_word函数中，上述代码使用了&s[..1]的取切片的操作，那我们就要确保变量s是一个可被取切片的类型，而决定一个类型是否可被取切片，本质是看这个类型是否实现了这两个Trait，即std::ops::Index和std::ops::IndexMut，在Rust标准库中就有两个常见的类型实现了这两个Trait，一是&str字符串切片类型，二是&[T]数组类型，因此我们传入first_word的参数就必须得是上述的一种情况，这里的本意应该是想传入一个&str字符串类型，但实际上却传的是&String类型。这就引发了第二个问题。
2. 为什么传&String也能成功地取到切片呢?
   这涉及到了Rust的另一个机制，自动解引用Autoderef，什么是自动解引用？以函数调用为例，当我们调用一个函数并为这个函数传递传参时（如果这个函数有参数），就要求咱们传入的参数类型必须和函数定义的参数类型一致，Rust编译器会在这里进行类型是否匹配的检查，当然，类型检查无处不在，但Rust具体是如何去做的呢？
   假如某个类型的引用不直接和参数要求的类型匹配，Rust就会检查传入的类型在经过自动解引用后是否能和参数类型匹配上，也即，传入的类型是否实现了Deref Trait，比如说某个类型T对于Deref Trait的具体实现就是将类型T转成U类型，那这个时候自动解引用机制就能把&T类型的函数入参转成&U类型，而函数如果要的就是&U类型，那类型就匹配上了。
   当前例子就是这种场景，在对s这个入参进行取切片的操作时，就需要变量s是可以取切片的类型，即s的类型得是第一个问题中提及的实现了std::ops::IndexTrait的类型，我们才可以进行取切片的操作，否则就会报类型不匹配。这里的s是&String类型，但是因为自动解引用机制，Rust编译器会“尽一切努力”去为s解引用出一个能够取切片的类型，而比较美好的一件事就是，String类型确实实现了Deref Trait，并且他对这个Trait的实现恰恰就是从&String转成&str，因此，在这里一个&String类型的变量s成功地取了切片&s[..1]。

[Wan-Yifei]

及时雨，我是回头研究fn say_hello(s: &str)时发现直接传入&s的类型是&String而不是&str，很费解为啥可以运行。原来还有Autoderef的机制。

[koalahl]

👍，刚好看到这里，顺便贴一下源码里的实现：

#[stable(feature = "rust1", since = "1.0.0")]
impl ops::Deref for String {
    type Target = str;

    #[inline]
    fn deref(&self) -> &str {
        unsafe { str::from_utf8_unchecked(&self.vec) }
    }
}

[AndySpf]

这里还有一个问题，如果把first_word中返回值改掉：

fn first_word(s: &String) -> &str {
    "1"
}

依然编译失败

[koalahl]

插入方法这里不严谨：根据源码定义，insert方法的index是指字节位置，不是字符位置。字符表示的是’中‘， ’国‘，’人‘ （🇨🇳emoji占用两个字符，打不出来😂）

pub fn insert(&mut self, idx: usize, ch: char)
Inserts a character into this String at a byte position.

示例代码：

let mut s2 = String::from("中国人🇨🇳");
s2.insert(3, 'c');
println!("s2: {}", s2);

//打印结果：
s2: 中c国人🇨🇳

[koalahl]

“可以考虑尝试下这个库：utf8_slice。”
————
！！！一定要用这个库，不然搞死人。 官方居然不提供这样的方法，非要去精细到byte，累的还是程序员。

[koalahl]

作为一个iOS开发，跟swift对比着看文章。虽然很多相似的概念，但就字符串这一节看下来，swift真的是太友好了，容易入门多了。

[LoserJL]

这设计的怎么那么矛盾呢，字符串不能索引，但是操作字符串的方法又需要传递索引参数，设计者估计都不知道怎么会这样吧

[fredlifeup]

Mark:
let hello = String::from("中国人");

如果问你该字符串多长，你可能会说 3，但是实际上是 9 个字节的长度，因为大部分常用汉字在 UTF-8 中的长度是 3 个字节，因此这种情况下对 hello 进行索引，访问 &hello[0] 没有任何意义，因为你取不到 中 这个字符，而是取到了这个字符三个字节中的第一个字节，这是一个非常奇怪而且难以理解的返回值。

[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复杂太多了。

[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无返回值，我查了查文档，感觉是不是应该说返回单元类型()？