design-patterns - 闭包设计模式

Question

这些天我正在学习设计模式。有很多关于编程设计模式的文档，但我对闭包设计模式很感兴趣。

我找到了关于 Design Patterns in Java and Groovy 的 Venkat Subramaniam 的介绍。 ，并根据我自己的经验提取此演示文稿的一些模式，这些模式涉及闭包和其他模式。

执行环绕方法

操作前后需要执行的一对操作。

def operations(closure) {
    println "Open"
    closure()
    println "Close"
}

operations { println "Operation" }

===> Open
===> Operation
===> Close

可插拔行为

指定对象在运行时的行为。

def selectValues(number, closure) {
    def list = []
    1.upto(number) {
        if (closure(it)) list << it
    }
    return list
}

assert [2, 4, 6, 8, 10] == selectValues(10) { it % 2 == 0 }  // even
assert [1, 3, 5, 7, 9]  == selectValues(10) { it % 2 != 0 }  // odd

迭代器模式

允许顺序访问元素。

def listNumbers(closure) {
    (0..5).each { closure it }
}

listNumbers {
    if (it < 3) println "$it is a little number"
    else println "$it is a big number"
}

===> 0 is a little number
===> 1 is a little number
===> 2 is a little number
===> 3 is a big number
===> 4 is a big number
===> 5 is a big number

动态条件执行

创建并执行条件操作。

def greet(user, successClosure, failClosure) {
    if (isAdmin(user)) successClosure()
    else failClosure()
}

greet(user, { println "Hi Admin!" }, { println "Hello User" })

我想了解更多闭包设计模式。有没有关于这个话题的引用？随意用你最喜欢的编程语言编写一个新模式。

更新

我写了一篇关于这个主题的帖子(Groovy 和 Ruby，但内容相同):
Closure Design Patterns
Closure Design Patterns. Ruby Edition

Answer 1

我认为您将闭包与 lambda/匿名函数混淆了？

Closure是具有绑定(bind)变量的词汇上下文。简而言之，如果您从函数内部定义函数，则内部函数可以访问外部函数中定义的变量。在这种情况下，“词汇上下文”是外部函数。

Lambdas是没有变量赋值的函数。例如，在 Ruby 中，您可以将 block 传递给函数，而函数可以在内部调用它，仅使用 yield关键词。在 JavaScript 中，您可以定义一个函数并同时将其作为参数传递。你的例子就是这样。

First-class functions是另一件事，它们是可以像常规对象一样传递的函数。您可以将它们作为参数传递给函数调用并保存对它们的引用。这就像 Ruby 的 Proc .在 JS 中，所有的函数都是一等的，所有的函数都是对象。

在 JavaScript 中，我们可以用一个愚蠢的例子来说明所有 3 个:

function foo(func) {
  func();
}
var bar = function() {    // bar is a first-class function
  var i = 5;
  foo(function() {        // this is the anonymous function (lambda)
    console.log(i);       // i is the closure-bound variable
  });
}
foo(bar);   // Prints 5

因此，这使您的问题令人困惑。闭包是一种语言特性，而不是一种设计模式。有很多设计模式的实现可以使用闭包或 lambda 或模或构造函数或其他任何东西，正如您通过这些示例向自己展示的那样。虽然这些都不是 classical design patterns ，所以我不确定我什至会这样称呼他们。也许我会称它们为糖。

Java 可以实现各种设计模式，但没有这些特性。很多这类事情都是通过接口(interface)完成的，这是一种完全不同的语言特性。