Przypisania zmiennych JavaScript z krotek

W innych językach, takich jak Python 2 i Python 3, możesz definiować i przypisywać wartości do zmiennej krotkiej oraz pobierać ich wartości w następujący sposób:

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

Czy jest coś podobnego w JavaScript? A może po prostu muszę to zrobić w brzydki sposób z tablicą:

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

Czy istnieje lepszy sposób na symulowanie krotek Pythona w JavaScript 5?

Aktualizacja: Zobacz odpowiedź dotyczącą ES6, która powinna być preferowana w nowych projektach od CoffeeScript.

Javascript 1.7 dodał zniszczone przypisanie, które pozwala robić zasadniczo to, czego szukasz.

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

Musisz to zrobić w brzydki sposób. Jeśli naprawdę chcesz czegoś takiego, możesz sprawdzić CoffeeScript , który ma to i wiele innych funkcji, które sprawiają, że wygląda bardziej jak Python (przepraszam, że brzmi to jak reklama, ale naprawdę to lubię).

Możesz zrobić coś podobnego:

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

a następnie odnosić się do imienia i wieku jako atrybutów

tuple.name 
tuple.age 

Ta funkcja „krotki” w EcmaScript 2015 nazywa się destrukturyzacją i wkrótce ma być obsługiwana przez najnowsze przeglądarki. Na razie obsługują go tylko Firefox i Chrome .

Ale hej, możesz użyć transpilera .

Kod wyglądałby tak ładnie jak python:

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

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

Zamrożona tablica zachowuje się identycznie jak krotka Pythona:

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

Bądź fantazyjny i zdefiniuj klasę

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

Działa dzisiaj we wszystkich najnowszych przeglądarkach.

Krotki nie są obsługiwane w JavaScript

Jeśli szukasz niezmiennej listy, możesz użyć Object.freeze (), aby uczynić tablicę niezmienną.

Metoda Object.freeze () zamraża obiekt: to znaczy zapobiega dodawaniu do niego nowych właściwości; zapobiega usuwaniu istniejących nieruchomości; i zapobiega zmianie istniejących właściwości lub ich wyliczalności, konfigurowalności lub zapisywalności. W istocie przedmiot staje się skutecznie niezmienny. Metoda zwraca zamrożony obiekt.

Źródło: Mozilla Developer Network - Object.freeze ()

Przypisz tablicę jak zwykle, ale zablokuj ją za pomocą 'Object.freeze ()

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

Używaj wartości tak, jak w przypadku zwykłej tablicy (wielokrotne przypisanie w Pythonie nie jest obsługiwane)

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

Spróbuj przypisać nową wartość

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

Ale wartość się nie zmienia

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

Niestety nie możesz użyć tej składni przypisania krotki w skrypcie (ECMA | Java).

EDYCJA: Ktoś powiązany z Mozillą / JS 1.7 - to nie działałoby w różnych przeglądarkach, ale jeśli nie jest to wymagane, to jest twoja odpowiedź.

To nie jest przeznaczone do rzeczywistego wykorzystania, tylko interesujące ćwiczenie. Zobacz Dlaczego używanie funkcji eval JavaScript to zły pomysł? dla szczegółów.

Jest to najbliższe rozwiązanie, jakie można uzyskać bez uciekania się do rozszerzeń specyficznych dla dostawcy:

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

Funkcja pomocnicza:

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

Dowód, że działa w dowolnym zakresie:

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

eval nie jest obsługiwany w przeglądarce Safari.

Jako aktualizacja odpowiedzi ministra możesz to teraz zrobić za pomocą 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

Możesz również mieć typ krotki w JavaScript. Po prostu zdefiniuj to za pomocą funkcji wyższego rzędu (termin akademicki to kodowanie Kościoła):

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

Pamiętaj, że Tuplenie jest używany jako normalny konstruktor. Rozwiązanie wcale nie opiera się na systemie prototypowym, ale wyłącznie na funkcjach wyższego rzędu.

Jakie są zalety krotek Arrayużywanych jak krotki? Krotki kodowane w kościele są niezmienne z założenia i zapobiegają skutkom ubocznym powodowanym przez mutacje. Pomaga to w tworzeniu bardziej niezawodnych aplikacji. Ponadto łatwiej jest wnioskować o kodzie, który rozróżnia Arrays jako typ kolekcji (np. [a]) I krotki jako powiązane dane różnych typów (np (a, b).).

Oto prosta implementacja krotki 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.

To jest 2 krotka, jednak możesz zmodyfikować mój przykład, aby obsługiwał krotki 3,4,5,6 itp.

Oto wersja odpowiedzi Matthew Jamesa Davisa z dodanymi metodami krotek w języku Python:

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)