（翻译）Rust中的设计模式(1-Use borrowed types for arguments）

引言

设计模式

在开发程序中，我们必须解决许多问题。一个程序可以看作是一个问题的解决方案。它也可以被看作是许多不同问题的解决方案的集合。所有这些解决方案共同解决一个更大的问题。

在Rust中的设计模式

有许多问题的形式是相同的，由于事实上，rust不是面向对象设计，模式不同于其他面向对象程序设计语言，虽然细节是不同的，因为他们有相同的形式，他们可以解决使用相同的基本方法。

设计模式是解决编写软件时常见问题的方法。

反模式是解决这些相同问题的方法。

然而，尽管设计模式给我们带来了好处，反模式却带来了更多的问题。

惯用法，是编码是要遵守的指南，他们是社区的社区规范，你可以破他们，但如果你这样做，你应该有一个很好的理由。

TODO: 说明为什么Rust是一个有点特殊功能要素，类型系统，借用检查。

Idioms

惯用法是一种常用的风格和模式，在很大程度上得到了社区的认可，他们是指导方针，编写惯用代码可以让其他开发人员理解正在发生的事情，因为他们熟悉代码的形式。

计算机理解编译器生成的机器代码，因此，这种语言对开发人员来说是最有利的，所以既然我们有了这个抽象层，为什么不好好利用它，然它变得简单呢？

记住KISS原则，"保持简单，Stupid。" 他声称“大多数系统如果有保持简单而不是复杂，就能工作的最好，因此，简单应该是设计的一个关键目标，应该避免不必要的复杂性。

代码是给人类而不是计算机去理解的。

Use borrowed types for arguments

对参数使用borrowed types

描述

当你决定使用哪种参数作为函数参数时，使用强制解引用(deref coerrcion) 的目标可以增加代码的灵活性。这样，函数将接受更多的输入类型。

这不经限于可切片类型或者胖指针类型。事实上，你总是更喜欢borrowed type 而不是 borrowing the owned type, 例如， &str Over &String, &[T] Over &Vec<T>, or &T Over &Box<T>

对于owned type 已经提供了间接层的实例，使用borrowed type可以避免使用间接层。例如，String有一个间接层，因此&String将有两个间接层。我们可以通过使用&str来避免这种情况，并且在调用函数时让&String强制转换到&str.

例子

在本例中，我们将说明使用&String作为函数参数与使用&str的区别。但是这些思想也适用于使用&Vec <T> 与使用&[T] 或者使用&T 与&Box<T> .

考虑一个例子，我们希望确定一个单词是否包含三个连续的元音，我们不需要拥有字符串来确定这一点。因为我们将采用一个引用。

代码可能是这样的

fn three_vowels(word: &String) -> bool {
  let mut vowel_ocunt = 0;
  for c in word.chars() {
    match c {
      'a' | 'e' | 'i' | 'o' | 'u' => {
        vowel_count += 1;
        if vowel_count >= 3 {
          return true;
        }
      }
      _ => vowel_count = 0;
    }
  }
  false
}
fn main() {
  let ferris = "Ferris".to_string();
  let curious = "Curious".to_string();
  println!("{}: {}", ferris, three_vowels(&ferris));
  println!("{}: {}", curious, three_vowels(&curious));

  // This work fine,but the following two lines would fail;
  // println!("Ferris: {}", three_vowles("Ferris"));
  // println!("Currious: {}", three_vowles("Curious"));
}

这样做很好，因为我们将&String类型作为参数传递。我们在最后两行中进行注释，这个示例就会失败，因为&str类型不会强制转换为&String。我们可以通过简单地修改参数的类型来解决这个问题。

例如，我们将函数声明更改为

fn three_vowels(word: &str) -> bool {

然后两个版本将编译并打印相同的输出

Ferris: false
Curious: true

但是，等等，这还不是全部。这个故事还有更多内容。很可能你会对自己说：这不重要，我们永远不会使用&' static str作为输入方式(就像我们使用"Ferris"时所作的那样)。即使忽略这个特殊的示例，您可能仍然会发现使用&str比使用&String更具灵活性.

现在让我们举一个例子，有人给我们一个句子，我们想确定句子中的任何一个单词是否有一个包含三个连续元音的单词，我们可能应该利用我们已经定义的函数，简单的输入句子中的每个单词。

下面试一个例子：

fn three_vowels(word: &String) -> bool {
  let mut vowel_ocunt = 0;
  for c in word.chars() {
    match c {
      'a' | 'e' | 'i' | 'o' | 'u' => {
        vowel_count += 1;
        if vowel_count >= 3 {
          return true;
        }
      }
      _ => vowel_count = 0;
    }
  }
  false
}
fn main() {
  let sentence_string = "Once upon a time, there was a friendly curious crab named Ferris".to_string();
  for word in sentence_string.split(' ') {
    if three_vowels(word) {
      println!("{} has three consecutive vowels!", word);
    }
  }
}

带有&str类型参数声明的函数运行这个例子将产生

curious has three consecutive vowels!

但是，我们的函数使用&String类型的参数声明时，这个示例将不会运行。这是因为字符串切片是&str而不是&String,需要分配内存将&str转换为&String，但是这不是隐式的，而从String转换为&str是廉价且隐式的。

参见

• Rust Language Reference on Type Coercions
• For more discussion on how to handle String and &str see this blog series (2015) by Herman J. Radtke III.

原文： Rust Design Patterns