PS. Et pour supprimer n-ième élément du tableau 'normal', stp ?
[ pour supprimer un élément dans un tableau associatif ]
Je fais :
tata["titi"] = undefined ;
et ça l'air de marcher. Mais est-ce vraiment correct ?
Ceci devrait avoir plus de chances de marcher sur les divers interpréteurs JavaScript :
delete tata["titi"];
Olivier Miakinen
PS. Et pour supprimer n-ième élément du tableau 'normal', stp ?
Si je ne m'abuse, un tableau "normal" n'est qu'un tableau associatif dans lequel tous les index sont de la forme "0", "1", "2", "3", et ainsi de suite.
Donc : delete[n]
Maintenant, si tu veux que les éléments du tableau se renumérotent automatiquement, c'est peut-être avec splice(). Je vérifierai dans la norme, demain.
[citation intégrale]
Merci d'apprendre à citer utile : http://www.usenet-fr.net/fur/usenet/repondre-sur-usenet.html
PS. Et pour supprimer n-ième élément du tableau 'normal', stp ?
Si je ne m'abuse, un tableau "normal" n'est qu'un tableau associatif
dans lequel tous les index sont de la forme "0", "1", "2", "3", et
ainsi de suite.
Donc :
delete[n]
Maintenant, si tu veux que les éléments du tableau se renumérotent
automatiquement, c'est peut-être avec splice(). Je vérifierai dans la
norme, demain.
[citation intégrale]
Merci d'apprendre à citer utile :
http://www.usenet-fr.net/fur/usenet/repondre-sur-usenet.html
PS. Et pour supprimer n-ième élément du tableau 'normal', stp ?
Si je ne m'abuse, un tableau "normal" n'est qu'un tableau associatif dans lequel tous les index sont de la forme "0", "1", "2", "3", et ainsi de suite.
Donc : delete[n]
Maintenant, si tu veux que les éléments du tableau se renumérotent automatiquement, c'est peut-être avec splice(). Je vérifierai dans la norme, demain.
[citation intégrale]
Merci d'apprendre à citer utile : http://www.usenet-fr.net/fur/usenet/repondre-sur-usenet.html
YD
PS. Et pour supprimer n-ième élément du tableau 'normal', stp ?
Si je ne m'abuse, un tableau "normal" n'est qu'un tableau associatif dans lequel tous les index sont de la forme "0", "1", "2", "3", et ainsi de suite. Donc : delete[n]
plutôt delete titi[n]; mais si delete supprime bien l'élément, il ne modifie pas la propriété length, même si c'est l'élément de plus grand indice qui est supprimé. On peut obtenir un Array dont la propriété length est non nulle mais qui ne contient aucun élément.
Maintenant, si tu veux que les éléments du tableau se renumérotent automatiquement, c'est peut-être avec splice().
Confirmation, c'est bien avec splice(), définie ainsi : Array.prototype.splice (start, deleteCount [ , item1 [ , item2 [ , … ] ] ] ) qui supprime les 'deleteCount' éléments (s'ils existent) à partir de la position 'start' d'un tableau, insère à cet endroit les arguments item1, item2..., renumérote les éléments et modifie length : par ex. titi.splice(n,1);
-- Y.D.
PS. Et pour supprimer n-ième élément du tableau 'normal', stp ?
Si je ne m'abuse, un tableau "normal" n'est qu'un tableau associatif
dans lequel tous les index sont de la forme "0", "1", "2", "3", et
ainsi de suite.
Donc :
delete[n]
plutôt delete titi[n]; mais si delete supprime bien l'élément,
il ne modifie pas la propriété length, même si c'est l'élément
de plus grand indice qui est supprimé. On peut obtenir un
Array dont la propriété length est non nulle mais qui ne
contient aucun élément.
Maintenant, si tu veux que les éléments du tableau se renumérotent
automatiquement, c'est peut-être avec splice().
Confirmation, c'est bien avec splice(), définie ainsi :
Array.prototype.splice (start, deleteCount [ , item1 [ , item2 [ , … ] ] ] )
qui supprime les 'deleteCount' éléments (s'ils existent) à partir
de la position 'start' d'un tableau, insère à cet endroit les
arguments item1, item2..., renumérote les éléments
et modifie length :
par ex. titi.splice(n,1);
PS. Et pour supprimer n-ième élément du tableau 'normal', stp ?
Si je ne m'abuse, un tableau "normal" n'est qu'un tableau associatif dans lequel tous les index sont de la forme "0", "1", "2", "3", et ainsi de suite. Donc : delete[n]
plutôt delete titi[n]; mais si delete supprime bien l'élément, il ne modifie pas la propriété length, même si c'est l'élément de plus grand indice qui est supprimé. On peut obtenir un Array dont la propriété length est non nulle mais qui ne contient aucun élément.
Maintenant, si tu veux que les éléments du tableau se renumérotent automatiquement, c'est peut-être avec splice().
Confirmation, c'est bien avec splice(), définie ainsi : Array.prototype.splice (start, deleteCount [ , item1 [ , item2 [ , … ] ] ] ) qui supprime les 'deleteCount' éléments (s'ils existent) à partir de la position 'start' d'un tableau, insère à cet endroit les arguments item1, item2..., renumérote les éléments et modifie length : par ex. titi.splice(n,1);
-- Y.D.
jacek55
Donc si je parcours mon tableau par index et tombe sur un élément qui ne me plait pas, il me faut deplacer 'manuellement' restant du tableau (tab[k] = tab[k+1]; k++ jusqu'à fin du tab) et ensuite virer le dernier élément par tab.pop().
ai-je raison ?
jacek
PS. Et pour supprimer n-ième élément du tableau 'normal', stp ?
Si je ne m'abuse, un tableau "normal" n'est qu'un tableau associatif dans lequel tous les index sont de la forme "0", "1", "2", "3", et ainsi de suite. Donc : delete[n]
plutôt delete titi[n]; mais si delete supprime bien l'élément, il ne modifie pas la propriété length, même si c'est l'élément de plus grand indice qui est supprimé. On peut obtenir un Array dont la propriété length est non nulle mais qui ne contient aucun élément.
Maintenant, si tu veux que les éléments du tableau se renumérotent automatiquement, c'est peut-être avec splice().
Confirmation, c'est bien avec splice(), définie ainsi : Array.prototype.splice (start, deleteCount [ , item1 [ , item2 [ , ... ] ] ] ) qui supprime les 'deleteCount' éléments (s'ils existent) à partir de la position 'start' d'un tableau, insère à cet endroit les arguments item1, item2..., renumérote les éléments et modifie length : par ex. titi.splice(n,1);
-- Y.D.
Donc si je parcours mon tableau par index et tombe sur un élément qui
ne me plait pas, il me faut deplacer 'manuellement' restant du tableau
(tab[k] = tab[k+1]; k++ jusqu'à fin du tab) et ensuite virer le
dernier élément par tab.pop().
ai-je raison ?
jacek
PS. Et pour supprimer n-ième élément du tableau 'normal', stp ?
Si je ne m'abuse, un tableau "normal" n'est qu'un tableau associatif
dans lequel tous les index sont de la forme "0", "1", "2", "3", et
ainsi de suite.
Donc :
delete[n]
plutôt delete titi[n]; mais si delete supprime bien l'élément,
il ne modifie pas la propriété length, même si c'est l'élément
de plus grand indice qui est supprimé. On peut obtenir un
Array dont la propriété length est non nulle mais qui ne
contient aucun élément.
Maintenant, si tu veux que les éléments du tableau se renumérotent
automatiquement, c'est peut-être avec splice().
Confirmation, c'est bien avec splice(), définie ainsi :
Array.prototype.splice (start, deleteCount [ , item1 [ , item2 [ , ... ] ] ] )
qui supprime les 'deleteCount' éléments (s'ils existent) à partir
de la position 'start' d'un tableau, insère à cet endroit les
arguments item1, item2..., renumérote les éléments
et modifie length :
par ex. titi.splice(n,1);
Donc si je parcours mon tableau par index et tombe sur un élément qui ne me plait pas, il me faut deplacer 'manuellement' restant du tableau (tab[k] = tab[k+1]; k++ jusqu'à fin du tab) et ensuite virer le dernier élément par tab.pop().
ai-je raison ?
jacek
PS. Et pour supprimer n-ième élément du tableau 'normal', stp ?
Si je ne m'abuse, un tableau "normal" n'est qu'un tableau associatif dans lequel tous les index sont de la forme "0", "1", "2", "3", et ainsi de suite. Donc : delete[n]
plutôt delete titi[n]; mais si delete supprime bien l'élément, il ne modifie pas la propriété length, même si c'est l'élément de plus grand indice qui est supprimé. On peut obtenir un Array dont la propriété length est non nulle mais qui ne contient aucun élément.
Maintenant, si tu veux que les éléments du tableau se renumérotent automatiquement, c'est peut-être avec splice().
Confirmation, c'est bien avec splice(), définie ainsi : Array.prototype.splice (start, deleteCount [ , item1 [ , item2 [ , ... ] ] ] ) qui supprime les 'deleteCount' éléments (s'ils existent) à partir de la position 'start' d'un tableau, insère à cet endroit les arguments item1, item2..., renumérote les éléments et modifie length : par ex. titi.splice(n,1);
-- Y.D.
jero
jacek55 wrote:
Donc si je parcours mon tableau par index et tombe sur un élément qui ne me plait pas, il me faut deplacer 'manuellement' restant du tableau (tab[k] = tab[k+1]; k++ jusqu'à fin du tab) et ensuite virer le dernier élément par tab.pop().
ai-je raison ?
Dans le principe ca fonctionne ..
il faudrait comptabiliser le nombre d'éléments supprimés pour à la fin rétablir la vérité objective sur tab.length par unes soustraction : tab.length -= nbrSuppr ;
mais bon je suis sûr que plein d'experts ont des méthodes bien plus rationnelles et efficaces ... jérô.
jacek55 wrote:
Donc si je parcours mon tableau par index et tombe sur un élément qui
ne me plait pas, il me faut deplacer 'manuellement' restant du tableau
(tab[k] = tab[k+1]; k++ jusqu'à fin du tab) et ensuite virer le
dernier élément par tab.pop().
ai-je raison ?
Dans le principe ca fonctionne ..
il faudrait comptabiliser le nombre d'éléments supprimés pour à la
fin rétablir la vérité objective sur tab.length par unes
soustraction :
tab.length -= nbrSuppr ;
mais bon je suis sûr que plein d'experts ont des méthodes bien plus
rationnelles et efficaces ...
jérô.
Donc si je parcours mon tableau par index et tombe sur un élément qui ne me plait pas, il me faut deplacer 'manuellement' restant du tableau (tab[k] = tab[k+1]; k++ jusqu'à fin du tab) et ensuite virer le dernier élément par tab.pop().
ai-je raison ?
Dans le principe ca fonctionne ..
il faudrait comptabiliser le nombre d'éléments supprimés pour à la fin rétablir la vérité objective sur tab.length par unes soustraction : tab.length -= nbrSuppr ;
mais bon je suis sûr que plein d'experts ont des méthodes bien plus rationnelles et efficaces ... jérô.
Donc si je parcours mon tableau par index et tombe sur un élément qui ne me plait pas, il me faut deplacer 'manuellement' restant du tableau (tab[k] = tab[k+1]; k++ jusqu'à fin du tab) et ensuite virer le dernier élément par tab.pop().
ai-je raison ?
jacek
PS. Et pour supprimer n-ième élément du tableau 'normal', stp ?
Si je ne m'abuse, un tableau "normal" n'est qu'un tableau associatif dans lequel tous les index sont de la forme "0", "1", "2", "3", et ainsi de suite. Donc : delete[n]
plutôt delete titi[n]; mais si delete supprime bien l'élément, il ne modifie pas la propriété length, même si c'est l'élément de plus grand indice qui est supprimé. On peut obtenir un Array dont la propriété length est non nulle mais qui ne contient aucun élément.
Maintenant, si tu veux que les éléments du tableau se renumérot ent automatiquement, c'est peut-être avec splice().
Confirmation, c'est bien avec splice(), définie ainsi : Array.prototype.splice (start, deleteCount [ , item1 [ , item2 [ , ... ] ] ] ) qui supprime les 'deleteCount' éléments (s'ils existent) à partir de la position 'start' d'un tableau, insère à cet endroit les arguments item1, item2..., renumérote les éléments et modifie length : par ex. titi.splice(n,1);
Donc si je parcours mon tableau par index et tombe sur un élément qui
ne me plait pas, il me faut deplacer 'manuellement' restant du tableau
(tab[k] = tab[k+1]; k++ jusqu'à fin du tab) et ensuite virer le
dernier élément par tab.pop().
ai-je raison ?
jacek
PS. Et pour supprimer n-ième élément du tableau 'normal', stp ?
Si je ne m'abuse, un tableau "normal" n'est qu'un tableau associatif
dans lequel tous les index sont de la forme "0", "1", "2", "3", et
ainsi de suite.
Donc :
delete[n]
plutôt delete titi[n]; mais si delete supprime bien l'élément,
il ne modifie pas la propriété length, même si c'est l'élément
de plus grand indice qui est supprimé. On peut obtenir un
Array dont la propriété length est non nulle mais qui ne
contient aucun élément.
Maintenant, si tu veux que les éléments du tableau se renumérot ent
automatiquement, c'est peut-être avec splice().
Confirmation, c'est bien avec splice(), définie ainsi :
Array.prototype.splice (start, deleteCount [ , item1 [ , item2 [ , ... ] ] ] )
qui supprime les 'deleteCount' éléments (s'ils existent) à partir
de la position 'start' d'un tableau, insère à cet endroit les
arguments item1, item2..., renumérote les éléments
et modifie length :
par ex. titi.splice(n,1);
Donc si je parcours mon tableau par index et tombe sur un élément qui ne me plait pas, il me faut deplacer 'manuellement' restant du tableau (tab[k] = tab[k+1]; k++ jusqu'à fin du tab) et ensuite virer le dernier élément par tab.pop().
ai-je raison ?
jacek
PS. Et pour supprimer n-ième élément du tableau 'normal', stp ?
Si je ne m'abuse, un tableau "normal" n'est qu'un tableau associatif dans lequel tous les index sont de la forme "0", "1", "2", "3", et ainsi de suite. Donc : delete[n]
plutôt delete titi[n]; mais si delete supprime bien l'élément, il ne modifie pas la propriété length, même si c'est l'élément de plus grand indice qui est supprimé. On peut obtenir un Array dont la propriété length est non nulle mais qui ne contient aucun élément.
Maintenant, si tu veux que les éléments du tableau se renumérot ent automatiquement, c'est peut-être avec splice().
Confirmation, c'est bien avec splice(), définie ainsi : Array.prototype.splice (start, deleteCount [ , item1 [ , item2 [ , ... ] ] ] ) qui supprime les 'deleteCount' éléments (s'ils existent) à partir de la position 'start' d'un tableau, insère à cet endroit les arguments item1, item2..., renumérote les éléments et modifie length : par ex. titi.splice(n,1);
-- Y.D.
YD
Donc si je parcours mon tableau par index et tombe sur un élément qui ne me plait pas, il me faut deplacer 'manuellement' restant du tableau (tab[k] = tab[k+1]; k++ jusqu'à fin du tab) et ensuite virer le dernier élément par tab.pop().
À quoi fais-tu référence ? à delete ou à splice ? (merci de jeter un oeil attentif sur le lien donné par Olivier Miakinen http://www.usenet-fr.net/fur/usenet/repondre-sur-usenet.html)
ai-je raison ?
Oui avec : delete titi[n]; il te faut déplacer "manuellement" les éléments suivants si tu veux modifier la propriété length et éviter un 'trou' dans l'Array.
Non avec titi.splice(n,1); le javascript s'en charge, renumérotation des éléments et modification de la longueur.
-- Y.D.
Donc si je parcours mon tableau par index et tombe sur un élément qui
ne me plait pas, il me faut deplacer 'manuellement' restant du tableau
(tab[k] = tab[k+1]; k++ jusqu'à fin du tab) et ensuite virer le
dernier élément par tab.pop().
À quoi fais-tu référence ? à delete ou à splice ? (merci de jeter
un oeil attentif sur le lien donné par Olivier Miakinen
http://www.usenet-fr.net/fur/usenet/repondre-sur-usenet.html)
ai-je raison ?
Oui avec : delete titi[n];
il te faut déplacer "manuellement" les éléments suivants si tu veux
modifier la propriété length et éviter un 'trou' dans l'Array.
Non avec titi.splice(n,1); le javascript s'en charge, renumérotation
des éléments et modification de la longueur.
Donc si je parcours mon tableau par index et tombe sur un élément qui ne me plait pas, il me faut deplacer 'manuellement' restant du tableau (tab[k] = tab[k+1]; k++ jusqu'à fin du tab) et ensuite virer le dernier élément par tab.pop().
À quoi fais-tu référence ? à delete ou à splice ? (merci de jeter un oeil attentif sur le lien donné par Olivier Miakinen http://www.usenet-fr.net/fur/usenet/repondre-sur-usenet.html)
ai-je raison ?
Oui avec : delete titi[n]; il te faut déplacer "manuellement" les éléments suivants si tu veux modifier la propriété length et éviter un 'trou' dans l'Array.
Non avec titi.splice(n,1); le javascript s'en charge, renumérotation des éléments et modification de la longueur.
-- Y.D.
jacek55
Donc si je parcours mon tableau par index et tombe sur un élément q ui ne me plait pas, il me faut deplacer 'manuellement' restant du tableau (tab[k] = tab[k+1]; k++ jusqu'à fin du tab) et ensuite virer le dernier élément par tab.pop().
À quoi fais-tu référence ? à delete ou à splice ? (merci de jet er un oeil attentif sur le lien donné par Olivier Miakinen http://www.usenet-fr.net/fur/usenet/repondre-sur-usenet.html)
ai-je raison ?
Oui avec : delete titi[n]; il te faut déplacer "manuellement" les éléments suivants si tu veux modifier la propriété length et éviter un 'trou' dans l'Array.
Non avec titi.splice(n,1); le javascript s'en charge, renumérotation des éléments et modification de la longueur.
-- Y.D.
Merci pour les remarques.
Pour les tables je retiens que, contrairement aux tableaux associatifs ou "delete tata['titi']" arrange tout, les tableaux indexés peuvent se retrouvés "troués" si on veut enlever un élément du milieu. D'ou les solution avec le déplacement "manuel" dans une boucle suivie du "tata.pop()" , voir la solution "tata = (tata.slice(0,k-1)).concat(tata.slice(k,tata.length-1)) "
J'imagine que dans les deux cas tata.length est mis à jour par le navigateur
Par contre je ne vois pas comment employer tata.splice() dans la mesure ou il faut donner la liste des éléments déplacés (ceux qui se trouvent derrière l'élément supprimé) comme argument du "splice()", ce qui ne me semble pas évident
Jacek
Donc si je parcours mon tableau par index et tombe sur un élément q ui
ne me plait pas, il me faut deplacer 'manuellement' restant du tableau
(tab[k] = tab[k+1]; k++ jusqu'à fin du tab) et ensuite virer le
dernier élément par tab.pop().
À quoi fais-tu référence ? à delete ou à splice ? (merci de jet er
un oeil attentif sur le lien donné par Olivier Miakinen
http://www.usenet-fr.net/fur/usenet/repondre-sur-usenet.html)
ai-je raison ?
Oui avec : delete titi[n];
il te faut déplacer "manuellement" les éléments suivants si tu veux
modifier la propriété length et éviter un 'trou' dans l'Array.
Non avec titi.splice(n,1); le javascript s'en charge, renumérotation
des éléments et modification de la longueur.
--
Y.D.
Merci pour les remarques.
Pour les tables je retiens que, contrairement aux tableaux associatifs
ou "delete tata['titi']" arrange tout, les tableaux indexés peuvent se
retrouvés "troués" si on veut enlever un élément du milieu.
D'ou les solution avec le déplacement "manuel" dans une boucle suivie
du "tata.pop()" , voir la solution
"tata = (tata.slice(0,k-1)).concat(tata.slice(k,tata.length-1)) "
J'imagine que dans les deux cas tata.length est mis à jour par le
navigateur
Par contre je ne vois pas comment employer tata.splice() dans la mesure
ou il faut donner la liste des éléments déplacés (ceux qui se
trouvent derrière l'élément supprimé) comme argument du "splice()",
ce qui ne me semble pas évident
Donc si je parcours mon tableau par index et tombe sur un élément q ui ne me plait pas, il me faut deplacer 'manuellement' restant du tableau (tab[k] = tab[k+1]; k++ jusqu'à fin du tab) et ensuite virer le dernier élément par tab.pop().
À quoi fais-tu référence ? à delete ou à splice ? (merci de jet er un oeil attentif sur le lien donné par Olivier Miakinen http://www.usenet-fr.net/fur/usenet/repondre-sur-usenet.html)
ai-je raison ?
Oui avec : delete titi[n]; il te faut déplacer "manuellement" les éléments suivants si tu veux modifier la propriété length et éviter un 'trou' dans l'Array.
Non avec titi.splice(n,1); le javascript s'en charge, renumérotation des éléments et modification de la longueur.
-- Y.D.
Merci pour les remarques.
Pour les tables je retiens que, contrairement aux tableaux associatifs ou "delete tata['titi']" arrange tout, les tableaux indexés peuvent se retrouvés "troués" si on veut enlever un élément du milieu. D'ou les solution avec le déplacement "manuel" dans une boucle suivie du "tata.pop()" , voir la solution "tata = (tata.slice(0,k-1)).concat(tata.slice(k,tata.length-1)) "
J'imagine que dans les deux cas tata.length est mis à jour par le navigateur
Par contre je ne vois pas comment employer tata.splice() dans la mesure ou il faut donner la liste des éléments déplacés (ceux qui se trouvent derrière l'élément supprimé) comme argument du "splice()", ce qui ne me semble pas évident
Jacek
YD
[...] je ne vois pas comment employer tata.splice() dans la mesure ou il faut donner la liste des éléments déplacés (ceux qui se trouvent derrière l'élément supprimé) comme argument du "splice()", ce qui ne me semble pas évident
Mais non !
Pour splice il faut deux arguments obligatoires : - le rang de l'élément de départ : start - le nombre d'éléments à supprimer de l'Array
et des éléments facultatifs item1, item2... qui sont des éléments *à insérer* à l'endroit où on a supprimé...
Exemples : 1. a = new Array(0, 1, 2, 3, 4) //length 5 a.splice(1,3); //on supprime 3 éléments à partir de celui de rang 1 (le 2e donc) //a est alors 0 4, length 2
2. a = new Array(0, 1, 2, 3, 4) //length 5 a.splice(1, 3, 'A', 'B', 'C', 'D'); //on supprime 3 éléments à partir de celui de rang 1 (le 2e donc) et à cet //endroit on insère les éléments A B C et D //a est alors 0 A B C D 4, length 6
-- Y.D.
[...] je ne vois pas comment employer tata.splice() dans la mesure
ou il faut donner la liste des éléments déplacés (ceux qui se
trouvent derrière l'élément supprimé) comme argument du "splice()",
ce qui ne me semble pas évident
Mais non !
Pour splice il faut deux arguments obligatoires :
- le rang de l'élément de départ : start
- le nombre d'éléments à supprimer de l'Array
et des éléments facultatifs item1, item2... qui sont
des éléments *à insérer* à l'endroit où on a supprimé...
Exemples :
1. a = new Array(0, 1, 2, 3, 4)
//length 5
a.splice(1,3);
//on supprime 3 éléments à partir de celui de rang 1 (le 2e donc)
//a est alors 0 4, length 2
2. a = new Array(0, 1, 2, 3, 4)
//length 5
a.splice(1, 3, 'A', 'B', 'C', 'D');
//on supprime 3 éléments à partir de celui de rang 1 (le 2e donc) et à cet
//endroit on insère les éléments A B C et D
//a est alors 0 A B C D 4, length 6
[...] je ne vois pas comment employer tata.splice() dans la mesure ou il faut donner la liste des éléments déplacés (ceux qui se trouvent derrière l'élément supprimé) comme argument du "splice()", ce qui ne me semble pas évident
Mais non !
Pour splice il faut deux arguments obligatoires : - le rang de l'élément de départ : start - le nombre d'éléments à supprimer de l'Array
et des éléments facultatifs item1, item2... qui sont des éléments *à insérer* à l'endroit où on a supprimé...
Exemples : 1. a = new Array(0, 1, 2, 3, 4) //length 5 a.splice(1,3); //on supprime 3 éléments à partir de celui de rang 1 (le 2e donc) //a est alors 0 4, length 2
2. a = new Array(0, 1, 2, 3, 4) //length 5 a.splice(1, 3, 'A', 'B', 'C', 'D'); //on supprime 3 éléments à partir de celui de rang 1 (le 2e donc) et à cet //endroit on insère les éléments A B C et D //a est alors 0 A B C D 4, length 6
