Question

我想与Redis数据库进行延迟连接。我有一个Db结构，它包含Redis Client。默认情况下为None。以下是Python中的示例代码：

import redis


class Db:

    def __init__(self):
        self.client = None

    def get_client(self):
        if self.client is None:
            self.client = redis.StrictRedis(host='127.0.0.1')
        return self.client

我试过这个

extern crate redis;

use redis::Client;

struct Db {
    client: Option<Client>,
}

impl Db {
    fn new() -> Db {
        Db { client: None }
    }

    fn get_client(&mut self) -> Result<&Client, &'static str> {
        if let Some(ref client) = self.client {
            Ok(client)
        } else {
            let connection_string = "redis://127.0.0.1";
            match Client::open(connection_string) {
                Ok(client) => {
                    self.client = Some(client);
                    Ok(&self.client.unwrap())
                }
                Err(err) => Err("Error!"),
            }
        }
    }
}

fn main() {
    let mut db = Db::new();
    db.get_client();
}

我有编译错误。我几乎明白编译器说的是什么，但我不知道如何解决这个问题。

    error: borrowed value does not live long enough
  --> src/main.rs:28:29
   |
28 |                         Ok(&self.client.unwrap())
   |                             ^^^^^^^^^^^^^^^^^^^^ does not live long enough
29 |                     },
   |                     - temporary value only lives until here
   |
note: borrowed value must be valid for the anonymous lifetime #1 defined on the body at 19:66...
  --> src/main.rs:19:67
   |
19 |         fn get_client(&mut self) -> Result<&Client, &'static str> {
   |                                                                   ^

error[E0507]: cannot move out of borrowed content
  --> src/main.rs:28:29
   |
28 |                         Ok(&self.client.unwrap())
   |                             ^^^^ cannot move out of borrowed content

Answer 1

如果您致电unwrap()，请将T移出Option。由于您只借了self，这会导致cannot move out of borrowed content错误。

如果您想借用Option<T>中的值，可以使用as_ref方法：

extern crate redis;

use redis::Client;

struct Db {
    client: Option<Client>,
}

impl Db {
    fn new() -> Db {
        Db { client: None }
    }

    fn get_client(&mut self) -> Result<&Client, &'static str> {
        if let Some(ref client) = self.client {
            Ok(client)
        } else {
            let connection_string = "redis://127.0.0.1";
            match Client::open(connection_string) {
                Ok(client) => {
                    self.client = Some(client);
                    Ok(self.client.as_ref().unwrap())
                }
                Err(_) => Err("Error!"),
            }
        }
    }
}

fn main() {
    let mut db = Db::new();
    db.get_client().expect("get_client failed");
}

Answer 2

所以，有解决方案，我来了

struct Db {
    connection: Option<Connection>,
    host: String,
    port: u16,
    db: u8,
}


impl Db {

    fn new(host: String, port: u16, db: u8) -> Db {
        Db {
            host: host,
            port: port,
            db: db,
            connection: None,
        }
    }

    fn get_connection(&mut self) -> RedisResult<&Connection> {
        if let Some(ref connection) = self.connection {
            Ok(connection)
        }
        else {
            let connection_string = format!("redis://{0}:{1}/{2}", self.host, self.port, self.db);
            self.connection = Some(
                Client::open(connection_string.as_ref())?.get_connection()?);
            Ok(self.connection.as_ref().unwrap())
        }
    }

    fn keys(&mut self) -> RedisResult<Vec<String>> {
        let key_iter: redis::Iter<String> = self.get_connection()?.scan()?;
        Ok(key_iter.collect())
    }
}

返回对可选struct成员的可变引用

2 个答案: