swift - 传递函数和 inout 参数

Question

构造函数正在接收两个参数。

a) 一个函数，其类型是接收 inout 参数的函数(因此它可以更改参数)

b) 传递你的 params 对象，期望传递的函数能够修改该对象

然后触发apply方法，这样你传递的函数就可以改变传递的参数。

如果有一个在闭包中传递参数的解决方案，那也可以。

class Test {

    var params: Any?

    var myFunc: (inout params: Any?) -> () = { (inout params: Any?) in return } //default value


    //constructor receving a function and a address to inout params object
    init(myFunc: (inout params: Any?) -> (), inout params: Any?) {
        self.myFunc = myFunc
        self.params = params
    }

    //call the passed function (extern) and pass the address of given params
    func apply() {
        self.myFunc(params: &self.params)
    }
}

func extern(inout params: Any?) {
    var a = params as [String: Int]
    a["factor"] = 11
}

var p: Any = ["factor": 10]
var test = Test(myFunc: extern, params: &p)

test.apply() //p["factor"] should be 11 now here

p["factor"] as [String: Int]

我第二次尝试使用闭包

//Utility

class Test {

    var closure: () -> Any

    var myFunc: (message: String, closure: () -> Any) -> () = { (message: String, closure: () -> Any) in return }

    init(myFunc: (message: String, closure: () -> Any) -> (), closure: () -> Any) {
        self.myFunc = myFunc
        self.closure = closure
    }

    func apply(message: String) {
        self.myFunc(message: message, closure: self.closure)
    }

}

//users of the utility

func extern(message: String, closure: () -> Any) {
    println(message)
    var name = closure() as [String: String]
    name["name"] = "Doe"
}

var name: Any = ["name": "John"]

var test = Test(myFunc: extern, closure: {name})
test.apply("hello ")
name //it's still John here

第三次尝试使用 AnyObject 和闭包，当然它有效，但仍然需要你们的意见来制定最佳策略。

//Utility

class Test {

    var closure: () -> AnyObject

    var myFunc: (message: String, closure: () -> AnyObject) -> () = { (message: String, closure: () -> AnyObject) in return }

    init(myFunc: (message: String, closure: () -> AnyObject) -> (), closure: () -> AnyObject) {
        self.myFunc = myFunc
        self.closure = closure
    }

    func apply(message: String) {
        self.myFunc(message: message, closure: self.closure)
    }

}

//users of the utility

func extern(message: String, closure: () -> AnyObject) {
    println(message)
    var name: Name = closure() as Name
    name.name = "Doe"
}

class Name {
    var name = "John"
}

var name = Name()

var test = Test(myFunc: extern, closure: {name})
test.apply("hello ")
name //it's changed here

Answer 1

看起来你正试图在这里重新发明闭包。闭包的一点是它们可以捕获对其周围值的引用。这应该执行您上面描述的操作，并让您继续为变量使用正确的类型，而不是依赖 Any:

class Test {
    var myFunc: () -> Void = { }

    init(myFunc: () -> Void) {
        self.myFunc = myFunc
    }

    func apply() {
        self.myFunc()
    }
}

func extern(inout dict: [String: Int]) {
    dict["factor"] = 11
}

var p = ["factor": 10]

let test = Test {
    extern(&p)
}

test.apply() // p["factor"] is now 11 here

println(p)
// ["factor": 11]