Rust - 字符串

  • 简述

    Rust 中的 String 数据类型可以分为以下几类 -
    • 字符串字面量(&str)
    • 字符串对象(String)
  • 字符串字面量

    当字符串的值在编译时已知时使用字符串文字 (&str)。字符串文字是一组字符,它们被硬编码到一个变量中。例如,let company="CAINIAOYA"。字符串文字可在模块 std::str 中找到。字符串文字也称为字符串切片。
    以下示例声明了两个字符串文字 - companylocation
    
    fn main() {
       let company:&str="Jc2182Point";
       let location:&str = "Hyderabad";
       println!("company is : {} location :{}",company,location);
    }
    
    默认情况下,字符串文字是静态的。这意味着字符串文字保证在整个程序的持续时间内有效。我们还可以明确地将变量指定为静态变量,如下所示 -
    
    fn main() {
       let company:&'static str = "Jc2182Point";
       let location:&'static str = "Hyderabad";
       println!("company is : {} location :{}",company,location);
    }
    
    上述程序将生成以下输出 -
    
    company is : Jc2182Point location :Hyderabad
    
  • 字符串对象

    标准库中提供了 String 对象类型。与字符串字面量不同,字符串对象类型不是核心语言的一部分。它在标准库pub struct String 中被定义为公共结构。String 是一个可增长的集合。它是可变的 UTF-8 编码类型。这String对象类型可用于表示在运行时提供的字符串值。String 对象在堆中分配。

    句法

    要创建一个 String 对象,我们可以使用以下任何一种语法 -
    
    String::new()
    
    上面的语法创建了一个空字符串
    
    String::from()
    
    这将创建一个字符串,其中一些默认值作为参数传递给 from() 方法。
    以下示例说明了 String 对象的使用。
    
    fn main(){
       let empty_string = String::new();
       println!("length is {}",empty_string.len());
       let content_string = String::from("Jc2182Point");
       println!("length is {}",content_string.len());
    }
    
    上面的例子创建了两个字符串——一个使用new方法的空字符串对象和一个使用from方法从字符串文字中创建的字符串对象。
    输出如下所示 -
    
    length is 0
    length is 14
    

    常用方法——字符串对象

    序号 方法 签名 描述
    1 new() pub const fn new() → String 创建一个新的空字符串。
    2 to_string() fn to_string(&self) → String 将给定值转换为字符串。
    3 replace() pub fn replace<'a, P>(&'a self, from: P, to: &str) → String 将一个模式的所有匹配替换为另一个字符串。
    4 as_str() pub fn as_str(&self) → &str 提取包含整个字符串的字符串片。
    5 push() pub fn push(&mut self, ch: char) 将给定字符追加到该字符串的末尾。
    6 push_str() pub fn push_str(&mut self, string: &str) 将给定的字符串切片追加到该字符串的末尾。
    7 len() pub fn len(&self) → usize 返回此字符串的长度,以字节为单位。
    8 trim() pub fn trim(&self) → &str 返回删除前导和尾随空格的字符串切片。
    9 split_whitespace() pub fn split_whitespace(&self) → SplitWhitespace 用空格分割字符串切片并返回一个迭代器。
    10 split() pub fn split<'a, P>(&'a self, pat: P) → Split<'a, P> 其中P是模式,可以是&str, char,或决定拆分的闭包。返回此字符串切片的子串上的迭代器,子串由模式匹配的字符分隔。
    11 chars() pub fn chars(&self) → Chars 返回string切片的char类型的迭代器。
  • Illustration:new()

    使用以下命令创建一个空字符串对象 new()方法及其值设置为hello
    
    fn main(){
       let mut z = String::new();
       z.push_str("hello");
       println!("{}",z);
    }
    

    输出

    上述程序生成以下输出 -
    
    hello
    
  • Illustration:to_string()

    要访问 String 对象的所有方法,请使用 to_string() 功能。
    
    fn main(){
       let name1 = "Hello Jc2182Point , 
       Hello!".to_string();
       println!("{}",name1);
    }
    

    输出

    上述程序生成以下输出 -
    
    Hello Jc2182Point , Hello!
    
  • Illustration:replace()

    replace()函数采用两个参数 - 第一个参数是要搜索的字符串模式,第二个参数是要替换的新值。在上面的例子中,Helloname1字符串中出现了两次。
    replace 函数替换所有出现的字符串 HelloHowdy.
    
    fn main(){
       let name1 = "Hello Jc2182Point , 
       Hello!".to_string();         //String object
       let name2 = name1.replace("Hello","Howdy");    //find and replace
       println!("{}",name2);
    }
    

    输出

    上述程序生成以下输出 -
    
    Howdy Jc2182Point , Howdy!
    
  • Illustration:as_str()

    as_str() 函数提取包含整个字符串的字符串切片。
    
    fn main() {
       let example_string = String::from("example_string");
       print_literal(example_string.as_str());
    }
    fn print_literal(data:&str ){
       println!("displaying string literal {}",data);
    }
    

    输出

    上述程序生成以下输出 -
    
    displaying string literal example_string
    
  • Illustration:push()

    push() 函数将给定的字符附加到此字符串的末尾。
    
    fn main(){
       let mut company = "Tutorial".to_string();
       company.push('s');
       println!("{}",company);
    }
    

    输出

    上述程序生成以下输出 -
    
    Jc2182
    
  • Illustration:push_str()

    push_str() 函数将给定的字符串切片附加到字符串的末尾。
    
    fn main(){
       let mut company = "Jc2182".to_string();
       company.push_str(" Point");
       println!("{}",company);
    }
    

    输出

    上述程序生成以下输出 -
    
    CAINIAOYA
    
  • Illustration:len ()

    len() 函数返回字符串中的总字符数(包括空格)。
    
    fn main() {
       let fullname = " CAINIAOYA";
       println!("length is {}",fullname.len());
    }
    

    输出

    上述程序生成以下输出 -
    
    length is 20
    
  • Illustration:trim()

    trim() 函数删除字符串中的前导和尾随空格。请注意,此函数不会删除内联空格。
    
    fn main() {
       let fullname = " CAINIAOYA \r\n";
       println!("Before trim ");
       println!("length is {}",fullname.len());
       println!();
       println!("After trim ");
       println!("length is {}",fullname.trim().len());
    }
    

    输出

    上述程序生成以下输出 -
    
    Before trim
    length is 24
    After trim
    length is 15
    
  • Illustration:split_whitespace()

    split_whitespace()将输入字符串拆分为不同的字符串。它返回一个迭代器,因此我们正在迭代令牌,如下所示 -
    
    fn main(){
       let msg = "CAINIAOYA has good t
       utorials".to_string();
       let mut i = 1;
       
       for token in msg.split_whitespace(){
          println!("token {} {}",i,token);
          i+=1;
       }
    }
    

    输出

    
    token 1 Jc2182
    token 2 Point
    token 3 has
    token 4 good
    token 5 tutorials
    
  • Illustration:split() 字符串

    split() string方法在字符串切片的子字符串上返回一个迭代器,由模式匹配的字符分隔。split() 方法的局限性在于无法存储结果以备后用。这collect 方法可用于将 split() 返回的结果存储为向量。
    
    fn main() {
       let fullname = "Kannan,Sudhakaran,Jc2182point";
       for token in fullname.split(","){
          println!("token is {}",token);
       }
       //store in a Vector
       println!("\n");
       let tokens:Vec<&str>= fullname.split(",").collect();
       println!("firstName is {}",tokens[0]);
       println!("lastname is {}",tokens[1]);
       println!("company is {}",tokens[2]);
    }
    
    上面的例子分割字符串 fullname, 每当遇到逗号时 (,).

    输出

    
    token is Kannan
    token is Sudhakaran
    token is Jc2182point
    firstName is Kannan
    lastname is Sudhakaran
    company is Jc2182point
    
  • Illustration:chars()

    可以使用 chars 方法访问字符串中的单个字符。让我们考虑一个例子来理解这一点。
    
    fn main(){
       let n1 = "Jc2182".to_string();
       for n in n1.chars(){
          println!("{}",n);
       }
    }
    

    输出

    
    J
    c
    2
    1
    8
    2
    
  • 使用 + 运算符连接字符串

    字符串值可以附加到另一个字符串。这称为串联或插值。字符串连接的结果是一个新的字符串对象。+ 运算符在内部使用add方法。add 函数的语法有两个参数。第一个参数是self——字符串对象本身,第二个参数是第二个字符串对象的引用。这如下所示 -
    
    //add function
    add(self,&str)->String { 
       // returns a String object
    }
    

    Illustration:字符串连接

    
    fn main(){
       let n1 = "Jc2182".to_string();
       let n2 = "Point".to_string();
       let n3 = n1 + &n2 // n2 reference is passed
       println!("{}",n3);
    }
    
    输出将如下所示
    
    Jc2182Point
    
  • Illustration:类型转换

    以下示例说明将数字转换为字符串对象 -
    
    fn main(){
       let number = 2020;
       let number_as_string = number.to_string(); 
       
       // convert number to string
       println!("{}",number_as_string);
       println!("{}",number_as_string=="2020");
    }
    
    输出将如下所示
    
    2020
    true
    
  • Illustration:格式!宏

    另一种将 String 对象添加到一起的方法是使用名为 format 的宏函数。格式的使用!如下图所示。
    
    fn main(){
       let n1 = "Jc2182".to_string();
       let n2 = "Point".to_string();
       let n3 = format!("{} {}",n1,n2);
       println!("{}",n3);
    }
    
    输出将如下所示
    
    CAINIAOYA