Rust字符串 - 芒果文档

📌 相关文章

📜 Rust字符串

📅 最后修改于: 2021-01-08 13:49:32 🧑 作者: Mango

串

Rust包含两种类型的字符串： ＆str和String 。

串：

字符串被编码为UTF-8序列。
在堆内存上分配了一个字符串。
字符串的大小可以增长。
它不是一个以零结尾的序列。

＆str

'＆str'也称为字符串切片。
它用＆[u8]表示以指向UTP-8序列。
'＆str'用于查看字符串存在的数据。
它的大小是固定的，即无法调整大小。

黑白相差'String'和'＆str'。

字符串是可变的引用，而＆str是对字符串的不可变的引用，即，我们可以更改String的数据，但是＆str的数据无法操作。
字符串包含其数据的所有权，而＆str没有所有权，它从另一个变量借用它。

创建一个新的字符串

创建字符串的方式与创建矢量类似。让我们来看一下：

创建一个空字符串：

Let mut s = String::new();

在上面的声明中，String是使用new()函数创建的。现在，如果要在声明时初始化String，则可以使用to_string()方法来实现。

在数据上实现to_string()方法：

let a = "javaTpoint";
let s = a.to_string();

我们还可以直接在字符串字面量上实现to_string方法：

let s = "javaTpoint".to_string();

让我们通过一个例子来理解这一点：

 fn main()
{
  let data="javaTpoint";
  let s=data.to_string();
  print!("{} ",s);
  let str="tutorial".to_string();
  print!("{}",str);
}

输出：

javaTpoint tutorial

创建String的第二种方法是使用String :: from函数，这等效于String :: new()函数。

让我们通过一个简单的例子来理解这一点：

fn main()
    {
          let str = String::from("javaTpoint tutorial");
          print!("{}",str);
    }

输出：

javaTpoint tutorial

更新字符串

我们可以通过将更多数据推入String来更改String的大小和String的内容。我们还可以使用格式宏的“ +”运算符！连接字符串值。

用push_str和push附加到字符串

push_str()：我们可以使用push_str()函数来增大String的大小。它将内容附加在字符串的末尾。假设s1和s2是两个字符串，我们想将字符串s2附加到字符串s1上。

s1.push_str(s2);

让我们通过一个简单的例子来理解这一点：

fn main()
{
  let mut s=String::from("java is a");
  s.push_str(" programming language");
  print!("{}",s);
}

输出：

java is a programming language

push_str()函数不获取参数的所有权。让我们通过一个简单的例子来了解这种情况。

fn main()
{
  let mut s1 = String::from("Hello");
  let s2 = "World";
  s1.push_str(s2);
  print!("{}",s2);
}

输出：

World

如果push_str()函数拥有参数的所有权，则程序的最后一行将不起作用，并且s2的值将不会被打印。

push()： push()函数用于在字符串末尾添加单个字符。假设字符串是s1，而字符ch将添加到字符串s1的末尾。

s1.push(ch);

让我们看一个简单的例子：

fn main()
{
  let mut s = String::from("java");
  s.push('c');
  print!("{}",s);
}

输出：

javac

与“ +”运算符或格式宏串联

'+'运算符： '+'运算符用于连接两个字符串。让我们看看：

let s1 = String::from("javaTpoint ");
let s2 = String::from("tutorial!!");
let s3 = s1+&s2;

让我们看一个简单的例子：

  fn main()
{
 let s1 = String::from("javaTpoint");
 let s2 = String::from(" tutorial!!");
 let s3 = s1+&s2; 
 print!("{}",s3);
}

输出：

javaTpoint tutorial!!

在上面的示例中，s3包含两个字符串的串联结果，即javaTpoint教程。 's1'不再有效，我们根据使用'+'运算符时所调用方法的签名使用s2的引用，即＆s2。 “ +”运算符调用add()方法，其声明如下：

fn add(self,s:&str)->String
{
 }

首先，s2具有“＆”运算符意味着我们要添加对s1的引用。根据add()函数的签名，我们可以将＆str添加到String中，并且不能将两个字符串值加在一起。但是根据add()方法中指定的第二个参数，s2的类型是＆String而不是＆str。但是仍然可以在add方法中使用s2，因为编译器会将＆string强制转换为＆str。因此，可以说，当我们调用add()方法时，Rust使用了deref强制。

其次，add()函数的第一个参数是self，而add()获取self的所有权。这意味着在语句let s3 = s1 +＆s2;之后s1不再有效。

格式！巨集
- 当我们要连接多个字符串，在这种情况下，使用'+'运算符变得非常笨拙。要连接多个字符串，首选使用format宏。
- 格式宏的功能与println相似！宏。格式宏和println之间的区别！巨集是指巨集格式不会在萤幕上显示，它会传回字符串的内容。

让我们通过一个简单的例子来理解这一点：

fn main()
{
 let s1 = String::from("C");
 let s2 = String::from("is");
 let s3 = String::from("a");
 let s4 = String::from("programming");
 let s5 = String::from("language.");
 let s = format!("{} {} {} {} {}",s1,s2,s3,s4,s5);
 print!("{}",s);
}

输出：

      C is a programming language.

索引成字符串

字符串以UTF-8序列编码。因此，无法为字符串索引。让我们通过一个例子来理解这个概念：

fn main() 
{
    let s = String::from("javaTpoint");
    print!("{}",s[1]);
}

输出：

error[E0277]: the trait bound `std::string::String: std::ops::Index<{integer}>` is not satisfied
 --> jdoodle.rs:4:17
  |
4 |     print!("{}",s[1]);
  |                 ^^^^ the type `std::string::String` cannot be indexed by `{integer}`
  |
  = help: the trait `std::ops::Index<{integer}>` is not implemented for `std::string::String`

error: aborting due to previous error

通过索引访问非常快。但是，该字符串以UTF-8序列编码，该序列可以具有多个字节，并且找到字符串的第n个字符将证明是昂贵的操作。

切片字符串

字符串未提供索引，因为不知道索引操作的返回类型应该具有字节值，字符还是字符串切片。 Rust通过提供[]内的范围而不是单个数字，为索引字符串提供了一种更具体的方法。

我们看看吧：

let s = "Hello World";
let a = &s[1..4];

在上述情况下，s包含字符串字面量，即Hello World。我们指定[1..4]索引意味着我们正在从索引为1到3的字符串s中获取子字符串。

fn main() {
    
    let s = "Hello World";
    let a = &s[1..4];
    print!("{}",a);
}

输出：

ell

遍历字符串的方法

我们还可以通过其他方式访问字符串。我们可以使用chars()方法遍历字符串的每个元素。

让我们看一个简单的例子：

fn main() 
{
    let s = "C is a programming language";
    for i in s.chars()
    {
      print!("{}",i);
    }
}

输出：

C is a programming language