Mais attention à prendre garde de ne pas avoir modifié Object.prototype, sinon on se retrouve avec des "collections" (hash) toutes cassées.
* démonstration sommaire *
Object.prototype.fclj = function() { alert('KC'); }; var tCollect = {"a":9, "b":1, "c":5}; for ( var k in tCollect ) { // doc.write c'est pas top, juste utilisé ici pour la démo document.write(k + ' = ' + tCollect[k] + '<br>'); }
* résultat "affiché" *
a = 9 b = 1 c = 5 fclj = function () { alert("KC"); }
Comme attendu, le hash contient 4 éléments au lieu des 3 définis. Tout ça à cause de la manipulation de Object.prototype. Donc conclusion, ne toucher saus aucun prétexte à Object.prototype :)
On peut passer outre et retomber sur ces pieds avec un hash correct en modifiant un peut la boucle d'énumération, mais c'est pas terrible d'aller modifier toutes ces boucles de partout.
Object.prototype.fclj = function() { alert('KC'); }; var tCollect = {"a":9, "b":1, "c":5}; for ( var k in tCollect ) { if ( tCollect.hasOwnProperty(k) ) { document.write(k + ' = ' + tCollect[k] + '<br>'); } }
* résultat : a = 9 b = 1 c = 5
Mais il n'empêche que les règles à suivre sont
1) Ne jamais, sous *aucun* prétexte, modifier Object.prototype
2) Ne pas utiliser autre chose que le "type" Object pour créer le hash. Quoiqu'on puisse en dire Array n'est *pas* le type valide utilisable pour créer des hash. C'est Object et personne d'autre.
Mais attention à prendre garde de ne pas avoir modifié Object.prototype,
sinon on se retrouve avec des "collections" (hash) toutes cassées.
* démonstration sommaire *
Object.prototype.fclj = function() { alert('KC'); };
var tCollect = {"a":9, "b":1, "c":5};
for ( var k in tCollect )
{
// doc.write c'est pas top, juste utilisé ici pour la démo
document.write(k + ' = ' + tCollect[k] + '<br>');
}
* résultat "affiché" *
a = 9
b = 1
c = 5
fclj = function () { alert("KC"); }
Comme attendu, le hash contient 4 éléments au lieu des 3 définis. Tout
ça à cause de la manipulation de Object.prototype. Donc conclusion, ne
toucher saus aucun prétexte à Object.prototype :)
On peut passer outre et retomber sur ces pieds avec un hash correct en
modifiant un peut la boucle d'énumération, mais c'est pas terrible
d'aller modifier toutes ces boucles de partout.
Object.prototype.fclj = function() { alert('KC'); };
var tCollect = {"a":9, "b":1, "c":5};
for ( var k in tCollect )
{
if ( tCollect.hasOwnProperty(k) )
{
document.write(k + ' = ' + tCollect[k] + '<br>');
}
}
* résultat :
a = 9
b = 1
c = 5
Mais il n'empêche que les règles à suivre sont
1) Ne jamais, sous *aucun* prétexte, modifier Object.prototype
2) Ne pas utiliser autre chose que le "type" Object pour créer le hash.
Quoiqu'on puisse en dire Array n'est *pas* le type valide utilisable
pour créer des hash. C'est Object et personne d'autre.
Mais attention à prendre garde de ne pas avoir modifié Object.prototype, sinon on se retrouve avec des "collections" (hash) toutes cassées.
* démonstration sommaire *
Object.prototype.fclj = function() { alert('KC'); }; var tCollect = {"a":9, "b":1, "c":5}; for ( var k in tCollect ) { // doc.write c'est pas top, juste utilisé ici pour la démo document.write(k + ' = ' + tCollect[k] + '<br>'); }
* résultat "affiché" *
a = 9 b = 1 c = 5 fclj = function () { alert("KC"); }
Comme attendu, le hash contient 4 éléments au lieu des 3 définis. Tout ça à cause de la manipulation de Object.prototype. Donc conclusion, ne toucher saus aucun prétexte à Object.prototype :)
On peut passer outre et retomber sur ces pieds avec un hash correct en modifiant un peut la boucle d'énumération, mais c'est pas terrible d'aller modifier toutes ces boucles de partout.
Object.prototype.fclj = function() { alert('KC'); }; var tCollect = {"a":9, "b":1, "c":5}; for ( var k in tCollect ) { if ( tCollect.hasOwnProperty(k) ) { document.write(k + ' = ' + tCollect[k] + '<br>'); } }
* résultat : a = 9 b = 1 c = 5
Mais il n'empêche que les règles à suivre sont
1) Ne jamais, sous *aucun* prétexte, modifier Object.prototype
2) Ne pas utiliser autre chose que le "type" Object pour créer le hash. Quoiqu'on puisse en dire Array n'est *pas* le type valide utilisable pour créer des hash. C'est Object et personne d'autre.
Mais attention à prendre garde de ne pas avoir modifié Object.prototype, sinon on se retrouve avec des "collections" (hash) toutes cassées.
je sais meme pas a quoi ca sert donc effectivement y a peu de chance que j'y touche :)
* démonstration sommaire *
Object.prototype.fclj = function() { alert('KC'); }; var tCollect = {"a":9, "b":1, "c":5}; for ( var k in tCollect ) { // doc.write c'est pas top, juste utilisé ici pour la démo document.write(k + ' = ' + tCollect[k] + '<br>'); }
* résultat "affiché" *
a = 9 b = 1 c = 5 fclj = function () { alert("KC"); }
Comme attendu, le hash contient 4 éléments au lieu des 3 définis. Tout ça à cause de la manipulation de Object.prototype. Donc conclusion, ne toucher saus aucun prétexte à Object.prototype :)
On peut passer outre et retomber sur ces pieds avec un hash correct en modifiant un peut la boucle d'énumération, mais c'est pas terrible d'aller modifier toutes ces boucles de partout.
Object.prototype.fclj = function() { alert('KC'); }; var tCollect = {"a":9, "b":1, "c":5}; for ( var k in tCollect ) { if ( tCollect.hasOwnProperty(k) ) { document.write(k + ' = ' + tCollect[k] + '<br>'); } }
* résultat : a = 9 b = 1 c = 5
Mais il n'empêche que les règles à suivre sont
1) Ne jamais, sous *aucun* prétexte, modifier Object.prototype
2) Ne pas utiliser autre chose que le "type" Object pour créer le hash. Quoiqu'on puisse en dire Array n'est *pas* le type valide utilisable pour créer des hash. C'est Object et personne d'autre.
Mais attention à prendre garde de ne pas avoir modifié Object.prototype,
sinon on se retrouve avec des "collections" (hash) toutes cassées.
je sais meme pas a quoi ca sert donc effectivement y a peu de chance que j'y
touche :)
* démonstration sommaire *
Object.prototype.fclj = function() { alert('KC'); };
var tCollect = {"a":9, "b":1, "c":5};
for ( var k in tCollect )
{
// doc.write c'est pas top, juste utilisé ici pour la démo
document.write(k + ' = ' + tCollect[k] + '<br>');
}
* résultat "affiché" *
a = 9
b = 1
c = 5
fclj = function () { alert("KC"); }
Comme attendu, le hash contient 4 éléments au lieu des 3 définis. Tout ça
à cause de la manipulation de Object.prototype. Donc conclusion, ne
toucher saus aucun prétexte à Object.prototype :)
On peut passer outre et retomber sur ces pieds avec un hash correct en
modifiant un peut la boucle d'énumération, mais c'est pas terrible d'aller
modifier toutes ces boucles de partout.
Object.prototype.fclj = function() { alert('KC'); };
var tCollect = {"a":9, "b":1, "c":5};
for ( var k in tCollect )
{
if ( tCollect.hasOwnProperty(k) )
{
document.write(k + ' = ' + tCollect[k] + '<br>');
}
}
* résultat :
a = 9
b = 1
c = 5
Mais il n'empêche que les règles à suivre sont
1) Ne jamais, sous *aucun* prétexte, modifier Object.prototype
2) Ne pas utiliser autre chose que le "type" Object pour créer le hash.
Quoiqu'on puisse en dire Array n'est *pas* le type valide utilisable pour
créer des hash. C'est Object et personne d'autre.
Mais attention à prendre garde de ne pas avoir modifié Object.prototype, sinon on se retrouve avec des "collections" (hash) toutes cassées.
je sais meme pas a quoi ca sert donc effectivement y a peu de chance que j'y touche :)
* démonstration sommaire *
Object.prototype.fclj = function() { alert('KC'); }; var tCollect = {"a":9, "b":1, "c":5}; for ( var k in tCollect ) { // doc.write c'est pas top, juste utilisé ici pour la démo document.write(k + ' = ' + tCollect[k] + '<br>'); }
* résultat "affiché" *
a = 9 b = 1 c = 5 fclj = function () { alert("KC"); }
Comme attendu, le hash contient 4 éléments au lieu des 3 définis. Tout ça à cause de la manipulation de Object.prototype. Donc conclusion, ne toucher saus aucun prétexte à Object.prototype :)
On peut passer outre et retomber sur ces pieds avec un hash correct en modifiant un peut la boucle d'énumération, mais c'est pas terrible d'aller modifier toutes ces boucles de partout.
Object.prototype.fclj = function() { alert('KC'); }; var tCollect = {"a":9, "b":1, "c":5}; for ( var k in tCollect ) { if ( tCollect.hasOwnProperty(k) ) { document.write(k + ' = ' + tCollect[k] + '<br>'); } }
* résultat : a = 9 b = 1 c = 5
Mais il n'empêche que les règles à suivre sont
1) Ne jamais, sous *aucun* prétexte, modifier Object.prototype
2) Ne pas utiliser autre chose que le "type" Object pour créer le hash. Quoiqu'on puisse en dire Array n'est *pas* le type valide utilisable pour créer des hash. C'est Object et personne d'autre.
