Getter/setter de tableau javascript?

D'accès au tableau n'est pas différent de la normale l'accès à la propriété. array[0] signifie array['0'], de sorte que vous pouvez définir une propriété de nom '0' et à intercepter l'accès au premier élément de tableau grâce à cela.

Cependant, cela fait qu'il est impossible pour tous mais de courte durée, plus-ou-moins-Tableaux de longueur fixe. Vous ne pouvez pas définir une propriété pour “tous les noms qui se trouvent être des entiers” tout en un aller.

J'ai regardé dans John Resig de l'article JavaScript Getters Et Les Setters, mais son prototype exemple ne fonctionne pas pour moi. Après avoir essayé quelques solutions de rechange, j'en ai trouvé un qui semblait fonctionner. Vous pouvez utiliser Array.prototype.__defineGetter__ de la manière suivante:

Array.prototype.__defineGetter__("sum", function sum(){
var r = 0, a = this, i = a.length - 1;
do {
    r += a[i];
    i -= 1;
} while (i >= 0);
return r;
});
var asdf = [1, 2, 3, 4];
asdf.sum; //returns 10

A fonctionné pour moi sur Chrome et Firefox.

Il est possible de définir des Accesseurs et Mutateurs pour les tableaux JavaScript. Mais vous ne pouvez pas avoir des accesseurs et des valeurs en même temps. Voir la Mozilla la documentation:

Il n'est pas possible d'avoir simultanément un getter lié à une propriété et qui ont cette propriété a une valeur

Donc, si vous définir des accesseurs pour un tableau, vous devez avoir un second tableau de la valeur réelle. La suite exemple illustre.

//
//Poor man's prepare for querySelector.
//
//Example:
//  var query = prepare ('#modeler table[data-id=?] tr[data-id=?]');
//  query[0] = entity;
//  query[1] = attribute;
//  var src = document.querySelector(query);
//
var prepare;
{
let r = /^([^?]+)\?(.+)$/; //Regular expression to split the query
prepare = function (query, base)
{
if (!base) base = document;
var q  = []; //List of query fragments
var qi = 0;  //Query fragment index
var v  = []; //List of values
var vi = 0;  //Value index
var a  = []; //Array containing setters and getters
var m;       //Regular expression match
while (query) {
m = r.exec (query);
if (m && m[2]) {
q[qi++] = m[1];
query   = m[2];
(function (qi, vi) {
Object.defineProperty (a, vi, {
get: function() { return v[vi]; },
set: function(val) { v[vi] = val; q[qi] = JSON.stringify(val); }});
})(qi++, vi++);
} else {
q[qi++] = query;
query   = null;
}
}
a.toString = function () { return q.join(''); }
return a;
}
}

Le code utilise trois tableaux:

1. un pour les valeurs réelles,
2. un pour le JSON codé valeurs
3. et un pour les accesseurs.

Le tableau avec les accesseurs est retournée à l'appelant. Lorsqu'un set est appelé par l'affectation d'une valeur à l'élément de tableau, les tableaux contenant la plaine et codé valeurs sont mises à jour. Lorsque get est appelée, elle retourne simplement la plaine de la valeur. Et toString retourne la totalité de la requête contenant les valeurs codées.

Mais comme d'autres l'ont déjà dit: cela n'a de sens qu', lorsque la taille de la matrice est constante. Vous pouvez modifier les éléments de la matrice, mais vous ne pouvez pas ajouter d'autres éléments.

Il est possible de créer des setters pour chaque élément d'un tableau, mais il n'y a qu'une seule restriction: vous ne seriez pas en mesure de régler directement les éléments du tableau pour les index qui sont à l'extérieur de la initialisé région (p. ex. myArray[2] = ... //wouldn't work if myArray.length < 2) à l'Aide de la Matrice.prototype des fonctions de travail. (par exemple, push, pop, splice, maj, unshift.) Je donne un exemple de la façon d'accomplir cette ici.

c'est la façon dont je fais les choses. Vous devrez ajuster la Création de Prototypes (j'ai enlevé un peu de ma Version). Mais cela vous donnera la valeur par défaut getter /setter comportement, je suis employé dans d'autres Langages Basés sur des classes.
La définition d'un Getter et pas de Setter signifie que l'écriture de l'élément sera ignorée...

Espère que cette aide.

function Game () {
var that = this;
this._levels = [[1,2,3],[2,3,4],[4,5,6]];
var self = {
levels: [],
get levels () {
return that._levels;
},
setLevels: function(what) {
that._levels = what;
//do stuff here with
//that._levels
}
};
Object.freeze(self.levels);
return self;
}

Cela me donne le comportement attendu de:

var g = new Game()
g.levels
///--> [[1,2,3],[2,3,4],[4,5,6]]
g.levels[0]
///--> [1,2,3]

De prendre le critizism de dmvaldman: l'Écriture doit maintenant être impossible.
J'ai réécrit le code pour 1)ne pas utiliser depracated éléments (__ defineGetter __) et 2) ne pas accepter toute écriture (qui est: incontrôlé de l'écriture) aux niveaux de l'élément. Un exemple setter est inclus. (J'ai dû ajouter de l'espacement __ defineGetter en raison de markdown)

De dmvaldmans demande:

g.levels[0] = [2,3,4];
g.levels;
///--> [[1,2,3],[2,3,4],[4,5,6]]
//using setter
g.setLevels([g.levels, g.levels, 1,2,3,[9]]);
g.levels;
///--> [[[1,2,3],[2,3,4],[4,5,6]],[[1,2,3],[2,3,4],[4,5,6]], ....]
//using setLevels
g.setLevels([2,3,4]);
g.levels;
///--> [2,3,4]