封闭性设计模式

Question

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

我发现了Venkat关于Java和Groovy中的设计模式的演示，并根据自己的经验提取了涉及闭包的一些模式和其他模式。

循环执行法

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

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，但内容相同)：

封闭性设计模式

封闭设计模式。红宝石版

Answer 1

我觉得你把闭包和lambda/匿名函数搞混了？

闭包是一个具有绑定变量的词法上下文。简而言之，如果从函数内部定义函数，则内部函数可以访问外部函数中定义的变量。在这种情况下，“词法上下文”是外部功能。

兰巴斯是没有变量赋值的函数。例如，在Ruby中，您可以将块传递给函数，并且函数可以只使用yield关键字在内部调用它。在JavaScript中，您可以定义函数并同时将其作为参数传递。你的例子就是这些。

一级函数是另一回事，它是可以像普通对象一样传递的函数。您可以将它们作为参数传递给函数调用，并保存对它们的引用。这就像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、模块化或构造函数等等，就像您在这些示例中展示的那样。虽然这些都不是古典设计模式，所以我不确定我是否会这样称呼它们。也许我该叫他们糖。

Java可以实现各种设计模式，但没有这些特性。很多这样的东西都是用接口来完成的，这是一种完全不同的语言特性。

Answer 2

正如人们所说的，这些不是真正的“模式”，而且是Groovy特有的，但是闭包的另外两种用法是：

1.可组合性

def sum    = { Collection a -> a.sum() }
def first2 = { Collection a -> a.take( 2 ) }

def take2andAdd = sum << first2

println take2andAdd( [ 1, 2, 3, 4 ] ) // Prints 3

2.竞逐

def add = { a, b -> a + b }
def add2 = add.curry( 2 )

println add2( 3 ) // Prints 5

当然，可以将这些因素结合起来：

def square = { a -> a * a }
def add = { a, b -> a + b }
def add2 = add.curry( 2 )

def add2andSquare = square << add2

println add2andSquare( 3 ) // prints 25

Answer 3

我同意其他回应，因为谈论闭包设计模式(特别是当你真的在谈论一流的函数时)是没有意义的。我认为，您真正想要了解的一点是，在实现设计模式时，如何使用诸如一流函数、lambda和闭包之类的工具。虽然它是特定于Groovy的，但是您可能会发现查看这个页面是有用的：http://groovy.codehaus.org/Design+Patterns+with+Groovy

例如，“”展示了如何使用闭包的方式非常类似于您的“”模式，而"Visitor模式“也很好地利用了闭包，并且没有包含在列表中。