Rust字符串

Rust中的String数据类型可以分为以下两种：

• 字符串常量(＆str)

• 字符串对象(String)

字符串常量（String Literal）

字符串常量（&str）是在编译时已知的一个字符串值，字符串常量也叫字符串切片。

字符串常量是被硬编码到一个变量中的一组字符，例如company =“ Newbie Go”。

下面的示例声明两个字符串常量： company 和 location 。

fn main() {
    let company:&str="newbiego";
    let location:&str = "Hyderabad";
    println!("company is : {} location :{}",company,location);
}

字符串默认是静态的，即字符串常量保证在整个程序中都是有效的，我们也可以明确指定变量为静态的，如下图所示：

fn main() {
    let company:&'static str = "newbiego";
    let location:&'static str = "Hyderabad";
    println!("company is : {} location :{}",company,location);
}

上面的程序将产生以下输出：

company is : newbiego location :Hyderabad

字符串对象（String Object）

标准库中提供了字符串对象类型，与字符串常量不同，字符串对象类型不是语言内核的一部分，在标准库中被定义为公共结构 pub struct String 。

字符串对象是可增长的集合，它是可变长的，并且是UTF-8编码的类型。

字符串对象类型可用于表示运行时提供的字符串值，字符串对象在堆中分配。

语法

要创建一个字符串对象，我们可以使用以下任何一种语法：

String::new()

上面的语法创建一个空字符串

String::from()

这会创建一个带有一些默认值的字符串，该默认值将作为参数传递给from()方法。

以下示例说明了字符串对象的用法。

fn main(){
    let empty_string = String::new();
    println!("length is {}",empty_string.len());

    let content_string = String::from("newbiego");
    println!("length is {}",content_string.len());
}

上面的示例创建了两个字符串：使用new方法和使用from方法创建的字符串对象。

输出如下：

length is 0
length is 14

字符串对象的常用方法

例子：new()

使用创建空字符串对象new()方法，其值设置为 hello .

fn main(){
    let mut z = String::new();
    z.push_str("hello");
    println!("{}",z);
}

上面的程序产生以下输出：

hello

例子：to_string()

要访问String对象的所有方法，请使用to_string()功能。

fn main(){
    let name1 = "Hello newbiego ,
    Hello!".to_string();
    println!("{}",name1);
}

上面的程序产生以下输出：

Hello newbiego , Hello!

例子：replace()

replace()函数有两个参数：第一个参数是要搜索的字符串模式，第二个参数是要替换的新值。在上面的示例中， Hello 出现两次 name1 string.

replace函数替换所有出现的字符串Hello为Howdy.

fn main(){
    let name1 = "Hello newbiego ,
    Hello!".to_string();         //字符串对象
    let name2 = name1.replace("Hello","Howdy");    // 查找和替换
    println!("{}",name2);
}

上面的程序产生以下输出：

Howdy newbiego , Howdy!

例子：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

例子：push()

push()函数将给定的char附加到此String的末尾。

fn main(){
    let mut company = "Tutorial".to_string();
    company.push('s');
    println!("{}",company);
}

上面的程序产生以下输出：

Tutorials

例子：push_str()

push_str()函数将给定的字符串切片附加到String的末尾。

fn main(){
    let mut company = "Tutorials".to_string();
    company.push_str(" Point");
    println!("{}",company);
}

上面的程序产生以下输出：

Newbie Go

例子：len()

len()函数返回字符串中的字符总数(包括空格)。

fn main() {
    let fullname = " Newbie Go";
    println!("length is {}",fullname.len());
}

上面的程序产生以下输出：

length is 20

例子：trim()

trim()函数删除字符串中的前导和尾随空格。注意此功能不会删除行内空格。

fn main() {
    let fullname = " Newbie Go \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

例子：split_whitespace()

split_whitespace()将输入字符串拆分为不同的字符串。它返回一个迭代器，因此我们要遍历令牌，如下所示：

fn main(){
    let msg = "Newbie Go has good t
    utorials".to_string();
    let mut i = 1;
   
    for token in msg.split_whitespace(){
        println!("token {} {}",i,token);
        i+=1;
    }
}

token 1 Tutorials
token 2 Point
token 3 has
token 4 good
token 5 tutorials

例子：split()字符串

split()字符串方法在字符串切片的子字符串上返回迭代器，该迭代器由模式匹配的字符分隔。 split()方法的局限性在于无法存储结果供以后使用。这collect方法可用于将split()返回的结果存储为向量。

fn main() {
    let fullname = "Kannan,Sudhakaran,newbiego";

    for token in fullname.split(","){
        println!("token is {}",token);
    }

    //存储在一个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 newbiego

firstName is Kannan
lastname is Sudhakaran
company is newbiego

例子：chars()

可以使用chars方法访问字符串中的各个字符。让我们考虑一个例子来理解这一点。

fn main(){
    let n1 = "Tutorials".to_string();

    for n in n1.chars(){
        println!("{}",n);
    }
}

T
u
t
o
r
i
a
l
s

用+运算符连接字符串

可以将一个字符串值附加到另一个字符串。这称为串联或插值。字符串串联的结果是一个新的字符串对象。 +运算符在内部使用 add 方法。 add函数的语法带有两个参数。第一个参数是 self –字符串对象本身，第二个参数是第二个字符串对象的引用。如下图所示：

//添加功能
add(self,&str)->String { 
    //返回一个String对象
}

例子：字符串连接

fn main(){
    let n1 = "Tutorials".to_string();
    let n2 = "Point".to_string();

    let n3 = n1 + &n2; //传递n2引用
    println!("{}",n3);
}

输出如下

newbiego

例子：类型转换

以下示例说明了将数字转换为字符串对象的方法：

fn main(){
    let number = 2020;
    let number_as_string = number.to_string();
   
    //将数字转换为字符串
    println!("{}",number_as_string);
    println!("{}",number_as_string=="2020");
}

输出如下

2020
true

例子：format!宏

一起添加到String对象的另一种方法是使用称为format的宏函数，使用格式！如下图所示。

fn main(){
    let n1 = "Tutorials".to_string();
    let n2 = "Point".to_string();
    let n3 = format!("{} {}",n1,n2);
    println!("{}",n3);
}

输出如下

Newbie Go