used - Asignaciones de variables JavaScript desde Tuples

object destructuring javascript

Question

En otros lenguajes como Python 2 y Python 3, puede definir y asignar valores a una variable de tupla y recuperar sus valores de esta manera:

tuple = ("Bob", 24)
name, age = tuple
print(name)           #name evaluates to Bob
print(age)            #age evaluates to 24

¿Hay algo similar en JavaScript? O simplemente tengo que hacerlo de la manera fea con una matriz:

tuple = ["Bob", 24]
name = tuple[0]       //name Evaluates to Bob
age = tuple[1]        //age Evaluates to 24

¿Hay una mejor manera de simular tuplas de Python en JavaScript 5?

Answer 1

Aquí hay una implementación simple de Javascript Tuple:

var Tuple = (function () {
   function Tuple(Item1, Item2) {
      var item1 = Item1;
      var item2 = Item2;
      Object.defineProperty(this, "Item1", {
          get: function() { return item1  }
      });
      Object.defineProperty(this, "Item2", {
          get: function() { return item2  }
      });
   }
   return Tuple;
})();

var tuple = new Tuple("Bob", 25); // Instantiation of a new Tuple
var name = tuple.Item1; // Assignment. name will be "Bob"
tuple.Item1 = "Kirk"; // Will not set it. It''s immutable.

Esta es una tupla de 2, sin embargo, puedes modificar mi ejemplo para soportar tuplas de 3,4,5,6, etc.

Answer 2

Como actualización de la respuesta del Ministro, ahora puede hacer esto con es2015:

function Tuple(...args) {
  args.forEach((val, idx) => 
    Object.defineProperty(this, "item"+idx, { get: () => val })
  )
}


var t = new Tuple("a", 123)
console.log(t.item0) // "a"
t.item0 = "b"
console.log(t.item0) // "a"

https://jsbin.com/fubaluwimo/edit?js,console

Answer 3

Esta característica de "tupla" se denomina desestructuración en EcmaScript2015 y pronto será respaldada por navegadores actualizados. Por el momento, solo Firefox y Chrome lo admiten .

Pero oye, puedes usar un transpiler .

El código se vería tan bien como Python:

let tuple = ["Bob", 24]
let [name, age] = tuple

console.log(name)
console.log(age)

Answer 4

Esto no pretende ser utilizado realmente en la vida real, solo un ejercicio interesante. Consulte ¿Por qué el uso de la función de evaluación de JavaScript es una mala idea? para detalles.

Esto es lo más cercano que puede obtener sin recurrir a extensiones específicas del proveedor:

myArray = [1,2,3];
eval(set(''a,b,c = myArray''));

Función de ayudante:

function set(code) {
    var vars=code.split(''='')[0].trim().split('','');
    var array=code.split(''='')[1].trim();
    return ''var ''+vars.map(function(x,i){return x+''=''+array+''[''+i+'']''}).join('','');
}

Prueba de que funciona en un alcance arbitrario:

(function(){
    myArray = [4,5,6];
    eval(set(''x,y,z = myArray''));
    console.log(y);  // prints 5
})()

eval no es compatible con Safari.

Answer 5

Javascript 1.7 agregó una asignación desestructurada que le permite hacer esencialmente lo que busca.

function getTuple(){
   return ["Bob", 24];
}
var [a, b] = getTuple();
// a === "bob" , b === 24 are both true

Answer 6

Lamentablemente, no puede usar esa sintaxis de asignación de tuplas en Script (ECMA | Java).

EDITAR: Alguien vinculado a Mozilla / JS 1.7 - esto no funcionaría en todos los navegadores, pero si eso no es necesario, entonces está su respuesta.

Answer 7

Puedes hacer algo similar:

var tuple = Object.freeze({ name:''Bob'', age:14 })

y luego se refieren al nombre y la edad como atributos

tuple.name 
tuple.age 

Answer 8

También puede tener un tipo de tupla en Javascript. Simplemente defínalo con funciones de orden superior (el término académico es la codificación de la Iglesia):

const Tuple = (...args) => {
  const Tuple = f => f(...args);
  return Object.freeze(Object.assign(Tuple, args));
};

const get1 = tx => tx((x, y) => x);

const get2 = tx => tx((x, y) => y);

const bimap = f => g => tx => tx((x, y) => Tuple(f(x), g(y)));

const toArray = tx => tx((...args) => args);

// aux functions

const inc = x => x + 1;
const toUpperCase = x => x.toUpperCase();

// mock data

const pair = Tuple(1, "a");

// application

console.assert(get1(pair) === 1);
console.assert(get2(pair) === "a");

const {0:x, 1:y} = pair;
console.log(x, y); // 1 a

console.log(toArray(bimap(inc) (toUpperCase) (pair))); // [2, "A"]

const map = new Map([Tuple(1, "a"), Tuple(2, "b")]);
console.log(map.get(1), map.get(2)); // a b

Tenga en cuenta que Tuple no se usa como un constructor normal. La solución no se basa en absoluto en el sistema prototipo, sino únicamente en funciones de orden superior.

¿Cuáles son las ventajas de las tuplas sobre las Array utilizadas como tuplas? Las tuplas codificadas por la iglesia son inmutables por diseño y así evitan los efectos secundarios causados ​​por mutaciones. Esto ayuda a construir aplicaciones más robustas. Además, es más fácil razonar sobre el código que distingue entre Array s como un tipo de colección (por ejemplo, [a] ) y las tuplas como datos relacionados de varios tipos (por ejemplo, (a, b) ).

Answer 9

Tienes que hacerlo de la manera fea. Si realmente quieres algo como esto, puedes echar un vistazo a CoffeeScript , que tiene eso y muchas otras características que lo hacen parecer más a python (lo siento por hacer que parezca un anuncio, pero realmente me gusta).

Answer 10

Una matriz congelada se comporta de forma idéntica a una tupla de python:

const tuple = Object.freeze(["Bob", 24]);
let [name, age]; = tuple
console.debug(name); // "Bob"
console.debug(age); // 24

Sé elegante y define una clase

class Tuple extends Array { 
  constructor(...items) { 
    super(...items); 
    Object.freeze(this);
  } 
}

let tuple = new Tuple("Jim", 35);
let [name, age] = tuple;
console.debug(name); // Jim
console.debug(age); // 35
tuple = ["Bob", 24]; // no effect 
console.debug(name); // Jim
console.debug(age); // 25

Funciona hoy en todos los navegadores más recientes.

Answer 11

Tuplas no son compatibles con JavaScript

Si está buscando una lista inmutable, Object.freeze () se puede usar para hacer que una matriz sea inmutable.

El método Object.freeze () inmoviliza un objeto: es decir, evita que se le agreguen nuevas propiedades; impide que las propiedades existentes sean eliminadas; e impide que se cambien las propiedades existentes, o su enumerabilidad, configurabilidad o capacidad de escritura. En esencia, el objeto se hace efectivamente inmutable. El método devuelve el objeto que se congela.

Fuente: Object.freeze()

Asigna una matriz como de costumbre pero bloquéala usando ''Object.freeze ()

> tuple = Object.freeze([''Bob'', 24]);
[ ''Bob'', 24 ]

Utilice los valores como lo haría con una matriz normal (no se admite la asignación múltiple de Python)

> name = tuple[0]
''Bob''
> age = tuple[1]
24

Intentar asignar un nuevo valor

> tuple[0] = ''Steve''
''Steve''

Pero el valor no ha cambiado

> console.log(tuple)
[ ''Bob'', 24 ]

Answer 12

[a, b, c] = [2, ''momo'', 7]  // b === ''momo'', c ===7 ...