Les matrices peuvent être manipulées grâce à différentes méthodes que je vais aujourd'hui expliquer certaines d'entre elles, car ce sujet est très simple. On va commencer!
Ajouter / supprimer des éléments
Nous connaissons déjà des méthodes qui ajoutent et suppriment des éléments du début ou de la fin:
- arr.push (… éléments) - ajouter des éléments à la fin,
- arr.pop () - Extraire un article de la fin,
- arr.shift () - Extraire un article du début,
- arr.unshift (… éléments) - Ajoutez des éléments au début.
Cependant, en voici quelques autres.
Épissure
Comment supprimer un élément du tableau?
Les tableaux sont des objets, nous pouvons donc essayer d'utiliser delete:
let arr = ["je veux", "manger", "maintenant"]; supprimer arr [2]; // supprime l'alerte "maintenant" (arr [2]); // indéfini // maintenant arr = ["je veux", "manger",]; alert (arr.length); // 3
L'élément a été supprimé, mais le tableau contient toujours 3 éléments, nous pouvons voir que arr.length == 3.
C'est naturel, car supprimer obj.key supprimer une valeur pour le clé. C'est tout ce qu'il fait. Bon pour les objets. Mais pour les arrangements, nous voulons généralement que le reste des éléments se déplace et occupe la place libérée. Nous espérons avoir une matrice plus courte maintenant.
Par conséquent, des méthodes spéciales doivent être utilisées.
La méthode arr.splice (str) C'est comme un couteau suisse pour les arrangements. Vous pouvez tout faire: ajouter, supprimer et insérer des éléments.
La syntaxe est:
arr.splice (index [, deleteCount, elem1, ..., elemN])
Comienza desde la posición indice: deleteCount elementos y luego los inserta elem1, …, elemN en su lugar. Devuelve la matriz de elementos eliminados.
Cette méthode est facile à comprendre à l'aide d'exemples.
Commençons par la suppression:
let arr = ["I", "study", "JavaScript"]; arr.splice (1, 1); // de l'index 1 supprime 1 élément alert (arr); // ["I", "JavaScript"]
Facile non? À partir de l'indice 1, l'élément 1 a été éliminé.
Dans l'exemple suivant, nous supprimons 3 éléments et les remplaçons par les deux autres:
let arr = ["I", "study", "JavaScript", "now", "same"]; // supprimer les 3 premiers éléments et les remplacer par un autre arr.splice (0, 3, "Nous", "nous avons dansé"); alert (arr) // maintenant ["Nous", "nous dansons", "maintenant", "même"]
Ici, nous pouvons voir que splice renvoie le tableau des éléments supprimés:
let arr = ["I", "study", "JavaScript", "now", "same"]; // supprime les deux premiers éléments let enlevé = arr.splice (0, 2); alerte (supprimé); // "YoI", "study" <- ensemble d'éléments supprimés
La méthode épissure Il est également capable d'insérer les éléments sans aucune suppression. Pour cela, nous devons configurer deleteCount à 0:
let arr = ["I", "study", "JavaScript"]; // à partir de l'index 2 // supprimer 0 // puis insérer "complexe" et "langage". //arr.splice(2, 0, "complexe", "langage"); alerte (arr); // "I", "study", "language", "complex", "JavaScript"
Les indices négatifs sont autorisés
Ici et dans d'autres méthodes de tableau, les indices négatifs sont autorisés. Ils spécifient la position à partir de la fin du tableau, comme ici:
soit arr = [1, 2, 5]; // à partir de l'index -1 (un pas à partir de la fin) // supprimer 0 élément, // puis ajouter les points 3 et 4 splice.array (-1, 0, 3, 4); alerte (arr); // 1,2,3,4,5
Tranche
La méthode arr.slice c'est beaucoup plus simple que le similaire arr.splice.
La syntaxe est:
arr.slice (début, fin);
Renvoie un nouveau tableau dans lequel il copie tous les éléments de l'index de début «début» à «fin» (sans compter «fin»). Le début et la fin peuvent être négatifs, dans ce cas, la position à partir de la fin du tableau est supposée.
Par exemple:
let str = "test"; let arr = ["t", "e", "s", "t"]; alert (str.slice (1, 3)); // est alert (arr.slice (1, 3)); // e, s alert (str.slice (-2)); // st alerte (arr.slice (-2)); // s, t concat
La méthode arr.concat unit la matrice avec d'autres matrices et / ou éléments.
La syntaxe est:
arr.concat (arg1, arg2 ...)
Acepta cualquier número de argumentos, ya être matrices o valores.
Le résultat est un nouveau tableau contenant des éléments de arr, donc arg1, arg2etc.
Si un argument est un tableau ou possède une propriété Symbol.isConcatSpreadable, tous ses éléments sont copiés. Sinon, l'argument lui-même est copié.
Par exemple:
soit arr = [1, 2]; // fusionne arr avec [3,4] alert (arr.concat ([3, 4])); // 1,2,3,4 // fusionne arr avec [3,4] et [5,6] alert (arr.concat ([3, 4], [5, 6])); // 1,2,3,4,5,6 // fusionne arr avec [3,4], puis ajoute les valeurs 5 et 6 alert (arr.concat ([3, 4], 5, 6)) ; // 1,2,3,4,5,6
Normalement, il copie simplement les éléments des tableaux (les "étend"). D'autres objets, même s'ils ressemblent à des tableaux, ont été ajoutés dans leur ensemble:
soit arr = [1, 2]; let arrayHello = {0: "certains", longueur: 1}; alert (arr.concat (arrayHello)); // 1,2, [objet Object] // [1, 2, arrayLike]
Mais si un objet de type tableau a des propriétés Symbol.is, Concat, Spreadable, alors ses éléments sont ajoutés à la place:
soit arr = [1, 2]; let arrayHello = {0: "certains", 1: "flaso", [Symbol.isConcatSpreadable]: true, length: 2}; alert (arr.concat (arrayHello)); // 1,2, certains, faux
Recherche de la matrice
Ce sont des méthodes de recherche de quelque chose dans un tableau.
indexOf / lastIndexOf et comprend
Méthodes arr.indexOf , arr.lastIndexOf y arr.inclut Ils ont la même syntaxe et font essentiellement la même chose que leurs homologues de chaîne, mais ils fonctionnent sur des éléments plutôt que sur des caractères:
- arr.indexOf (élément, de) chercher un Objet à partir de l'index depuis, et renvoie l'index où il a été trouvé, sinon -1.
- arr.lastIndexOf (élément, de) - Idem, mais regardez de droite à gauche.
- arr.includes (item, from)- Chercher Objet à partir de l'index desde, et retourne vrai si trouvé.
Par exemple:
soit arr = [1, 0, faux]; alert (arr.indexOf (0)); // 1 alerte (arr.indexOf (false)); // 2 alerte (arr.indexOf (null)); // -1 alerte (arr.includes (1)); // vrai
Notez que les méthodes utilisent la comparaison ===. Donc, si nous recherchons faux, il trouve exactement faux et non zéro.
Si nous voulons vérifier l'inclusion et que nous ne voulons pas connaître l'index exact, alors arr.inclut Il est préférable.
De plus, une très petite différence par rapport aux inclusions est qu'il gère correctement NaN, Contrairement à indexOf / lastIndexOf:
const arr = [NaN]; alert (arr.indexOf (NaN)); // -1 (devrait être 0, mais ==== l'égalité ne fonctionne pas pour NaN) alert (arr.includes (NaN)); // true (correct)
trouver et trouverIndex
Imaginez que nous ayons une variété d'objets. Comment trouver un objet avec la condition spécifique?
Voici la méthode arr.find Elle est utile.
La syntaxe est:
let result = arr.find (function (item, index, array) {// devrait retourner true si l'item est ce que nous recherchons});
La fonction est appelée de manière répétitive pour chaque élément du tableau:
- Objet est l'élément
- indice est votre index.
- déployer c'est l'utérus lui-même.
S'il revient vrai, la recherche s'arrête, Objet Il est retourné. Si rien n'est trouvé, indéfini Il est retourné.
Par exemple, nous avons un tableau d'utilisateurs, chacun avec les champs id et name. Trouvons celui avec id == 1:
laissez les utilisateurs = [{id: 1, nom: "Juan"}, {id: 2, nom: "Pedro"}, {id: 3, nom: "Maria"}]; laissez les utilisateurs = users.find (item => item.id == 1); alert (utilisateurs.nom); // John
Dans la vraie vie, les arrangements d'objets sont une chose courante, donc le méthode de recherche C'est très utile.
Notez que dans l'exemple que nous avons fourni d'une fonction trouve argument unique item => item.id == 1. Autres paramètres de trouve ils sont rarement utilisés.
le méthode arr.findIndex est essentiellement le même, mais il renvoie l'index où l'élément a été trouvé plutôt que l'élément lui-même.
Filtre
le méthode de recherche recherche un (premier) élément unique qui fait que la fonction retourne vrai.
S'il peut y en avoir beaucoup, nous pouvons utiliser arr.filtre (fn).
La syntaxe est à peu près la même que trouve, mais il renvoie un tableau d'éléments correspondants:
let result = arr.filter (function (item, index, array) {// devrait retourner true si l'élément passe le filtre});
Par exemple:
laissez les utilisateurs = [{id: 1, nom: "Juan"}, {id: 2, nom: "Pedro"}, {id: 3, nom: "Maria"}]; // retourne le tableau des premiers utilisateurs let someUsers = users.filter (item => item.id <3); alert (someUsers.length); // deux
