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

[xianzheTM]

“ 这里因为word是s的不可变引用”这个说法不对，二者没有任何关系

[Tmem0rethinks]

关于所有权:
你有一把锤子，第一天先借给邻居甲，第二天邻居乙向你借锤子，第三天邻居家还要用来锤人，不能还，所以第二天向你借锤子自然报错，第三天邻居甲拿锤子锤完人后，锤子消失。
关于作用域，第一天先借给邻居甲邻居甲，看似锤子任务完成，实际上，没有完成，否则第一天后消失，会导致第三天邻居甲拿空气锤人，很不安全（悬空指针）。

[ddx533534]

word是s切片的不可变引用 - &s[..1]，word的作用域从2-4。
但此时又调用了s.clear()，你可以看下源码，s.clear()实际上是s.clear(&mut self)，即在3处又产生了一个可变引用
违反"某一作用域内不能同时存在可变和不可变引用"

[lincyyaran]

说的太复杂了
let mut s = String::from("hello world"); //1 => 定义了一个引用值,值的所有者属于s
let word = first_word(&s); //2 => 值被first_word函数使用了, s这个变量对应的值,只能读,不不能改写了(可变)
s.clear(); // error! //3=> 我就不信邪,我就是想改写,不好意思,就是不行,错了
println!("the first word is: {}", word); //4 => 哈哈,我还没有结束对s的改写权限, s.clear你的操真SB,到我后面去操作吧

[lincyyaran]

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

相互交错不行

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

[iegad]

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

[Young-Flash]

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

[791045873]

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

[fenglea]

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

[fenglea]

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

[thethinking]

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

[Muzych]

Mark

[Tornoto]

有一个疑问，切片的时候是按照字节去切分，那String的pop是按照字符？

[eulerianZou]

为此，Rust 的开发者想出了一个无比惊艳的办法：变量在离开作用域后，就自动释放其占用的内存

是挺惊艳的，就是费点程序员

[ryzalin]

觉得这个教程很不好的一点就是每次用到一个新的函数都不说明一下函数是做什么的。
比如dbg!这个函数，在本章第一次出现，但却连个简单的函数作用说明都没有，让人学着相当难受。

[pzhasaki]

请问 &str 执行 replace 的时候，会修改源数据吗？还是说会返回一个新的 String呢？

[GangJust]

这个其实只需要ctrl点进去看实现就行了，第一行就new了一个

pub fn replace<'a, P: Pattern<'a>>(&'a self, from: P, to: &str) -> String {
        let mut result = String::new();
        //...
        result
}

[mouxue23]

练习题似乎打不开了

[Skyfacon]

感觉字符串的使用这一块坑很大啊，实际使用中会遇到很多相关的问题

[Skyfacon]

其实更感兴趣的是rust对于json字符串以及rust原生对象的转换（支持）

[TianChen-Yu]

是不是在已经知道要用String的场合，对&str用into会更简单？

struct S(String);
fn main() {
    let s = S("hello string!".into());
    println!("s: S({:?})", s.0);
}

这个"XXX".into就比"XXX".to_string和String::from("XXX")简洁🤔

[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] 没有任何意义，因为你取不到 中 这个字符，而是取到了这个字符三个字节中的第一个字节，这是一个非常奇怪而且难以理解的返回值。