我們知道在ruby之類的動態語言中對象方法可以先從類中預先抽取,然後再應用到某個具體對象上.這稱為無綁定的method對象,也可以叫做lazy綁定.

下面舉個例子:

irb(main):004:0> system("ruby -v")
ruby 2.0.0p648 (2015-12-16 revision 53162) [universal.x86_64-darwin15]
=> true
irb(main):005:0> class A
irb(main):006:1> def test(i)
irb(main):007:2> return i*i
irb(main):008:2> end
irb(main):009:1> end
=> nil

以上在ruby中創建了一個類A,我們可以用它的實例調用test方法:

a = A.new
a.test(11)    => 121

我們也可以先創建一個無綁定的method,然後綁定到特定的實例上去:

irb(main):021:0> f_no_bind = A.instance_method("test")
=> #
irb(main):022:0> f = f_no_bind.bind(A.new)
=> #
irb(main):023:0> f.call(11)
=> 121
irb(main):024:0> f[11]
=> 121

最後一句是倒數第二句的語法糖,效果是一樣的.

那麼如果是類方法呢?那更簡單了,直接用Obj.method()即可:

irb(main):025:0> class A
irb(main):026:1> def self.test(i)
irb(main):027:2> i*i*i
irb(main):028:2> end
irb(main):029:1> end

irb(main):037:0> f_class_func = A.method("test")
=> #
irb(main):038:0> f_class_func[11]
=> 1331
irb(main):039:0> f_class_func.call(11)
=> 1331

無論你承認與否,ruby比swift還要簡潔,更具有美感!

現在回過頭來看一下Swift中方法的lazy綁定又是什麼樣子的:

class Foo{
    func test(val:Int)->Int{
        return val * val
    }
}

let foo = Foo()
foo.test(val: 11)

let f = Foo.test
f(foo)(11)

如果你查看f的類型會發現它是一個柯裡函數:

(Foo) -> (Int) -> Int

那麼如果是類方法呢?給Foo類新增一個類方法:

class func test(val:Int)->Int{
        return val * val * val
    }

這時你會發現原來let f = Foo.test的結果變成了其類方法:

如果你想綁定其實例方法,你必須將其類型補全:

很好很強大,但還是沒有ruby的簡潔哦!