标签: lexical-closures

我需要一个回调函数,对于一系列gui事件几乎完全相同.该函数的行为会略有不同,具体取决于调用它的事件.对我来说似乎是一个简单的案例,但我无法弄清楚lambda函数的这种奇怪的行为.

所以我在下面有以下简化代码:

def callback(msg):
    print msg

#creating a list of function handles with an iterator
funcList=[]
for m in ('do', 're', 'mi'):
    funcList.append(lambda: callback(m))
for f in funcList:
    f()

#create one at a time
funcList=[]
funcList.append(lambda: callback('do'))
funcList.append(lambda: callback('re'))
funcList.append(lambda: callback('mi'))
for f in funcList:
    f()

此代码的输出是:

mi
mi
mi
do
re
mi

我期望:

do
re
mi
do
re
mi

为什么使用迭代器搞砸了？

我尝试过使用深度镜:

import copy
funcList=[]
for m in ('do', 're', 'mi'):
    funcList.append(lambda: callback(copy.deepcopy(m)))
for f in funcList:
    f()

但这也存在同样的问题.

我正在阅读关于网上关闭的内容.我想知道C++是否有一个内置的闭包工具,或者我们是否可以用C++实现闭包？

我正在尝试创建可应用于任何函数的curry函数,并返回另一个函数,并应用了1个参数.我想要的属性:

1. 如果函数只有一个参数curry函数应该返回值:f(a); 咖喱(f,x)= f(x);
2. 如果函数有很多参数,则应该重新计算curried函数:g(a1,a2,..,aN); 咖喱(g,x)= g2(a2,..,aN):g2(a2,.. aN)= g(x,a2,...,aN)
3. 咖喱功能的长度应该"根据需要"工作g.length = N =>咖喱(g,x).长度= N-1

Prototype Framework中有一些咖喱实现,并在一个博客中进行讨论.但是这个实现并不好,因为它对只有一个参数(1)的函数不起作用,并且返回函数'length'属性为0(3).

对于第一个属性,有一个简单的实现:

 function curry(f,x) {
    if (f.length == 1) return f(x);
    ...
 }

但是我不知道如何使用第3个规则,即函数可以被构造为内部函数,因为将有一个嵌套的词法环境并且能够使用f:

function curry(f,x) {
   return function() { ... }
}

但在这种情况下,我将不再能够显式设置参数.另一方面,函数可以使用'new Function'语句构造,类似于:

 function curry(f,x) {
    var args = [];
    for (var i=1; i<f.length; i++) {
       args.push('a'+i);
    }
    var sa = args.join();
    return new Function(sa,"return f(x,"+sa+")");
 }

但在这种情况下,f和x将解除绑定,因为将在Global Lexical Environment中创建匿名函数.

所以问题:

1. 有没有办法在用函数关键字创建函数时显式设置参数计数？
2. 有没有办法设置用'new Function'语句创建的函数的环境？
3. 我们有办法以任何其他方式解决我的问题吗？

有问题的性别是

(((lambda (b)
  (lambda (a)
    (+ b a))) 3) 5)

对我来说,它看起来应该评估8,并且在其他lisps(例如Racket)中它确实如此,但在elisp中它反而抛出了这个错误:

Debugger entered--Lisp error: (invalid-function ((lambda (b) (lambda (a) (+ b a))) 3))

它似乎在告诉我

((lambda (b)
  (lambda (a)
    (+ b a))) 3)

不是有效的功能.这似乎是错误的,因为当我评估那个表达式时,我得到了

(lambda (a) (+ b a))

这看起来对我来说是一个有效的功能.有谁知道为什么会这样？它与动态范围有关吗？

我理解'js'中的函数具有词法范围(即函数在定义它们时不创建它们的环境(范围).)

function f1() {
    var a = 1;
    f2();
}

function f2() {
    return a;
}
f1(); // a is not defined

当我只运行'f()'时,它返回内部函数.我得到了,这就是"回归"的作用!

function f() {
    var b = "barb";
    return function() {
        return b;
    }
}
console.log(b); //ReferenceError: b is not defined

为什么会出现'ReferenceError:b未定义？' 但是上面的内部函数是不是可以访问它的空间,f()的空间等.由于'b'被返回到全局空间,console.log()不会工作吗？

但是,当我将'f()'分配给一个新变量并运行它时:

 var x = f(); 
 x();// "barb"
 console.log(b); //ReferenceError: b is not defined

这将返回'b',即"barb",但是当你再次运行console.log()时,你会得到'ReferenceError:'b'没有被定义'; 现在不是'b'在全球范围内,因为它已被退回？为什么'x()'也没有像'f()'那样返回内部函数呢？

我正在阅读关于C#和闭包,各种文章,Jon Skeet非常棒的" C#in Depth ",我看到像"C#和ruby实现词汇封闭"这样的陈述.

为什么作者包含"词汇"这个词？为什么不说他们"实施封闭"？

如果只是实施"封闭",而不是"词汇封闭(如果可能的话)",这意味着什么？

我理解箭头函数在ES6中是如何工作的,以及词汇这个,但是我想知道是否有人知道如何将参数传递给箭头函数？

在ES5中,您可以简单地执行以下操作:

function foo( bar, baz ){
    console.log('Args:', arguments.join(', '))
}

但是,在ES6中,如果使用箭头功能,如下所示:

const foo = ( bar, baz ) => {
    console.log('Args:', arguments.join(', '))
}

该arguments变量返回一个对象,该对象与参数无关.

所以,我想知道是否有人有办法将参数传递给箭头函数？

编辑

我想也许我应该提供一些关于我想要完成的事情的信息,也许如果以上是不可能的,有人有更好的主意.

基本上,我正在向BluebirdJS asCallback方法添加一个IIEF ,它将确定是否实际提供了回调,如果没有,则返回promise.

下面是ES5中的一个工作示例:

var _ = require('lodash')
var Promise = require('bluebird')

function testFunc( foo, callback ) {
    return new Promise( function ( res, rej ){
        res('You Said: ' + (_.isString( foo ) ? foo : 'NOTHING') )
    })
        .asCallback((function ( args ) {
            return _.findLast(args, function(a) { …

function buildList( list ) {
  var i      = 0;
  var first  = function () {
    console.log( "in" )
    console.log( i );
  }
  var Second = function () {
    console.log( "out" )
    first();
  }
  return Second;
}

var a = buildList( [1, 2, 3] )
console.dir( a );

a(); // Here closure is created which has function first ,Here first also has one closure of itself that means recursive closure

当我在Chrome中看到我的控制台时,它有一个闭包,它首先有一个函数,它本身就有一个闭包,即它有关闭时自身功能的重复循环,有没有人知道这里发生了什么,我很困惑,为什么有infinte闭环

我有一个Vue JS(Vuetify)应用程序,它发出一个ajax请求,我想用响应填充div的内容,但是我在访问实例的数据时遇到了困难.我看到的所有示例都使用它来指向数据对象,但是当我这样做时,我得到了这个错误

Unable to set property 'message' of undefined or null reference

该应用程序非常简单:

main.js:

import Vue from 'vue'
import App from './App.vue'
import Vuetify from 'vuetify'


Vue.use(Vuetify)

new Vue({
  el: '#app',
  render: h => h(App)
})

App.vue

export default {
  data () {
    return {
    ....
    message: '',
    order: {},
    ...
  },
  methods: {
    send: function() {
      axios.post(this.api+"orders",this.order).then(function(response) {
        this.message = "Your payment was successful";
        ...
      }
   }
 }

this.order是不与爱可信的问题访问后法然而,处理返回的承诺匿名函数似乎有访问问题this.message,在违背我所看到的例子. …

我经常交换！使用匿名函数的原子值，该匿名函数在计算新值时使用一个或多个外部值。有两种方法可以执行此操作，一种是我了解的是闭合，而另一种则不是，我的问题是哪种方法更好/更有效？

这是一个简单的示例-向原子添加变量数值-显示两种方法：

(def my-atom (atom 0))

(defn add-val-with-closure [n]
  (swap! my-atom 
         (fn [curr-val] 
           ;; we pull 'n' from outside the scope of the function
           ;; asking the compiler to do some magic to make this work
           (+ curr-val n)) ))

(defn add-val-no-closure [n]
  (swap! my-atom 
         (fn [curr-val val-to-add] 
           ;; we bring 'n' into the scope of the function as the second function parameter
           ;; so no closure is needed
           (+ curr-val val-to-add))
         n))

这是一个虚构的示例，当然，您实际上不会编写此代码来解决此特定问题，因为：

(swap! my-atom + n)

无需额外功能即可完成相同的操作。

但是在更复杂的情况下，您确实需要一个函数，然后问题就出现了。对我来说，从编码的角度来看，解决问题的两种方法的复杂度大致相同。如果是这样，我应该选择哪个？我的工作假设是，非封闭方法是更好的方法（因为编译器更容易实现）。 …