我们知道在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") => #<UnboundMethod: A#test>
irb(main):022:0> f = f_no_bind.bind(A.new) => #<Method: A#test>
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") => #<Method: A.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的简洁哦!