本文首發于 微信公眾號“編程派” 。微信搜索“編程派”，關注我們吧。

</div>

方法鏈（method chaining）是面向對象的編程語言中的一種常見語法，可以讓開發者在只引用對象一次的情況下，對同一個對象進行多次方法調用。舉個例子：

假設我們有一個Foo類，其中包含有兩個方法—— bar 和 baz 。

我們創建一個Foo類的實例：

foo = Foo()

如果不使用方法鏈，要想連續調用對象 foo 的 bar 和 baz 方法的話，我們得這樣做：

foo.bar() # Call method bar() on object foo.
foo.baz() # Call method baz() on object foo.

如果使用方法鏈的話，我們就能這樣實現： foo.bar().baz()

方法鏈的一個好處，是可以減少你使用對象名的次數。調用的方法越多，能夠減少的次數就越多。因此，這個方法也能一定程度上減少需要閱讀、測試、調試、維護的代碼數量。這個好處不大，但也是有用的。

請注意，方法鏈的一個限制是，只能用在不需要返回其他值的方法上，因為你需要返回 self 對象。即使Python支持用一個 return 語句返回多個值，也可能無法解決這個問題。

下面是在Python中實現方法鏈的一個示例：

class Person:
    def name(self, value):
        self.name = value
        return self


def age(self, value):
    self.age = value
    return self

def introduce(self):
    print "Hello, my name is", self.name, "and I am", self.age, "years old."


person = Person()
person.name("EarlGrey").age(21).introduce()
=> Hello, my name is EarlGrey and I am 21 years old.</pre>
 上面那種實現可能太簡單了。下面我們來看一種更加現實的方法鏈使用方法：編寫一個字符串處理程序 string_processor.py ，支持方法鏈。 
import copy

class StringProcessor(object):
    '''
    A class to process strings in various ways.
    '''
    def init(self, st):
        '''Pass a string for st'''
        self._st = st

def lowercase(self):
    '''Make lowercase'''
    self._st = self._st.lower()
    return self

def uppercase(self):
    '''Make uppercase'''
    self._st = self._st.upper()
    return self

def capitalize(self):
    '''Make first char capital (if letter); make other letters lower'''
    self._st = self._st.capitalize()
    return self

def delspace(self):
    '''Delete spaces'''
    self._st = self._st.replace(' ', '')
    return self

def rep(self):
    '''Like Python's repr'''
    return self._st

def dup(self):
    '''Duplicate the object'''
    return copy.deepcopy(self)


def process_string(s):
    print
    sp = StringProcessor(s)
    print 'Original:', sp.rep()
    print 'After uppercase:', sp.dup().uppercase().rep()
    print 'After lowercase:', sp.dup().lowercase().rep()
    print 'After uppercase then capitalize:', sp.dup().uppercase().\
    capitalize().rep()
    print 'After delspace:', sp.dup().delspace().rep()
def main():
    print "Demo of method chaining in Python:"

# Use extra spaces between words to show effect of delspace.
process_string('hOWz  It     GoInG?')
process_string('The      QUIck   brOWn         fOx')


main()</pre> 
 
下面是這個程序的運行結果：

$ python string_processor.py

Original: hOWz  It     GoInG?
After uppercase: HOWZ  IT     GOING?
After lowercase: howz  it     going?
After uppercase then capitalize: Howz  it     going?
After delspace: hOWzItGoInG?
Original: The      QUIck   brOWn         fOx
After uppercase: THE      QUICK   BROWN         FOX
After lowercase: the      quick   brown         fox
After uppercase then capitalize: The      quick   brown         fox
After delspace: TheQUIckbrOWnfOx</pre> 
 
綜上，我們可以發現，方法鏈有其用處，不過過度使用可能不太好。

 本文摘譯、修改自 Vasudev Ram 。 
歡迎大家掃描下方二維碼關注我的公眾號“編程派”，謝謝支持！
  
 </div>