boucle dans un tableau indicé de façon non consécutive

je suis en train de me prendre les pieds dans le tapis ...

visiblement oui :)

j'ai stocké ces données dans une variable globale de mon javascript :
var window.mesDonnees = new Array();

pas de /var/ ici puisque tu ajoute une propriété à un objet (window)
existant.

juste
window.mesDonnees = new Array();

new Array() est transformable à volonté par []

donc
window.mesDonnees = [];

Afin de stocké chaque colonne de chaque ligne récupérée dans ma
base j'ai imbriqué un tableau dans mon tableau windows.mesDonnes que
j'ai indicé avec l'identifiant numérique de chaque élément
récupéré :

var window.mesDonnees[identifiantNumérique] = new Array();
var window.mesDonnees[identifiantNumérique][0] = valeurColonne_0
var window.mesDonnees[identifiantNumérique][1] = valeurColonne_1
etc...

je ne trouve pas de methode pour faire une boucle dans mon tableau au
niveau ou il est indicé par les identifiants numériques, dans la
mesure où ils ne sont pas nécessairement consécutifs !

// puisque mesDonnees est un hash,
// tu veux en fait un objet et un pas un array
window.mesDonnees = {};

puis

for ( var index in window.mesDonnees )
{
var tableau = window.mesDonnees[index];
}

--
laurent

Bonjour

Bonjour,

je suis en train de me prendre les pieds dans le tapis ...

j'ai récupéré des données dans une base de données via
XMLHttpRequest jusque là tout va bien.

on ne dirait pas :-)

j'ai stocké ces données dans une variable globale de mon javascript :

var window.mesDonnees = new Array();

Afin de stocké chaque colonne de chaque ligne récupérée dans ma
base j'ai imbriqué un tableau dans mon tableau windows.mesDonnes que
j'ai indicé avec l'identifiant numérique de chaque élément
récupéré :

var window.mesDonnees[identifiantNumérique] = new Array();

Si vraiment tu veux faire ça via JS, à mon idée et au plus simple, ton
php devra créer un tableau javascript des lignes, chaque ligne étant un
tableau des colonnes de la ligne.
Mais via php il est aussi facile de faire l'inverse
tableau des colonnes des tableaux des lignes

echo "var mesDonnees = new Array();"
$i = 0;
machin-truc php d'esstraction des lignes de la bdd habituel
echo "mesDonnees[$i] = new Array();"
machin-truc php pour séparer les colonnes
for($j=0; $j<$machintrucphp.count;$j++)
echo "mesdonnes[$i][$j] = $trucbiduleColonnePhp;"

Après, en JS, il suffit de faire écrire le table,

var L = mesdonnees.length;
vac C = mesdonnees[0].length;
var t = '<table>n';
for(var i=0;i<L;i++)
{
t += '<tr>n';
for(var j=0;j<c;j++)
t += '<td>'+mesdonnes[i].[j]+'</td>';
t += '</tr>n';
}
t += '</table>';

document.getElementById('truc').innerHTML = t;


trier un tableau JavaScript à 2 entrees :
http://www.asp-php.net/scripts/scripting/array_sort.php

Perso, puisqu'on a la chance d'avoir du php
je pense que ce tri aurait plus sa place en php
lors de sa requete à la bdd
(qui printera directement le bazar html inclus par XMLHttpRequest)

C'est le grand PLUS du XMLHttpRequest de faire lien avec du vrai php.

Gosso modo, la méthode est identique à appeller une page php dans une
iframe (sauf qu'on n'a besoin que du code du table au lieu d'une page
complète).

--
Stephane Moriaux et son [moins] vieux Mac

Merci je vais essayer cette piste là !
jérôme.

je suis en train de me prendre les pieds dans le tapis ...

visiblement oui :)

j'ai stocké ces données dans une variable globale de mon javascript :
var window.mesDonnees = new Array();

pas de /var/ ici puisque tu ajoute une propriété à un objet (window)
existant.

juste
window.mesDonnees = new Array();

new Array() est transformable à volonté par []

donc
window.mesDonnees = [];

Afin de stocké chaque colonne de chaque ligne récupérée dans ma
base j'ai imbriqué un tableau dans mon tableau windows.mesDonnes que
j'ai indicé avec l'identifiant numérique de chaque élément
récupéré :

var window.mesDonnees[identifiantNumérique] = new Array();
var window.mesDonnees[identifiantNumérique][0] = valeurColonne_0
var window.mesDonnees[identifiantNumérique][1] = valeurColonne_1
etc...

je ne trouve pas de methode pour faire une boucle dans mon tableau au
niveau ou il est indicé par les identifiants numériques, dans la
mesure où ils ne sont pas nécessairement consécutifs !

// puisque mesDonnees est un hash,
// tu veux en fait un objet et un pas un array
window.mesDonnees = {};

puis

for ( var index in window.mesDonnees )
{
var tableau = window.mesDonnees[index];
}

--
laurent

je suis en train de me prendre les pieds dans le tapis ...

visiblement oui :)

Non, il ne manque qu'un petit coup de pouce dans la bonne direction.

j'ai stocké ces données dans une variable globale de mon javascript :
var window.mesDonnees = new Array();

pas de /var/ ici puisque tu ajoute une propriété à un objet (window)
existant.

Ben c'est une faute de frappe, sinon le script n'aurait pas été bien
loin...

juste
window.mesDonnees = new Array();

new Array() est transformable à volonté par []

donc
window.mesDonnees = [];

Ça ajoute quoi d'écrire [] au lieu de Array() ou new Array() ???
Idem pour {} au lieu de Object()

Afin de stocké chaque colonne de chaque ligne récupérée dans ma
base j'ai imbriqué un tableau dans mon tableau windows.mesDonnes que
j'ai indicé avec l'identifiant numérique de chaque élément
récupéré :

var window.mesDonnees[identifiantNumérique] = new Array();
var window.mesDonnees[identifiantNumérique][0] = valeurColonne_0
var window.mesDonnees[identifiantNumérique][1] = valeurColonne_1
etc...

je ne trouve pas de methode pour faire une boucle dans mon tableau au
niveau ou il est indicé par les identifiants numériques, dans la
mesure où ils ne sont pas nécessairement consécutifs !

// puisque mesDonnees est un hash,
// tu veux en fait un objet et un pas un array
window.mesDonnees = {};

En passant un Array (majuscule STP) est un Object qui dispose de toutes
les propriétés des objets Javascript et d'autres spécifiques en plus.

for ( var index in window.mesDonnees )

Cela suffit et fonctionne pour un Array. Donc :

mesDonnees = new Array();
mesDonnees[identifiantNumerique] = new Array();
mesDonnees[identifiantNumerique][0] = valeurColonne_0;
mesDonnees[identifiantNumerique][1] = valeurColonne_1;

//etc.

for (identifiantNumerique in mesDonnees)
{
//on ne récupère que les indices définis !
mesDonnees[identifiantNumerique]
}

Quant au var mesDonnees ou window.mesDonnees, tout dépend de la
portée souhaitée pour cette variable et de l'endroit où on la
définit.

--
Y.D.

j'ai stocké ces données dans une variable globale de mon javascript :
var window.mesDonnees = new Array();

pas de /var/ ici puisque tu ajoute une propriété à un objet (window)
existant.

Ben c'est une faute de frappe, sinon le script n'aurait pas été bien
loin...

Et ? Faute de frappe ou pas, c'est pas correct d'utiliser /var/ lors de
la déclaration d'une propriété, qu'on soit sur l'objet window ou
n'importe quel autre. Donc il aurait fallu utiliser une boule de cristal
pour deviner ce qui était une faute de frappe ou pas ? Et laisser
l'erreur en l'état dans les archives des news ? Désolé mais non. Et
plutot que de modifier la syntaxe initiale j'ai préféré rester sur une
base commune à ce qu'avait écrit l'OP, car sans le code source *complet*
on a aucun moyen de savoir ce qu'il veut faire et comment il veut le faire.

On peut très bien considérer que l'OP a sa fonction définie de telle manière

function remplir()
{
window.mesDonnees = 'foo';
}

Et là, c'est pas lui rendre service que de lui dire qu'il suffirait de
faire ceci pour arriver au même résultat, ça conduit à de TRES mauvaises
façons de coder !

function remplir()
{
mesDonnees = 'foo';
}

Tout simplement parce qu'on a *aucun* moyen de connaître la façon dont
est appelée sa méthode de remplissage et ce qu'il veut en faire. Et lui
donner un *mauvais* exemple n'est pas rendre service ni à lui ni aux
lecteurs de fclj.

Ça ajoute quoi d'écrire [] au lieu de Array() ou new Array() ???
Idem pour {} au lieu de Object()

Preque aucune différence, si ce n'est que c'est moins de caractères,
c'est "transmissible" par JSON et que new Array() ainsi que new Object()
sont des notations d'un age antidéluvien (cad IE4/NS4 c'est dire si
c'est obsolète). Les navigateurs dit "modernes" (ceux qui se faisaient
appeler 4eme génération il y a quelques temps) permettent l'utilisation
de la notation courte, pourquoi s'en priver ?

D'autant plus que la notation courte permet d'écrire ceci :

var foo = [5];

alors qu'avec la notation longue

var bar = new Array(5);

n'aura *pas* du tout la même signification.

alert(foo.length) ==> 1
alert(bar.length) ==> 5

Mieux encore, la notation courte permet également des définitions que
new Array() ne permettra jamais aussi simplement

var foo = [[1,2,3],[4,5,6],[7,8,9]];
http://www.json.org/

// puisque mesDonnees est un hash,
// tu veux en fait un objet et un pas un array
window.mesDonnees = {};

En passant un Array (majuscule STP) est un Object qui dispose de toutes
les propriétés des objets Javascript et d'autres spécifiques en plus.

Hurm, majuscule, euh, seulement si j'écris du code qui doit être
interprété, pas que j'en parle. Merci de me laisser écrire un
commentaire comme je l'entend !

Cela suffit et fonctionne pour un Array. Donc :

Non ! Ce n'est pas parce que, oh miracle, ça à l'air de passer que c'est
la bonne solution. Pourquoi pas utiliser un new Boolean(), new String(),
new Regexp() ou encore pendant qu'on est à faire n'importe quoi, un new
Function() ?
http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array
<quote>
An array is an ordered set of values associated with a single variable
name. *Note that you shouldn't use it as an associative array, use
Object instead.*
</quote>
http://www.andrewdupont.net/2006/05/18/javascript-associative-arrays-considered-harmful/

Le type Array dans le cas de l'OP n'est donc tout simplement pas la
solution à retenir.

var tbl = [];
tbl['cleOne'] = 'foo';
tbl['cleTwo'] = 'bar';
tbl[5] = 'foobar';
// tbl.cleOne et tbl.cleTwo serait une meilleure notation,
// mais c'est pour la compréhension de l'exemple
// que je garde exprès les crochets autour

alert(tbl.length);
// == 6 ?!?!

Les tableaux avec indexes *numériques séquentiels* (Array) ne sont donc
*pas* (jamais) à utiliser lorsque les clés ne sont pas numériques
séquentielles (cad lorsque l'on a clé/valeur au lieu de index/valeur).
On est donc bien dans le cas d'un tableau associatif (hash, clé/valeur)
et le plus proche en javascript (bien que ça n'existe pas) c'est le type
Object et non pas Array !

Quant au var mesDonnees ou window.mesDonnees, tout dépend de la
portée souhaitée pour cette variable et de l'endroit où on la
définit.

Oui, on est d'accord, mais c'est pas une raison pour indiquer de
mauvaises pistes et considérer que le lecteur pourra faire la différence
entre ce qui doit être fait, ce qui ne doit pas l'être et ce qui est
sous entendu !

Javascript est déjà suffisemment mal compris pour ne pas indiquer de
mauvaises "solutions" comme tu viens de le faire dans ton message.

--
laurent

trés trés technique votre échange et je ne compte pas vraiment
m'imicer dedans à peine foutu que je suis de ne pas me vautrer à
force de tapis prets à se saisir de mes pieds gauches....

cependant je retiens une chose c'est que le code source complet aide à
la compréhension de ce que je voulais faire ; soit :

j'ai une xmlHttpRequest à l'issue de laquelle je traite des données
de la façon suivante :


donneesTab =
_XmlHttpRequest.responseXML.getElementsByTagName('mesDonnees);
window._cacheDonnees = new Array();

for (i=0; i < donneesTab.length; ++i) {
var idDonnees = donnesTab[i].childNodes[0].firstChild.data;
window._cacheDonnees[idDonnees][0] =
donneesTab[i].childNodes[1].firstChild.data;
}


plus loin dans une fonction j'écris ceci

var liste = window._cacheDonnes;
for ( var indice in liste ) {
var mesDonnees = liste[indice];
div = document.createElement('div');
// il existe une div qui s'appelle divParent
divParent.appendChild(div);
div.id = indice;
div.title = mesDonnees[0]
// etc ....
}

ce qui fait exactement ce que je recherchais, et grâce à votre aide
généreuse !
merci encore.
jérôme

PS. j'ai retranscrit mon code source : il se peut qu'une/des fautes de
frappe s'y soit glissée/s

Je ne vais pas répondre dans le fil, ça serait indigeste, mais reprendre
quelques points et développer.

1) L'OP devait-il utiliser un Array ?

Dans la mesure où il dit utiliser des identifiants numériques (qu'on peut
supposer entiers et inférieurs à la valeur maximale possible), pourquoi
pas ? Par ailleurs on ne sait pas quelles propriétés spécifiques aux Arrays
sont utilisées. S'il n'y en a aucune, il est alors possible d'utiliser
des Objects mais pourquoi pas un Array qui permettra de connaître très
vite le plus grand identifiant numérique utilisé (mesDonnees.length-1).


2) La question de l'OP était : existe-t-il un moyen de parcourir un Array
qui n'est pas 'dense' (qui ne possède pas une valeur pour chaque indice
inférieur à sa propriété length) ?

La réponse est oui, for(p in o) qui énumérera en p les propriétés
énumérables définies de l'objet o. Ceci n'est pas propre aux Arrays mais
à tous les objets JS. Ça présente l'avantage pour les Arrays de ne donner
que les "indices" pour lesquels une valeur est définie. Il donnera également
les autres propriétés qu'on aura pu ajouter à l'objet Array... Se servir
dans les Arrays des méthodes et opérateurs définis pour les Objects c'est
prévu. Et ce n'est pas un miracle, c'est de la programmation orientée
objet -- enfin, tu dois le savoir.


3) Sur l'utilisation de l'objet global du navigateur : window.
Tu prétends que
function remplir() {window.mesDonnees = 'foo';}
est 'mieux' que
function remplir() {mesDonnees = 'foo';}

Je ne te suis pas là-dessus. Si une variable est affectée d'une valeur
dans une fonction et qu'elle n'a pas été déclarée auparavant *dans la
fonction* c'est qu'elle est appartient à un contexte d'exécution 'supérieur'
voire, /in fine/, au niveau global. La bonne utilisation de la portée
des variables vient avec la longueur et la complexité des scripts.

L'intérêt d'une écriture comme window.mesDonnees est à mon sens davantage
de permettre de tester l'existence d'une variable mesDonnees et non de la
définir...


4) Ce que tu appelles "notation courte" versus "notations d'un âge
antidéluvien" (quel argument !)

Pour ces notations abrégées de l'initialisation d'un Array ou Object,
la norme ECMA262 emploie l'expression Array Initialiser :
"An array initialiser is an expression describing the initialisation
of an Array object, written in a form of a literal."
Dans ce cas la première étape que doit faire le moteur JS, face à ce
type d'écriture :
"1. Create a new array as if by the expression new Array()."
Dans un cas on fait appel explicitement au constructeur, dans l'autre
c'est implicite.
Tu peux donc trouver cela très pratique mais ce n'est qu'une facilité
d'écriture et n'est pas particulièrement à recommander. On se sert de
l'un ou l'autre selon ses besoins et préférences -- et ce n'est pas
parce qu'un script est abscons qu'il est forcément 'mieux'.

Javascript est déjà suffisemment mal compris pour ne pas indiquer de
mauvaises "solutions" comme tu viens de le faire dans ton message.

Ça s'appelle une attaque ad hominem ? Ou alors tu es *vraiment* persuadé
de détenir la vérité sur le bon usage du Javascript ?


--
Y.D.

Je ne vais pas répondre dans le fil, ça serait indigeste, mais reprendre
quelques points et développer.

Mouais évidemment, ça va aider à comprendre c'est certain. D'un autre
côté, ça va te permettre de me préter des paroles qui ne sont pas les
miennes, belle technique.

1) L'OP devait-il utiliser un Array ?

Non !

Dans la mesure où il dit utiliser des identifiants numériques (qu'on peut
supposer entiers et inférieurs à la valeur maximale possible), pourquoi
pas ?

Tout simplement parce qu'il dit *aussi* ceci :

<cite>
je ne trouve pas de methode pour faire une boucle dans mon tableau au
niveau ou il est indicé par les identifiants numériques, dans la mesure
où ils ne sont pas nécessairement consécutifs
</cite>

Toute la problématique est résumé avec ces 3 mots :

"pas nécessairement consécutifs"

Par ailleurs on ne sait pas quelles propriétés spécifiques aux Arrays
sont utilisées. S'il n'y en a aucune, il est alors possible d'utiliser
des Objects mais pourquoi pas un Array qui permettra de connaître très
vite le plus grand identifiant numérique utilisé (mesDonnees.length-1).

Non, ce n'est pas consécutifs, d'après ce qu'il dit il a potentiellement
ceci :

mesDonnees[0] = [];
mesDonnees[1] = [];
mesDonnees[31] = [];
mesDonnees[20] = [];
mesDonnees[8] = [];

alert(mesDonnees.length - 1);
// 31

31 ?!?! Ce n'est pas vrai, tout simplement.

Je remets l'url qui explique bien mieux que moi pourquoi il ne faut
*pas* utiliser un Array() dans ce cas précis puisque tu insistes dans
cette direction qui est fausse, et même pire que fausse, c'est la
direction à ne *pas* prendre :
http://www.andrewdupont.net/2006/05/18/javascript-associative-arrays-considered-harmful/

Ce qu'il a besoin n'est pas un tableau au sens Array() du terme
javascript mais bien un Object().

2) La question de l'OP était : existe-t-il un moyen de parcourir un Array
qui n'est pas 'dense' (qui ne possède pas une valeur pour chaque indice
inférieur à sa propriété length) ?

La réponse est oui, for(p in o) qui énumérera en p les propriétés
énumérables définies de l'objet o.

Oui, ai-je proposé qqchose de différents ?
Et comme tu le dis - l'objet o - alors pourquoi aller utiliser un
Array() quand on parle d'Object() ? On retombe sur le problème
d'utiliser un type incompatible avec le besoin.

var x = new Boolean();
x[0] = 'foo';
x[10] = 'bar';
x[20] = 'foobar';

for ( var i in x )
{
alert(i);
}

Ca donne : 0 puis 10 puis 20

Est-ce une raison pour autant d'aller utiliser un Boolean() ? non !

Ceci n'est pas propre aux Arrays mais
à tous les objets JS. Ça présente l'avantage pour les Arrays de ne donner
que les "indices" pour lesquels une valeur est définie. Il donnera
également
les autres propriétés qu'on aura pu ajouter à l'objet Array... Se servir
dans les Arrays des méthodes et opérateurs définis pour les Objects c'est
prévu. Et ce n'est pas un miracle, c'est de la programmation orientée
objet -- enfin, tu dois le savoir.

Ah, et depuis quand javascript est orienté objet ? C'est un langage
prototypé, pas du tout objet dans le sens OOP qu'on peut trouver en php
par exemple. Faire l'amalgamme n'est pas aider le lecteur.

3) Sur l'utilisation de l'objet global du navigateur : window.
Tu prétends que
function remplir() {window.mesDonnees = 'foo';}
est 'mieux' que
function remplir() {mesDonnees = 'foo';}

Non, relis mieux au lieu de survoler, j'ai jamais dit que c'était
'mieux', j'ai dit que c'était pas lui rendre service que de lui donner
juste ça comme prétendue "solution". Merci de ne *pas* m'attribuer des
paroles que je n'ai *pas* dites.

Je ne te suis pas là-dessus. Si une variable est affectée d'une valeur
dans une fonction et qu'elle n'a pas été déclarée auparavant *dans la
fonction* c'est qu'elle est appartient à un contexte d'exécution
'supérieur'
voire, /in fine/, au niveau global. La bonne utilisation de la portée
des variables vient avec la longueur et la complexité des scripts.

Non, la bonne utilisation de la portée des variables vient avec la
rigueur dans la façon d'écrire le code, faire un peu n'importe quoi en
espérant que ça marche, c'est pas comme ça que javascript sera perçu
autrement que comme un langage "gadget".

L'intérêt d'une écriture comme window.mesDonnees est à mon sens davantage
de permettre de tester l'existence d'une variable mesDonnees et non de la
définir...

Je rappelle qu'on a pas la moitié des informations nécessaires pour
déterminer ce que l'OP veut faire ni comment il compte s'y prendre. Sous
prétexte que je n'ai pas voulu perturber l'OP dans ma réponse initiale
tu me prètes des intentions qui ne sont pas les miennes. Tu t'obstines à
interpréter ce que je dit de travers, tant pis. Je remarque que quand
c'est à ton sens ca semble évidemment être la solution universelle à
retenir. Ok, message reçu et évidemment immédiatement ignoré.

4) Ce que tu appelles "notation courte" versus "notations d'un âge
antidéluvien" (quel argument !)

Lol, comme si c'était le seul "argument" que j'avais énoncé. Et quand tu
me demandes les différences et que je réponds "presque aucune". Est-ce
que tu comprends autre chose ? Encore une fois, tant pis.

Pour ces notations abrégées de l'initialisation d'un Array ou Object,
la norme ECMA262 emploie l'expression Array Initialiser :

Oui, chapitre 11.1.4 et appendice A.3, où la norme parle d'expression.

<snip>

Dans un cas on fait appel explicitement au constructeur, dans l'autre
c'est implicite.

Et ? Si je te suis bien et en appliquant ton raisonnement (explicite vs
implicite) à tous les types existants en javascript, tu prétends que

var x = new String('foo');

serait à conseiller au dépend de

var x = 'foo';

Les deux existent, alors pourquoi prétendre que pour le type tableau
(Array) la notation courte est à proscrire. J'ai juste énoncé le fait
que ça existait, pas que c'était préférable, simplement que ça existait.

Tu peux donc trouver cela très pratique mais ce n'est qu'une facilité
d'écriture et n'est pas particulièrement à recommander. On se sert de
l'un ou l'autre selon ses besoins et préférences -- et ce n'est pas
parce qu'un script est abscons qu'il est forcément 'mieux'.

Encore une fois, tu m'as lu de travers et tu m'attribues des paroles qui
ne sont *pas*, n'ont jamais et ne seront jamais les miennes.

J'ai jamais dit 'mieux' ni recommandé de l'utiliser, relis moi *mieux*,
j'ai dit :

<cite>
new Array() est transformable à volonté par []
</cite>

Ce qui sous entend bien qu'on peut se servir de l'un ou de l'autre selon
ses besoins et préférences. Et ce n'est pas être abscons que d'indiquer
que ça existe, d'autant plus que la norme, toujours chapitre 11.1.4,
indique bien que la notation est valide. D'autant que tu prétends que ce
n'est pas à recommander, alors je vais te retourner la question. Tu sors
ça d'où que c'est pas recommandé ?

Javascript est déjà suffisemment mal compris pour ne pas indiquer de
mauvaises "solutions" comme tu viens de le faire dans ton message.

Ça s'appelle une attaque ad hominem ? Ou alors tu es *vraiment* persuadé
de détenir la vérité sur le bon usage du Javascript ?

Lol, je persiste et signe. Dans ton message tu disais :

<cite>
Cela suffit et fonctionne pour un Array.
</cite>

C'est faux, archi faux et absolument pas à préconiser pour le besoin de
l'OP. Donc oui, merci de ne pas indiquer de mauvaises "solutions" comme
tu viens *encore* une fois de le faire, ceci afin de permettre aux
lecteurs de fclj de ne pas enregistrer et reproduire des erreurs dans
leurs developpements.

Pour finir sur le sujet, saches que non, je suis loin d'être persuadé de
détenir une quelconque vérité sur le bon usage de javascript, mais je
suis absolument convaincu du fait que tu ne la détiens pas. Considère ça
comme une attaque ad hominem si ça te chante, et profites en pour relire
la réponse que tu avais faite à mon message, réponse où tu avais
commencé les hostilités. Message ou je te rappelle j'ai donné la
solution adéquate alors que tu donnes la *mauvaise* "solution" !

Détiendrais-tu la vérité sur le bon usage du Javascript ?

--
laurent

4) Ce que tu appelles "notation courte" versus "notations d'un âge
antidéluvien" (quel argument !)

Pour ces notations abrégées de l'initialisation d'un Array ou Object,
la norme ECMA262 emploie l'expression Array Initialiser :
"An array initialiser is an expression describing the initialisation
of an Array object, written in a form of a literal."
Dans ce cas la première étape que doit faire le moteur JS, face à ce
type d'écriture :
"1. Create a new array as if by the expression new Array()."
Dans un cas on fait appel explicitement au constructeur, dans l'autre
c'est implicite.
Tu peux donc trouver cela très pratique mais ce n'est qu'une facilité
d'écriture et n'est pas particulièrement à recommander.

Et bien, il suffit de vérifier pour se persuader du contraire :

http://mokhet.com/tests/benchArray.html

resultats (A) pour new Array()
resultats (B) pour []

IE6
(A) : 141 - 156 - 141 - 141 - 141
(B) : 110 - 110 - 110 - 109 - 110
moyenne (A) : 144
moyenne (B) : 109,8
gagnant : (B)

Fx 1.5.0.6
(A) : 609 - 610 - 625 - 625 - 640
(B) : 609 - 609 - 609 - 594 - 610
moyenne (A) : 621,8
moyenne (B) : 606,2
gagnant : (B)

Opéra 9
(A) : 266 - 234 - 265 - 203 - 234
(B) : 188 - 172 - 172 - 156 - 172
moyenne (A) : 240,4
moyenne (B) : 172
gagnant : (B)

Il semblerait donc que la notation [] soit à *recommander* par rapport à
la notation new Array(), au moins pour ces 3 navigateurs en
environnement windows (pas le courage de tester ni en slackware ni sur
d'autres navigateurs, j'ai assez perdu mon temps avec ça), puisque :
- la notation courte [] va un tantinet plus vite,
- permet une écriture plus concise,
- permet de préremplir les tableaux de façon simplifiée,
- permet même la création de tableaux multidimensionnels ce que ne
permet pas new Array().

Mais je suis d'accord, ce n'est pas sur quelques microsecondes que va se
faire la vrai différence et tout dépend de ce qui tourne en fond de
tache, des extensions, etc.

A la vue des moyennes obtenues, ll n'y a *aucune* raison de ne pas
l'utiliser.

<script type="text/javascript">
var bench {
D:0,
T:'',
init:function(T)
{
bench.T = T;
bench.D = (new Date()).valueOf();
},
fin:function()
{
return (new Date()).valueOf() - bench.D;
}
};

var MSG = '';

function b1()
{
bench.init('new Array()');
var X;
for ( var i = 0; i < 100000; i++ )
{
X = new Array();
}
MSG += bench.T + ' : ' + bench.fin() + '<br>';
setTimeout(b2, 50);
}

function b2()
{
bench.init('[]');
var X;
for ( var i = 0; i < 100000; i++ )
{
X = [];
}
MSG += bench.T + ' : ' + bench.fin() + '<br>';
document.getElementById('results').innerHTML = MSG;
}

window.onload = b1;
</script>

<div id="results"></div>

--
laurent

Laurent vilday wrote:

Il semblerait donc que la notation [] soit à *recommander* par rapport à
la notation new Array(), au moins pour ces 3 navigateurs en
environnement windows (pas le courage de tester ni en slackware ni sur
d'autres navigateurs, j'ai assez perdu mon temps avec ça), puisque :
- la notation courte [] va un tantinet plus vite,
- permet une écriture plus concise,
- permet de préremplir les tableaux de façon simplifiée,
- permet même la création de tableaux multidimensionnels ce que ne
permet pas new Array().

En effet ça semble assez séduisant d'un point de vue syntaxe
Par contre quid du support ? (je pense en particulier à IE 5 et Safari ?)