Swift 中的嵌套函数重载

Question

Swift 中的重载方法按预期工作，但是当我尝试重载嵌套函数时，例如

func foo() {
    func bar(param: Int) {
        // do stuff
    }
    func bar(param: Double) {
        // do stuff
    }

    // call functions here
}

我收到一条错误消息 Definition conflicts with previous value。为什么会这样？

Answer 1

好问题。

请注意，此 behaviour/restriction 未记录在案，答案是我最好的猜测。

考虑以下这段代码：

func foo() -> (param:Int)->() {
    func bar(param: Int) {
        // do stuff
    }
    return bar
}

函数将return闭包bar。如果你在同一个函数中有另一个名为 bar 的闭包，就像这样...

func foo() -> (param:Int)->() {
    func bar(param: Int) {
        // do stuff
    }
    func bar(param: Float) {
        // do stuff
    }
    return bar
}

...它们会有冲突的名称，编译器不知道要做什么 return。这与您很容易承认错误的以下代码相同：

func foo() -> Int {
    let a:Int = 0
    let a:Int = 0 //Error
    return a
}

多观察

class 中一组类似函数的行为很奇怪。

class Test {
    func foo(param:Float) {
        let bar = { (param:Int) -> () in
            //do stuff
        }
    }
    func foo(param:Int) {
        let bar = { (param:Int) -> () in
            //do stuff
        }
    }
    func anotherFoo() {
        println(self.foo) //Compile time error - Ambiguous use of foo
    }
}

虽然...

class Test {
    func foo(param:Float) {
        let bar = { (param:Int) -> () in
            //do stuff
        }
    }
    func anotherFoo() {
        println(self.foo) //Compiles
    }
}

有意思。

Answer 2

恕我直言，如果您考虑这种变化，这会更清楚：

func foo() {

    let bar: (param: Int) -> () = { p in
        // do stuff
    }

    func bar(param: Double) {
        // do stuff
    }

    // call functions here
}

在您的第一个 bar 函数定义中，您只是声明了一个 (param: Int) -> () 类型的常量。因此，在你的第二个声明中，你声明了另一个不同类型的常量 (param: Double) -> () 但与已声明的 bar.

具有相同的名称

简而言之就像你写的那样：

let bar: Int = 0
let bar: Double = 0.0

在这种情况下，编译器也会报错。

希望这对您有所帮助。

Swift 中的嵌套函数重载

Nested function overloading in Swift

swift

methods

user-defined-functions

overloading