Assegnazioni di variabili JavaScript da tuple

In altri linguaggi come Python 2 e Python 3, puoi definire e assegnare valori a una variabile tupla e recuperarne i valori in questo modo:

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

C'è qualcosa di simile in JavaScript? O devo solo farlo nel modo brutto con un array:

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

C'è un modo migliore per simulare le tuple Python in JavaScript 5?

Aggiornamento: vedere la risposta relativa a ES6, che dovrebbe essere preferito a CoffeeScript per i nuovi progetti.

Javascript 1.7 ha aggiunto l' assegnazione destrutturata che ti consente di fare essenzialmente quello che stai cercando.

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

Devi farlo nel modo brutto. Se vuoi davvero qualcosa di simile, puoi dare un'occhiata a CoffeeScript , che ha questo e molte altre caratteristiche che lo fanno sembrare più simile a Python (scusami per averlo fatto sembrare una pubblicità, ma mi piace molto.)

Puoi fare qualcosa di simile:

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

e quindi fare riferimento a nome ed età come attributi

tuple.name 
tuple.age 

Questa caratteristica "tupla" si chiama destrutturazione in EcmaScript2015 e presto sarà supportata dai browser aggiornati. Per il momento, solo Firefox e Chrome lo supportano .

Ma hey, puoi usare un transpiler .

Il codice sarebbe bello come Python:

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

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

Un array congelato si comporta in modo identico a una tupla python:

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

Sii fantasioso e definisci una 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

Funziona oggi in tutti i browser più recenti.

Le tuple non sono supportate in JavaScript

Se stai cercando un elenco immutabile, Object.freeze () può essere utilizzato per rendere immutabile un array.

Il metodo Object.freeze () congela un oggetto: cioè, impedisce l'aggiunta di nuove proprietà; impedisce la rimozione delle proprietà esistenti; e impedisce la modifica delle proprietà esistenti o della loro enumerabilità, configurabilità o scrivibilità. In sostanza l'oggetto è reso effettivamente immutabile. Il metodo restituisce l'oggetto congelato.

Fonte: Mozilla Developer Network - Object.freeze ()

Assegna un array come al solito ma bloccalo usando 'Object.freeze ()

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

Usa i valori come faresti con un normale array (l'assegnazione multipla di Python non è supportata)

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

Tenta di assegnare un nuovo valore

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

Ma il valore non viene modificato

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

Sfortunatamente non puoi usare quella sintassi di assegnazione delle tuple nello script (ECMA | Java).

EDIT: Qualcuno collegato a Mozilla / JS 1.7 - questo non funzionerebbe cross-browser, ma se ciò non è richiesto, c'è la tua risposta.

Questo non è inteso per essere effettivamente utilizzato nella vita reale, ma solo un esercizio interessante. Vedi Perché usare la funzione di valutazione JavaScript è una cattiva idea?per dettagli.

Questo è il massimo che puoi ottenere senza ricorrere a estensioni specifiche del fornitore:

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

Funzione di aiuto:

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 che funziona in ambito arbitrario:

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

eval non è supportato in Safari.

Come aggiornamento alla risposta del ministro, ora puoi farlo 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

Puoi anche avere un tipo di tupla in Javascript. Basta definirlo con funzioni di ordine superiore (il termine accademico è codifica Church):

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

Si noti che Tuplenon viene utilizzato come un normale costruttore. La soluzione non si basa affatto sul sistema prototipo, ma esclusivamente su funzioni di ordine superiore.

Quali sono i vantaggi delle tuple rispetto a quelle Arrayusate come le tuple? Le tuple con codice Church sono immutabili per impostazione predefinita e quindi prevengono gli effetti collaterali causati dalle mutazioni. Questo aiuta a creare applicazioni più robuste. Inoltre, è più facile ragionare sul codice che distingue tra Arrays come tipo di raccolta (ad esempio [a]) e tuple come dati correlati di vario tipo (ad esempio (a, b)).

Ecco una semplice implementazione della tupla 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.

Questa è una tupla a 2, tuttavia, potresti modificare il mio esempio per supportare le tuple 3,4,5,6 ecc.

Ecco una versione della risposta di Matthew James Davis con i metodi della tupla Python aggiunti in:

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)