函數是偉大的,不過如果你在一些數據上調用了一堆函數,這將是令人尷尬的。 考慮下面代碼:
~~~
baz(bar(foo(x)));
~~~
我們可以從左向右閱讀,我們會看到“baz bar foo”。不過這不是函數被調用的順序,調用應該是從內向外的:“foo bar baz”。如果能這么做不是更好嗎?
~~~
x.foo().bar().baz();
~~~
幸運的是,正如對上面那個問題的猜測,你可以!Rust通過`impl`關鍵字提供了使用_方法調用語法_(_method call syntax_)。
## 方法調用
這是它如何工作的:
~~~
struct Circle {
x: f64,
y: f64,
radius: f64,
}
impl Circle {
fn area(&self) -> f64 {
std::f64::consts::PI * (self.radius * self.radius)
}
}
fn main() {
let c = Circle { x: 0.0, y: 0.0, radius: 2.0 };
println!("{}", c.area());
}
~~~
這會打印`12.566371`。
我們創建了一個代表圓的結構體。我們寫了一個`impl`塊,并且在里面定義了一個方法,`area`。方法的第一參數比較特殊,`&self`。它有3種變體:`self`,`&self`和`&mut self`。你可以認為這第一個參數就是`x.foo()`中的`x`。這3種變體對應`x`可能的3種類型:`self`如果只是棧上的一個值,`&self`如果是一個引用,然后`&mut self`如果是一個可變引用。我們應該默認使用`&self`,因為它最常見。這是一個三種變體的例子:
~~~
struct Circle {
x: f64,
y: f64,
radius: f64,
}
impl Circle {
fn reference(&self) {
println!("taking self by reference!");
}
fn mutable_reference(&mut self) {
println!("taking self by mutable reference!");
}
fn takes_ownership(self) {
println!("taking ownership of self!");
}
}
~~~
最后,你可能還記得,一個圓的面積是`π*r2`。因為我們向`area`傳遞了`&self`參數,我們可以像任何其它參數那樣使用它。因為我們知道它是一個`Circle`,我們可以像處理其它結構體一樣訪問`radius`。導入`π`再進行一些乘法,我們就有了面積。
## 鏈式方法調用(Chaining method calls)
現在我們知道如何調用方法了,例如`foo.bar()`。那么我們最開始的那個例子呢,`foo.bar().baz()`?我們稱這個為“方法鏈”,我們可以通過返回`self`來做到這點。
~~~
struct Circle {
x: f64,
y: f64,
radius: f64,
}
impl Circle {
fn area(&self) -> f64 {
std::f64::consts::PI * (self.radius * self.radius)
}
fn grow(&self) -> Circle {
Circle { x: self.x, y: self.y, radius: (self.radius * 10.0) }
}
}
fn main() {
let c = Circle { x: 0.0, y: 0.0, radius: 2.0 };
println!("{}", c.area());
let d = c.grow().area();
println!("{}", d);
}
~~~
注意返回值:
~~~
fn grow(&self) -> Circle {
~~~
我們看到我們返回了一個`Circle`。通過這個函數,我們可以增長一個圓的面積100倍。
## 靜態方法
我們也可以定義一個不帶`self`參數的方法。這是一個Rust代碼中非常常見的模式:
~~~
struct Circle {
x: f64,
y: f64,
radius: f64,
}
impl Circle {
fn new(x: f64, y: f64, radius: f64) -> Circle {
Circle {
x: x,
y: y,
radius: radius,
}
}
}
fn main() {
let c = Circle::new(0.0, 0.0, 2.0);
}
~~~
這個_靜態函數_(_static method_)為我們構建了一個新的`Circle`。注意靜態函數是通過`Struct::method()`語法調用的,而不是`ref.method()`語法。
## 創建者模式(Builder Pattern)
我們說我們需要我們的用戶可以創建圓,不過我們只允許他們設置他們關心的屬性。否則,`x`和`y`將是`0.0`,并且`radius`將是`1.0`。Rust并沒有方法重載,命名參數或者可變參數。我們利用創建者模式來代替。它看起像這樣:
~~~
struct Circle {
x: f64,
y: f64,
radius: f64,
}
impl Circle {
fn area(&self) -> f64 {
std::f64::consts::PI * (self.radius * self.radius)
}
}
struct CircleBuilder {
coordinate: f64,
radius: f64,
}
impl CircleBuilder {
fn new() -> CircleBuilder {
CircleBuilder { coordinate: 0.0, radius: 0.0, }
}
fn coordinate(&mut self, coordinate: f64) -> &mut CircleBuilder {
self.coordinate = coordinate;
self
}
fn radius(&mut self, radius: f64) -> &mut CircleBuilder {
self.radius = radius;
self
}
fn finalize(&self) -> Circle {
Circle { x: self.coordinate, y: self.coordinate, radius: self.radius }
}
}
fn main() {
let c = CircleBuilder::new()
.coordinate(10.0)
.radius(5.0)
.finalize();
println!("area: {}", c.area());
}
~~~
我們在這里又聲明了一個結構體,`CircleBuilder`。我們給它定義了一個創建者函數。我們也在`Circle`中定義了`area()`方法。我們還定義了另一個方法`CircleBuilder: finalize()`。這個方法從構造器中創建了我們最后的`Circle`。現在我們使用類型系統來強化我們的考慮:我們可以用`CircleBuilder`來強制生成我們需要的`Circle`。
- 前言
- 1.介紹
- 2.準備
- 2.1.安裝Rust
- 2.2.Hello, world!
- 2.3.Hello, Cargo!
- 3.學習Rust
- 3.1.猜猜看
- 3.2.哲學家就餐問題
- 3.3.其它語言中的Rust
- 4.高效Rust
- 4.1.棧和堆
- 4.2.測試
- 4.3.條件編譯
- 4.4.文檔
- 4.5.迭代器
- 4.6.并發
- 4.7.錯誤處理
- 4.8.外部語言接口
- 4.9.Borrow 和 AsRef
- 4.10.發布途徑
- 5.語法和語義
- 5.1.變量綁定
- 5.2.函數
- 5.3.原生類型
- 5.4.注釋
- 5.5.If語句
- 5.6.for循環
- 5.7.while循環
- 5.8.所有權
- 5.9.引用和借用
- 5.10.生命周期
- 5.11.可變性
- 5.12.結構體
- 5.13.枚舉
- 5.14.匹配
- 5.15.模式
- 5.16.方法語法
- 5.17.Vectors
- 5.18.字符串
- 5.19.泛型
- 5.20.Traits
- 5.21.Drop
- 5.22.if let
- 5.23.trait對象
- 5.24.閉包
- 5.25.通用函數調用語法
- 5.26.包裝箱和模塊
- 5.27.`const`和`static`
- 5.28.屬性
- 5.29.`type`別名
- 5.30.類型轉換
- 5.31.關聯類型
- 5.32.不定長類型
- 5.33.運算符和重載
- 5.34.`Deref`強制多態
- 5.35.宏
- 5.36.裸指針
- 6.Rust開發版
- 6.1.編譯器插件
- 6.2.內聯匯編
- 6.3.不使用標準庫
- 6.4.固有功能
- 6.5.語言項
- 6.6.鏈接參數
- 6.7.基準測試
- 6.8.裝箱語法和模式
- 6.9.切片模式
- 6.10.關聯常量
- 7.詞匯表
- 8.學院派研究
- 勘誤