Chuyển đổi từ Option <String> thành Option <& str>

Rất thường xuyên, tôi nhận được Option<String>từ một phép tính và tôi muốn sử dụng giá trị này hoặc giá trị được mã hóa cứng mặc định.

Điều này sẽ là nhỏ với một số nguyên:

let opt: Option<i32> = Some(3);
let value = opt.unwrap_or(0); // 0 being the default

Nhưng với a Stringvà a &str, trình biên dịch phàn nàn về các kiểu không khớp:

let opt: Option<String> = Some("some value".to_owned());
let value = opt.unwrap_or("default string");

Lỗi chính xác ở đây là:

error[E0308]: mismatched types
 --> src/main.rs:4:31
  |
4 |     let value = opt.unwrap_or("default string");
  |                               ^^^^^^^^^^^^^^^^
  |                               |
  |                               expected struct `std::string::String`, found reference
  |                               help: try using a conversion method: `"default string".to_string()`
  |
  = note: expected type `std::string::String`
             found type `&'static str`

Một tùy chọn là chuyển đổi lát cắt chuỗi thành Chuỗi được sở hữu, như được đề xuất bởi gỉc:

let value = opt.unwrap_or("default string".to_string());

Nhưng điều này gây ra phân bổ, điều này không mong muốn khi tôi muốn ngay lập tức chuyển đổi kết quả trở lại một lát chuỗi, như trong lệnh gọi này tới Regex::new():

let rx: Regex = Regex::new(&opt.unwrap_or("default string".to_string()));

Tôi muốn chuyển đổi Option<String>thành an Option<&str>để tránh phân bổ này.

Cách viết này là gì?

Kể từ Rust 1.40, thư viện tiêu chuẩn Option::as_derefphải thực hiện điều này:

fn main() {
    let opt: Option<String> = Some("some value".to_owned());
    let value = opt.as_deref().unwrap_or("default string");
}

Bạn có thể sử dụng as_ref()và map()chuyển đổi một Option<String>thành một Option<&str>.

fn main() {
    let opt: Option<String> = Some("some value".to_owned());
    let value = opt.as_ref().map(|x| &**x).unwrap_or("default string");
}

Đầu tiên, as_ref()mặc nhiên nhận một tham chiếu vào opt, đưa ra một &Option<String>(bởi vì as_ref()take &self, tức là nó nhận một tham chiếu) và biến nó thành một Option<&String>. Sau đó, chúng tôi sử dụng mapđể chuyển đổi nó thành một Option<&str>. Đây là những gì &**xhiện: ngoài cùng bên phải *(được đánh giá đầu tiên) chỉ đơn giản là bỏ qua &String, đưa ra một Stringgiá trị. Sau đó, ngoài cùng bên trái *thực sự gọi Derefđặc điểm, bởi vì String thực hiện Deref<Target=str> , cho chúng ta một strgiá trị. Cuối cùng, &lấy địa chỉ của strlvalue, cho chúng ta một &str.

Bạn có thể đơn giản hóa điều này hơn một chút bằng cách sử dụng map_orkết hợp mapvà unwrap_ortrong một thao tác duy nhất:

fn main() {
    let opt: Option<String> = Some("some value".to_owned());
    let value = opt.as_ref().map_or("default string", |x| &**x);
}

Nếu &**xtrông quá kỳ diệu với bạn, bạn có thể viết String::as_str:

fn main() {
    let opt: Option<String> = Some("some value".to_owned());
    let value = opt.as_ref().map_or("default string", String::as_str);
}

hoặc String::as_ref(từ AsRefđặc điểm, ở phần dạo đầu ):

fn main() {
    let opt: Option<String> = Some("some value".to_owned());
    let value = opt.as_ref().map_or("default string", String::as_ref);
}

hoặc String::deref(mặc dù bạn cũng cần nhập Derefđặc điểm):

use std::ops::Deref;

fn main() {
    let opt: Option<String> = Some("some value".to_owned());
    let value = opt.as_ref().map_or("default string", String::deref);
}

Để một trong hai thứ này hoạt động, bạn cần phải giữ một chủ sở hữu Option<String>miễn là vẫn có sẵn Option<&str>hoặc chưa bao gói &str. Nếu điều đó quá phức tạp, bạn có thể sử dụng Cow.

use std::borrow::Cow::{Borrowed, Owned};

fn main() {
    let opt: Option<String> = Some("some value".to_owned());
    let value = opt.map_or(Borrowed("default string"), |x| Owned(x));
}

Một cách tốt hơn có thể là triển khai điều này một cách chung chung cho T: Deref:

use std::ops::Deref;

trait OptionDeref<T: Deref> {
    fn as_deref(&self) -> Option<&T::Target>;
}

impl<T: Deref> OptionDeref<T> for Option<T> {
    fn as_deref(&self) -> Option<&T::Target> {
        self.as_ref().map(Deref::deref)
    }
}

mà hiệu quả khái quát as_ref.

Mặc dù tôi yêu câu trả lời Veedrac của (tôi đã sử dụng nó), nếu bạn cần nó tại chỉ là một điểm và bạn muốn một cái gì đó là biểu cảm, bạn có thể sử dụng as_ref(), mapvà String::as_strchuỗi:

let opt: Option<String> = Some("some value".to_string());

assert_eq!(Some("some value"), opt.as_ref().map(String::as_str));

Đây là một cách bạn có thể làm. Hãy nhớ rằng bạn phải giữ nguyên bản gốc Stringxung quanh, nếu không thì đó sẽ &strlà một lát cắt thành gì?

let opt = Some(String::from("test")); // kept around

let unwrapped: &str = match opt.as_ref() {
  Some(s) => s, // deref coercion
  None => "default",
};

vở kịch