closures

When we are creating a method inside a closure it becomes private to that closure and can't be accessed until we expose it in some way. How can it be exposed? You can return a reference to it... var a = function() { var b = function() { // I'm private! alert('go away!'); }; return { b: b // Not anymore! }; }; See it on jsFiddle . You could also bind it to the window object . But I prefer the method above, otherwise you are exposing it via a global variable (being a property of the window object). You need to pass it to the outside in some manner. Example: http://jsfiddle.net/patrick_dw/T9vnn/1

for (var i = 0; i < somearray.length; i++) { myclass.foo({'arg1':somearray[i][0]}, function() { console.log(somearray[i][0]); }); } How do I pass somearray or one of its indexes into the anonymous function ? somearray is already in the global scope, but I still get somearray[i] is undefined The i in the anonymous function captures the variable i , not its value . By the end of the loop, i is equal to somearray.length , so when you invoke the function it tries to access an non-existing element array. You can fix this by making a function-constructing function that captures the variable's value:

A PowerShell ScriptBlock is not a lexical closure as it does not close over the variables referenced in its declaring environment. Instead it seems to leverage dynamic scope and free variables which are bound at run time in a lambda expression. function Get-Block { $b = "PowerShell" $value = {"Hello $b"} return $value } $block = Get-Block & $block # Hello # PowerShell is not written as it is not defined in the scope # in which the block was executed. function foo { $value = 5 function bar { return $value } return bar } foo # 5 # 5 is written $value existed during the evaluation of the bar

class A { public event EventHandler AEvent; } class B { private A _foo; private int _bar; public void AttachToAEvent() { _foo.AEvent += delegate() { ... UseBar(_bar); ... } } } Since delegate captures variable this._bar , does it implicitly hold to the instance of B ? Will instance of B be referenced through the event handler and captured variable by an instance of A ? Would it be different if _bar was a local variable of the AttachToAEvent method? Since in my case an instance of A lives far longer and is far smaller than an instance of B , I'm worried to cause a "memory leak" by doing this.

Update: I tried writing it without making it weak, and there doesn't seem to be a leak. So maybe the question is no longer necessary. In Objective-C ARC, when you want to have a closure be able to use itself inside of the closure, the block cannot capture a strong reference to itself, or it will be a retain cycle, so instead you can make the closure capture a weak reference to itself, like so: // This is a simplified example, but there are real uses of recursive closures int (^fib)(int); __block __weak int (^weak_fib)(int); weak_fib = fib = ^(int n) { if (n < 2) return n; else return weak_fib