变量在其自己的初始值内使用,而变量在 init 之后的闭包内使用

Variable used within its own initial value while variable is used inside a closure past init

typealias CBType = () -> Void

class A {

    let b = B()

    func test() {
        let token = b.register { CBType in
            self.b.waitFor([token]) // ERROR: Variable used within its own initial value
        }

        b.dispatch()
    }
}

class B {
    private var _callbacks = [String:CBType]()

    func register(callback: CBType) -> String {
        let id = "1234"
        _callbacks[id] = callback
        return id
    }

    func dispatch() {
        for (_, cb) in self._callbacks {
            cb()
        }
    }

    func waitFor(tokens: [String]) {
    }
}

A().test()

当我修改测试函数以使用实例变量时,一切正常,但语法感觉有点沉重。

class A {

    let b = B()
    var token: String?

    func test() {
        token = b.register { CBType in
            self.b.waitFor([self.token!])
        }

        b.dispatch()
    }
}

为什么我不能在闭包中使用局部变量,因为当闭包最终被调用时它已经过了初始化阶段?

在您的第一个示例中,token 在您调用 self.b.waitFor([token]) 时没有值。

在你的第二个例子中,一切似乎都有效,因为通过像这样声明 tokenvar token: String? 它被赋予了一个初始值 (nil)。

问题不在于您是在使用实例变量还是局部变量(或者它在闭包中使用),问题在于(在第一个示例中)您正在尝试使用token 在提供其初始值的表达式中。

相当于这样声明一个 Intlet myValue: Int = myValue + 1 - 它的初始值应该是 "what" + 1?

常量 token 在被闭包捕获时没有值。

您可以改用可变变量,闭包将捕获变量而不是它的值。

func test() {
    var token = ""
    token = b.register {
        self.b.waitFor([token])
    }

    b.dispatch()
}

或者,您可以将令牌作为参数传递到闭包中:

typealias CBType = (String) -> Void

class A {
    let b = B()

    func test() {
        let token = b.register { theToken in
            self.b.waitFor([theToken])
        }

        b.dispatch()
    }
}

class B {
    private var _callbacks = [String:CBType]()

    func register(callback: CBType) -> String {
        let id = "1234"
        _callbacks[id] = callback
        return id
    }

    func dispatch() {
        for (id, cb) in self._callbacks {
            cb(id)
        }
    }

    func waitFor(tokens: [String]) {
        println("Wait for \(tokens)")
    }
}

A().test()