Is it possible to access local variable in another function by any trick ?

Question

4.00/5 (1 vote)

See more:

Hi, need a help on this. is this possible ?

https://jsfiddle.net/57jtpssr/[^]

I just wanted to access a & b variable in a() function. is there is any trick or tricky closures or callback or deferred or work around to make it work without making a & b variables are global ?

We can even consider module variable is a function in custom widget when it comes to dojo.

any workaround without making the variables global would be much appreciated :)

Thanks in advance. :)

Posted 29-Jul-15 7:58am

zingcoders

Add a Solution

4 solutions

Solution 1

No.
Local variables are stack based: which means that they exist for the lifetime of the function only, and when the function exits the memory they occupied is re-cycled for use by the next function. Additionally, they are not in a fixed location in memory each time, because where on the stack they are stored depends on the activity which lead up to the function being called.

Posted 29-Jul-15 8:40am

OriginalGriff

v2

Comments

Sergey Alexandrovich Kryukov 29-Jul-15 14:47pm

Sorry, you missed such important feature as closure. Formally, and lexically, the local variables which belong to a closure should also be called "local", but by their lifetime they behave like "static" (there is no such notion in JavaScript, but global-context variables behave like that). So, as the inquirer asked just about "local variable", such variables should be considered as "local", and closure case is applicable to the topic of the question.
—SA

Afzaal Ahmad Zeeshan 29-Jul-15 14:57pm

OriginalGriff, time to learn some Object-oriented JavaScript too. :-) Read my answer Solution 3 to learn how to convert JavaScript to OOP to access variables (as members) from functions.

Sergey Alexandrovich Kryukov 29-Jul-15 15:29pm

Too bad 1) it is not really object-oriented, 2) irrelevant to the question. The way to mimic OOP syntax with JavaScript is not real OOP could be useful in some cases, but would rather distract from understanding what JavaScript does. Even if it is rather colloquially called "OOP", it does not give those dramatic OOP benefits as in .NET or C++.
—SA

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Sergey Alexandrovich Kryukov · Accepted Answer · 2015-07-29T08:41:00

The whole idea of "trick" in programming is wrong.

Short answer is: you cannot access a local variable, and it makes no sense because such variables are placed on stack; and the stack frame is removed after the return from a function.

But let's go deeper. Strictly speaking, this is not always exactly so, because you can make some local variable a part of the closure. Please see: https://en.wikipedia.org/wiki/Closure_%28computer_programming%29[^].

Let's consider the following JavaScript:

JavaScript

function getAccessToLocalVariable() {
      var localVariable = 0;
      return function() {
          localVariable++;
          return localVariable;
      }
}

// let's test it:
var incrementor = getAccessToLocalVariable();
alert(incrementor());
alert(incrementor());

If you run the "test it" fragment, you will get the value of localVariable incremented on each call. Of course, you could return an object which gives direct access to the variable, through two functions returned in this object: one for "getter", another one for "setter":

JavaScript

function getAccessToLocalVariable() {
      var localVariable = 1;
      var getter = function() {
          return localVariable;
      }
      var setter = function(value) {
          localVariable = value;        
      }
      return {"getter": getter, "setter": setter};
}

// let's test it:
var accessor = getAccessToLocalVariable();
alert(accessor.getter());
accessor.setter(10);
alert(accessor.getter());

It's much easier to implement than to explain how it works. I hope the article I referenced above can help you to understand it. First of all, throw out the common misconception that JavaScript is a pure interpreter which process statements one by one. No, it does forward lexical analysis and some pre-processing first. So, when the JavaScript engine detects that some function accesses some objects from the outer context, such as getter accessing localVariable, and the object is accessed through some local variable of the outer context, this local variable changes the way it is stored: it joins the closure, which should be understood as a set of objects "with extended lifetime". Roughly speaking, the objects from this set behave exactly as the object of the global context, but the variables used to access them behave like local variables.

The techniques based on closures can be very useful, because they can help you to hide some context intended to serve as implementation detail, with limited and controlled access from outside context. Of course, the second example makes little practical sense; but such technique (called property feature in object-oriented languages) is introduce to implement some side effect in addition to usual read/assign semantics. Of course, there are many other applications of closures.

—SA

kellyapt1 · Accepted Answer · 2015-07-29T09:10:00

Another approach is to return an object from the function like this:

C#

var module = function(){
    
    var a = 10;
    var b = 20;
    
    return {
        a: a   
    }
    
};

function a(){
    console.log("hi");
    console.log(module().a);
}

a();

https://jsfiddle.net/kellyapt1/57jtpssr/2/[^]

Afzaal Ahmad Zeeshan · Accepted Answer · 2015-07-29T08:53:00

Initially, I was gonna say, No. Just by judging the question by the term "local variable". But no the answer is Yes, but a simple Object-oriented JavaScript hack. Although JavaScript is not based on Object-oriented semantics but it can be casted to one. The problem that you are having is that the scope goes out as soon as the function hits final bracket.

For this sake, I came to remember I was using the same thing back a few months where I learnt OOP in JavaScript. The scenario was same, so, I created a quick fix to your fiddle to convert the pattern to OOP.

In JS-OOP, you create a variable holding a function, and you design their members using this keyword. Like this,

JavaScript

var module = function () {
  this.a = 10;
  this.b = 20;
}

Now, module is similar to the class in C#. You can create a new instance of it, as,

JavaScript

var mod = new module();

Now our context is similar to C# or Java. Call members on it, do what so ever you want to do. :-) Your code is now changed to this,

JavaScript

var module = function(){
    
    // members
    this.a = 10;
    this.b = 20;
    
};

function a(){
    console.log("hi"); // Your console log
    console.log(new module().a); // Logs 10
}

a();

// Output:
// hi
// 10

You can try out your code sample at: https://jsfiddle.net/afzaal_ahmad_zeeshan/57jtpssr/1/[^]

For more on Object-oriented JavaScript, please refer to MDN[^].

Is it possible to access local variable in another function by any trick ?

4 solutions

Solution 2

Solution 4

Solution 3

Solution 1

Add your solution here

Preview 0