variable local de Javascript declarar

Question

Básicamente se trata de una cuestión de cómo acceder al controlador de ámbito local. Estoy tratando de lograr algo similar para la definición de variable global como:

window['newObject'] = "some string"; 
alert(newObject); 

pero para alcance local. En este momento la única solución que tengo es que utilizan evals:

eval("var newObject='some string'"); 

pero esto es realmente una solución fea ... La mejor uno sería como usar alguna referencia al ámbito local como en una solución de ventana [], pero nunca oí de cualquier referencia al alcance local ... ¿Alguna idea?

Ejemplo va aquí:

function x(arg) 
{ 
    localScope[arg.name]=arg.value; 
    alert(sex); 
} 

x({name:"sex", value:"Male"}); 

Answer 1

Okey He encontrado una pregunta relacionada que está hablando de lo que necesito ...

How can I access local scope dynamically in javascript?

Sólo recuerdo que, en ECMA 262 es sólo una manera de añadir las variables dinámicamente locales de alcance utilizando "with" (y eval por supuesto), he aquí la solución:

var x=function(obj) 
{ 

    with(obj) 
    { 
     alert(someObj); 
    } 
} 
alert(typeof someObj); 


x ({someObj:"yea"}) ; 

alert(typeof someObj); 

Answer 2

Debo estar perdiendo algo. ¿Qué es lo que quiere diferente de simplemente hacer:

var newObject = 'some string'; 

? (OP ha aclarado la pregunta)

No creo que haya una manera de hacer lo que está pidiendo. Use miembros de un objeto local, p.

function doSomething(name, value) 
{ 
    var X = {}; 
    X[name] = value; 
    if (X.foo == 26) 
    alert("you apparently just called doSomething('foo',26)"); 
} 

Si elige una variable 1-personaje como $ o X, se "costos" encontrado 2 caracteres (nombre de variable más un punto), y evita tratar de usar eval o haciendo algo raro.

Answer 3

Pregunta interesante, nunca pensé en algo como esto. Pero, ¿cuál es el uso?

La razón por la que querría hacer algo como esto, es si no conoce el nombre de la variable. Pero luego, en ese caso, la única forma de acceder a la variable nuevamente sería utilizando el mismo objeto de referencia. Es decir. solo podría usar cualquier objeto antiguo para almacenar datos.

La lectura de un objeto de referencia de este tipo sería interesante para la depuración, pero no veo por qué querría escribir en ella.

Editar:

El ejemplo informados no convencerme de la necesidad de acceso al ámbito local, ya que todavía tiene el nombre sex codificado en la alerta. Esto podría implementarse como:

function x(arg) 
{ 
    container = {}; 
    container[arg.name] = arg.value; 
    alert(container.sex); 
} 

¿Podría dar más detalles sobre el ejemplo?

Answer 4

¿Por qué no crear un objeto en el ámbito local y luego usarlo como un contenedor para las variables que desea crear dinámicamente?

function x(arg) 
{ 
    var localSpace = {}; 
    localSpace[arg.name] = arg.value; 
} 

Answer 5

No estoy del todo seguro de entender tu pregunta. Al crear una clase X, por lo general hago esto:

function x(args) { 
    var _self = this; 

    _self.PriviledgedMethod(a) { 
     // some code 
    } 

    function privateMethod(a) { 
     // some code 
    } 
} 

var newObject = new x(args); 

Puede seguir teniendo acceso a _self y argumentos ya que está cerrado por las funciones contenidas.

Answer 6

puede probar con el llamado argumentos truco
EDIT: Esto no es el navegador cruz

function x({sex:sex, height:height}) { 
    alert(sex); 
    alert(height); 
} 

x({ sex: 'male', height: 'short' }); 
x({ height: 'medium', sex: 'female' }); 

// male 
// short 
// female 
// medium 

Answer 7

Lo que estamos buscando se llama el objeto llamada. Pero de acuerdo con this, no puede acceder directamente, por lo que no tiene suerte.

Answer 8

No estoy seguro de lo que necesita exactamente, pero aquí está mi 2 centavos.

La única manera de crear dinámicamente vars en una función existente es el método eval que ya ha mencionado.

Otra opción (mencionado por otros) es que su función de tomar un mapa de contexto, y la plantilla de acceso con la notación de puntos (context.var1)

Mi sugerencia final es el constructor de funciones. Pero tengo la sensación de que esto es lo que estás buscando. (Tenga en cuenta que el constructor función adolece de los mismos problemas que una llamada eval)

var arg1 = "first"; 
var arg2 = "last"; 

// This is the body of the function that you want to execute with first 
// and last as local variables. It would come from your template 
var functionBody = "alert(first + ' ' + last)"; 

var myCustomFun = new Function(arg1, arg2, functionBody); 

myCustomFun("Mark", "Brown"); // brings up and alert saying "Mark Brown"; 

creo que sirve