Rust小技巧 - 让函数既可接受String或&str，也可以返回String或&str

七元权

已于 2022-05-12 09:55:01 修改

阅读量2.3k

点赞数 1

分类专栏： rust小技巧文章标签： rust 开发语言后端 Into Cow

于 2022-05-04 19:22:19 首次发布

本文链接：https://blog.csdn.net/zjupeco/article/details/124421804

版权

rust小技巧专栏收录该内容

3 篇文章 0 订阅

订阅专栏

文章目录

1 场景说明

假设我们有一个函数foo，它既要允许&str也要允许String作为输入参数。或是既要允许&str也要允许String作为输出。&str和String之间的转换，我们不希望让调用方来操心。这在开发过程中，是经常遇到的需求。

涉及到的知识点：Into，Cow。

2 解决方案

2.1 允许不同的输入参数

我们先来让函数接受不同的输入参数，不同的输入参数可以通过给输入参数绑定Into这个trait来实现。输入参数有这个trait，就可以通过.into()方法来将输入参数转化为需要的类型。

str已经实现了Into这个trait，我们可以直接使用。如果是自己定义的类型，则需要自己实现Into。一般自己实现Into会优先实现From这个trait，有了这个trait，Into就自动实现了，这个是完全免费的。

struct MyStr{
    s: String
}

impl From<MyStr> for String{
    fn from(s: MyStr)-> Self{
        s.s
    }
}

fn foo<T: Into<String>>(s: T) -> String{
    s.into()
    // 可以在这里做些操作
}


fn main() {
    let s = "abds";
    let foo_s = foo(s);
    assert_eq!(String::from("abds"), foo_s);
    
    let s = MyStr{
        s: String::from("jojsd")
    };
    let foo_s = foo(s);
    assert_eq!(String::from("jojsd"), foo_s);
}

2.2 允许不同的输出参数

如果我们希望函数返回不同的参数，可以用Cow，这是一个枚举类型，本质是一个智能指针。

pub enum Cow<'a, B> 
where
    B: 'a + ToOwned + ?Sized, 
 {
    Borrowed(&'a B),
    Owned(<B as ToOwned>::Owned),
}

ToOwned表示这个泛型B可以从借用变成拥有所有权，比如&str是借用，没有所有权的，通过to_owned()方法，可以变成String，就有所有权了。?Sized表示这个类型的size是不确定的，比如String的长度是可变的。

use std::borrow::Cow;

fn foo<'a>(s: &'a str) -> Cow<'a, str>{
    if s.len() > 5{
        let s = String::from(&s[0..4]);
        return Cow::Owned(s);
    } else {
        return Cow::Borrowed(s);
    }
    
}

fn main() {
    let s = "adsfadsf";
    let mut foo_s = foo(s);
    assert_eq!("adsf", foo_s.to_mut());
    assert_eq!("adsf".to_string(), foo_s.into_owned());

    let s = "adf";
    let mut foo_s = foo(s);
    assert_eq!("adf", foo_s.to_mut());
    assert_eq!("adf".to_string(), foo_s.into_owned());
}

如果既希望输入不同参数，也希望同时返回不同参数，目前还没有找到特别好的办法。

2.3 让调用方来做处理

如果是不希望输入或者输出是可以转换的，我们最好用&str作为输入和输出，因为&String和&str的切片都是&str。

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let my_string = String::from("hello world");
    let word = first_word(&my_string[..]);
    assert_eq!("hello", word);
    let word = first_word(&my_string);
    assert_eq!("hello", word);

    let my_string_literal = "hello world";
    let word = first_word(&my_string_literal[..]);
    assert_eq!("hello", word);
    let word = first_word(&my_string_literal);
    assert_eq!("hello", word);
}