rust语言学习笔记Trait之 AsRef 和 AsMut（引用转换）

1、AsRef 不可变引用

pub trait AsRef<T> {
    fn as_ref(&self) -> &T;
}

• String 实现了 AsRef<str>，所以你可以把 String 当作 &str 用
• Vec<T> 实现了 AsRef<[T]>，让你能用切片接口操作向量
• PathBuf 实现了 AsRef<Path>，统一了路径操作

（1）转为：&str，函数可接收： String 、 &str

fn str_test_fn<S: AsRef<str>>(s: S) {
    println!("{}", s.as_ref());
}

fn main() {
    str_test_fn("&str 字符串");
    str_test_fn(String::from("String 字符串"));
}

（2）转为：&[T]，函数可接收： Vec、切片、数组

fn vec_test_fn<V: AsRef<[i32]>>(v: V) {
    println!("{:?}", v.as_ref());
}
fn main() {
    vec_test_fn(vec![1, 2, 3]);   // Vec
    vec_test_fn(&[5, 6, 7]);      // 切片
    vec_test_fn([10, 11, 12]);    // 数组
}

（3）转为：&[u8]，函数可接收：String 、&str、Vec<u8>、&[u8]、[u8;n]

fn bytes_test_fn<T: AsRef<[u8]>>(data: T) {
    let bytes = data.as_ref();
    println!("{:?}", bytes);
}

fn main() { // 可以接受多种类型
    let s = String::from("String 字符串");     // String
    let s2 = "&str 字符串";                    // &str
    let v: Vec<u8> = vec![1, 2, 3];           // Vec<u8>
    let arr: &[u8] = &[4, 5, 6];              // &[u8]
    let arr2: [u8; 3] = [7, 8, 9];            // u8数组
}

（4）转为： &Path，函数可接收：PathBuf、String、&str、&Path

use std::path::{Path, PathBuf};

fn path_test_fn<P: AsRef<Path> + 'static>(p: P) {
    let path = p.as_ref();
    println!("{}", path.display());
}

fn main() {
    // PathBuf
    let p1 = PathBuf::from("/tmp/test1");
    path_test_fn(p1);

    // String
    path_test_fn(String::from("/tmp/test2"));

    // &str
    path_test_fn("/tmp/test3");

    // &Path
    let p2 = Path::new("/tmp/test4");
    path_test_fn(p2);
}

2、AsMut 可变引用

pub trait AsMut<T> {
    fn as_mut(&mut self) -> &mut T;
}

• String 实现了 AsMut<str>
• Vec<T> 实现了 AsMut<[T]>
• Box<T> 实现了 AsMut<T>

（1）转为：&mut str，函数可接收：&mut str、String、Box<str>

fn str_test_fn<S: AsMut<str>>(mut s: S) {
    let str = s.as_mut();
    println!("{}", str);
}

fn main() {
    str_test_fn(String::from("String 字符串"));    // String
    str_test_fn(Box::from("Box<str>"));           // Box<str>
}

（2）转为：&mut [T]，函数可接收：Vec<T>、[T;N]

fn mut_t_test_fn<T: AsMut<[i32]>>(mut data: T) {
    let d = data.as_mut();              // 获取 &mut [i32] 可变引用
    for da in d.iter_mut() {            // 遍历
        *da += 2;                       // 修改每一项的值
    }
    println!("{:?}", d);
}

fn main() { 
    let v: Vec<i32> = vec![1, 2, 3];               // Vec<i32>
    let arr: [i32; 3] = [7, 8, 9];                 // i32数组
    let bx: Box<[i32]> = Box::from([33, 34, 5]);   //Box<[i32]>
}