Atribuições de variáveis ​​JavaScript de tuplas

Em outras linguagens, como Python 2 e Python 3, você pode definir e atribuir valores a uma variável de tupla e recuperar seus valores assim:

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

Existe algo semelhante em JavaScript? Ou eu apenas tenho que fazer isso da maneira feia com um array:

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

Existe uma maneira melhor de simular tuplas Python em JavaScript 5?

Atualização: Veja a resposta sobre ES6, que deve ser preferido em relação ao CoffeeScript para novos projetos.

Javascript 1.7 adicionou atribuição desestruturada que permite que você faça essencialmente o que você está procurando.

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

Você tem que fazer da maneira mais feia. Se você realmente quer algo assim, pode dar uma olhada no CoffeeScript , que tem isso e muitos outros recursos que o tornam mais parecido com o python (desculpe por fazer parecer um anúncio, mas eu realmente gosto).

Você pode fazer algo semelhante:

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

e então se referem ao nome e idade como atributos

tuple.name 
tuple.age 

Esse recurso de "tupla" é chamado de desestruturação no EcmaScript2015 e em breve será compatível com navegadores atualizados. Por enquanto, apenas Firefox e Chrome suportam .

Mas hey, você pode usar um transpiler .

O código seria tão bom quanto python:

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

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

Uma matriz congelada se comporta de forma idêntica a uma tupla Python:

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

Seja sofisticado e defina uma classe

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 hoje em todos os navegadores mais recentes.

Tuplas não são compatíveis com JavaScript

Se você estiver procurando por uma lista imutável, Object.freeze () pode ser usado para tornar um array imutável.

O método Object.freeze () congela um objeto: isto é, evita que novas propriedades sejam adicionadas a ele; impede que as propriedades existentes sejam removidas; e impede que as propriedades existentes, ou sua enumerabilidade, configurabilidade ou capacidade de gravação, sejam alteradas. Em essência, o objeto é tornado efetivamente imutável. O método retorna o objeto que está sendo congelado.

Fonte: Mozilla Developer Network - Object.freeze ()

Atribua uma matriz como de costume, mas bloqueie-a usando 'Object.freeze ()

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

Use os valores como faria com uma matriz regular (a multi-atribuição de python não é compatível)

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

Tentar atribuir um novo valor

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

Mas o valor não é alterado

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

Infelizmente, você não pode usar essa sintaxe de atribuição de tupla no (ECMA | Java) Script.

EDIT: Alguém vinculado ao Mozilla / JS 1.7 - isso não funcionaria em vários navegadores, mas se não for necessário, aí está sua resposta.

Isso não se destina a ser usado na vida real, apenas um exercício interessante. Veja Por que usar a função eval JavaScript é uma má ideia? para detalhes.

Este é o mais próximo que você pode obter sem recorrer a extensões específicas do fornecedor:

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

Função auxiliar:

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(',');
}

Prova de que funciona em âmbito arbitrário:

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

eval não é compatível com Safari.

Para atualizar a resposta do Ministro, agora você pode fazer isso com 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

Você também pode ter um tipo de tupla em Javascript. Basta defini-lo com funções de ordem superior (o termo acadêmico é codificação de Igreja):

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

Observe que Tuplenão é usado como um construtor normal. A solução não depende do sistema de protótipo, mas apenas de funções de ordem superior.

Quais são as vantagens das tuplas sobre Arrayas usadas como tuplas? As tuplas codificadas por igreja são imutáveis ​​por design e, portanto, evitam os efeitos colaterais causados ​​por mutações. Isso ajuda a construir aplicativos mais robustos. Além disso, é mais fácil raciocinar sobre o código que distingue entre Arrays como um tipo de coleção (por exemplo [a]) e tuplas como dados relacionados de vários tipos (por exemplo (a, b)).

Aqui está uma implementação simples de Tuple Javascript:

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 é uma tupla de 2, no entanto, você pode modificar meu exemplo para suportar tuplas 3,4,5,6 etc.

Aqui está uma versão da resposta de Matthew James Davis com os métodos de tupla Python adicionados em:

class Tuple extends Array { 
  constructor(...items) { 
    super(...items); 
    Object.freeze(this);
  }
  toArray() {
    return [...this];
  }
  toString() {
    return '('+super.toString()+')';
  }
  count(item) {
    var arr = this.toArray();
    var result = 0;
    for(var i = 0; i < arr.length; i++) {
       if(arr[i] === item) {
         result++;
       }
    }
    return result;
  }

  

  
}

   let tuple = new Tuple("Jim", 35);
   let [name,age] = tuple;

console.log("tuple:"+tuple)
console.log("name:"+name)
console.log("age:"+age)