Les mots précédents
Il y a 22 méthodes dans le tableau. Cet article les divise en méthodes d'hérédité des objets, méthodes de conversion de tableau, méthodes de pile et de file d'attente, méthodes de tri des tableaux, méthodes d'épissage du tableau, méthodes de création de sous-réseau, méthodes de suppression de tableau, méthodes de position de tableau, méthodes de fusion du tableau et méthodes d'itération du tableau.
Méthode d'héritage d'objet
Le tableau est un objet spécial qui hérite des méthodes toString (), tolocalestring () et valeurof () de l'objet objet.
【ToString ()】
La méthode toString () renvoie une chaîne séparée par des virgules épissée à partir de la forme de chaîne de chaque valeur dans le tableau.
[Remarque] La valeur de retour de cette méthode est la même que la chaîne renvoyée en appelant la méthode join () sans aucun paramètre.
[1,2,3] .toString (); // '1,2,3' ['a', 'b', 'c']. ToString (); // 'a, b, c' [1, [2, 'c']]. ToString (); // '1,2, c'
Étant donné qu'Alert () veut recevoir des paramètres de chaîne, il appellera la méthode toString () en arrière-plan et obtiendra le même résultat que la méthode toString ()
alerte ([1,2,3]); // '1,2,3'
【Tolocalestring ()】
Tolocalestring () est une version localisée de la méthode toString (), qui renvoie souvent la même valeur que la méthode toString (), mais ce n'est pas toujours le cas. Parce qu'il appelle l'élément, la méthode tolocalestring () convertit chaque élément de tableau en une chaîne
var person1 = {tolocalestring: function () {return 'nikolaos';}, toString: function () {return 'nikolas';}}; var person2 = {tolocalestring: function () {return 'grigorios';}, toString: function () {return 'greg';}}; [Person1, Person2]; console.log (People.ToString ()); // 'Nikolas, Greg'console.log (People.tolocalestring ()); //' Nikolas, Grigorios 'Si la valeur d'un élément dans le tableau est nulle ou non définie, la valeur est représentée comme une chaîne vide dans les résultats renvoyés par les méthodes tolocalestring () et toString ().
var couleurs = [1, undefined, 2, null, 3]; console.log (couleurs.tostring ()); // '1 ,, 2 ,, 3'console.log (Colors.tolocalestring ()); //' 1 ,, 2 ,, 3 '
【Valeur de ()】
La méthode de valeur de () renvoie l'objet de tableau lui-même
var a = [1, 2, 3]; console.log (a.valueof ()); // [1, 2, 3] console.log (a.valueof () instance d'instance); // true
Méthode de conversion du tableau
【rejoindre()】
La méthode Array.Join () est une opération inverse de la méthode String.Split (), qui divise la chaîne en plusieurs blocs pour créer un tableau.
Les méthodes tolocalestring () et toString () héritées par les tableaux renverront par défaut les éléments du tableau dans les caractères séparés par les virgules; La méthode join () peut utiliser différents délimiteurs pour construire cette chaîne. La méthode join () ne reçoit qu'un seul paramètre, qui est utilisé comme délimiteur, puis renvoie une chaîne contenant tous les éléments du tableau.
Si aucune valeur n'est transmise à la méthode join (), utilisez une virgule comme séparateur
var a = [1,2,3]; console.log (a.join ()); // '1,2,3'console.log (a.join (' ')); //' 1 2 3'console.log (a.join ('')); // '123'var b = new Array (10); B.Join ('-'); // '------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Si le paramètre de la méthode join () n'est pas défini, le navigateur standard renvoie la chaîne avec une virgule comme séparateur, et le navigateur IE7 renvoie la chaîne avec «Undefined» comme séparateur.
// Le navigateur standard est «1,2,3»; IE7-Le navigateur est '1UNDEFINED2UNDEFINED3'VAR A = [1,2,3]; console.log (a.join (indéfini));
Si la valeur d'un élément dans le tableau est nulle ou non définie, la valeur est représentée comme une chaîne vide dans le résultat renvoyé par la méthode join ()
var couleurs = [1, indéfini, 2, null, 3]; console.log (couleurs.join ()); // '1 ,, 2 ,, 3'
Cette méthode peut également être utilisée sur les objets de tableau de classe
console.log (array.prototype.join.call ('hello', '-')); // "hello" var obj = {0: 'a', 1: 'b', longueur: 2}; console.log (array.prototype.join.call (obj, '-'); // 'ab'[Remarque] Si l'objet n'a pas d'attribut de longueur, ce n'est pas un tableau de classe et que la méthode du tableau ne peut pas être appelée
var obj = {0: 'a', 1: 'b'}; console.log (typeof array.prototype.join.call (obj, '-')); // ''Méthodes de pile et de file d'attente
Les méthodes push () et pop () permettent aux tableaux d'être utilisés comme piles. Le comportement des méthodes UNSHIFT () et Shift () est très similaire à push () et pop (). La différence est que le premier insère et supprime des éléments à la tête du tableau plutôt qu'à la queue.
La pile est une structure de données LIFO (dernier-début, plus tard dans la première sortie), c'est-à-dire que le dernier élément ajouté est supprimé au plus tôt. L'insertion (appelée poussée) et le retrait (appelé pop-up) des éléments de la pile ne se produisent qu'à un seul endroit - le haut de la pile. JavaScript fournit des méthodes push () et pop () spécifiquement pour les tableaux pour obtenir un comportement de type pile
La règle d'accès pour la structure des données de file d'attente est FIFO (premier entrée en dépasse, premier-in, premier-out). La file d'attente ajoute des éléments à la fin de la liste et supprime les éléments de l'extrémité avant de la liste. En utilisant les méthodes Shift () et push () en combinaison, vous pouvez utiliser des tableaux comme des files d'attente
【pousser()】
La méthode push () peut recevoir n'importe quel nombre de paramètres, les ajouter une par une à la fin du tableau et renvoyer la longueur du tableau modifié. Ainsi, le tableau changera le tableau d'origine
var a = []; console.log (a, a.push (1)); // [1] 1Console.log (a, a.push ('a')); // [1, 'a'] 2console.log (a, a.push (true, {})); // [1, 'a', true, {}]] 4Console.log (a, a.push ([5,6])); // [1, 'a', true, {}, [5,6]] 5Si vous devez fusionner deux tableaux, vous pouvez utiliser la méthode d'application
var a = [1, 2, 3]; var b = [4, 5, 6]; console.log (a, array.prototype.push.apply (a, b)); // [1,2,3,4,5,6] 6
[Remarque] Si vous utilisez la méthode d'appel, le tableau B sera considéré comme un paramètre dans son ensemble
var a = [1, 2, 3]; var b = [4, 5, 6]; console.log (a, array.prototype.push.call (a, b)); // [1,2,3, [4,5,6]] 4
La méthode push () peut également ajouter des éléments à l'objet, et l'objet ajouté devient un objet de tableau, c'est-à-dire l'index du tableau correspondant de la clé de l'élément nouvellement ajouté, et l'objet a un attribut de longueur
var obj = {a: 1}; console.log (obj, []. push.call (obj, 2)); // {a: 1, 0: 2, longueur: 1} console.log (obj, []. push.call (obj, [3])); // {a: 1, 0: 2, 1: [3], la longueur: 2}【populaire()】
La méthode POP () supprime le dernier élément de la fin du tableau, réduit la valeur de longueur du tableau et renvoie l'élément supprimé. Ainsi, le tableau changera le tableau d'origine
var a = ['a', 'b', 'c']; console.log (a, a.pop ()); // ['a', 'b'] 'c'
L'utilisation de la méthode pop () pour les tableaux vides ne rapportera pas une erreur, mais renvoiera indéfini
var a = []; console.log (a, a.pop ()); // [] indéfini
【changement()】
La méthode Shift () supprime le premier élément du tableau et renvoie l'élément, tandis que la longueur du tableau est réduite de 1. Ainsi, le tableau changera le tableau d'origine
var a = ['a', 'b', 'c']; console.log (a, a.shift ()); // ['b', 'c'] 'a'
Utilisez la méthode Shift () pour les tableaux vides, et aucune erreur ne sera signalée, mais ne renverra pas défini
var a = []; console.log (a, a.shift ()); // [] indéfini
【Unhift ()】
La méthode UNSHIFT () ajoute n'importe quel élément à l'extrémité avant du tableau et renvoie la nouvelle longueur du tableau. Ainsi, le tableau changera le tableau d'origine
var a = ['a', 'b', 'c']; console.log (a, a.unshift ('x')); // ['x', 'a', 'b', 'c'] 4Lorsque Unhift () est appelé avec plusieurs paramètres, les paramètres sont insérés à un moment donné plutôt qu'à un à la fois. Cela signifie que l'ordre des éléments insérés dans le tableau final est cohérent avec leur commande dans la liste des paramètres
var a = ['a', 'b', 'c']; console.log (a, a.unshift ('x', 'y', 'z')); // ['x', 'y', 'z', 'a', 'b', 'c'] 6[Remarque] Dans IE7-Browser, la méthode UNSHIFT () renvoie toujours indéfinie
// dans le navigateur standard, retour [1] 1; et dans IE7-Browser, retour [1] undefinedvar a = []; console.log (a, a.unshift (1));
Méthode de tri du tableau
Il existe deux méthodes dans le tableau qui peuvent être utilisées pour réorganiser directement: reverse () et tri ()
【inverse()】
La méthode reverse () est utilisée pour inverser l'ordre du tableau et renvoyer le tableau trié; Et l'ordre d'origine du tableau a également changé.
var array = [1,2,4,3,5]; console.log (array, array.reverse ()); // [5,3,4,2,1] [5,3,4,2,1] var array = ['str', true, 3]; console.log (array, array.revers
【trier()】
Par défaut, la méthode tri () organise les éléments du tableau dans l'ordre croissant des chaînes. La méthode de tri appellera la méthode toString () de chaque élément de tableau, puis comparera le tri de chaîne résultant pour renvoyer le tableau trié, et l'ordre du tableau d'origine change également.
Var Array = [1,2,4,3,5]; console.log (array, array.sort ()); // [1,2,3,4,5] [1,2,3,4,5] var array = ['3Str', 3,2, '2']; console.log (array, array.sort ()); // [2, "2", "3St [1,5,10,50]; console.log (array, array.sort ()); // [1, 10, 5, 50]
Si le tableau contient des éléments non définis, ils sont placés à la fin du tableau
var array = ['3', 3, undefined, 2, '2']; console.log (array, array.sort ()); // ["2", 2, "3", 3, undefined] ["2", 2, "3", 3, non défini]
La méthode tri () peut accepter une fonction de comparaison comme un argument pour spécifier quelle valeur est précédée par quelle valeur. La fonction de comparaison reçoit deux paramètres, renvoie un nombre négatif si le premier paramètre doit être avant le deuxième paramètre, renvoie 0 si les deux paramètres sont égaux et renvoie un nombre positif si le premier paramètre doit être après le deuxième paramètre
fonction compare (value1, value2) {if (value1 <value2) {return -1;} else if (value1> value2) {return 1;} else {return 0;}} var array = ['5px', 50,1,10]; // lorsque le nombre est plus grand que la chaîne, la chaîne '5px' sera convertie en nan, et le résultat est faux seconsole.log (array.sort (comparer)); // ["5px", 1, 10, 50]Pour les types numériques ou la méthode de valeur de (), la fonction de comparaison peut simplifier le type d'objet du type numérique.
fonction compare (valeur1, valeur2) {return value1 - value2;} var array = ['5px', 50,1,10]; console.log (array.sort (compare)); // ["5px", 1,10,50] var array = [5,50,1,10]; console.50]Si un tableau de chaînes est effectué un tri d'alphabet insensible, la fonction de comparaison convertit d'abord les paramètres en chaînes en minuscules puis démarre la comparaison
a = ['ant', 'bug', 'cat', 'dog']; a.sort (); // ['bug', 'dog', 'ant', 'cat']; a.sort (fonction (s, t) {var a = s.tolowercase (); var b = t.tolowercase (); if (a <b) return -1; if (a> b) return 1; 0;}); // ['Ant', 'Bug', 'Cat', 'Dog']【Conseils】 Créez un tableau aléatoire en utilisant la méthode Sort ()
fonction compare () {return math.random () - 0,5;} var array = [1,2,3,4,5]; console.log (array.sort (compare)); // [2,1,5,4,3]Méthode de couture du tableau
【Concat ()】
La méthode CONCAT () crée un nouveau tableau basé sur tous les éléments du tableau actuel. Créez d'abord une copie du tableau actuel, puis ajoutez les paramètres reçus à la fin de la copie et renvoie enfin le tableau nouvellement construit. Par conséquent, Concat () n'affecte pas le tableau d'origine
Si le paramètre n'est pas transmis à la méthode Concat (), il copie simplement le tableau actuel; Si le paramètre est un ou plusieurs tableaux, la méthode ajoute chaque élément dans ces tableaux au tableau de résultat; Si la valeur passée n'est pas un tableau, ces valeurs sont simplement ajoutées à la fin du tableau de résultat
var nombres = [1,2]; console.log (nombres, nombres.concat (3,4)); // [1,2] [1,2,3,4] console.log (nombres, nombres.concat ([5,4,3], [3,4,5], 1,2)); // [1,2] [1,2,5,4,3,3,4,5,1,2] console.log (nombres, nombres.concat (4, [5, [6,7]])); // [1,2] [1,2,4,5, [6,7]]
Si aucun paramètre n'est fourni, la méthode Concat () renvoie une copie peu profonde du tableau actuel. Le soi-disant «copie peu profonde» signifie que si le membre du tableau comprend une valeur de type composé (comme un objet), le nouveau tableau copie une référence à la valeur.
// Cette méthode ne copie en fait que la première dimension du tableau. La première dimension du tableau stocke la référence de la deuxième dimension, et la deuxième dimension stocke en fait leurs nombres var de contenu = [1,2]; var newNumbers = nombres.concat (); console.log (nombres, newnumbers); // [1,2] [1,2] [[1,2]]; var newNumbers = nombres.concat (); console.log (nombres, newNumbers); // [[1,2]] [[1,2]] nombres [0] [0] = 0; console.log (nombres, newnumbers); // [[0,2]] [[0,2]]
La méthode CONCAT () peut également être utilisée pour fusionner des objets en tableaux, mais il doit être fait avec la méthode Call ().
var newArray = array.prototype.concat.call ({a: 1}, {b: 2}) console.log (newArray); // [{a: 1}, {b: 2}] console.log (newArray [0] .a); // 1Créer une méthode de sous-référence
【tranche()】
La méthode Slice () crée un nouveau tableau basé sur un ou plusieurs éléments dans le tableau actuel, accepte un ou deux paramètres, c'est-à-dire pour retourner les positions de début et de fin de l'élément, et enfin renvoyer le nouveau tableau, donc Slice () n'affecte pas le tableau d'origine
La méthode Slice (démarrage, fin) nécessite deux paramètres de démarrage et de fin, qui renvoie un sous-réseau dans ce tableau de la position de début à (mais ne contient pas) la position finale; Si la fin n'est pas définie ou n'existe pas, il renvoie tous les éléments de la position de départ à la fin du tableau
Si Start est un nombre négatif, démarrez = max (longueur + démarrage, 0)
Si la fin est un nombre négatif, end = max (longueur + fin, 0)
Démarrer et fin ne peut pas échanger des positions
S'il n'y a pas de paramètres, retournez au tableau d'origine
nombres var = [1,2,3,4,5]; console.log (nombres.slice (2)); // [3,4,5] console.log (nombres.slice (2, indéfini)); // [3,4,5] consol e.log (nombres.slice (2,3)); // [3] console.log (nombres.slice (2,1)); // [] console.log (nombres.slice (-3)); // - 3 + 5 = 2 -> [3,4,5] console.log (nombres.slice (-8)); // max (5 + -8,0) = 0 -> [1,2,3,4,5] console.log (nombres.slice (0, -3)); // - 3 + 5 = 2 -> [1,2] console.log (nombres.slice (-2, -1)); // - 2 + 5 = 3; -1 + 5 = 4; -> [4]
Si aucun paramètre n'est fourni, la méthode Slice () renvoie une copie peu profonde du tableau actuel
// Cette méthode ne copie en fait que la première dimension du tableau. La première dimension du tableau stocke la référence de la deuxième dimension, et la deuxième dimension stocke en fait leurs nombres Var de contenu = [1,2]; var newNumbers = nombres.slice (); console.log (nombres, NewNumbers); // [1,2] [1,2] [[1,2]]; var newNumbers = nombres.slice (); console.log (nombres, newNumbers); // [[1,2]] [[1,2]] nombres [0] [0] = 0; console.log (nombres, newnumbers); // [[0,2]] [[0,2]]]
La méthode Slice () implique la conversion de type implicite de la fonction de transformation nombre (). Lorsque le démarrage est converti en NAN, il est équivalent à démarrer = 0; Lorsque la fin est convertie en nan (sauf que la fin n'est pas définie), un tableau vide est sortie
nombres var = [1,2,3,4,5]; console.log (nombres.slice (nan)); // [1,2,3,4,5] console.log (nombres.slice (0, nan)); // [] console.log (nombres.slice (true, [3])); // [2,3] conc. sole.log (nombres.slice (null, undefined)); // [1,2,3,4,5] console.log (nombres.slice ({})); // [1,2,3,4,5] console.log (nombres.slice ('2', [5])); // [3,4,5]Vous pouvez utiliser la méthode Slice () pour transformer l'objet de tableau de classe en un tableau réel
var arr = array.prototype.slice.call (arraylike); array.prototype.slice.call ({0: 'a', 1: 'b', longueur: 2}) // ['a', 'b'] array.prototype.slice.call (document.Quelectorall ("div")); array.pototype.slice.call ("div")); array.pototype.slice.call ("div")); array.pototype.Méthode de suppression du tableau
【épissure()】
Splice () et Slice () ont des noms très similaires, mais leurs fonctions sont essentiellement différentes. La méthode Splice () est utilisée pour supprimer une partie du tableau d'origine et peut ajouter de nouveaux membres du tableau à l'emplacement supprimé. Cette méthode modifiera le tableau d'origine.
Splice () renvoie un tableau composé d'éléments supprimés, ou un tableau vide si aucun éléments supprimés n'est retourné.
Le premier paramètre de Splice () Start spécifie la position de début pour l'insertion ou la suppression. Si Start est un nombre négatif, start = max (longueur + start, 0); Si le démarrage est nan, il est équivalent à démarrer = 0
Si un seul élément est fourni, il équivaut à diviser le tableau d'origine en deux tableaux à l'emplacement spécifié
var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice ()); // [1,2,3,4,5,6,8];] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (4)); // [1,2,3,4] [ = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (-4)); // - 4 + 8 = 4; [1,2,3,4] [5,6,7,8] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (-9)); // max (-9 + 8,0) = 0 [] [1,2,3,4,5,6,7,8] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (nan)); // [] [1,2,3,4,5,6,7,8]
Le deuxième numéro de paramètre spécifie le nombre d'éléments qui doivent être supprimés du tableau. Si le deuxième paramètre est omis, tous les éléments du point de départ à la fin du tableau seront supprimés. Si le nombre est négatif ou nan ou non défini, numéro = 0, donc l'élément n'est pas supprimé
var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (0,2)); // [3,4,5,6,7,8] [1,2] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (10,2)); // [1,2,3,4,5,6,7,8] [] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (1,100)); // [1] [2,3,4,5,6,7,8] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (1, -5)); // [1,2,3,4,5,6,7,8] [] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (1, nan)); // [1,2,3,4,5,6,7,8] [] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (1, non défini)); // [1,2,3,4,5,6,7,8] [] var a = [1,2,3,4,5,6,7,8]; console.log (a, a.splice (1, non défini)); // [1,2,3,4,5,6,7,8] []
S'il y a plus de paramètres plus tard, cela signifie que ce sont les nouveaux éléments à insérer dans le tableau
var a = [1,2,3,4,5]; console.log (a, a.splice (2,0, 'a', 'b')); // [1,2, 'a', 'b', 3,4,5] [] console.log (a, a.splice (2,2, [1,2], 3)); // [1,2, [1,2], 3,4]); // [1,2, [1,2], 3,4]); // [1,2, [1,2], 3,4]); // [1,2, [1,2], 3,4]); // [1,2, [1,2], 3,4]); // [1,2, [1,2], 3,4]); // [1,2, [1,2], 3,4]); // [1,2, [1,2], 3, 3 ['a', 'b']
Méthode de position du tableau
ES5 ajoute deux méthodes de position pour les instances de tableau: indexof () et lastIndexof ()
【Indexof ()】
La méthode indexof (Search, Start) reçoit deux paramètres Rechercher et Démarrer, renvoyant l'emplacement où la recherche apparaît d'abord, et si elle n'est pas trouvée, elle renvoie -1
Le paramètre de recherche indique l'élément à rechercher; Utilisez l'opérateur d'égalité strict (===) pour comparaison
var arr = [1,2,3, '1', '2', '3']; console.log (arr.indexof ('2')); // 4Console.log (arr.indexof (3)); // 2Console.log (arr.indexof (0)); // - 1Le paramètre de démarrage indique la position de début de la recherche. Cette méthode appelle implicitement la fonction de transformation numéro () pour convertir des valeurs non nucères de démarrage (sauf non définies) en nombres. Si ce paramètre est ignoré ou si le paramètre n'est pas défini ou nan, démarrez = 0
var arr = ['a', 'b', 'c', 'd', 'e', 'a', 'b']; console.log (arr.indexof ('a', indéfini)); // 0console.log (arr.indexof ('a', nan)); // 0consol e.log (arr.indexof ('a', 1)); // 5Console.log (arr.indexof ('a', true)); // 5Console.log (arr.indexof ('a', - 1)); // max (0, -1 + 7) = 6; -1Console.log (arr.indexof ('a', - 5)); // max (0, -5 + 7) = 2; 5Console.log (arr.indexof ('a', - 50)); // max (0, -50 + 7) = 0; 0 var personne = {nom: 'Nicholas'}; var peuple = [{name: 'Nicholas'}]; var plusPeople = [personne]; alert (People.indexof (personne)); // - 1, car bien que la personne et les personnes [0] aient les mêmes valeurs, ils sont deux références alertes (plus de pèople. alert (MorePeople.Indexof ({nom: 'Nicholas'})); // - 1, car ils ne sont pas la même référenceMéthode d'écriture compatible de la méthode d'index ()
if (typeof array.prototype.indexof! = "function") {array.prototype.indexof = function (SearchElement, FromIndex) {var index = -1; FromIndex = FromIndex * 1 || 0; pour (var k = 0, longueur = this.length; k <longueur; k ++) {if (k> = fromIndex && this [k] === SearchElement) {index = k; break;}} return index;};}【LastIndexof ()】
Contrairement à indexof (), LastIndexof () regarde de droite à gauche
La méthode LastIndexof (Search, Start) reçoit deux paramètres Recherche et démarrer, renvoyant l'emplacement où la recherche apparaît d'abord, et si elle n'est pas trouvée, elle revient -1
Le paramètre de recherche indique l'élément à rechercher; Utilisez l'opérateur d'égalité strict (===) pour comparaison
var arr = [1,2,3, '1', '2', '3']; console.log (arr.lastIndexof ('2')); // 4Console.log (arr.lastIndexof (3)); // 2Console.log (arr.LasTinDExof (0)); // - 1Le démarrage signifie la position de début de la recherche, qui appelle implicitement la fonction de transformation numéro () pour convertir Start Notnumeric Valers (sauf non défini) en nombres. Si ce paramètre est ignoré ou si le paramètre n'est pas défini ou nan, démarrez = 0
Contrairement à la méthode LastIndexof () d'une chaîne, lorsque la méthode de recherche est un nombre négatif, search = max (0, longueur + search)
var arr = ['a', 'b', 'c', 'd', 'e', 'a', 'b']; console.log (arr.lastIndexof ('b')); // 6Console.log (arr.lasteIndexof ('b', undefined)); // - 1Console.log (arr.lastexof ('a', u, u ndefined)); // 0console.log (arr.lastIndexof ('b', nan)); // - 1Console.log (arr.lastIndexof ('b', 1)); // 1Console.log (arr.lastindexof ('b', - 1)); // max (0, -1 + 7) = 6; 6Console.log (arr.LastIndexof ('b', - 5)); // max (0, -5 + 7) = 2; 1Console.log (arr.LastIndexof ('b', - 50)); // max (0, -50 + 7) = 0; -1【Conseils】 Renvoie toutes les valeurs d'index des éléments qui répondent aux critères
Tous les éléments correspondants peuvent être trouvés par boucle pour appeler indexof () ou lastIndexof ()
fonction AllIndexof (array, valeur) {var result = []; var pos = array.indexof (valeur); if (pos === -1) {return -1;} while (pos> -1) {result.push (pos); pos = array.indexof (value, pos + 1);} return result;} var array = [1,2,3,3,2,1]; console.log (ALLINDEXOF (Array, 1)); // [0,5]Méthode d'écriture compatible de la méthode LastIndexof ()
if (typeof array.prototype.lastIndexof! = "fonction") {array.prototype.lastIndexof = fonction (SearchElement, FromIndex) {var index = -1, longueur = this.length; FromIndex = FromIndex * 1 || longueur - 1; for (var k = longueur - 1; k> -1; k- = 1) {if (k <= fromIndex && this [k] === SearchElement) {index = k; break;}} return index;};}Méthode de fusion du tableau
Les méthodes de fusion du tableau comprennent des méthodes réduites () et reduceRight (). Ils utilisent la fonction spécifiée pour combiner des éléments du tableau pour générer une seule valeur. Il s'agit d'une opération courante dans la programmation fonctionnelle, également connue sous le nom de "injection" et "effondrement"
【réduire()】
La méthode Reduce () nécessite deux paramètres. Le premier est une fonction qui effectue des opérations simplifiées. La tâche de simplification des fonctions consiste à utiliser une méthode pour combiner ou soustraire deux valeurs en une seule valeur et renvoyer la valeur simplifiée.
La fonction simplifiée accepte quatre paramètres, à savoir:
【1】 Variable initiale, par défaut, la première valeur d'élément du tableau. La valeur de retour après la première exécution de la fonction est utilisée comme variable initiale pour la deuxième exécution de la fonction, et ainsi de suite
【2】 La variable actuelle, si le deuxième paramètre est spécifié, la variable est la valeur du premier élément du tableau, sinon, la valeur du deuxième élément est la valeur du deuxième élément.
【3】 L'indice des éléments correspondant à la variable actuelle dans le tableau (à partir de 0)
【4】 objet de tableau d'origine
Parmi ces quatre paramètres de la fonction simplifiée, seuls les deux premiers sont nécessaires, tandis que les deux derniers sont facultatifs.
valeurs.reduce (fonction (prev, cur, index, array) {// todo});Le deuxième paramètre (facultatif) de la méthode Reduce () est une valeur initiale transmise à la fonction
var a = [1,2,3,4,5]; var sum = a.reduce (fonction (x, y) {return x + y}, 0); // sum of array Var Product = a.reduce (function (x, y) {return x * y}, 1); // Produit de produit de l'array var max = a.reduce (fonction (x, y) {return (x> y)? x: y;}); 2, 3, 4, 5] .reduce (fonction (prev, cur) {console.log (prev, cur) return prev + cur;}); // 1 2 // 3 3 // 6 4 // 10 5 // dernier résultat: 15 [1, 2, 3, 3, 4, 5] .reduce (function (prev, cur) {console.log (prev, cur); return prev + cur;}, 0); 3 // 6 4 // 10 5 // Dernier résultat: 15[Remarque] Le type de résultat de retour de la méthode Reduce () est le même que la valeur initiale transmise dans
[1, 2, 3, 4, 5] .reduce (fonction (prev, cur) {console.log (prev.sum, cur); prev.sum = prev.sum + cur; return prev;}, {sum: 0}); // 0 1 // 1 2 // 3 3 // 6 4 // 10 5 // objet {sum: 15}En utilisant la méthode Reduce (), vous pouvez écrire une méthode de somme pour la somme des tableaux
Array.prototype.sum = function () {return this.reduce (function (prev, cur) {return prev + cur;})}; [3,4,5,6,10] .sum (); // 28Étant donné que la méthode de réduction traite chaque élément de séquence, il peut en fait être utilisé pour rechercher un élément. Par exemple, trouvez l'élément de tableau le plus long
Fonction FindLongest (entrées) {return entrées.reduce (fonction (prev, cur) {return cur.length> prev.length? Cur: Prev;}, '');} console.log (findLongest ([1,2,3, 'ab', 4, 'bcd', 5,6785,4]); // 'bcd'Vous pouvez utiliser la méthode Reduce () pour obtenir l'aplatissement des tableaux bidimensionnels
Var Matrix = [[1, 2], [3, 4], [5, 6]]; // 2d Array Flatten var Flatten = Matrix.reduce (fonction (prev, cur) {return Prev.Concat (cur);}); console.log (aplaten); // [1, 2, 3, 4, 5, 6]Sur un tableau vide, appeler réduction () sans le paramètre de valeur initiale entraînera une exception d'erreur de type. S'il n'y a qu'une seule valeur lorsqu'elle est appelée - le tableau n'a qu'un seul élément et qu'aucune valeur initiale n'est spécifiée, ou il y a un tableau vide et une valeur initiale est spécifiée - réduir () renvoie simplement cette valeur sans appeler la fonction simplifiée
var arr = []; arr.reduce (function () {}); // non apparié TypeError: réduction du tableau vide sans valeur initiale arr = []; arr.reduce (function () {}, 1); // 1Méthode d'écriture compatible de la méthode de réduction ()
if (typeof array.prototype.reduce! = "function") {array.prototype.reduce = function (callback, initialValue) {var promed = initialValue, k = 0, longueur = this.length; if (typeof initialValue === "" Undefined ") {précédent = this [0]; k = 1;} if (type de callback ==" ")" pour (k = 1;} longueur;【ReduceRight ()】
ReduceRight () fonctionne la même
var valeurs = [1,2,3,4,5]; var sum = valeurs.reduceRight (fonction (prev, cur, index, array) {console.log (prev, cur); retour prev + cur;}); console.log (sum); // 5 4 // 9 3 // 12 2 // 14 1 // 15Méthode d'écriture compatible méthode reduceRight ()
if (typeof array.prototype.reduceRight! = "function") {array.prototype.reduceRight = fonction (rappel, initialValue) {var longueur = this.length, k = longueur - 1, préalable = initialValue; if (typeof initialValue === "Undefined") {précédemment = this [le long - 1]; k -; otMéthode d'itération du tableau
Ecmascript5 définit 5 méthodes itératives pour les tableaux. Chaque méthode reçoit deux paramètres: la fonction à exécuter sur chaque élément et l'objet Scope qui (facultatif) exécute la fonction - affectant la valeur de cela. Les fonctions transmises dans ces méthodes reçoivent trois paramètres: la valeur de l'élément de tableau, la position de l'élément dans le tableau et l'objet de tableau lui-même. Selon la méthode utilisée, la valeur de retour après l'exécution de cette fonction peut affecter ou non la valeur de retour accessible
fonction (item, index, array) {// todo}【carte()】
La méthode map () exécute une fonction donnée sur chaque élément du tableau, renvoyant un tableau composé des résultats de chaque appel de fonction
// f est la fonction appelée chaque élément du tableau. Sa valeur de retour devient l'élément du tableau de retour; O est une valeur facultative lorsque f est appelé array.map (f, o); [1,2,3] .map (fonction (item, index, arr) {return item * item}); // [1,4,9] [1,2,3] .map (fonction (item, index, arr) {return item * index}); // [0,2,6]La méthode map () peut également accepter un deuxième paramètre, indiquant l'objet pointé par cela lorsque la fonction de rappel est exécutée
var arr = ['a', 'b', 'c']; [1,2] .map (fonction (item, index, arr) {return this [item]}, arr); // ['b', 'c']Lorsque vous l'utilisez dans la pratique, vous pouvez utiliser la méthode map () pour faciliter l'acquisition de valeurs d'attribut spécifiques dans le tableau d'objets
var utilisateurs = [{nom: 't1', e-mail:'[email protected] '}, {name:' t2 ', e-mail:'[email protected]'}, {name: 't3', e-mail:'[email protected] '}] "[email protected]", "[email protected]"]La méthode map () peut également être utilisée pour les objets de tableau de classe
Array.prototype.map.call ('abc', fonction (item, index, arr) {return item.toupperase ()}); // ["a", "b", "c"]Pour les tableaux clairsemés, la méthode MAP () n'appelle pas la fonction sur le numéro de séquence où l'élément n'existe pas réellement.
var a = [1 ,, 3]; console.log (a.map (fonction (élément, index, arr) {return item * 2;})); // [2, 2: 6]MOTHE () Méthode Méthode d'écriture compatible
if (typeof array.prototype.map! = "function") {array.prototype.map = fonction (fn, context) {var arr = []; if (typeof fn === "function") {for (var k = 0, longueur = this.length; k <longueur; k ++) {arr.push (fn.Call (contexte, ce [k], k, thy); arr;};}【Foreach ()】
La méthode foreach () exécute une fonction donnée sur chaque élément du tableau, et cette méthode ne renvoie pas de valeur. Essentiellement le même que d'itérer sur un tableau de boucle. Si vous avez besoin d'une valeur de retour, vous utilisez généralement la méthode de la carte
[1,2,3,4] .ForEach (fonction (item, index, arr) {console.log (item)}); // 1 // 2 // 3 // 4Similaire à la boucle pour
var array = [1, 2, 3, 4]; for (var k = 0, longueur = array.length; k <longueur; k ++) {console.log (array [k]);}Utilisez la méthode foreach () pour implémenter un ajout simple
var sum = 0; [1, 2, 3, 4] .ForEach (fonction (élément, index, array) {sum + = item;}); console.log (sum); // 10En plus d'accepter un paramètre de fonction de rappel nécessaire, le deuxième paramètre peut également accepter un paramètre de contexte facultatif (modifiez ce pointeur dans la fonction de rappel)
var out = []; [1, 2, 3] .ForEach (fonction (elem) {this.push (elem * elem);}, out); console.log (out); // [1, 4, 9]Le deuxième paramètre est très utile pour la multicouche, car plusieurs couches cela pointe généralement incohérente, vous pouvez utiliser le deuxième paramètre de la méthode foreach () pour résoudre ce problème
var obj = {name: 'zhang san', fois: [1, 2, 3], imprimer: function () {// Cela pointe vers objconsole.log (this); this.times.ForEach (fonction (n) {// Cela pointe vers windowConsole.log (this);});}}; obj.print (); var obj = {name: 'zhang san', fois: [1, 2, 3], print: function () {// Cela pointe vers objconsole.log (this); this.times.ForEach (function (n) {// Cela pointe également vers objconsole.log (this);}, this);}}; obj.print ();Une boucle foreach () peut être utilisée pour les objets de tableau de classe
var str = 'ABC'; array.prototype.Forach.Call (str, fonction (item, index, array) {console.log (item + ':' + index);}); // a: 0 // b: 1 // c: 2Contrairement aux boucles, pour les tableaux clairsemés, la méthode foreach () n'appelle pas la fonction sur le numéro de commande où l'élément n'existe pas réellement.
var a = [1,2,3]; delete a [1]; for (var i = 0; i <a.Length; i ++) {console.log (a [i]);} // 1 // undefined // 3 A.ForEach (Fonction (item, index, arr) {console.log (élément)}); // 1 // 3La méthode foreach () ne peut pas terminer la traversée avant que tous les éléments ne soient transmis à la fonction appelée. Autrement dit, il n'y a pas de déclaration de rupture correspondante comme celle utilisée dans la boucle pour. Si vous souhaitez vous terminer tôt, vous devez mettre la méthode foreach () dans un bloc d'essai et lancer une exception
pour (var i = 0; i <5; i ++) {if (i == 2) Break;} console.log (i); // 2 var a = [1,2,3,4,5]; console.log (a.ForEach (élément, index, arr) {if (index == 2) Break; // non apparenté Syntaxerror: Énoncé de rupture illégal})); var a = [1,2,3,4,5]; a.ForEach (fonction (item, index, arr) {try {if (item == 2) lance une nouvelle erreur;} catch (e) {console.log (item);}});ForEach () Méthode Méthode d'écriture compatible
if(typeof Array.prototype.forEach != 'function'){Array.prototype.forEach = function(fn,context){for(var k = 0,length = this.length; k < length; k++){if(typeof fn === 'function' && Object.prototype.hasownproperty.call (this, k)) {fn.call (contexte, this [k], k, this);}}}}}【filtre()】
La méthode Filter () exécute une fonction donnée sur chaque élément du tableau et renvoie un tableau d'éléments qui reviendront True. Cette méthode est souvent utilisée pour interroger tous les éléments du tableau qui répondent aux critères
[1, 2, 3, 4, 5] .filter (fonction (elem) {return (elem> 3);}); // [4, 5] [0, 1, 'a', false] .filter (booléen); // [1, "a"] [1, 2, 3, 4, 5] .filter (fonction (elem, arr) {return index% 2 ==. 3, 5]La méthode Filter () peut également accepter un deuxième paramètre, spécifiant l'objet contextuel (cet objet) où se trouve la fonction de test
var obj = fonction () {this.max = 3;}; var myFilter = function (item) {if (item> this.max) {return true;}}; var arr = [2, 8, 3, 4, 1, 3, 2, 9]; arr.filter (myFilter, new Obj (); // [8, 4, 9]Filter () sautera les éléments manquants dans des tableaux clairsemés. Son tableau de retour est toujours dense, il peut donc comprimer les lacunes dans des tableaux clairsemés.
var a = [1,2 ,,,, 3 ,,, 4]; console.log (a.length); // 10var density = a.filter (function () {return true;}) console.log (dense, dense.length); // [1,2,3,4] 4Si vous souhaitez comprimer les postes vacants et supprimer des éléments non définis et nuls, vous pouvez utiliser la méthode Filter () comme celle-ci
var a = [1,2,, indéfini ,, 3 ,, null ,, 4]; console.log (a.Length); // 10var density = a.filter (fonction (item) {return item! = undefined;}) console.log (dense, dense.length); // [1,2,4] 4Filter () méthode Méthode d'écriture compatible
if (typeof array.prototype.filter! = "function") {array.prototype.filter = function (fn, context) {var arr = []; if (typeof fn === "function") {for (var k = 0, longueur = this.length; k <longueur; k ++) {fn.call (context, this [k], k, this) &&& par arr.push (this [k]);}} return arr;};}【quelques()】
La méthode Some () exécute une fonction donnée sur chaque élément du tableau, et si la fonction renvoie true pour l'un ou l'autre élément, il renvoie true. Et si et seulement si tous les éléments de la valeur appellent la fonction de décision renvoie faux, il renvoie faux
a = [1,2,3,4,5]; a.some (fonction (elem, index, arr) {return elem% 2 === 0;}) // truea.some (isnan); // falseAppeler une méthode () sur un tableau vide renverra faux
[] .Some (function () {}); // falseUne méthode de rédaction compatible de la méthode (
if (typeof Array.prototype.some != "function") {Array.prototype.some = function (fn, context) {var passed = false;if (typeof fn === "function") {for (var k = 0, length = this.length; k < length; k++) {if (passed === true) break;passed = !!fn.call(context, this[k], k, this);}}return passed;};}【chaque()】
every()方法对数组中的每一项运行给定函数，如果该函数对每一项都返回true，则返回true；只要有一项返回false，则返回false
a = [1,2,3,4,5];a.every(function(elem, index, arr){elem < 10;})//truea.every(function(elem, index, arr){return elem%2 ===0;});//false在空数组上调用every()方法会返回true
[].every(function(){});//trueevery()方法兼容写法
if (typeof Array.prototype.every != "function") {Array.prototype.every = function (fn, context) {var passed = true;if (typeof fn === "function") {for (var k = 0, length = this.length; k < length; k++) {if (passed === false) break;passed = !!fn.call(context, this[k], k, this);}}return passed;};}Résumer
Les méthodes de tableau JavaScript sont spécifiquement définies comme générales, elles fonctionnent donc correctement non seulement sur les tableaux réels mais aussi sur les objets de tableau de classe. Of these 22 methods, all methods except toString() and toLocaleString() are common
可以改变原数组的方法总共有7种：包括unshift()、shift()、push()、pop()这4种栈和队列方法，reverse()和sort()这2种数组排列方法，数组删改方法splice()
The above is the 22 must-learn methods of arrays in JavaScript introduced to you by the editor (recommended). J'espère que cela vous sera utile. Si vous avez des questions, veuillez me laisser un message et l'éditeur vous répondra à temps. Merci beaucoup pour votre soutien au site Web Wulin.com!