• 方法语法
    • 方法调用
    • 链式方法调用（Chaining method calls）
    • 关联函数（Associated functions）
    • 创建者模式（Builder Pattern）

    方法语法

    method-syntax.md


    commit ccb1d87d6faa9ff528d22b96595a0e2cbb16c0f2

    函数是伟大的，不过如果你在一些数据上调用了一堆函数，这将是令人尴尬的。
    考虑下面代码：

    1. baz(bar(foo));

    我们可以从左向右阅读，我们会看到“baz bar foo”。不过这不是函数被调用的顺序，调用应该是从内向外的：“foo bar baz”。如果能这么做不是更好吗？

    1. foo.bar().baz();

    幸运的是，正如对上面那个问题的猜测，你可以！Rust 通过impl关键字提供了使用方法调用语法（method call syntax）。

    方法调用

    这是它如何工作的：

    1. struct Circle {
    2.     x: f64,
    3.     y: f64,
    4.     radius: f64,
    5. }
    7. impl Circle {
    8.     fn area(&self) -> f64 {
    9.         std::f64::consts::PI * (self.radius * self.radius)
    10.     }
    11. }
    13. fn main() {
    14.     let c = Circle { x: 0.0, y: 0.0, radius: 2.0 };
    15.     println!("{}", c.area());
    16. }

    这会打印12.566371。

    我们创建了一个代表圆的结构体。我们写了一个impl块，并且在里面定义了一个方法，area。

    方法的第一参数比较特殊，&self。它有3种变体：self，&self和&mut self。你可以认为这第一个参数就是x.foo()中的x。这3种变体对应x可能的3种类型：self如果它只是栈上的一个值，&self如果它是一个引用，然后&mut self如果它是一个可变引用。因为我们的area以&self作为参数，我们就可以可以像其他参数那样使用它。因为我们知道是一个Circle，我们可以像任何其他结构体那样访问radius字段。

    我们应该默认使用&self，就像相比获取所有权你应该更倾向于借用，同样相比获取可变引用更倾向于不可变引用一样。这是一个三种变体的例子：

    1. struct Circle {
    2.     x: f64,
    3.     y: f64,
    4.     radius: f64,
    5. }
    7. impl Circle {
    8.     fn reference(&self) {
    9.        println!("taking self by reference!");
    10.     }
    12.     fn mutable_reference(&mut self) {
    13.        println!("taking self by mutable reference!");
    14.     }
    16.     fn takes_ownership(self) {
    17.        println!("taking ownership of self!");
    18.     }
    19. }

    你可以有任意多个impl块。上面的例子也可以被写成这样：

    1. struct Circle {
    2.     x: f64,
    3.     y: f64,
    4.     radius: f64,
    5. }
    7. impl Circle {
    8.     fn reference(&self) {
    9.        println!("taking self by reference!");
    10.     }
    11. }
    13. impl Circle {
    14.     fn mutable_reference(&mut self) {
    15.        println!("taking self by mutable reference!");
    16.     }
    17. }
    19. impl Circle {
    20.     fn takes_ownership(self) {
    21.        println!("taking ownership of self!");
    22.     }
    23. }

    链式方法调用（Chaining method calls）

    现在我们知道如何调用方法了，例如foo.bar()。那么我们最开始的那个例子呢，foo.bar().baz()？我们称这个为“方法链”，我们可以通过返回self来做到这点。

    1. struct Circle {
    2.     x: f64,
    3.     y: f64,
    4.     radius: f64,
    5. }
    7. impl Circle {
    8.     fn area(&self) -> f64 {
    9.         std::f64::consts::PI * (self.radius * self.radius)
    10.     }
    12.     fn grow(&self, increment: f64) -> Circle {
    13.         Circle { x: self.x, y: self.y, radius: self.radius + increment }
    14.     }
    15. }
    17. fn main() {
    18.     let c = Circle { x: 0.0, y: 0.0, radius: 2.0 };
    19.     println!("{}", c.area());
    21.     let d = c.grow(2.0).area();
    22.     println!("{}", d);
    23. }

    注意返回值：

    1. # struct Circle;
    2. # impl Circle {
    3. fn grow(&self, increment: f64) -> Circle {
    4. # Circle } }

    我们看到我们返回了一个Circle。通过这个函数，我们可以增长一个圆的面积到任意大小。

    关联函数（Associated functions）

    我们也可以定义一个不带self参数的关联函数。这是一个 Rust 代码中非常常见的模式：

    1. struct Circle {
    2.     x: f64,
    3.     y: f64,
    4.     radius: f64,
    5. }
    7. impl Circle {
    8.     fn new(x: f64, y: f64, radius: f64) -> Circle {
    9.         Circle {
    10.             x: x,
    11.             y: y,
    12.             radius: radius,
    13.         }
    14.     }
    15. }
    17. fn main() {
    18.     let c = Circle::new(0.0, 0.0, 2.0);
    19. }

    这个关联函数（associated function）为我们构建了一个新的Circle。注意静态函数是通过Struct::method()语法调用的，而不是ref.method()语法。

    创建者模式（Builder Pattern）

    我们说我们需要我们的用户可以创建圆，不过我们只允许他们设置他们关心的属性。否则，x和y将是0.0，并且radius将是1.0。Rust 并没有方法重载，命名参数或者可变参数。我们利用创建者模式来代替。它看起像这样：

    1. struct Circle {
    2.     x: f64,
    3.     y: f64,
    4.     radius: f64,
    5. }
    7. impl Circle {
    8.     fn area(&self) -> f64 {
    9.         std::f64::consts::PI * (self.radius * self.radius)
    10.     }
    11. }
    13. struct CircleBuilder {
    14.     x: f64,
    15.     y: f64,
    16.     radius: f64,
    17. }
    19. impl CircleBuilder {
    20.     fn new() -> CircleBuilder {
    21.         CircleBuilder { x: 0.0, y: 0.0, radius: 1.0, }
    22.     }
    24.     fn x(&mut self, coordinate: f64) -> &mut CircleBuilder {
    25.         self.x = coordinate;
    26.         self
    27.     }
    29.     fn y(&mut self, coordinate: f64) -> &mut CircleBuilder {
    30.         self.y = coordinate;
    31.         self
    32.     }
    34.     fn radius(&mut self, radius: f64) -> &mut CircleBuilder {
    35.         self.radius = radius;
    36.         self
    37.     }
    39.     fn finalize(&self) -> Circle {
    40.         Circle { x: self.x, y: self.y, radius: self.radius }
    41.     }
    42. }
    44. fn main() {
    45.     let c = CircleBuilder::new()
    46.                 .x(1.0)
    47.                 .y(2.0)
    48.                 .radius(2.0)
    49.                 .finalize();
    51.     println!("area: {}", c.area());
    52.     println!("x: {}", c.x);
    53.     println!("y: {}", c.y);
    54. }

    我们在这里又声明了一个结构体，CircleBuilder。我们给它定义了一个创建者函数。我们也在Circle中定义了area()方法。我们还定义了另一个方法CircleBuilder: finalize()。这个方法从构造器中创建了我们最后的Circle。现在我们使用类型系统来强化我们的考虑：我们可以用CircleBuilder来强制生成我们需要的Circle。