Rust字符串深度解析String与str的问题小结

// String - 可变的、拥有所有权的
let mut s: String = String::from("hello");
// &str - 不可变的引用
let slice: &str = "world";

// 1. 使用new()创建空字符串
let mut s1 = String::new();
// 2. 从字符串字面值创建
let s2 = "hello".to_string();
let s3 = String::from("world");
// 3. 从其他类型转换
let s4 = format!("{} {}", s2, s3); // 使用format!宏

let mut s = String::from("hello");
// 附加字符串
s.push_str(" world"); // "hello world"
// 附加单个字符
s.push('!'); // "hello world!"
// 连接字符串（消耗第一个String）
let s1 = String::from("hello");
let s2 = String::from("world");
let s3 = s1 + &s2; // s1被移动，s2被借用

let mut s = String::with_capacity(10); // 预分配容量
s.push_str("hello");
s.push_str(" world");

let s = "hello"; // 字符串字面值，类型是&str
let slice: &str = &s[0..2]; // 字符串切片

fn print_text(text: &str) {
    println!("Text: {}", text);
}
fn main() {
    let s = String::from("hello");
    // String自动转换为&str
    print_text(s); // 等同于 print_text(&s)
    // 也可以显式转换
    print_text(&s);
    // 字符串字面值也自动转换为&str
    print_text("world");
}

// String实现了Deref<Target = str>
impl Deref for String {
    type Target = str;
    fn deref(&self) -> &str {
        &self[..]
    }
}

// 函数接受&str，可以接受多种输入
fn process(text: &str) {
    println!("Processing: {}", text);
}
fn main() {
    let s1 = String::from("hello");
    let s2 = "world";
    // String自动转换为&str
    process(s1);
    // &str直接传递
    process(s2);
    // &String也转换为&str
    let s3 = String::from("rust");
    process(&s3);
}

fn takes_ownership(s: String) {
    // 这里不会自动转换，必须传递String
}
fn main() {
    let s = String::from("hello");
    takes_ownership(s); // 必须传递String
    // s在这里已移动，不能再使用
}

let s: &str = "hello world"; // 类型推导

// 错误：不允许通过索引访问
let s = String::from("hello");
let c = s[0]; // 编译错误！

// 正确的方式：使用chars()方法
for c in "hello".chars() {
    println!("{}", c);
}

let s = String::from("Привет"); // 俄语
println!("Length in bytes: {}", s.len()); // 12字节
println!("Character count: {}", s.chars().count()); // 6个字符

let s = String::from("hello world");
// 正确的切片方式
let hello = &s[0..5]; // "hello"
let world = &s[6..11]; // "world"
// 等效语法
let hello = &s[..5];   // 从开始到索引5
let world = &s[6..];   // 从索引6到结束
let full = &s[..];     // 整个字符串

let s = String::from("Привет");
// 错误：切在字符中间
let invalid = &s[0..1]; // 编译错误！
// 正确：切在字符边界
let valid = &s[0..2]; // "Пр"

let s = String::from("hello");
// 遍历Unicode标量值（字符）
for c in s.chars() {
    println!("{}", c);
}
// 输出：h e l l o

let s = String::from("hello");

// 遍历原始字节
for b in s.bytes() {
    println!("{}", b);
}

// 输出：104 101 108 108 111

// 推荐：接受&str，支持多种输入类型
fn process_text(text: &str) {
    println!("Processing: {}", text);
}
// 不推荐：只接受String，限制较大
fn process_text_limited(text: String) {
    println!("Processing: {}", text);
}

// 使用+操作符（消耗第一个String）
let s1 = String::from("hello");
let s2 = String::from("world");
let s3 = s1 + " " + &s2;
// 使用format!宏（更灵活）
let s = format!("{} {}", s1, s2); // s1和s2仍然可用

// 不推荐：不必要的String创建
let s = String::from("hello");
// 推荐：直接使用&str
let text: &str = "hello";

fn main() {
    let s1 = String::from("hello");
    let s2 = String::from("world");
    // 使用+操作符连接
    let result1 = s1 + &s2;
    // 使用format!宏连接
    let result2 = format!("{} {}", s1, s2);
    // 比较两种方法的区别
}

fn main() {
    let s = String::from("Привет");
    // 尝试不同的切片方式
    let slice1 = &s[0..2];
    let slice2 = &s[0..3];
    // 观察编译结果
}

fn main() {
    let s = String::from("hello 你好");
    // 使用chars()遍历
    for c in s.chars() {
        println!("{}", c);
    }
    // 使用bytes()遍历
    for b in s.bytes() {
        println!("{}", b);
    }
}