One place for hosting & domains

      verwenden

      Verwenden von Font Awesome 5 mit React


      Einführung

      Font Awesome ist ein Toolkit für Websites, das Symbole und soziale Logos zur Verfügung stellt. React ist eine Programmierbibliothek, die zur Erstellung von Benutzeroberflächen verwendet wird. Obwohl das Font Awesome-Team eine React-Komponente zur Förderung der Integration entwickelt hat, gibt es einige Grundlagen über Font Awesome 5 und seine Strukturierung zu verstehen. In diesem Tutorial erfahren Sie, wie Sie die Komponente React Font Awesome verwenden können.

      Font Awesome-Website mit ihren Symbolen

      Voraussetzungen

      Für dieses Tutorial ist keine Programmierung erforderlich. Wenn Sie jedoch mit einigen der Beispiele experimentieren möchten, benötigen Sie Folgendes:

      Schritt 1 – Verwenden von Font Awesome

      Das Font Awesome-Team hat eine React-Komponente erstellt, damit Sie beide zusammen verwenden können. Mit dieser Bibliothek können Sie dem Tutorial folgen, nachdem Sie Ihr Symbol ausgewählt haben.

      In diesem Beispiel verwenden wir das Home-Symbol und führen alles in der Datei App.js aus:

      src/App.js

      import React from "react";
      import { render } from "react-dom";
      
      // get our fontawesome imports
      import { faHome } from "@fortawesome/free-solid-svg-icons";
      import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
      
      // create our App
      const App = () => (
        <div>
          <FontAwesomeIcon icon={faHome} />
        </div>
      );
      
      // render to #root
      render(<App />, document.getElementById("root"));
      

      Ihre Anwendung verfügt nun über ein kleines Home-Symbol. Sie werden feststellen, dass dieser Code nur das Home-Symbol auswählt, sodass nur ein Symbol zu unserer Bundle-Größe hinzugefügt wird.

      Code-Sandbox mit angezeigtem Home-Symbol

      Nun wird Font Awesome dafür sorgen, dass diese Komponente sich durch die SVG-Version dieses Symbols ersetzt, sobald diese Komponente installiert ist.

      Schritt 2 — Auswählen der Symbole

      Vor dem Installieren und Verwenden der Symbole ist es wichtig zu wissen, wie die Font Awesome Bibliotheken strukturiert sind. Da es viele Symbole gibt, hat das Team beschlossen, sie in mehrere Pakete aufzuteilen.

      Bei der Auswahl und Entscheidung über die gewünschten Symbole empfiehlt es sich, die Seite Font Awesome Icons zu besuchen, um Ihre Optionen zu erkunden. Auf der linken Seite der Seite sehen Sie verschiedene Filter, aus denen Sie auswählen können. Diese Filter sind sehr wichtig, da sie angeben, aus welchem Paket Ihr Symbol importiert werden soll.

      Im obigen Beispiel haben wir das Home-Symbol aus dem Paket @fortawesome/free-solid-svg-icons abgerufen.

      Bestimmen, zu welchem Paket ein Symbol gehört

      Sie können herausfinden, zu welchem Paket ein Symbol gehört, indem Sie sich die Filter auf der linken Seite ansehen. Sie können auch in ein Symbol klicken und das Paket sehen, zu dem es gehört.

      Sobald Sie wissen, zu welchem Paket eine Schriftart gehört, ist es wichtig, sich die dreibuchstabige Kurzform für dieses Paket zu merken:

      • Stil „Solid“ – fas
      • Stil „Regular“ – far
      • Stil „Light“ – fal
      • Stil „Duotone“ – fad

      Auf der Symbole-Seite können Sie nach einem bestimmten Typ suchen:

      Symbol-Seite mit einigen der Paketnamen auf der linken Seite

      Verwenden von Symbolen aus bestimmten Paketen

      Wenn Sie die Font Awesome Symbole-Seite durchblättern, werden Sie feststellen, dass es normalerweise mehrere Versionen desselben Symbols gibt. Sehen wir uns beispielsweise das Symbol boxing-glove an:

      Boxhandschuh-Symbol, drei verschiedene Versionen

      Um ein bestimmtes Symbol zu verwenden, müssen Sie <FontAwesomeIcon> anpassen. Im Folgenden werden mehrere Arten des gleichen Symbols aus verschiedenen Paketen angezeigt. Dazu gehören die bereits erwähnten dreibuchstabigen Kurzformen.

      Anmerkung: Die folgenden werden nicht funktionieren, bis wir in einigen Abschnitten eine Symbol-Bibliothek aufgebaut haben.

      Hier ist ein Beispiel für die „Solid“-Version:

      <FontAwesomeIcon icon={['fas', 'code']} />
      

      Wenn kein Typ angegeben ist, wird standardmäßig die „Solid“-Version verwendet:

      <FontAwesomeIcon icon={faCode} />
      

      Und die „Light“-Version, unter Verwendung von fal:

      <FontAwesomeIcon icon={['fal', 'code']} />;
      

      Wir mussten unser icon-Prop zu einem Array statt einer einfachen Zeichenfolge ändern.

      Schritt 3 — Installieren von Font Awesome

      Da es mehrere Versionen eines Symbols, mehrerer Pakete und kostenlose/Pro-Pakete gibt, erfordert das Installieren aller mehr als ein npm-Paket. Möglicherweise müssen Sie mehrere installieren und dann die gewünschten Symbole auswählen.

      Für diesen Artikel installieren wir alles, damit wir zeigen können, wie mehrere Pakete installiert werden.

      Führen Sie den folgenden Befehl aus, um die Basispakete zu installieren:

      • npm i -S @fortawesome/fontawesome-svg-core @fortawesome/react-fontawesome

      Führen Sie die folgenden Befehle aus, um die regulären Symbole zu installieren:

      • # regular icons
      • npm i -S @fortawesome/free-regular-svg-icons
      • npm i -S @fortawesome/pro-regular-svg-icons

      Dadurch werden die „Solid“-Symbole (gefüllte Symbole) installiert:

      • # solid icons
      • npm i -S @fortawesome/free-solid-svg-icons
      • npm i -S @fortawesome/pro-solid-svg-icons

      Verwenden Sie diesen Befehl für „Light“-Symbole (Symbole mit dünnem Rand):

      • # light icons
      • npm i -S @fortawesome/pro-light-svg-icons

      Dies installiert die „Duotone“-Symbole (Symbole mit zwei Farben):

      • # duotone icons
      • npm i -S @fortawesome/pro-duotone-svg-icons

      Zum Schluss installiert dies die Marken-Symbole:

      • # brand icons
      • npm i -S @fortawesome/free-brands-svg-icons

      Oder, wenn Sie es vorziehen, alle auf einmal zu installieren, können Sie diesen Befehl verwenden, um die kostenlosen Symbol-Sätze zu installieren:

      • npm i -S @fortawesome/fontawesome-svg-core @fortawesome/react-fontawesome @fortawesome/free-regular-svg-icons @fortawesome/free-solid-svg-icons @fortawesome/free-brands-svg-icons

      Wenn Sie ein Pro-Konto mit Font Awesome haben, können Sie den folgenden Befehl verwenden, um alle Symbole zu installieren:

      • npm i -S @fortawesome/fontawesome-svg-core @fortawesome/react-fontawesome @fortawesome/free-regular-svg-icons @fortawesome/pro-regular-svg-icons @fortawesome/free-solid-svg-icons @fortawesome/pro-solid-svg-icons @fortawesome/pro-light-svg-icons @fortawesome/pro-duotone-svg-icons @fortawesome/free-brands-svg-icons

      Sie haben die Pakete installiert, aber sie noch nicht in Ihrer Anwendung verwendet oder zu unseren App-Bundles hinzugefügt. Sehen wir uns im nächsten Schritt an, wie Sie dies tun können.

      Schritt 4 — Erstellen einer Symbol-Bibliothek

      Es kann mühsam sein, das gewünschte Symbol in mehrere Dateien zu importieren. Angenommen, Sie verwenden das Twitter-Logo an mehreren Stellen, dann wollen Sie das nicht mehrfach schreiben müssen.

      Um alles an einem Ort zu importieren, anstatt jedes Symbol in jede separate Datei zu importieren, erstellen wir eine Font Awesome Bibliothek.

      Erstellen wir fontawesome.js im Ordner src und importieren diese dann in index.js. Es steht Ihnen frei, diese Datei an beliebiger Stelle hinzuzufügen, solange die Komponenten, in denen Sie die Symbole verwenden möchten, Zugriff haben (untergeordnete Komponenten sind). Sie können dies sogar direkt in Ihrer index.js oder App.js tun. Es kann jedoch besser sein, dies in eine separate Datei auszulagern, da es groß werden kann:

      src/fontawesome.js

      // import the library
      import { library } from '@fortawesome/fontawesome-svg-core';
      
      // import your icons
      import { faMoneyBill } from '@fortawesome/pro-solid-svg-icons';
      import { faCode, faHighlighter } from '@fortawesome/free-solid-svg-icons';
      
      library.add(
        faMoneyBill,
        faCode,
        faHighlighter
        // more icons go here
      );
      

      Wenn Sie dies in einer eigenen Datei getan haben, müssen Sie in index.js importieren:

      src/index.js

      import React from 'react';
      import { render } from 'react-dom';
      
      // import your fontawesome library
      import './fontawesome';
      
      render(<App />, document.getElementById('root'));
      

      Importieren eines kompletten Symbol-Pakets

      Das Importieren eines kompletten Pakets wird nicht empfohlen, da Sie jedes einzelne Symbol in Ihre Anwendung importieren, wodurch ein großes Bundle entstehen kann. Wenn Sie ein komplettes Paket importieren müssen, können Sie dies selbstverständlich tun.

      Nehmen wir in diesem Beispiel an, Sie wollen alle Marken-Symbole in @fortawesome/free-brands-svg-icons haben. Um das komplette Paket zu importieren, würden Sie Folgendes verwenden:

      src/fontawesome.js

      import { library } from '@fortawesome/fontawesome-svg-core';
      import { fab } from '@fortawesome/free-brands-svg-icons';
      
      library.add(fab);
      

      fab repräsentiert das gesamte Markensymbol-Paket.

      Importieren einzelner Symbole

      Es wird empfohlen, die Symbole von Font Awesome einzeln zu importieren, damit Ihre endgültigen Bundle-Größen so klein wie möglich sind, da Sie nur das importieren, was Sie benötigen.

      Auf diese Weise können Sie eine Bibliothek aus mehreren Symbolen aus den verschiedenen Paketen erstellen:

      src/fontawesome.js

      import { library } from '@fortawesome/fontawesome-svg-core';
      
      import { faUserGraduate } from '@fortawesome/pro-light-svg-icons';
      import { faImages } from '@fortawesome/pro-solid-svg-icons';
      import {
        faGithubAlt,
        faGoogle,
        faFacebook,
        faTwitter
      } from '@fortawesome/free-brands-svg-icons';
      
      library.add(
        faUserGraduate,
        faImages,
        faGithubAlt,
        faGoogle,
        faFacebook,
        faTwitter
      );
      

      Importieren desselben Symbols aus mehreren Stilen

      Wenn Sie alle Arten von boxing-glove für die Pakete fal, far und fas wünschen, können Sie sie alle unter einem anderen Namen importieren und dann hinzufügen.

      src/fontawesome.js

      import { library } from '@fortawesome/fontawesome-svg-core';
      import { faBoxingGlove } from '@fortawesome/pro-light-svg-icons';
      import {
        faBoxingGlove as faBoxingGloveRegular
      } from '@fortawesome/pro-regular-svg-icons';
      import {
        faBoxingGlove as faBoxingGloveSolid
      } from '@fortawesome/pro-solid-svg-icons';
      
      library.add(
          faBoxingGlove,
          faBoxingGloveRegular,
          faBoxingGloveSolid
      );
      

      Sie können sie dann verwenden, indem Sie die verschiedenen Präfixe implementieren:

      <FontAwesomeIcon icon={['fal', 'boxing-glove']} />
      <FontAwesomeIcon icon={['far', 'boxing-glove']} />
      <FontAwesomeIcon icon={['fas', 'boxing-glove']} />
      

      Schritt 5 — Verwenden von Symbolen

      Nachdem Sie nun alles Notwendige installiert haben und Ihre Symbole zu Ihrer Font Awesome Bibliothek hinzugefügt haben, können Sie sie verwenden und Größen zuweisen. In diesem Tutorial verwenden wir das Paket „light“ (fal).

      Dieses erste Beispiel verwendet die normale Größe:

      <FontAwesomeIcon icon={['fal', 'code']} />
      

      Das zweite Beispiel kann benannte Größenanpassung verwenden, wobei Abkürzungen für klein (sm), mittel (md), groß (lg) und extragroß (xl) verwendet werden:

      <FontAwesomeIcon icon={['fal', 'code']} size="sm" />
      <FontAwesomeIcon icon={['fal', 'code']} size="md" />
      <FontAwesomeIcon icon={['fal', 'code']} size="lg" />
      <FontAwesomeIcon icon={['fal', 'code']} size="xl" />
      

      Die dritte Möglichkeit ist die Verwendung der nummerierten Größenanpassung, die bis zu 6 gehen kann:

      <FontAwesomeIcon icon={['fal', 'code']} size="2x" />
      <FontAwesomeIcon icon={['fal', 'code']} size="3x" />
      <FontAwesomeIcon icon={['fal', 'code']} size="4x" />
      <FontAwesomeIcon icon={['fal', 'code']} size="5x" />
      <FontAwesomeIcon icon={['fal', 'code']} size="6x" />
      

      Wenn Sie die nummerierte Größenanpassung verwenden, können Sie auch Dezimalzahlen verwenden, um die perfekte Größe zu finden:

      <FontAwesomeIcon icon={['fal', 'code']} size="2.5x" />
      

      Font Awesome formatiert die von ihm verwendeten SVGs, indem es die Textfarbe der CSS übernimmt. Wenn Sie ein Tag <p> an der Stelle platzieren würden, an der das Symbol erscheinen soll, wäre die Farbe des Absatzes die Farbe des Symbols:

      <FontAwesomeIcon icon={faHome} style={{ color: 'red' }} />
      

      Font Awesome verfügt auch über eine Power Transforms-Funktion, mit der Sie verschiedene Transformationen aneinander reihen können:

      <FontAwesomeIcon icon={['fal', 'home']} transform="down-4 grow-2.5" />
      

      Sie können jede der Transformationen verwenden, die auf der Website Font Awesome zu finden sind. Damit können Sie Symbole nach oben, unten, links oder rechts verschieben, um eine perfekte Positionierung neben dem Text oder innerhalb von Schaltflächen zu erzielen.

      Symbole mit fester Breite

      Wenn Symbole an einer Stelle verwendet werden, an der sie alle gleich breit und einheitlich sein müssen, können wir mit Font Awesome das Prop fixedWidth verwenden. Nehmen wir zum Beispiel an, dass Sie feste Breiten für Ihre Navigation-Dropdown-Liste benötigen:

      Scotch Website mit Menü-Dropdown und „Courses“ hervorgehoben

      <FontAwesomeIcon icon={['fal', 'home']} fixedWidth />
      <FontAwesomeIcon icon={['fal', 'file-alt']} fixedWidth />
      <FontAwesomeIcon icon={['fal', 'money-bill']} fixedWidth />
      <FontAwesomeIcon icon={['fal', 'cog']} fixedWidth />
      <FontAwesomeIcon icon={['fal', 'usd-square']} fixedWidth />
      <FontAwesomeIcon icon={['fal', 'play-circle']} fixedWidth />
      <FontAwesomeIcon icon={['fal', 'chess-king']} fixedWidth />
      <FontAwesomeIcon icon={['fal', 'sign-out-alt']} fixedWidth />
      

      Sich drehende Symbole

      Das Implementieren von sich drehenden Symbolen auf Formularschaltflächen ist hilfreich, wenn ein Formular verarbeitet wird. Sie können das Dreh-Symbol verwenden, um einen schönen Ladeeffekt zu erzielen:

      <FontAwesomeIcon icon={['fal', 'spinner']} spin />
      

      Sie können das Prop spin auf allem Möglichen verwenden!

      <FontAwesomeIcon icon={['fal', 'code']} spin />
      

      Erweitert: Maskierende Symbole

      Mit Font Awesome können Sie zwei Symbole kombinieren, um Effekte mit Maskierung zu erzielen. Sie definieren Ihr normales Symbol und verwenden dann das Prop mask, um ein zweites Symbol zu definieren, das darüber gelegt wird. Das erste Symbol wird innerhalb des Maskierungssymbols beschränkt.

      In diesem Beispiel haben wir Tag-Filter mit Maskierung erstellt:

      Tag-Filter mit Font Awesome

      <FontAwesomeIcon
        icon={['fab', 'javascript']}
        mask={['fas', 'circle']}
        transform="grow-7 left-1.5 up-2.2"
        fixedWidth
      />
      

      Beachten Sie, wie Sie mehrere Props transform aneinanderketten können, um das innere Symbol so zu verschieben, dass es in das Maskierungssymbol passt.

      Wir färben und ändern mit Font Awesome sogar das Hintergrundlogo:

      Erneut die Tag-Filter, aber jetzt mit einem blauen Hintergrund

      Schritt 6 — Verwenden von react-fontawesome und Symbolen außerhalb von React

      Wenn Ihre gesamte Website keine einseitige Anwendung (Single Page Application, SPA) ist und Sie stattdessen eine traditionelle Website und React darüber hinzugefügt haben. Um den Import der SVG/JS-Hauptbibliothek und auch der Bibliothek react-fontawesome zu vermeiden, hat Font Awesome eine Möglichkeit geschaffen, die React-Bibliotheken zu verwenden, um auf Symbole außerhalb der React-Komponenten zu achten.

      Wenn Sie eine <i class="fas fa-stroopwafel"></i> haben, können wir Font Awesome mit dem Folgenden anweisen, diese zu überwachen und zu aktualisieren:

      import { dom } from '@fortawesome/fontawesome-svg-core'
      
      dom.watch() // This will kick off the initial replacement of i to svg tags and configure a MutationObserver
      

      MutationObserver ist eine Webtechnologie, die es uns ermöglicht, DOM auf Änderungen performant zu überwachen. Weitere Informationen über diese Technik finden Sie in den Dokumenten zu React Font Awesome.

      Zusammenfassung

      Die gemeinsame Verwendung von Font Awesome und React ist eine großartige Kombination, macht es jedoch erforderlich, mehrere Pakete zu verwenden und verschiedene Kombinationen zu berücksichtigen. In diesem Tutorial haben Sie einige der Möglichkeiten untersucht, wie Sie Font Awesome und React zusammen verwenden können.



      Source link

      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

      Verwenden eines Unterprozesses zum Ausführen externer Programme in Python 3


      Der Autor hat den COVID-19 Relief Fund dazu ausgewählt, eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      Python 3 beinhaltet das subprocess-Modul zum Ausführen externer Programme und Lesen ihrer Ausgaben in Ihrem Python-Code.

      Möglicherweise finden Sie subprocess nützlich, wenn Sie in Ihrem Python-Code auf Ihrem Computer ein anderes Programm verwenden möchten. Beispielsweise möchten Sie vielleicht git aus Ihrem Python-Code aufrufen, um Dateien in Ihrem Projekt abzurufen, die in der git-Versionskontrolle verfolgt werden. Da sich jedes Programm, das Sie auf Ihrem Computer aufrufen können, über subprocess steuern lässt, gelten die hier angegebenen Beispiele für externe Programme, die Sie ggf. über Ihren Python-Code aufrufen möchten.

      subprocess enthält verschiedene Klassen und Funktionen; wir werden in diesem Tutorial jedoch eine der nützlichsten Funktionen von subprocess abdecken: subprocess.run. Wir werden uns die verschiedenen Einsatzmöglichkeiten und wichtigsten Schlüsselwortargumente ansehen.

      Voraussetzungen

      Um das Beste aus diesem Tutorial herauszuholen, empfiehlt es sich, eine gewisse Vertrautheit mit Programmierung in Python 3 aufzuweisen. Sie können sich für die erforderlichen Hintergrundinformationen folgende Tutorials ansehen:

      Ausführen eines externen Programms

      Sie können mit der Funktion subprocess.run ein externes Programm über Ihren Python-Code ausführen. Zuerst müssen Sie jedoch die Module subprocess und sys in Ihr Programm importieren:

      import subprocess
      import sys
      
      result = subprocess.run([sys.executable, "-c", "print('ocean')"])
      

      Wenn Sie dies ausführen, erhalten Sie eine Ausgabe wie die folgende:

      Output

      ocean

      Sehen wir uns dieses Beispiel an:

      • sys.executable ist der absolute Pfad zur ausführbaren Python-Datei, mit der Ihr Programm ursprünglich aufgerufen wurde. Beispielsweise kann sys.executable ein Pfad wie /usr/local/bin/python sein.
      • An subprocess.run wird eine Liste mit Zeichenfolgen übergeben, die aus den Komponenten des Befehls besteht, den wir ausführen möchten. Da die erste Zeichenfolge, die wir übergeben, sys.executable ist, weisen wir subprocess.run an, ein neues Python-Programm auszuführen.
      • Die Komponente -c ist eine python-Befehlszeilenoption, mit der Sie eine Zeichenfolge mit einem gesamten Python-Programm zur Ausführung übergeben können. In unserem Fall übergeben wir ein Programm, das die Zeichenkette ocean ausgibt.

      Sie können sich jeden Eintrag in der Liste, den wir an subprocess.run übergeben, als durch ein Leerzeichen getrennt vorstellen. Beispielsweise wird [sys.executable, "-c", "print('ocean')"] in etwa zu /usr/local/bin/python -c "print('ocean')". Beachten Sie, dass subprocess automatisch die Komponenten des Befehls angibt, bevor versucht wird, sie im zugrunde liegenden Betriebssystem auszuführen. So können Sie beispielsweise einen Dateinamen übergeben, der Leerzeichen enthält.

      Warnung: Übergeben Sie nie unvertrauenswürdige Eingaben an subprocess.run. Da subprocess.run die Fähigkeit hat, beliebige Befehle auf Ihrem Computer auszuführen, können bösartige Akteure damit Ihren Computer auf unerwartete Weise manipulieren.

      Erfassen von Ausgaben aus einem externen Programm

      Nachdem wir mit subprocess.run ein externes Programm aufrufen können, sehen wir uns nun an, wie wir Ausgaben von diesem Programm erfassen können. Beispielsweise kann dieser Prozess nützlich sein, wenn wir git ls-files verwenden möchten, um alle aktuell in der Versionskontrolle gespeicherten Dateien auszugeben.

      Anmerkung: Die in diesem Abschnitt angegebenen Beispiele benötigen Python 3.7 oder höher. Insbesondere wurden die Schlüsselwortargumente capture_output und text in Python 3.7 hinzugefügt, als es im Juni 2018 veröffentlicht wurde.

      Ergänzen wir unser vorheriges Beispiel:

      import subprocess
      import sys
      
      result = subprocess.run(
          [sys.executable, "-c", "print('ocean')"], capture_output=True, text=True
      )
      print("stdout:", result.stdout)
      print("stderr:", result.stderr)
      

      Wenn wir diesen Code ausführen, erhalten wir eine Ausgabe wie die folgende:

      Output

      stdout: ocean stderr:

      Dieses Beispiel ist weitgehend das gleiche wie das im ersten Abschnitt eingeführte: Wir führen noch immer einen Unterprozess zum Ausdrucken von ocean aus. Wichtig:Wir übergeben jedoch die Schlüsselwortargumente capture_output=True und text=True an subprocess.run.

      subprocess.run gibt ein subprocess.CompletedProcess-Objekt zurück, das an result gebunden ist. Das Objekt subprocess.CompletedProcess enthält Details zum Exitcode des externen Programms und seiner Ausgabe. capture_output=True sorgt dafür, dass result.stdout und result.stderr mit der entsprechenden Ausgabe aus dem externen Programm gefüllt werden. Standardmäßig sind result.stdout und result.stderr als Bytes gebunden; das Schlüsselwortargument text=True weist Python an, die Bytes in Zeichenfolgen zu decodieren.

      Im Ausgabebereich lautet stdout ocean (plus der nachfolgenden neuen Zeile, die print implizit hinzufügt); wir verfügen über kein stderr.

      Versuchen wir es mit einem Beispiel, das für stderr einen nicht leeren Wert erstellt:

      import subprocess
      import sys
      
      result = subprocess.run(
          [sys.executable, "-c", "raise ValueError('oops')"], capture_output=True, text=True
      )
      print("stdout:", result.stdout)
      print("stderr:", result.stderr)
      

      Wenn wir diesen Code ausführen, erhalten wir eine Ausgabe wie die folgende:

      Output

      stdout: stderr: Traceback (most recent call last): File "<string>", line 1, in <module> ValueError: oops

      Dieser Code führt einen Python-Unterprozess aus, der sofort einen ValueError auslöst. Wenn wir das endgültige Ergebnis prüfen, sehen wir in stdout nichts und ein Traceback unseres ValueError in stderr. Das liegt daran, dass Python das Traceback der nicht behandelten Ausnahme in stderr schreibt.

      Auslösen einer Ausnahme bei einem fehlerhaften Exitcode

      Manchmal ist es nützlich, eine Ausnahme auszulösen, wenn ein ausgeführtes Programm mit einem fehlerhaften Exitcode beendet wird. Programme, die mit einem Nullcode beendet werden, werden als erfolgreich betrachtet; Programme, die mit einem Nicht-Nullcode beendet werden, werden hingegen als fehlerhaft betrachtet. Als Beispiel kann dieses Muster nützlich sein, wenn wir eine Ausnahme auslösen möchten für den Fall, dass wir git ls-files in einem Verzeichnis ausführen, das in Wahrheit kein git-Repository ist.

      Wir können das Schlüsselwortargument check=True nutzen, damit für subprocess.run eine Ausnahme ausgelöst wird, wenn das externe Programm einen Nicht-Null-Exitcode zurückgibt:

      import subprocess
      import sys
      
      result = subprocess.run([sys.executable, "-c", "raise ValueError('oops')"], check=True)
      

      Wenn wir diesen Code ausführen, erhalten wir eine Ausgabe wie die folgende:

      Output

      Traceback (most recent call last): File "<string>", line 1, in <module> ValueError: oops Traceback (most recent call last): File "<stdin>", line 1, in <module> File "/usr/local/lib/python3.8/subprocess.py", line 512, in run raise CalledProcessError(retcode, process.args, subprocess.CalledProcessError: Command '['/usr/local/bin/python', '-c', "raise ValueError('oops')"]' returned non-zero exit status 1.

      Diese Ausgabe zeigt, dass wir einen Unterprozess ausgeführt haben, der einen Fehler ausgelöst hat, der in unserem Terminal in stderr ausgegeben wird. Dann hat subprocess.run in unserem Namen in unserem zentralen Python-Programm ordnungsgemäß einen subprocess.CalledProcessError ausgelöst.

      Alternativ enthält das subprocess-Modul auch die Methode subprocess.CompletedProcess.check_returncode, die wir mit ähnlicher Wirkung aufrufen können:

      import subprocess
      import sys
      
      result = subprocess.run([sys.executable, "-c", "raise ValueError('oops')"])
      result.check_returncode()
      

      Wenn wir diesen Code ausführen, erhalten wir:

      Output

      Traceback (most recent call last): File "<string>", line 1, in <module> ValueError: oops Traceback (most recent call last): File "<stdin>", line 1, in <module> File "/usr/local/lib/python3.8/subprocess.py", line 444, in check_returncode raise CalledProcessError(self.returncode, self.args, self.stdout, subprocess.CalledProcessError: Command '['/usr/local/bin/python', '-c', "raise ValueError('oops')"]' returned non-zero exit status 1.

      Da wir check=True nicht an subprocess.run übergeben haben, haben wir eine subprocess.CompletedProcess-Instanz erfolgreich an result gebunden, obwohl unser Programm mit einem Nicht-Nullcode beendet wurde. Ein Aufruf von result.check_returncode() löst jedoch einen subprocess.CalledProcessError aus, da erkannt wird, dass der abgeschlossene Prozess mit einem fehlerhaften Code beendet wurde.

      Verwenden von Timeouts zum frühzeitigen Beenden von Programmen

      subprocess.run enthält das timeout-Argument, sodass Sie ein externes Programm anhalten können, wenn dessen Ausführung zu lange dauert:

      import subprocess
      import sys
      
      result = subprocess.run([sys.executable, "-c", "import time; time.sleep(2)"], timeout=1)
      

      Wenn wir diesen Code ausführen, erhalten wir eine Ausgabe wie die folgende:

      Output

      Traceback (most recent call last): File "<stdin>", line 1, in <module> File "/usr/local/lib/python3.8/subprocess.py", line 491, in run stdout, stderr = process.communicate(input, timeout=timeout) File "/usr/local/lib/python3.8/subprocess.py", line 1024, in communicate stdout, stderr = self._communicate(input, endtime, timeout) File "/usr/local/lib/python3.8/subprocess.py", line 1892, in _communicate self.wait(timeout=self._remaining_time(endtime)) File "/usr/local/lib/python3.8/subprocess.py", line 1079, in wait return self._wait(timeout=timeout) File "/usr/local/lib/python3.8/subprocess.py", line 1796, in _wait raise TimeoutExpired(self.args, timeout) subprocess.TimeoutExpired: Command '['/usr/local/bin/python', '-c', 'import time; time.sleep(2)']' timed out after 0.9997982999999522 seconds

      Der Unterprozess, den wir ausführen wollten, verwendet die Funktion time.sleep, um für 2 Sekunden zu schlafen. Wir haben jedoch das Schlüsselwortargument timeout=1 an subprocess.run übergeben, um bei unserem Unterprozess nach 1 Sekunde für ein Timeout zu sorgen. Das erklärt, warum unser Aufruf an subprocess.run letztlich eine subprocess.TimeoutExpired-Ausnahme ausgelöst hat.

      Beachten Sie, dass das Schlüsselwortargument timeout für subprocess.run ungefähr ist. Python wird sich bemühen, den Unterprozess nach der timeout-Zahl von Sekunden zu beenden; der Vorgang wird jedoch nicht unbedingt genau sein.

      Übergeben von Eingaben an Programme

      Manchmal erwarten Programme, dass Eingaben über stdin an sie übergeben werden.

      Das Schlüsselwortargument input an subprocess.run ermöglicht Ihnen, Daten an stdin des Unterprozesses zu übergeben. Beispiel:

      import subprocess
      import sys
      
      result = subprocess.run(
          [sys.executable, "-c", "import sys; print(sys.stdin.read())"], input=b"underwater"
      )
      

      Nach Ausführung dieses Codes erhalten wir eine Ausgabe wie die folgende:

      Output

      underwater

      In diesem Fall haben wir die Bytes underwater an input übergeben. Unser Zielunterprozess hat sys.stdin verwendet, um das übergebene stdin (underwater) zu lesen und in unserer Ausgabe auszugeben.

      Das Schlüsselwortargument input kann nützlich sein, wenn Sie mehrere subprocess.run-Aufrufe verketten möchten, um die Ausgabe eines Programms als Eingabe an ein anderes zu übergeben.

      Zusammenfassung

      Das subprocess-Modul ist ein leistungsfähiger Bestandeil der Python-Standardbibliothek, mit dem Sie externe Programme ausführen und deren Ausgaben bequem überprüfen können. In diesem Tutorial haben Sie gelernt, wie Sie subprocess.run verwenden können, um externe Programme zu steuern, Eingaben an sie zu übergeben, ihre Ausgabe zu analysieren und ihre Rückgabecodes zu überprüfen.

      Das subprocess-Modul macht zusätzliche Klassen und Dienstprogramme verfügbar, auf die wir in diesem Tutorial nicht eingegangen sind. Nachdem Sie nun über Grundkenntnisse verfügen, können Sie die Dokumentation des subprocess-Moduls nutzen, um mehr über andere verfügbare Klassen und Dienstprogramme zu erfahren.



      Source link