Affectations de variables JavaScript à partir de tuples

Dans d'autres langages comme Python 2 et Python 3, vous pouvez définir et attribuer des valeurs à une variable de tuple et récupérer leurs valeurs comme ceci:

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

Y a-t-il quelque chose de similaire dans JavaScript? Ou est-ce que je dois juste le faire de la manière laide avec un tableau:

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

Existe-t-il un meilleur moyen de simuler des tuples Python dans JavaScript 5?

Mise à jour: voir la réponse concernant ES6, qui devrait être privilégiée par rapport à CoffeeScript pour les nouveaux projets.

Javascript 1.7 a ajouté une affectation déstructurée qui vous permet de faire essentiellement ce que vous recherchez.

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

Vous devez le faire de manière laide. Si vous voulez vraiment quelque chose comme ça, vous pouvez consulter CoffeeScript , qui a cela et beaucoup d'autres fonctionnalités qui le font ressembler davantage à python (désolé de le faire sonner comme une publicité, mais je l'aime vraiment.)

Vous pouvez faire quelque chose de similaire:

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

puis faites référence au nom et à l'âge comme attributs

tuple.name 
tuple.age 

Cette fonctionnalité "tuple" s'appelle la déstructuration dans EcmaScript2015 et sera bientôt prise en charge par des navigateurs à jour. Pour le moment, seuls Firefox et Chrome le prennent en charge .

Mais bon, tu peux utiliser un transpilateur .

Le code serait aussi beau que python:

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

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

Un tableau gelé se comporte de la même manière qu'un tuple python:

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

Soyez chic et définissez une 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

Fonctionne aujourd'hui dans tous les derniers navigateurs.

Les tuples ne sont pas pris en charge dans JavaScript

Si vous recherchez une liste immuable, Object.freeze () peut être utilisé pour rendre un tableau immuable.

La méthode Object.freeze () fige un objet: c'est-à-dire empêche l'ajout de nouvelles propriétés; empêche les propriétés existantes d'être supprimées; et empêche les propriétés existantes, ou leur énumérabilité, leur configurabilité ou leur capacité d'écriture, d'être modifiées. En substance, l'objet est rendu effectivement immuable. La méthode renvoie l'objet gelé.

Source: Réseau de développeurs Mozilla - Object.freeze ()

Assignez un tableau comme d'habitude mais verrouillez-le en utilisant 'Object.freeze ()

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

Utilisez les valeurs comme vous le feriez pour un tableau normal (la multi-affectation python n'est pas prise en charge)

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

Tentative d'attribution d'une nouvelle valeur

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

Mais la valeur n'est pas modifiée

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

Malheureusement, vous ne pouvez pas utiliser cette syntaxe d'affectation de tuple dans le script (ECMA | Java).

EDIT: Quelqu'un lié à Mozilla / JS 1.7 - cela ne fonctionnerait pas entre les navigateurs, mais si ce n'est pas nécessaire, il y a votre réponse.

Ce n'est pas destiné à être utilisé dans la vraie vie, juste un exercice intéressant. Voir Pourquoi l'utilisation de la fonction JavaScript eval est-elle une mauvaise idée?pour plus de détails.

C'est le plus proche que vous pouvez obtenir sans recourir aux extensions spécifiques au fournisseur:

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

Fonction d'assistance:

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

Preuve que cela fonctionne dans une portée arbitraire:

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

eval n'est pas pris en charge dans Safari.

Pour mettre à jour la réponse du ministre, vous pouvez maintenant le faire avec 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

Vous pouvez également avoir un type de tuple en Javascript. Définissez-le simplement avec des fonctions d'ordre supérieur (le terme académique est l'encodage de l'Église):

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

Veuillez noter que ce Tuplen'est pas utilisé comme un constructeur normal. La solution ne repose pas du tout sur le système prototype, mais uniquement sur des fonctions d'ordre supérieur.

Quels sont les avantages des tuples par rapport aux Arrays utilisés comme des tuples? Les tuples encodés en église sont immuables par conception et empêchent ainsi les effets secondaires causés par les mutations. Cela permet de créer des applications plus robustes. De plus, il est plus facile de raisonner sur le code qui distingue Arrays en tant que type de collection (par exemple [a]) et les tuples en tant que données liées de différents types (par exemple (a, b)).

Voici une implémentation 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.

Ceci est un 2-tuple, cependant, vous pouvez modifier mon exemple pour prendre en charge les tuples 3,4,5,6 etc.

Voici une version de la réponse de Matthew James Davis avec les méthodes de tuple Python ajoutées:

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)