Asignación de desestructuración en JavaScript

Question

Como se puede ver en el registro de cambios de Mozilla para JavaScript 1.7, se han agregado tareas de desestructuración. Lamentablemente, no me gusta mucho la sintaxis (¿por qué escribir ayb dos veces?):

var a, b;  
[a, b] = f();

Algo como esto hubiera sido mucho mejor:

var [a, b] = f();

Eso todavía sería compatible con versiones anteriores. La desestructuración tipo Python no sería compatible con versiones anteriores.

De todos modos, la mejor solución para JavaScript 1.5 que he podido encontrar es:

function assign(array, map) {
    var o = Object();
    var i = 0;
    $.each(map, function(e, _) {
        o[e] = array[i++];
    });
    return o;
}

Que funciona así:

var array = [1,2];
var _ = assign[array, { var1: null, var2: null });
_.var1; // prints 1
_.var2; // prints 2

Pero esto realmente apesta porque _ no tiene sentido. Es solo una cáscara vacía para almacenar los nombres. Pero lamentablemente es necesario porque JavaScript no tiene punteros. En el lado positivo, puede asignar valores predeterminados en caso de que los valores no coincidan. También tenga en cuenta que esta solución no intenta cortar la matriz. Así que no puedes hacer algo como {first: 0, rest: 0} . Pero eso podría hacerse fácilmente, si uno quisiera ese comportamiento.

¿Qué es una mejor solución?

Answer 1

Primero que nada, var [a, b] = f () funciona bien en JavaScript 1.7 - ¡pruébalo!

Segundo, puedes suavizar la sintaxis de uso ligeramente usando con () :

var array = [1,2];
with (assign(array, { var1: null, var2: null }))
{
   var1; // == 1
   var2; // == 2
}

Por supuesto, esto no le permitirá modificar los valores de las variables existentes, por lo que en mi humilde opinión es mucho menos útil que la característica JavaScript 1.7. En el código que estoy escribiendo ahora , solo devuelvo los objetos directamente y hago referencia a sus miembros. Esperaré que las características 1.7 estén más disponibles.

Answer 2

No necesitas el dummy " _ " variable. Puede crear directamente "global" variables utilizando el alcance del objeto ventana:

window["foo"] = "bar";
alert(foo); // Gives "bar"

Aquí hay algunos puntos más:

• no nombraría esta función " asignar " porque eso es demasiado genérico un término.
• Para parecerse más a JS 1.7 sintaxis, haría que la función tome el destino como el primero argumento y la fuente como el segundo argumento.
• Usar un literal de objeto para pasar las variables de destino es genial, pero se puede confundir con la desestructuración JS 1.7 donde el destino es en realidad un objeto y no una matriz. Prefiero usar una lista de nombres de variables delimitada por comas como una cadena.

Esto es lo que se me ocurrió:

function destructure(dest, src) {  
    dest = dest.split(",");  

    for (var i = 0; i < src.length; i++) {  
        window[dest[i]] = src[i];  
    }  
}  

var arr = [42, 66];  

destructure("var1,var2", arr); 

alert(var1); // Gives 42
alert(var2); // Gives 66

Answer 3

Esto es lo que hice en PHPstorm 10:

Archivo - > Configuración - > Idiomas y amperios; Marcos - > ...

... configura la versión de lenguaje JavaScript, por ejemplo JavaScript 1.8.5 ...

- > haga clic en Aplicar.

Answer 4

En JavaScript estándar nos acostumbramos a todo tipo de fealdad, y emular la asignación de desestructuración usando una variable intermedia no es tan malo:

function divMod1(a, b) {
    return [ Math.floor(a / b), a % b ];
}

var _ = divMod1(11, 3);
var div = _[0];
var mod = _[1];
alert("(1) div=" + div + ", mod=" + mod );

Sin embargo, creo que el siguiente patrón es más idomático:

function divMod2(a, b, callback) {
    callback(Math.floor(a / b), a % b);
}

divMod2(11, 3, function(div, mod) {
    alert("(2) div=" + div + ", mod=" + mod );
});

Tenga en cuenta que, en lugar de devolver los dos resultados como una matriz, los pasamos como argumentos a una función de devolución de llamada.

(Vea el código que se ejecuta en http://jsfiddle.net/vVQE3/ )