标签: closures

在 Swift 中，如何创建一个包含捕获列表和参数的闭包？

我使用过以任何一种形式呈现的代码，但不知道如何创建具有参数和捕获列表的闭包。

例如

关闭参数列表：

myFunction {
    (x: Int, y: Int) -> Int in
    return x + y
}

关闭捕获列表：

myFunction { [weak parent = self.parent] in print(parent!.title) }

使用捕获列表的示例尝试：

class MyTest {
    var value:Int = 3

    func myFunction(f: (x:Int, y:Int) -> Int) {
        print(f(x: self.value, y: 5))
    }

    func testFunction() {
        myFunction {
            [weak self] (x, y) in   //<--- This won't work, how to specify weak self here?
            print(self.value)
            return self.value + y
        }
    }
}

def test():
    x = 99
    def nested(x):
        print (x)
    return nested

a = test()
a()

TypeError:nested()缺少1个必需的位置参数:'x'

当我调用nested在闭包函数中分配的print参数x时test,TypeError会提示我将位置参数传递给嵌套,但为什么在测试函数中分配的'x'没有传递给嵌套？

我在网上做了一个小测试，有这个代码：

function getFunc() {
    var a = 7;
    return function(b) {
        alert(a+b);
    }
}
var f = getFunc();
f(5);

我想知道为什么我不能getFunct(5)直接打电话。

最后两行没看懂

为什么我需要将函数分配给变量。执行 f(5) 时会发生什么？

JS 如何解释 5 是内部函数而不是外部函数的变量？

我试图理解swift中的闭包.我有以下快速实现:

func whereToGo (ahead:Bool) -> (Int) -> Int{
    func goAhead(input:Int) ->Int{
        return input + 1 }
    func goBack(input:Int) ->Int{
        return input - 1 }
    return ahead ? goAhead : goBack
}

var stepsToHome = -10
let goHome = whereToGo(ahead: stepsToHome < 0)

while stepsToHome != 0 {
    print("steps to home: \(abs(stepsToHome))")
    stepsToHome = goHome(stepsToHome)
}

实现的输出如下:

steps to home: 10
steps to home: 9
steps to home: 8
steps to home: 7
steps to home: 6
steps to home: 5 …

所以据我所知，此时此刻显然是错误的，

return arg => arg*2

是相同的

return (arg)=>{arg*2}

我一直认为箭头函数在语法上更简洁。

但是用像这样的闭包来做这件事是行不通的。

function addTwoDigits(firstDigit){
    return (secondDigit)=>{firstDigit + secondDigit}
}
let closure = addTwoDigits(5);
console.log(closure(5)) // Undefined

然而这很好

function addTwoDigitsV2(firstDigit){
    return secondDigit => firstDigit + secondDigit
}
let closure2 = addTwoDigitsV2(10);
console.log(closure2(10))// 20

对于一个玩具示例，假设我有一个时钟小部件：

{\n  const clockElem = document.getElementById(\'clock\');\n\n  const timefmt = new Intl.DateTimeFormat(\n    \'default\', { timeStyle: \'medium\', });\n\n  setInterval(() => {\n    const d = new Date;\n    console.log(\'tick\', d, clockElem);\n    clockElem.querySelector(\'p\').innerHTML =\n      timefmt.format(d);\n  }, 1000);\n\n  clockElem.querySelector(\'button\')\n    .addEventListener(\'click\', ev => {\n      clockElem.remove();\n    });\n}

<div id="clock">\n  <button>Remove</button>\n  <p></p>\n</div>

\n

当我单击按钮删除时钟时，setInterval回调仍然被调用。回调闭包强力持有 DOM 节点，这意味着它的资源无法被释放。还有来自按钮事件处理程序的循环引用；尽管也许这个可以由 engine\xe2\x80\x99s 循环收集器处理。话又说回来，也许不是。

不用担心：我可以创建一个辅助函数，确保闭包仅通过弱引用保存 DOM 节点，并抛出FinalizationRegistry来清理计时器。

const weakCapture = (captures, func) => {\n  captures = captures.map(o => new WeakRef(o));\n …

• PHP 5.3中是否可以关闭？
• 我正在寻找一个简单的闭包示例,最少的代码是值得赞赏的.
• 如果在PHP 5.3中可以进行闭包,那么它在行为方面的行为是否类似于Javascript的闭包？
• Javascript闭包和PHP闭包有什么区别(如果存在)？

为什么我要执行以下操作在Go中定义迭代器：

func f() func() int {
    i := 1
    return func() int {
        i++
        return i
    }
}

但这会导致变量未使用错误（i未使用）？

func f() func() int {
    i := 1
    return func() (i int) {
        i++
        return
    }
}

主功能：

func main() {
    iter := f()
    fmt.Println(iter())
    fmt.Println(iter())
    fmt.Println(iter())
    fmt.Println(iter())
}

对我而言，这两个版本的功能完全相同：它们f用作迭代器。f利用闭包（更具体地讲i）。第一个版本i通过命名返回类型引用它来显式地返回一个增量，第二个隐式地。

对我来说，这两个版本是相同的，那么为什么会出现错误？

我理解python闭包的技术定义:让它具体化.

def foo(x):
    def bar(y):
        print(x+y)
    return bar

在这个例子x中将受到约束bar.但这些东西实际上有什么用呢？也就是说,在上面的玩具示例中,可以轻松地编写

def bar(x,y):
    print(x+y)

我想知道使用闭包的最佳用例,而不是例如向函数添加额外的参数.

我的问题可以通过简单的是或否回答:

• 是的,italic's"封闭样式"是编写python闭包的更好方法 - 换句话说 - italic's"封闭符号"不会破坏并且没有任何警告

• 不,italic关闭是有问题的,bold"封闭符号"是唯一的方法

为了以防万一,如果有人想知道"这件事是什么",那么为什么"他"不使用标准封口 - 标准形式,它让我想要逃跑.

def example():

    # The standard X_x closure...
    #
    def bold(predecessor):
        def successor():
            return "<bold/>" + predecessor() + "</bold>"
        return successor

    # ...this looks sooo much better ^.^
    #
    def italic(predecessor):
        x = predecessor
        def successor():
            return "<italic/>" + x() + "</italic>"
        return successor

    def underline(predecessor):
        x = predecessor
        def successor():
            return "<underline/>" + x() + "</underline>"
        return successor

    @italic
    @bold
    @underline
    def trademark(): …