One place for hosting & domains

      Verwenden von .map() zur Iteration durch Array-Elemente in JavaScript


      Einführung

      Von der klassischen forloop– bis zur forEach()-Methode werden verschiedene Techniken und Methoden verwendet, um durch Datensätze in JavaScript zu iterieren. Eine der beliebtesten Methoden ist die .map()-Methode. .map() erstellt ein Array durch den Aufruf einer bestimmten Funktion für jedes Element im übergeordneten Array. .map() ist eine nicht mutierende Methode, die ein neues Array erzeugt, im Gegensatz zu mutierenden Methoden, bei denen nur Änderungen am aufrufenden Array vorgenommen werden.

      Diese Methode kann bei der Arbeit mit Arrays viele Anwendungen haben. In diesem Tutorial behandeln wir vier bemerkenswerte Verwendungsmöglichkeiten von .map() in JavaScript: Aufrufen einer Funktion von Array-Elementen, Konvertieren von Zeichenfolgen in Arrays, Rendern von Listen in JavaScript-Bibliotheken und Neuformatieren von Array-Objekten.

      Voraussetzungen

      Dieses Tutorial erfordert keine Programmierung, aber wenn Sie die Beispiele mitverfolgen möchten, können Sie entweder das Node.js REPL oder Browser-Entwicklertools verwenden.

      Schritt 1 — Aufrufen einer Funktion für jedes Element in einem Array

      .map() akzeptiert eine Callback-Funktion als eines ihrer Argumente und ein wichtiger Parameter dieser Funktion ist der aktuelle Wert des Elements, das von der Funktion verarbeitet wird. Dies ist ein erforderlicher Parameter. Mit diesem Parameter können Sie jedes Element in einem Array ändern und eine neue Funktion erstellen.

      Hier ist ein Beispiel:

      const sweetArray = [2, 3, 4, 5, 35]
      const sweeterArray = sweetArray.map(sweetItem => {
          return sweetItem * 2
      })
      
      console.log(sweeterArray)
      

      Diese Ausgabe wird in der Konsole protokolliert:

      Output

      [ 4, 6, 8, 10, 70 ]

      Um sie sauberer zu gestalten, kann sie weiter vereinfacht werden mit:

      // create a function to use
      const makeSweeter = sweetItem => sweetItem * 2;
      
      // we have an array
      const sweetArray = [2, 3, 4, 5, 35];
      
      // call the function we made. more readable
      const sweeterArray = sweetArray.map(makeSweeter);
      
      console.log(sweeterArray);
      

      Die gleiche Ausgabe wird in der Konsole protokolliert:

      Output

      [ 4, 6, 8, 10, 70 ]

      Durch Verwendung von Code wie sweetArray.map(makeSweeter) wird Ihr Code etwas lesbarer.

      Schritt 2 — Konvertieren einer Zeichenfolge in ein Array

      .map() ist dafür bekannt, zum Array-Prototyp zu gehören. In diesem Schritt verwenden Sie es, um eine Zeichenfolge in ein Array zu konvertieren. Sie entwickeln hier nicht die Methode, die für Zeichenfolgen funktioniert. Vielmehr verwenden Sie die spezielle Methode .call().

      In JavaScript ist alles ein Objekt und Methoden sind Funktionen, die an diese Objekte angehängt sind. Mit .call() können Sie den Kontext eines Objekts auf ein anderes Objekt anwenden. Sie würden also den Kontext von .map() in einem Array in eine Zeichenfolge kopieren.

      .call() können Argumente des zu verwendenden Kontexts und Parameter für die Argumente der ursprünglichen Funktion übergeben werden.

      Hier ist ein Beispiel:

      const name = "Sammy"
      const map = Array.prototype.map
      
      const newName = map.call(name, eachLetter => {
          return `${eachLetter}a`
      })
      
      console.log(newName)
      

      Diese Ausgabe wird in der Konsole protokolliert:

      Output

      • [ "Sa", "aa", "ma", "ma", "ya" ]

      Hier haben Sie den Kontext von .map() auf einer Zeichenfolge verwendet und ein Argument der Funktion übergeben, die .map() erwartet.

      Dies funktioniert wie die .split()-Methode einer Zeichenfolge, nur dass jedes einzelne Zeichen einer Zeichenfolge geändert werden kann, bevor es in ein Array zurückgegeben wird.

      Schritt 3 — Rendern von Listen in JavaScript-Bibliotheken

      JavaScript-Bibliotheken wie React verwenden .map(), um Elemente in einer Liste zu rendern. Dies erfordert jedoch die JSX-Syntax, da die .map()-Methode in JSX-Syntax eingehüllt ist.

      Hier ist ein Beispiel für eine React-Komponente:

      import React from "react";
      import ReactDOM from "react-dom";
      
      const names = ["whale", "squid", "turtle", "coral", "starfish"];
      
      const NamesList = () => (
        <div>
          <ul>{names.map(name => <li key={name}> {name} </li>)}</ul>
        </div>
      );
      
      const rootElement = document.getElementById("root");
      ReactDOM.render(<NamesList />, rootElement);
      

      Dies ist eine zustandslose Komponente in React, die ein div mit einer Liste rendert. Die einzelnen Listenelemente werden mit .map() gerendert, um über das ursprünglich erstellte Namens-Array zu iterieren. Diese Komponente wird mit ReactDOM auf dem DOM-Element mit der Id von root gerendert.

      Schritt 4 — Neuformatieren von Array-Objekten

      .map() kann verwendet werden, um durch Objekte in einem Array zu iterieren und, ähnlich wie bei herkömmlichen Arrays, den Inhalt jedes einzelnen Objekts zu ändern und ein neues Array zurückzugeben. Diese Änderung erfolgt anhand dessen, was in der Callback-Funktion zurückgegeben wird.

      Hier ist ein Beispiel:

      const myUsers = [
          { name: 'shark', likes: 'ocean' },
          { name: 'turtle', likes: 'pond' },
          { name: 'otter', likes: 'fish biscuits' }
      ]
      
      const usersByLikes = myUsers.map(item => {
          const container = {};
      
          container[item.name] = item.likes;
          container.age = item.name.length * 10;
      
          return container;
      })
      
      console.log(usersByLikes);
      

      Diese Ausgabe wird in der Konsole protokolliert:

      Output

      [ {shark: "ocean", age: 50}, {turtle: "pond", age: 60}, {otter: "fish biscuits", age: 50} ]

      Hier haben Sie jedes Objekt im Array mit der Klammer- und Punktnotation geändert. Dieser Anwendungsfall kann zur Verarbeitung oder Kondensierung empfangener Daten verwendet werden, bevor sie in einer Frontend-Anwendung gespeichert oder geparst werden.

      Zusammenfassung

      In diesem Tutorial haben wir vier Verwendungsmöglichkeiten der Methode .map() in JavaScript betrachtet. In Kombination mit anderen Methoden kann die Funktionalität von .map() erweitert werden. Weitere Informationen finden Sie in unserem Artikel Verwenden von Array-Methoden in JavaScript: Iterationsmethoden.



      Source link

      Cómo usar .map() para iterar elementos de matriz en JavaScript


      Introducción

      Desde el método clásico forloop al método forEach(), se utilizan varias técnicas y métodos para iterar a través de conjuntos de datos en JavaScript. Uno de los métodos más populares es el método .map(). ,map() crea una matriz a partir de la invocación de una función específica sobre cada elemento de la matriz principal. .map() es un método sin mutación que crea una nueva matriz en vez de los métodos con mutación, que solo realizan cambios a la matriz que invoca.

      Este método puede tener muchos usos cuando se trabaja con matrices. En este tutorial, verá cuatro usos notales de .map() en JavaScript: invocar una función de elementos de matriz, convertir cadenas a matrices, renderizar listas en bibliotecas y cambiar el formato de los objetos de una matriz.

      Requisitos previos

      Este tutorial no requiere codificación, pero si está interesado en seguir los ejemplos, puede usar el Node.js REPL o las herramientas del desarrollador del navegador.

      Paso 1: Invocar una función en cada elemento en una matriz

      .map() acepta una función de invocación como uno de sus argumentos, y un parámetro importante de esa función es el valor actual del elemento que procesa la función. Este es un parámetro requerido. Con este parámetro, puede modificar cada elemento en una matriz y crear una nueva función.

      Aquí tiene un ejemplo:

      const sweetArray = [2, 3, 4, 5, 35]
      const sweeterArray = sweetArray.map(sweetItem => {
          return sweetItem * 2
      })
      
      console.log(sweeterArray)
      

      Este resultado se registra en la consola:

      Output

      [ 4, 6, 8, 10, 70 ]

      Esto se puede simplificar algo más para que esté más limpio con:

      // create a function to use
      const makeSweeter = sweetItem => sweetItem * 2;
      
      // we have an array
      const sweetArray = [2, 3, 4, 5, 35];
      
      // call the function we made. more readable
      const sweeterArray = sweetArray.map(makeSweeter);
      
      console.log(sweeterArray);
      

      Este resultado se registra en la consola:

      Output

      [ 4, 6, 8, 10, 70 ]

      Tener un código como sweetArray.map(makeSweeter) hace que su código sea un poco más legible..

      Paso 2: Convertir una cadena en una matriz

      .map() se conoce como que pertenece al prototipo de matriz. En este paso, lo usará para convertir una cadena a una matriz. No está desarrollando el método para trabajar para cadenas aquí. En vez de eso usará el método especial .call().

      Todo en JavaScript es un objeto, y los métodos son funciones asociadas con estos objetos. .call() permite usar el contexto de un objeto sobre otro. Por tanto, estaría copiando el contexto de .map() en una matriz sobre una cadena.

      Es posible pasar argumentos a .call() del contexto que se va a utilizar y los parámetros de los argumentos de la función original.

      Aquí tiene un ejemplo:

      const name = "Sammy"
      const map = Array.prototype.map
      
      const newName = map.call(name, eachLetter => {
          return `${eachLetter}a`
      })
      
      console.log(newName)
      

      Este resultado se registra en la consola:

      Output

      • [ "Sa", "aa", "ma", "ma", "ya" ]

      Aquí utilizó el contexto de .map() de una cadena y pasó un argumento de la función que .map() espera.

      Esto funciona como el método .split() de una cadena, solo que cada carácter individual de la cadena puede modificarse antes de ser devuelto en una matriz.

      Paso 3: Renderizar listas en bibliotecas JavaScript

      Las bibliotecas JavaScript como React utilizan .map() para renderizar elementos en una lista. Esto requiere sintaxis JSX ya que el método .map() está envuelto en la sintaxis JSX.

      Aquí tiene un ejemplo de un componente de React:

      import React from "react";
      import ReactDOM from "react-dom";
      
      const names = ["whale", "squid", "turtle", "coral", "starfish"];
      
      const NamesList = () => (
        <div>
          <ul>{names.map(name => <li key={name}> {name} </li>)}</ul>
        </div>
      );
      
      const rootElement = document.getElementById("root");
      ReactDOM.render(<NamesList />, rootElement);
      

      Este es un componente sin estado en React, que renderiza un div con una lista. Los elementos individuales de la lista se renderizan usando .map() para iterar sobre la matriz de nombres creada inicialmente. Este componente se renderiza usando ReactDOM en el elemento DOM con Id de root.

      Paso 4: Reformatear los objetos de la matriz

      .map() puede usarse para iterar en objetos en una matriz y, de forma similar a las matrices tradicionales, modificar el contenido de cada objeto individual y devolver una nueva matriz. Esta modificación se realiza según lo que se devuelve en la función de callback.

      Aquí tiene un ejemplo:

      const myUsers = [
          { name: 'shark', likes: 'ocean' },
          { name: 'turtle', likes: 'pond' },
          { name: 'otter', likes: 'fish biscuits' }
      ]
      
      const usersByLikes = myUsers.map(item => {
          const container = {};
      
          container[item.name] = item.likes;
          container.age = item.name.length * 10;
      
          return container;
      })
      
      console.log(usersByLikes);
      

      Este resultado se registra en la consola:

      Output

      [ {shark: "ocean", age: 50}, {turtle: "pond", age: 60}, {otter: "fish biscuits", age: 50} ]

      Aquí ha modificado cada objeto en la matriz usando la notación paréntesis y punto. Este caso de uso puede emplearse para procesar o condensar los datos recibidos antes de guardarlos o analizarlos en una aplicación frontend.

      Conclusión

      En este tutorial hemos visto cuatro usos del método .map() en JavaScript. En combinación con otros métodos, la funcionalidad de .map() puede ampliarse. Para obtener más información, consulte el artículo Cómo usar métodos de matriz en métodos de iteración de JavaScript.



      Source link

      Comment utiliser .map() pour Iterate via Array Items dans JavaScript


      Introduction

      De la forloop classique à la méthode forEach(), diverses techniques et méthodes sont utilisées pour itérer à travers des ensembles de données en JavaScript. L’une des méthodes les plus populaires est la méthode .map(). .map() crée un tableau à partir de l’appel d’une fonction spécifique sur chaque élément du tableau parent. .map() est une méthode non mutante qui crée un nouveau tableau par opposition aux méthodes mutantes, qui ne font que modifier le tableau appelant.

      Cette méthode peut avoir de nombreux usages lorsqu’on travaille avec des tableaux. Dans ce tutoriel, nous examinerons quatre utilisations importantes de .map() en JavaScript : appel d’une fonction d’éléments de tableau, conversion de chaînes de caractères en tableaux, rendu de listes dans des bibliothèques JavaScript et reformatage d’objets de tableau.

      Conditions préalables

      Ce tutoriel ne nécessite aucun codage, mais si vous souhaitez suivre les exemples, vous pouvez soit utiliser le Node.js REPL, soit recourir à des outils de développement de navigateur.

      Étape 1 – Appeler une fonction sur chaque élément d’un tableauélément

      .map() accepte une fonction de rappel comme l’un de ses arguments, et un paramètre important de cette fonction est la valeur actuelle de l’élément traité par la fonction.  Il s’agit d’un paramètre obligatoire. Avec ce paramètre, vous pouvez modifier chaque élément d’un tableau et créer une nouvelle fonction.

      Voici un exemple :

      const sweetArray = [2, 3, 4, 5, 35]
      const sweeterArray = sweetArray.map(sweetItem => {
          return sweetItem * 2
      })
      
      console.log(sweeterArray)
      

      Cette sortie est enregistrée sur la console :

      Output

      [ 4, 6, 8, 10, 70 ]

      Il est possible de la simplifier encore un peu pour la rendre plus claire :

      // create a function to use
      const makeSweeter = sweetItem => sweetItem * 2;
      
      // we have an array
      const sweetArray = [2, 3, 4, 5, 35];
      
      // call the function we made. more readable
      const sweeterArray = sweetArray.map(makeSweeter);
      
      console.log(sweeterArray);
      

      La même sortie est enregistrée sur la console :

      Output

      [ 4, 6, 8, 10, 70 ]

      Avoir un code comme sweetArray.map(makeSweeter) rend votre code un peu plus lisible.

      Étape 2 – Convertir une chaîne de caractères en un tableau

      .map() est connu pour faire partie du prototype de tableau. Dans cette étape, vous l’utiliserez pour convertir une chaîne de caractères en un tableau.  Vous ne développez pas ici la méthode afin qu’elle fonctionne pour des chaînes de caractères. Au contraire, vous utiliserez la méthode spéciale .call()

      Tout ce qui est en JavaScript est un objet, et les méthodes sont des fonctions attachées à ces objets. .call() vous permet d’utiliser le contexte d’un objet sur un autre. Par conséquent, vous copieriez le contexte de .map() dans un tableau sur une chaîne.de caractères.

      .call() peut être des arguments transmis du contexte à utiliser et des paramètres pour les arguments de la fonction d’origine.

      Voici un exemple :

      const name = "Sammy"
      const map = Array.prototype.map
      
      const newName = map.call(name, eachLetter => {
          return `${eachLetter}a`
      })
      
      console.log(newName)
      

      Cette sortie est enregistrée sur la console :

      Output

      • [ "Sa", "aa", "ma", "ma", "ya" ]

      Ici, vous avez utilisé le contexte de .map() sur une chaîne de caractères et passé un argument de la fonction que .map() attend.

      Elle fonctionne comme la méthode .split() d’une chaîne, à la différence près que chaque caractère de la chaîne peut être modifié avant d’être renvoyé dans un tableau.

      Étape 3 – Rendu des listes dans la bibliothèque JavaScript

      Les bibliothèques JavaScript comme React utilisent .map() pour rendre les éléments en une liste. Cela nécessite toutefois une syntaxe JSX, car la méthode .map() est enveloppée dans la syntaxe JSX.

      Voici un exemple d’une composante React :

      import React from "react";
      import ReactDOM from "react-dom";
      
      const names = ["whale", "squid", "turtle", "coral", "starfish"];
      
      const NamesList = () => (
        <div>
          <ul>{names.map(name => <li key={name}> {name} </li>)}</ul>
        </div>
      );
      
      const rootElement = document.getElementById("root");
      ReactDOM.render(<NamesList />, rootElement);
      

      Il s’agit d’un élément apatride dans React qui rend une div avec une liste.  Les différents éléments de la liste sont rendus à l’aide de .map() pour itérer sur le tableau de noms initialement créé. Ce composant est rendu à l’aide de ReactDOM sur l’élément DOM avec Id of root.

      Étape 4 – Reformater les objets de tableau

      .map() peut être utilisé pour itérer à travers des objets dans un tableau et, de manière similaire aux tableaux traditionnels, modifier le contenu de chaque objet individuel et renvoyer un nouveau tableau.  Cette modification est effectuée en fonction de ce qui est renvoyé dans la fonction de rappel.

      Voici un exemple :

      const myUsers = [
          { name: 'shark', likes: 'ocean' },
          { name: 'turtle', likes: 'pond' },
          { name: 'otter', likes: 'fish biscuits' }
      ]
      
      const usersByLikes = myUsers.map(item => {
          const container = {};
      
          container[item.name] = item.likes;
          container.age = item.name.length * 10;
      
          return container;
      })
      
      console.log(usersByLikes);
      

      Cette sortie est enregistrée sur la console :

      Output

      [ {shark: "ocean", age: 50}, {turtle: "pond", age: 60}, {otter: "fish biscuits", age: 50} ]

      Ici, vous avez modifié chaque objet du tableau en utilisant la notation par parenthèses et points. Ce cas d’utilisation peut être utilisé pour traiter ou condenser les données reçues avant qu’elles ne soient sauvegardées ou analysées sur une application frontale.

      Conclusion

      Dans ce tutoriel, nous avons examiné quatre utilisations de la méthode .map() en JavaScript. En combinaison avec d’autres méthodes, la fonctionnalité de .map() peut être étendue. Pour plus d’informations, consultez notre article Comment utiliser les méthodes de tableau en JavaScript : Méthodes d’itération.



      Source link