¿Cómo puedo acceder al ámbito local dinámicamente en javascript?

Question

Si desea utilizar las funciones globales y variables dinámicamente puede utilizar:

window[functionName](window[varName]); 

¿Es posible hacer lo mismo para las variables en el ámbito local?

Este código funciona correctamente pero actualmente usa eval y estoy tratando de pensar en qué otra manera hacerlo.

var test = function(){ 
    //this = window 
    var a, b, c; //private variables 

    var prop = function(name, def){ 
     //this = window 
     eval(name+ ' = ' + (def.toSource() || undefined) + ';');  

     return function(value){ 
      //this = test object 
      if (!value) { 
       return eval('(' + name + ')'); 
      } 
      eval(name + ' = value;') 
      return this; 
     }; 

    }; 

    return { 
     a:prop('a', 1), 
     b:prop('b', 2), 
     c:prop('c', 3), 
     d:function(){ 
      //to show that they are accessible via to methods 
      return [a,b,c]; 
     } 
    }; 
}(); 

>>>test 
Object 
>>>test.prop 
undefined 
>>>test.a 
function() 
>>>test.a() 
1 //returns the default 
>>>test.a(123) 
Object //returns the object 
>>>test.a() 
123 //returns the changed private variable 
>>>test.d() 
[123,2,3] 

Answer 1

No, como crescentfresh dicho. A continuación encontrará un ejemplo de cómo implementar sin eval, pero con un objeto privado interno.

var test = function() { 
    var prv={ }; 
    function prop(name, def) { 
    prv[name] = def; 
    return function(value) { 
     // if (!value) is true for 'undefined', 'null', '0', NaN, '' (empty string) and false. 
     // I assume you wanted undefined. If you also want null add: || value===null 
     // Another way is to check arguments.length to get how many parameters was 
     // given to this function when it was called. 
     if (typeof value === "undefined"){ 
     //check if hasOwnProperty so you don't unexpected results from 
     //the objects prototype. 
     return Object.prototype.hasOwnProperty.call(prv,name) ? prv[name] : undefined; 
     } 
     prv[name]=value; 
     return this; 
    } 
    }; 

    return pub = { 
    a:prop('a', 1), 
    b:prop('b', 2), 
    c:prop('c', 3), 
    d:function(){ 
     //to show that they are accessible via two methods 
     //This is a case where 'with' could be used since it only reads from the object. 
     return [prv.a,prv.b,prv.c]; 
    } 
    }; 
}(); 

Answer 2

Espero que no simplifique demasiado, pero ¿qué pasa con algo tan simple como usar un objeto?

var test = { 
    getValue : function(localName){ 
     return this[localName]; 
    }, 
    setValue : function(localName, value){ 
     return this[localName] = value; 
    } 
}; 

>>> test.a = 123 
>>> test.getValue('a') 
123 
>>> test.a 
123 

>>> test.setValue('b', 999) 
999 
>>> test.b 
999 

Answer 3

Para responder a su pregunta, no, no hay manera de hacer las operaciones de búsqueda variable dinámica en un ámbito local sin necesidad de utilizar eval().

La mejor alternativa es hacer que su "alcance" sea solo un objeto normal [literal] (es decir, "{}"), y pegar sus datos allí.