Bonjour,

Je ne connais pas trop le javascript et j'ai besoin d'aide pour comprendre le code suivant :

<script>
function Array() {
for (var i = 0; i <3 ; i++)
this[i] setter = myfunction;
}
<script>

Sachant que myfuntion est une fonction custom qui fait a priori ce que l'on veut avec. J'ai compris qu'il s'agit d'une surcharge de la fonction Array, mais est-ce que le "setter" est un mot clef ? J'en suis presque à me le demander...

Merci pour toute indication utilse

Je ne crois pas. En tout cas, ce code me paraît bien étrange. Tu l'as chopé où ?

(étrange dans l'objectif qu'il pourrait avoir)

Déjà, ça ne peut pas fonctionner. Il doit manquer quelque chose.

this[i] setter = myfunction; this[i].setter = myfunction();

Mais la fonction en elle-même ne sert strictement à rien.
Elle redéfinit le constructeur Array ; il y a confusion entre fonction et constructeur.

Un setter est censé être une méthode de Array ayant pour fonction la (re)définition d'une variable, mais dans ce code setter est une variable et non une fonction.

Je pense que le code recherché est le suivant :

function fillArray(arr)
{
     for (var i = 0; i < 3; i++)
     {
          arr[i].setter(myfunction());
     }
}

(Re)définir l'attribut nommé "setter" des trois premiers objets présents dans le tableau passé en paramètre ("arr") par la valeur retournée par la fonction myfunction().

Peut-être bien que l'attribut setter de chaque objet est censé avoir pour valeur le nom d'une fonction stockée dans la variable myfunction, après tout... Par contre je ne vois pas vraiment l'utilité d'une telle manip'.

Bref, plusieurs interprétations sont possibles.

Merci pour les réponses. Vous m'excuserez pour les fautes de syntaxe française...

En ce qui concerne le code, il est issu du livre "The Web Applications Hacker's Handbook" qui traite des méthodes pour protéger au mieux ses applications Web, avec exemple pratique à l'appui. Ici, il s'agit d'obtenir l'accès à des éléments JSON. D'ou la redéfinition du constructeur Array().

Les commentaires me semblent obscure et ne me permttent pas de comprendre, c'est pourquoi je vous sollicitais.

"Cette proof of concept réalise 3 actions clefs :
- elle implémente une fonction appelé capture [que j'ai moi-meme nommé myfunction puisque je ne souhaitais pas rentrer dans les détails dans un premier temps, leur fonction capture ne renvoit qu'un "alert" de ce qu'on lui passe en argument]
- elle surcharge [override] l'objet array et définie le setter pour les 3 premiers éléments du tableau qui seront amené à etre capturé par la fonction capture [ie myfunction]
- [inclusion d'une balise script vers une cible, mais cela ne concerne pas le code en question].

En fait je ne comprends pas ce code :
"this[i] setter = myfunction;"
qui après vérification est bel et bien le bon code, c'est celui qui est écrit dans le livre.

DN4, non : this[i].setter = myfunction;
On va chercher la référence vers la fonction, par un retour d'exécution de la dite fonction. Cependant, tu aurais pu écrire ça :
this[i].setter = function() { myfunction() };

Visiblement (mais je n'ai pas de quoi tester), quand tu indique une valeur dans un array à un index donné, la fonction "setter" est appellée avec la dite valeur pour l'index donné. A priori, setter ne doit rien faire de base, ici il définit que pour les 3 premiers index de l'array, setter vaut myFunction. D'après ce qu'il raconte, myFunction doit être qq chose de similaire à :

var myFunction = function(value) {
alert(value);
}

C'est cela.

Au final, c'est surement juste le "." qui n'a pas été imprimé, ou qui a disparu.

Ou est-ce que je pourrai le code source de la fonction array ?

Ah non, j'ai compris. En fait le code initial est correct, mais la syntaxe utilisée pour définir un setter est obsolète. Oui, "setter" est effectivement un "mot-clé" (ou plutôt une valeur).

On redéfinit en fait le comportement des initialisations. Au lieu d'attribuer une valeur à une propriété, on fait savoir que l'on veut afficher cette valeur ; et ce, pour chaque attribut de l'objet. Dans ce cas ledit objet est, d'après tes informations complémentaires, celui qui va être sérialisé au format JSON. On intercepte les données en construction en quelque sorte.

Ces données ne seront pas construites.

Tu as ici l'historique des syntaxes utilisées pour définir des setters / getters : http://whereswalden.com/2010/04/16/more-spidermonkey-changes-ancient-esoteric-very-rarely-used-syntax-for-creating-getters-and-setters-is-being-removed/

Un petit exemple au goût du jour pour illustrer :

var foo = {};

Object.defineProperty(foo, 'x', {
      set: function(val) {
            document.write('foo.x is set to ' + val +
                                         '<br />');
      }
});

foo.x = 42;
document.write("foo's value: " + foo.x); // undefined

Par contre le code que t'as posté n'est plus fonctionnel. ( cf « Starting in JavaScript 1.8.1, setters are no longer called when setting properties in object and array initializers. » )