在 Rust 中，有没有一种方法可以让我定义两个结构，并且两者都遵循标准结构？

Question

我正在尝试创建一个结构体，它将包含所有其他结构体中存在的基本函数，在这里：

pub struct GenericSelect {
    table: String,
    distinct: bool,
    columns: Option<String>,
    group: Option<String>,
    order: Option<String>,
    limit: Option<u32>,
    offset: Option<u32>,
}

impl GenericSelect {
    pub fn new<T: Into<String>>(table: T) -> GenericSelect {
        GenericSelect {
            table: table.into(),
            distinct: false,
            columns: None,
            group: None,
            order: None,
            limit: None,
            offset: None,
        }
    }

    pub fn distinct(&mut self) -> &mut Self {
        self.distinct = true;
        self
    }

    pub fn columns<T: Into<String>>(&mut self, columns: T) -> &mut Self {
        self.columns = Some(columns.into());
        self
    }

    pub fn group<T: Into<String>>(&mut self, group: T) -> &mut Self {
        self.group = Some(group.into());
        self
    }

    pub fn order<T: Into<String>>(&mut self, order: T) -> &mut Self {
        self.order = Some(order.into());
        self
    }

    pub fn limit(&mut self, limit: u32) -> &mut Self {
        self.limit = Some(limit);
        self
    }

    pub fn offset(&mut self, offset: u32) -> &mut Self {
        self.offset = Some(offset);
        self
    }

    pub fn build(&self) -> String {
        let mut statement = String::from("SELECT");

        if self.distinct {
            statement.push_str(" DISTINCT");
        }

        if let Some(columns) = &self.columns {
            statement.push_str(&format!(" {}", columns));
        } else {
            statement.push_str(" *");
        }

        statement.push_str(&format!(" FROM {}", self.table));

        if let Some(group) = &self.group {
            statement.push_str(&format!(" GROUP BY {}", group));
        }

        if let Some(order) = &self.order {
            statement.push_str(&format!(" ORDER BY {}", order));
        }

        if let Some(limit) = &self.limit {
            statement.push_str(&format!(" LIMIT {}", limit));
        }

        if let Some(offset) = &self.offset {
            statement.push_str(&format!(" OFFSET {}", offset));
        }

        statement.push(';');
        statement
    }
}

我希望一个特定的结构拥有这个结构所拥有的一切，而不需要逐个方法编写，并且我还希望有可能在必要时实现一个函数，例如更改特定函数的行为等。

Answer 1

特质将完全满足您的需求。

这是 Rust 文档中的示例：

pub trait Summary {
    fn summarize_author(&self) -> String;

    fn summarize(&self) -> String {
        format!("(Read more from {}...)", self.summarize_author())
    }
}

这是描述共享行为的模板。当您希望一个结构体参与这种共享行为时，请在其上编写一个 impl，至少编写所需的功能

impl Summary for Tweet {
    fn summarize_author(&self) -> String {
        format!("@{}", self.username)
    }
}

在特征中，您可以拥有具有默认实现的函数

summarize

。然后，指定像

summarize_author

这样的函数，它们为您提供一些跨结构的标准接口，供您的默认实现依赖。

如果您想覆盖汇总功能，您可以在

impl

中执行此操作：

impl Summary for Tweet {
    fn summarize_author(&self) -> String {
        format!("@{}", self.username)
    }

    fn summarize(&self) -> String {
        format!("(More about this tweet by {})...", self.summarize_author())
    }
}

来源：https://doc.rust-lang.org/book/ch10-02-traits.html