One place for hosting & domains

      Bearbeiten

      So bearbeiten Sie die Sudoers-Datei


      [*]

      Einführung

      Die Trennung von Berechtigungen ist eines der grundlegenden Sicherheitsparadigmen, die in Linux- und Unix-ähnlichen Betriebssystemen implementiert sind. Normale Benutzer arbeiten mit eingeschränkten Berechtigungen, um den Umfang ihres Einflusses auf ihre eigene Umgebung und nicht auf das breitere Betriebssystem zu reduzieren.

      Ein spezieller Benutzer namens root verfügt über Super-Benutzer-Berechtigungen. Dies ist ein Administratorkonto ohne die Einschränkungen, die für normale Benutzer gelten. Benutzer können Befehle mit Super-Benutzer- oder root-Berechtigungen auf verschiedene Arten ausführen.

      In diesem Artikel wird erläutert, wie Sie root-Berechtigungen korrekt und sicher erhalten. Ein besonderer Schwerpunkt liegt dabei auf der Bearbeitung der Datei /etc/sudoers.

      Wir werden diese Schritte auf einem Ubuntu 20.04-Server ausführen, aber die meisten modernen Linux-Distributionen wie Debian und CentOS sollten auf ähnliche Weise funktionieren.

      In diesem Leitfaden wird davon ausgegangen, dass Sie die hier beschriebene Ersteinrichtung des Servers bereits abgeschlossen haben. Melden Sie sich als regulärer Benutzer ohne root-Berechtigung bei Ihrem Server an und fahren Sie unten fort.

      Hinweis: Dieses Tutorial befasst sich ausführlich mit der Eskalation von Berechtigungen und der sudoers-Datei. Wenn Sie einem Benutzer nur sudo-Berechtigungen hinzufügen möchten, lesen Sie unsere Schnellstart-Tutorials zum Erstellen eines neuen Sudo-fähigen Benutzers für Ubuntu und CentOS.

      So erhalten Sie root-Berechtigungen

      Es gibt drei grundlegende Möglichkeiten, um root-Berechtigungen zu erhalten, die sich in ihrem Entwicklungsstand unterscheiden.

      Anmelden als root-Benutzer

      Die einfachste und unkomplizierteste Methode zum Abrufen von root-Berechtigungen besteht darin, sich direkt als root-Benutzer bei Ihrem Server anzumelden.

      Wenn Sie sich bei einem lokalen Computer anmelden (oder eine Out-of-Band-Konsolenfunktion auf einem virtuellen Server verwenden), geben Sie an der Anmeldeaufforderung root als Benutzernamen ein und geben Sie das root-Passwort ein, wenn Sie dazu aufgefordert werden.

      Wenn Sie sich über SSH anmelden, geben Sie den root-Benutzer vor der IP-Adresse oder dem Domänennamen in Ihrer SSH-Verbindungszeichenfolge an:

      • ssh root@server_domain_or_ip

      Wenn Sie keine SSH-Schlüssel für den root-Benutzer eingerichtet haben, geben Sie das root-Passwort ein, wenn Sie dazu aufgefordert werden.

      Verwenden Sie su, um ein root-Benutzer zu werden

      Die direkte Anmeldung als root-Benutzer wird normalerweise nicht empfohlen, da es einfach ist, das System für nicht administrative Aufgaben zu verwenden, was gefährlich ist.

      Der nächste Weg, um Superuser-Berechtigungen zu erhalten, ermöglicht es Ihnen, jederzeit der root-Benutzer zu werden, wie Sie es benötigen.

      Wir können dies tun, indem wir den Befehl su aufrufen, der für „Ersatzbenutzer“ steht. Geben Sie Folgendes ein, um root-Berechtigungen zu erhalten:

      Sie werden aufgefordert, das Kennwort des root-Benutzers einzugeben. Anschließend werden Sie in eine root-Shell-Sitzung versetzt.

      Wenn Sie die Aufgaben abgeschlossen haben, für die root-Berechtigungen erforderlich sind, kehren Sie zu Ihrer normalen Shell zurück, indem Sie Folgendes eingeben:

      Verwenden Sie sudo, um Befehle als root-Benutzer auszuführen

      Der letzte Weg, um root-Berechtigungen zu erhalten, den wir diskutieren werden, ist mit dem Befehl sudo.

      Mit dem Befehl sudo können Sie einmalige Befehle mit root-Berechtigungen ausführen, ohne eine neue Shell erstellen zu müssen. Es wird wie folgt ausgeführt:

      Im Gegensatz zu su fordert der Befehl sudo das Passwort des aktuellen Benutzers an, nicht das root-Passwort.

      Aufgrund seiner Auswirkungen auf die Sicherheit wird Sudo-Zugriff Benutzern standardmäßig nicht gewährt und muss eingerichtet werden, bevor er ordnungsgemäß funktioniert. In unseren Schnellstart-Tutorials zum Erstellen eines neuen Sudo-fähigen Benutzers für Ubuntu und CentOS erfahren Sie, wie Sie einen Sudo-fähigen Benutzer einrichten.

      Im folgenden Abschnitt werden wir ausführlicher erläutern, wie Sie die Sudo-Konfiguration ändern können.

      Was ist Visudo?

      Der Befehl sudo wird über eine Datei unter /etc/sudoers konfiguriert.

      Warnung: Bearbeiten Sie diese Datei nie mit einem normalen Texteditor! Verwenden Sie stattdessen immer den Befehl visudo!

      Da eine falsche Syntax in der Datei /etc/sudoers zu einem Systembruch führen kann, bei dem es nicht möglich ist, erhöhte Berechtigungen zu erhalten, ist es wichtig, den Befehl visudo zum Bearbeiten der Datei zu verwenden.

      Der Befehl visudo öffnet wie gewohnt einen Texteditor, überprüft jedoch beim Speichern die Syntax der Datei. Dies verhindert, dass Konfigurationsfehler sudo-Vorgänge blockieren. Dies ist möglicherweise Ihre einzige Möglichkeit, root-Berechtigungen zu erhalten.

      Traditionell öffnet visudo die Datei /etc/sudoers mit dem vi-Texteditor. Ubuntu hat visudo jedoch so konfiguriert, dass stattdessen der nano-Texteditor verwendet wird.

      Wenn Sie ihn wieder in vi ändern möchten, geben Sie den folgenden Befehl ein:

      • sudo update-alternatives --config editor

      Output

      There are 4 choices for the alternative editor (providing /usr/bin/editor). Selection Path Priority Status ------------------------------------------------------------ * 0 /bin/nano 40 auto mode 1 /bin/ed -100 manual mode 2 /bin/nano 40 manual mode 3 /usr/bin/vim.basic 30 manual mode 4 /usr/bin/vim.tiny 10 manual mode Press <enter> to keep the current choice[*], or type selection number:

      Wählen Sie die Zaus, die der Auswahl entspricht, die Sie treffen möchten.

      Unter CentOS können Sie diesen Wert ändern, indem Sie Ihrem ~/.bashrc die folgende Zeile hinzufügen:

      • export EDITOR=`which name_of_editor`

      Geben Sie die Datei ein, um die Änderungen zu implementieren:

      Nachdem Sie visudo konfiguriert haben, führen Sie den Befehl aus, um auf die Datei /etc/sudoers zuzugreifen:

      So bearbeiten Sie die Sudoers-Datei

      In Ihrem ausgewählten Texteditor wird die Datei /etc/sudoers angezeigt.

      Ich habe die Datei von Ubuntu 18.04 kopiert und eingefügt, wobei Kommentare entfernt wurden. Die Datei CentOS /etc/sudoers enthält viele weitere Zeilen, von denen einige in diesem Leitfaden nicht behandelt werden.

      /etc/sudoers

      Defaults        env_reset
      Defaults        mail_badpass
      Defaults        secure_path="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/snap/bin"
      
      root    ALL=(ALL:ALL) ALL
      
      %admin ALL=(ALL) ALL
      %sudo   ALL=(ALL:ALL) ALL
      
      #includedir /etc/sudoers.d
      

      Werfen wir einen Blick darauf, was diese Zeilen bewirken.

      Standardzeilen

      In der ersten Zeile „Defaults env_reset“ wird die Terminalumgebung zurückgesetzt, um alle Benutzervariablen zu entfernen. Dies ist eine Sicherheitsmaßnahme, mit der potenziell schädliche Umgebungsvariablen aus der sudo-Sitzung entfernt werden.

      In der zweiten Zeile, wird mit dem Befehl Defaults mail_badpass das System angewiesen, Benachrichtigungen über fehlerhafte sudo-Passwortversuche an den konfigurierten mailto-Benutzer zu senden. Standardmäßig ist dies das root-Konto.

      Die dritte Zeile, die mit „Defaults Secure_path=…“ beginnt, gibt den Pfad an (die Stellen im Dateisystem, nach denen das Betriebssystem nach Anwendungen sucht), die für sudo-Operationen verwendet werden. Dies verhindert, dass Benutzerpfade verwendet werden, was schädlich sein kann.

      Benutzerberechtigungszeilen

      Die vierte Zeile, die die sudo-Berechtigungen des root-Benutzers vorschreibt, unterscheidet sich von den vorhergehenden Zeilen. Schauen wir uns an, was die verschiedenen Felder bedeuten:

      • root ALL=(ALL:ALL) ALL Das erste Feld gibt den Benutzernamen an, für den die Regel gilt (root).

      • root ALL=(ALL:ALL) ALL Das erste „ALL“ gibt an, dass diese Regel für alle Hosts gilt.

      • root ALL=(ALL:ALL) ALL Dieses „ALL“ gibt an, dass der root-Benutzer Befehle wie alle Benutzer ausführen kann.

      • root ALL=(ALL:ALL) ALL Dieses „ALL“ gibt an, dass der root-Benutzer Befehle wie alle Gruppen ausführen kann.

      • root ALL=(ALL:ALL) ALL Das letzte „ALL“ gibt an, dass diese Regeln für alle Befehle gelten.

      Dies bedeutet, dass unser root-Benutzer jeden Befehl mit sudo ausführen kann, solange er sein Passwort angibt.

      Gruppenberechtigungszeilen

      Die nächsten beiden Zeilen ähneln den Benutzerberechtigungszeilen, geben jedoch sudo-Regeln für Gruppen an.

      Namen, die mit % beginnen, geben Gruppennamen an.

      Hier sehen wir, dass die Administratorgruppe jeden Befehl als jeder Benutzer auf jedem Host ausführen kann. Ebenso hat die sudo-Gruppe die gleichen Berechtigungen, kann aber auch wie jede andere Gruppe ausgeführt werden.

      Inklusive Zeile /etc/sudoers.d

      Die letzte Zeile könnte auf den ersten Blick wie ein Kommentar aussehen:

      /etc/sudoers

      . . .
      
      #includedir /etc/sudoers.d
      

      Sie **beginnt mit einem #, das normalerweise einen Kommentar anzeigt. Diese Zeile zeigt jedoch tatsächlich an, dass Dateien im Verzeichnis /etc/sudoers.d ebenfalls bezogen und angewendet werden.

      Dateien in diesem Verzeichnis folgen denselben Regeln wie die Datei /etc/sudoers. Jede Datei, die nicht mit ~ endet und keinen . enthält, wird gelesen und an die sudo-Konfiguration angehängt.

      Dies ist hauptsächlich für Anwendungen gedacht, die die sudo-Berechtigungen bei der Installation ändern möchten. Wenn Sie alle zugehörigen Regeln in einer einzigen Datei im Verzeichnis /etc/sudoers.d ablegen, können Sie leicht erkennen, welche Berechtigungen welchen Konten zugeordnet sind, und Anmeldeinformationen einfach umkehren, ohne die Datei /etc/sudoers direkt bearbeiten zu müssen.

      Wie bei der Datei /etc/sudoers selbst sollten Sie Dateien im Verzeichnis /etc/sudoers.d immer mit visudo bearbeiten. Die Syntax zum Bearbeiten dieser Dateien lautet:

      • sudo visudo -f /etc/sudoers.d/file_to_edit

      So geben Sie einem Benutzer Sudo-Berechtigungen

      Die häufigste Operation, die Benutzer beim Verwalten von sudo-Berechtigungen ausführen möchten, besteht darin, einem neuen Benutzer allgemeinen sudo-Zugriff zu gewähren. Dies ist nützlich, wenn Sie einem Konto vollen Administratorzugriff auf das System gewähren möchten.

      Der einfachste Weg, dies auf einem System zu tun, das mit einer Allzweck-Verwaltungsgruppe wie dem Ubuntu-System in diesem Leitfaden eingerichtet ist, besteht darin, den betreffenden Benutzer zu dieser Gruppe hinzuzufügen.

      Unter Ubuntu 20.04 verfügt die sudo-Gruppe beispielsweise über vollständige Administratorrechte. Wir können einem Benutzer dieselben Berechtigungen gewähren, indem wir ihn der Gruppe wie folgt hinzufügen:

      • sudo usermod -aG sudo username

      Der Befehl gpasswd kann auch verwendet werden:

      • sudo gpasswd -a username sudo

      Beides wird dasselbe bewirken.

      Unter CentOS ist dies normalerweise die wheel-Gruppe anstelle der sudo-Gruppe:

      • sudo usermod -aG wheel username

      Oder unter Verwendung von gpasswd:

      • sudo gpasswd -a username wheel

      Wenn das Hinzufügen des Benutzers zur Gruppe unter CentOS nicht sofort funktioniert, müssen Sie möglicherweise die Datei /etc/sudoers bearbeiten, um den Gruppennamen zu kommentieren:

      /etc/sudoers

      . . .
      %wheel ALL=(ALL) ALL
      . . .
      

      So richten Sie benutzerdefinierte Regeln ein

      Nachdem wir uns mit der allgemeinen Syntax der Datei vertraut gemacht haben, erstellen wir einige neue Regeln.

      So erstellen Sie Alias-Dateien

      Die sudoers-Datei kann einfacher organisiert werden, indem Dinge mit verschiedenen Arten von „Aliases“ gruppiert werden.

      Zum Beispiel können wir drei verschiedene Benutzergruppen mit überlappender Mitgliedschaft erstellen:

      /etc/sudoers

      . . .
      User_Alias      GROUPONE = abby, brent, carl
      User_Alias      GROUPTWO = brent, doris, eric,
      User_Alias      GROUPTHREE = doris, felicia, grant
      . . .
      

      Gruppennamen müssen mit einem Großbuchstaben beginnen. Wir können dann Mitgliedern von GROUPTWO erlauben, die apt-Datenbank zu aktualisieren, indem wir eine Regel wie die folgende erstellen:

      /etc/sudoers

      . . .
      GROUPTWO    ALL = /usr/bin/apt-get update
      . . .
      

      Wenn Sie keinen Benutzer/keine Gruppe angeben, die wie oben ausgeführt werden soll, ist sudo standardmäßig der root-Benutzer.

      Wir können Mitgliedern von GROUPTHREE erlauben, den Computer herunterzufahren und neu zu starten, indem wir einen „Befehls-Alias“ erstellen und diesen in einer Regel für GROUPTHREE verwenden:

      /etc/sudoers

      . . .
      Cmnd_Alias      POWER = /sbin/shutdown, /sbin/halt, /sbin/reboot, /sbin/restart
      GROUPTHREE  ALL = POWER
      . . .
      

      Wir erstellen einen Befehls-Alias namens POWER, der Befehle zum Ausschalten und Neustarten des Computers enthält. Wir erlauben dann den Mitgliedern von GROUPTHREE, diese Befehle auszuführen.

      Wir können auch Aliase „Ausführen als“ erstellen, die den Teil der Regel ersetzen können, der den Benutzer angibt, der den Befehl ausführen soll:

      /etc/sudoers

      . . .
      Runas_Alias     WEB = www-data, apache
      GROUPONE    ALL = (WEB) ALL
      . . .
      

      Auf diese Weise kann jeder, der Mitglied von GROUPONE ist, Befehle als www-Datenbenutzer oder Apache-Benutzer ausführen.

      Denken Sie daran, dass spätere Regeln frühere Regeln überschreiben, wenn ein Konflikt zwischen beiden besteht.

      So sperren Sie Regeln

      Es gibt eine Reihe von Möglichkeiten, wie Sie mehr Kontrolle darüber erlangen können, wie sudo auf einen Anruf reagiert.

      Der dem mlocate-Paket zugeordnete Befehl updateb ist auf einem Einzelbenutzersystem relativ harmlos. Wenn wir Benutzern erlauben möchten, es mit root-Berechtigungen auszuführen, ohne ein Passwort eingeben zu müssen, können wir eine Regel wie die folgende festlegen:

      /etc/sudoers

      . . .
      GROUPONE    ALL = NOPASSWD: /usr/bin/updatedb
      . . .
      

      NOPASSWD ist ein „Tag“, das bedeutet, dass kein Passwort angefordert wird. Es hat einen Begleitbefehl namens PASSWD, der das Standardverhalten ist. Ein Tag ist für den Rest der Regel relevant, es sei denn, es wird später von seinem „Twin“ -Tag außer Kraft gesetzt.

      Zum Beispiel können wir eine Zeile wie diese haben:

      /etc/sudoers

      . . .
      GROUPTWO    ALL = NOPASSWD: /usr/bin/updatedb, PASSWD: /bin/kill
      . . .
      

      Ein weiteres hilfreiches Tag ist NOEXEC, mit dem in bestimmten Programmen gefährliches Verhalten verhindert werden kann.

      Beispielsweise können einige Programme, wie z. B. less, andere Befehle erzeugen, indem man dies über seine Benutzeroberfläche eingibt:

      !command_to_run
      

      Dies führt grundsätzlich jeden Befehl aus, den der Benutzer mit denselben Berechtigungen erteilt, unter denen less ausgeführt wird, was sehr gefährlich sein kann.

      Um dies einzuschränken, könnten wir eine Zeile wie die folgende verwenden:

      /etc/sudoers

      . . .
      username  ALL = NOEXEC: /usr/bin/less
      . . .
      

      Verschiedene Informationen

      Es gibt einige weitere Informationen, die beim Umgang mit sudo nützlich sein können.

      Wenn Sie in der Konfigurationsdatei einen Benutzer oder eine Gruppe als „Ausführen als“ angegeben haben, können Sie Befehle als diese Benutzer mithilfe der Flags -u bzw. -g ausführen:

      • sudo -u run_as_user command
      • sudo -g run_as_group command

      Praktischerweise speichert sudo Ihre Authentifizierungsdaten standardmäßig für einen bestimmten Zeitraum in einem Terminal. Dies bedeutet, dass Sie Ihr Passwort erst erneut eingeben müssen, wenn dieser Timer abgelaufen ist.

      Wenn Sie diesen Timer aus Sicherheitsgründen löschen möchten, wenn Sie mit dem Ausführen von Verwaltungsbefehlen fertig sind, können Sie Folgendes ausführen:

      Wenn Sie andererseits den Befehl sudo „vorbereiten“ möchten, damit Sie später nicht dazu aufgefordert werden, oder Ihren sudo-Mietvertrag erneuern möchten, können Sie jederzeit Folgendes eingeben:

      Sie werden aufgefordert, Ihr Passwort einzugeben, das für spätere sudo-Verwendungen zwischengespeichert wird, bis der sudo-Zeitrahmen abläuft.

      Wenn Sie sich nur fragen, welche Berechtigungen für Ihren Benutzernamen definiert sind, können Sie Folgendes eingeben:

      Dadurch werden alle Regeln in der Datei /etc/sudoers aufgelistet, die für Ihren Benutzer gelten. Dies gibt Ihnen eine gute Vorstellung davon, was Sie mit sudo als Benutzer tun dürfen oder nicht.

      Es gibt viele Fälle, in denen Sie einen Befehl ausführen und dieser fehlschlägt, weil Sie vergessen haben, ihm sudo voranzustellen. Um zu vermeiden, dass Sie den Befehl erneut eingeben müssen, können Sie eine Bash-Funktion nutzen, die „letzten Befehl wiederholen“ bedeutet:

      Das doppelte Ausrufezeichen wiederholt den letzten Befehl. Wir haben sudo vorangestellt, um den nicht privilegierten Befehl schnell in einen privilegierten Befehl umzuwandeln.

      Für ein bisschen Spaß können Sie Ihrer /etc/sudoers-Datei mit visudo die folgende Zeile hinzufügen:

      /etc/sudoers

      . . .
      Defaults    insults
      . . .
      

      Dies führt dazu, dass sudo eine dumme Beleidigung zurückgibt, wenn ein Benutzer ein falsches Passwort für sudo eingibt. Wir können sudo -k verwenden, um das vorherige zwischengespeicherte sudo-Passwort zu löschen und es auszuprobieren:

      Output

      [sudo] password for demo: # enter an incorrect password here to see the results Your mind just hasn't been the same since the electro-shock, has it? [sudo] password for demo: My mind is going. I can feel it.

      Zusammenfassung

      Sie sollten nun ein grundlegendes Verständnis für das Lesen und Ändern der sudoers-Datei und einen Überblick über die verschiedenen Methoden haben, mit denen Sie root-Berechtigungen erhalten können.

      Denken Sie daran, dass Superuser-Berechtigungen regulären Benutzern aus einem bestimmten Grund nicht gewährt werden. Es ist wichtig, dass Sie verstehen, was jeder Befehl tut, den Sie mit root-Berechtigungen ausführen. Übernehmen Sie die Verantwortung nicht leichtfertig. Erfahren Sie, wie Sie diese Tools am besten für Ihren Anwendungsfall verwenden und nicht benötigte Funktionen sperren können.

      [*]
      [*]Source link

      So indizieren, teilen und bearbeiten Sie Zeichenfolgen in JavaScript


      Einführung

      Eine Zeichenfolge ist eine Sequenz von einem oder mehreren Zeichen, die aus Buchstaben, Zahlen oder Symbolen bestehen kann. Auf jedes Zeichen in einer JavaScript-Zeichenfolge kann über eine Indexnummer zugegriffen werden, und allen Zeichenfolgen stehen Methoden und Eigenschaften zur Verfügung.

      In diesem Tutorial lernen wir den Unterschied zwischen Zeichenfolgenprimitiven und dem Zeichenfolgenobjekt kennen, wie Zeichenfolgen indiziert werden, wie auf Zeichen in einer Zeichenfolge zugegriffen wird und welche allgemeinen Eigenschaften und Methoden für Zeichenfolgen verwendet werden.

      Zeichenfolgenprimitive und Zeichenfolgenobjekte

      Zuerst werden wir die beiden Arten von Zeichenfolgen klären. JavaScript unterscheidet zwischen der Zeichenfolgenprimitive, einem unveränderlichen Datentyp und dem Zeichenfolgenobjekt.

      Um den Unterschied zwischen den beiden zu testen, initialisieren wir eine Zeichenfolgenprimitive und ein Zeichenfolgenobjekt.

      // Initializing a new string primitive
      const stringPrimitive="A new string."
      
      // Initializing a new String object
      const stringObject = new String('A new string.')
      

      Wir können den Operator typeof verwenden, um den Typ eines Werts zu bestimmen. Im ersten Beispiel haben wir einer Variable einfach eine Zeichenfolge zugewiesen.

      typeof stringPrimitive
      

      Output

      string

      Im zweiten Beispiel haben wir eine neue Zeichenfolge() verwendet, um ein Zeichenfolgenobjekt zu erstellen und einer Variable zuzuweisen.

      typeof stringObject
      

      Output

      object

      Meistens erstellen Sie Zeichenfolgenprimitive. JavaScript kann auf die integrierten Eigenschaften und Methoden des Zeichenfolgen“objekt-Wrappers zugreifen und diese verwenden, ohne die von Ihnen erstellte Zeichenfolgenprimitive tatsächlich in ein Objekt zu ändern.

      Während dieses Konzepts zunächst etwas anspruchsvoll ist, sollten Sie sich der Unterscheidung zwischen Primitive und Objekt bewusst sein. Im Wesentlichen stehen allen Zeichenfolgen Methoden und Eigenschaften zur Verfügung. Im Hintergrund führt JavaScript bei jedem Aufruf einer Methode oder Eigenschaft eine Konvertierung in ein Objekt und zurück in eine Primitive durch.

      Wie Zeichenfolgen indiziert sind

      Jedes der Zeichen in einer Zeichenfolge entspricht einer Indexnummer, beginnend mit 0.

      Zur Demonstration erstellen wir eine Zeichenfolge mit dem Wert How are you?.

      Howareyou?
      01234567891011

      Das erste Zeichen in der Zeichenfolge ist H, was dem Index 0 entspricht. Das letzte Zeichen ist ?, was 11 entspricht. Die Leerzeichen haben auch einen Index bei 3 und 7.

      Wenn wir auf jedes Zeichen in einer Zeichenfolge zugreifen können, haben wir verschiedene Möglichkeiten, mit Zeichenfolgen zu arbeiten und diese zu bearbeiten.

      Zugriff auf Zeichen

      Wir zeigen Ihnen, wie Sie auf Zeichen und Indizes mit der Zeichenfolge How are you? zugreifen können.

      'How are you?'
      
      

      Mit der quadratischen Klammernotation können wir auf jedes Zeichen in der Zeichenfolge zugreifen.

      'How are you?'[5]
      

      Output

      r

      Wir können auch die charAt()-Methode verwenden, um das Zeichen mit der Indexnummer als Parameter zurückzugeben.

      'How are you?'.charAt(5)
      

      Output

      r

      Alternativ können wir indexOf() verwenden, um die Indexnummer durch die erste Instanz eines Zeichens zurückzugeben.

      'How are you?'.indexOf('o')
      

      Output

      1

      Obwohl „o“ zweimal in der Zeichenfolge How are you? erscheint, erhält indexOf() die erste Instanz.

      lastIndexOf() wird verwendet, um die letzte Instanz zu finden.

      'How are you?'.lastIndexOf('o')
      

      Output

      9

      Für beide Methoden können Sie auch nach mehreren Zeichen in der Zeichenfolge suchen. Sie gibt die Indexnummer des ersten Zeichens in der Instanz zurück.

      'How are you?'.indexOf('are')
      

      Output

      4

      Die slice()-Methode hingegen gibt die Zeichen zwischen zwei Indexnummern zurück. Der erste Parameter ist die Startindexnummer und der zweite Parameter ist die Indexnummer, an der sie enden soll.

      'How are you?'.slice(8, 11)
      

      Output

      you

      Beachten Sie, dass 11 ? ist, aber ? ist nicht Teil der zurückgegebenen Ausgabe. slice() gibt zurück, was zwischen dem letzten Parameter liegt, schließt ihn jedoch nicht ein.

      Wenn ein zweiter Parameter nicht enthalten ist, gibt slice() alles vom Parameter bis zum Ende der Zeichenfolge zurück.

      'How are you?'.slice(8)
      

      Output

      you?

      Zusammenfassend helfen charAt() und slice() dabei, Zeichenfolgenwerte basierend auf Indexnummern zurückzugeben, und indexOf() und lastIndexOf() machen das Gegenteil und geben Indexnummern basierend auf den angegebenen Zeichenfolgen zurück.

      Die Länge einer Zeichenfolge finden

      Mit der Eigenschaft length können wir die Anzahl der Zeichen in einer Zeichenfolge zurückgeben.

      'How are you?'.length
      

      Output

      12

      Denken Sie daran, dass die Eigenschaft length die tatsächliche Anzahl von Zeichen zurückgibt, die mit 1 beginnen, was 12 ergibt, und nicht die endgültige Indexnummer, die bei 0 beginnt und bei 11 endet.

      Konvertieren in Groß- oder Kleinschreibung

      Die beiden integrierten Methoden toUpperCase() und toLowerCase() sind hilfreiche Möglichkeiten, um Text zu formatieren und Textvergleiche in JavaScript zu erstellen.

      toUpperCase() konvertiert alle Zeichen in Großbuchstaben.

      'How are you?'.toUpperCase()
      

      Output

      HOW ARE YOU?

      toLowerCase() konvertiert alle Zeichen in Kleinbuchstaben.

      'How are you?'.toLowerCase()
      

      Output

      how are you?

      Diese beiden Formatierungsmethoden nehmen keine zusätzlichen Parameter.

      Es lohnt sich, zu beachten, dass diese Methoden die ursprüngliche Zeichenfolge nicht ändern.

      Zeichenfolgen teilen

      JavaScript bietet eine sehr nützliche Methode, um eine Zeichenfolge durch ein Zeichen zu teilen und aus den Abschnitten eine neue Anordnung zu erstellen. Wir verwenden die split()-Methode, um die Anordnung durch ein Leerzeichen zu trennen, das durch „“ dargestellt ist.

      const originalString = 'How are you?'
      
      // Split string by whitespace character
      const splitString = originalString.split(' ')
      
      console.log(splitString)
      

      Output

      [ 'How', 'are', 'you?' ]

      Nachdem wir eine neue Anordnung in der splitString-Variablen haben, können wir auf jeden Abschnitt mit einer Indexnummer zugreifen.

      splitString[1]
      

      Output

      are

      Wenn ein leerer Parameter angegeben ist, erstellt split() eine durch Komma getrennte Anordnung mit jedem Zeichen in der Zeichenfolge.

      Durch die Trennung von Zeichenfolgen können Sie bestimmen, wie viele Wörter sich in einer Satz befinden und die Methode als Möglichkeit verwenden, um beispielsweise die Vornamen und die Nachnamen von Leuten zu bestimmen.

      Leerzeichen kürzen

      Die JavaScript-Methode trim() entfernt Leerzeichen an beiden Enden einer Zeichenfolge, jedoch nicht irgendwo dazwischen. Leerzeichen können Tabulatoren oder Leerzeichen sein.

      const tooMuchWhitespace="     How are you?     "
      
      const trimmed = tooMuchWhitespace.trim()
      
      console.log(trimmed)
      

      Output

      How are you?

      Die trim()-Methode ist eine einfache Möglichkeit, die gemeinsame Aufgabe auszuführen, um überschüssige Leerzeichen zu entfernen.

      Zeichenfolgenwerte suchen und ersetzen

      Wir können eine Zeichenfolge nach einem Wert durchsuchen und ihn mithilfe der replace() -Methode durch einen neuen Wert ersetzen. Der erste Parameter ist der zu findende Wert und der zweite Parameter ist der Wert, der ihn ersetzen kann.

      const originalString = 'How are you?'
      
      // Replace the first instance of "How" with "Where"
      const newString = originalString.replace('How', 'Where')
      
      console.log(newString)
      

      Output

      Where are you?

      Wir können nicht nur einen Wert durch einen anderen Zeichenfolgenwert ersetzen, sondern auch reguläre Ausdrücke verwenden, um replace() leistungsfähiger zu machen. Zum Beispiel wirkt sich replace() nur auf den ersten Wert aus, aber wir können das Flag g (global) verwenden, um alle Instanzen eines Werts abzufangen, und das Flag i (ohne Berücksichtigung der Groß- und Kleinschreibung), um Groß- und Kleinschreibung zu ignorieren.

      const originalString =
        "Javascript is a programming language. I'm learning javascript."
      
      // Search string for "javascript" and replace with "JavaScript"
      const newString = originalString.replace(/javascript/gi, 'JavaScript')
      
      console.log(newString)
      

      Output

      JavaScript is a programming language. I'm learning JavaScript.

      Dies ist eine sehr häufige Aufgabe, die reguläre Ausdrücke verwendet. Besuchen Sie Regexr, um weitere Beispiele für RegEx zu üben.

      Zusammenfassung

      Zeichenfolgen sind einer der am häufigsten verwendeten Datentypen, und es gibt eine Menge, was wir mit ihnen tun können.

      In diesem Tutorial haben wir den Unterschied zwischen der Zeichenfolgenprimitive und dem Zeichenfolgenobjekt kennengelernt, wie Zeichenfolgen indiziert werden und wie die integrierten Methoden und Eigenschaften von Zeichenfolgen verwendet werden, um auf Zeichen zuzugreifen, Text zu formatieren und Werte zu suchen und zu ersetzen.

      Eine allgemeinere Übersicht über Zeichenfolgen finden Sie im Lernprogramm „So arbeiten Sie mit Zeichenfolgen in JavaScript“.



      Source link

      So bearbeiten Sie eingehende Anfragedaten in Flask


      Einführung

      Webanwendungen erfordern häufig die Verarbeitung eingehender Anforderungsdaten von Benutzern. Diese Nutzdaten können in Form von Abfragezeichenfolgen, Formulardaten und JSON-Objekten vorliegen. Mit Flask können Sie wie mit jedem anderen Webframework auf die Anforderungsdaten zugreifen.

      In diesem Tutorial erstellen Sie eine Flask-Anwendung mit drei Routen, die entweder Abfragezeichenfolgen, Formulardaten oder JSON-Objekte akzeptieren.

      Voraussetzungen

      Um diesem Tutorial zu folgen, benötigen Sie:

      • Dieses Projekt erfordert die Installation von Python in einer lokalen Umgebung.
      • In diesem Projekt wird Pipenv verwendet, ein produktionsfähiges Tool, mit dem das Beste aus allen Verpackungswelten in die Python-Welt gebracht werden soll. Es nutzt Pipfile, pip und virtualenv in einem einzigen Befehl.
      • Das Herunterladen und Installieren eines Tools wie Postman wird benötigt, um API-Endpunkte zu testen.

      Dieses Tutorial wurde mit Pipenv v2020.11.15, Python v3.9.0 und Flask v1.1.2 verifiziert.

      Einrichten des Projekts

      Um die verschiedenen Verwendungsmöglichkeiten von Anforderungen zu demonstrieren, müssen Sie eine Flask-App erstellen. Obwohl die Beispiel-App eine vereinfachte Struktur für die Ansichtsfunktionen und -routen verwendet, kann das, was Sie in diesem Tutorial lernen, auf jede Methode zum Organisieren Ihrer Ansichten angewendet werden, z. B. auf klassenbasierte Ansichten, Blaupausen oder eine Erweiterung wie Flask-Via.

      Zuerst müssen Sie ein Projektverzeichnis erstellen. Öffnen Sie Ihren Terminal und führen Sie folgenden Befehl aus:

      • mkdir flask_request_example

      Navigieren Sie dann zum neuen Verzeichnis:

      Installieren Sie als nächstes Flask. Öffnen Sie Ihren Terminal und führen Sie folgenden Befehl aus:

      Der Befehl pipenv erstellt eine virtuelle Umgebung für dieses Projekt, eine Pipfile, eine Installations-flask und eine Pipfile.lock.

      Führen Sie den folgenden Befehl aus, um virtualenv des Projekts zu aktivieren:

      Um auf die eingehenden Daten in Flask zuzugreifen, müssen Sie das Anforderungsobjekt verwenden. Das Anforderungsobjekt enthält alle eingehenden Daten aus der Anforderung, einschließlich Mimetyp, Referrer, IP-Adresse, Rohdaten, HTTP-Methode und Überschriften.

      Obwohl alle Informationen, die das Anforderungsobjekt enthält, nützlich sein können, konzentrieren Sie sich für die Zwecke dieses Artikels auf die Daten, die normalerweise direkt vom Aufrufer des Endpunkts bereitgestellt werden.

      Um Zugriff auf das Anforderungsobjekt in Flask zu erhalten, müssen Sie es aus der Flask-Bibliothek importieren:

      from flask import request
      

      Sie können es dann in jeder Ihrer Ansichtsfunktionen verwenden.

      Verwenden Sie Ihren Code-Editor, um eine Datei app.py zu erstellen. Importieren Sie Flask und das Anforderungsobjekt. Und erstellen Sie auch Routen für query-example, form-example und json-example:

      app.py

      # import main Flask class and request object
      from flask import Flask, request
      
      # create the Flask app
      app = Flask(__name__)
      
      @app.route('/query-example')
      def query_example():
          return 'Query String Example'
      
      @app.route('/form-example')
      def form_example():
          return 'Form Data Example'
      
      @app.route('/json-example')
      def json_example():
          return 'JSON Object Example'
      
      if __name__ == '__main__':
          # run app in debug mode on port 5000
          app.run(debug=True, port=5000)
      

      Öffnen Sie als nächstes Ihr Terminal und starten Sie die App mit dem folgenden Befehl:

      Die App wird auf Port 5000 gestartet, sodass Sie jede Route in Ihrem Browser über die folgenden Links anzeigen können:

      http://127.0.0.1:5000/query-example (or localhost:5000/query-example)
      http://127.0.0.1:5000/form-example (or localhost:5000/form-example)
      http://127.0.0.1:5000/json-example (or localhost:5000/json-example)
      

      Der Code erstellt drei Routen und zeigt die Nachrichten „Beispiel für Abfragezeichenfolge“,„Beispiel für Formulardaten“ bzw. „Beispiel für JSON-Objekt“ an.

      Verwenden von Abfrageargumenten

      URL-Argumente, die Sie einer Abfragezeichenfolge hinzufügen, sind eine übliche Methode, um Daten an eine Webanwendung zu übergeben. Beim Surfen im Internet sind Sie wahrscheinlich schon einmal auf eine Abfragezeichenfolge gestoßen.

      Eine Abfragezeichenfolge ähnelt der folgenden:

      example.com?arg1=value1&arg2=value2
      

      Die Abfragezeichenfolge beginnt nach dem Fragezeichen (?) Zeichen:

      example.com?arg1=value1&arg2=value2
      

      Und hat Schlüssel-Wert-Paare, die durch ein kaufmännisches Und (&) getrennt sind:

      example.com?arg1=value1&arg2=value2
      

      Für jedes Paar folgt auf den Schlüssel ein Gleichheitszeichen (=) und dann der Wert.

      arg1 : value1
      arg2 : value2
      

      Abfragezeichenfolgen sind nützlich, um Daten zu übergeben, für die der Benutzer keine Maßnahmen ergreifen muss. Sie können irgendwo in Ihrer App eine Abfragezeichenfolge generieren und an eine URL anhängen. Wenn ein Benutzer eine Anfrage stellt, werden die Daten automatisch für ihn übergeben. Eine Abfragezeichenfolge kann auch von Formularen generiert werden, deren Methode GET ist.

      Fügen wir der Abfragebeispielroute eine Abfragezeichenfolge hinzu. In diesem hypothetischen Beispiel geben Sie den Namen einer Programmiersprache an, die auf dem Bildschirm angezeigt wird. Erstellen Sie einen Schlüssel für „Sprache“ und einen Wert für „Python“:

      http://127.0.0.1:5000/query-example?language=Python
      

      Wenn Sie die App ausführen und zu dieser URL navigieren, wird weiterhin die Meldung „Beispiel für eine Abfragezeichenfolge“ angezeigt.

      Sie müssen den Teil programmieren, der die Abfrageargumente verarbeitet. Dieser Code liest den Schlüssel Sprache durch Verwendung von request.args.get('language') oder request.args.get('language').

      Durch den Aufruf von request.args.get('language') wird die Anwendung weiterhin ausgeführt, wenn der Schlüssel Sprache nicht in der URL vorhanden ist. In diesem Fall ist das Ergebnis der Methode Keine.

      Durch den Aufruf von request.args['language'] gibt die App einen 400-Fehler zurück, wenn der Schlüssel Sprache nicht in der URL vorhanden ist.

      Beim Umgang mit Abfragezeichenfolgen wird empfohlen, request.args.get () zu verwenden, um zu verhindern, dass die App fehlschlägt.

      Lesen wir den Schlüssel Sprache und zeigen ihn als Ausgabe an.

      Ändern Sie die Route query-example in app.py mit dem folgenden Code:

      app.py

      @app.route('/query-example')
      def query_example():
          # if key doesn't exist, returns None
          language = request.args.get('language')
      
          return '''<h1>The language value is: {}</h1>'''.format(language)
      

      Führen Sie dann die App aus und navigieren Sie zur URL:

      http://127.0.0.1:5000/query-example?language=Python
      

      Der Browser sollte die folgende Nachricht anzeigen:

      Output

      The language value is: Python

      Das Argument aus der URL wird der Variable Sprache zugewiesen und dann an den Browser zurückgegeben.

      Um weitere Parameter für Abfragezeichenfolgen hinzuzufügen, können Sie ein kaufmännisches Und und die neuen Schlüssel-Wert-Paare an das Ende der URL anhängen. Erstellen Sie einen Schlüssel für „Framework“ und einen Wert für „Flask“:

      http://127.0.0.1:5000/query-example?language=Python&framework=Flask
      

      Wenn Sie mehr möchten, fügen Sie weiterhin ein kaufmännisches Und und Schlüssel-Wert-Paare hinzu. Erstellen Sie einen Schlüssel für „Framework“ und einen Wert für „Flask“:

      http://127.0.0.1:5000/query-example?language=Python&framework=Flask&website=DigitalOcean
      

      Um Zugriff auf diese Werte zu erhalten, verwenden Sie weiterhin entweder request.args.get() oder request.args[]. Verwenden wir beide, um zu demonstrieren, was passiert, wenn ein Schlüssel fehlt. Ändern Sie die Route query_example, um den Wert der Ergebnisse in Variablen zu zuweisen und sie dann anzuzeigen:

      @app.route('/query-example')
      def query_example():
          # if key doesn't exist, returns None
          language = request.args.get('language')
      
          # if key doesn't exist, returns a 400, bad request error
          framework = request.args['framework']
      
          # if key doesn't exist, returns None
          website = request.args.get('website')
      
          return '''
                    <h1>The language value is: {}</h1>
                    <h1>The framework value is: {}</h1>
                    <h1>The website value is: {}'''.format(language, framework, website)
      

      Führen Sie dann die App aus und navigieren Sie zur URL:

      http://127.0.0.1:5000/query-example?language=Python&framework=Flask&website=DigitalOcean
      

      Der Browser sollte die folgende Nachricht anzeigen:

      Output

      The language value is: Python The framework value is: Flask The website value is: DigitalOcean

      Entfernen Sie den Schlüssel Sprache aus der URL:

      http://127.0.0.1:5000/query-example?framework=Flask&website=DigitalOcean
      

      Der Browser sollte die folgende Nachricht mit Keine anzeigen, wenn ein Wert nicht für Sprache bereitgestellt wird:

      Output

      The language value is: None The framework value is: Flask The website value is: DigitalOcean

      Entfernen Sie den Schlüssel Framework aus der URL:

      http://127.0.0.1:5000/query-example?language=Python&website=DigitalOcean
      

      Der Browser sollte auf einen Fehler stoßen, da er einen Wert für Framework erwartet:

      Output

      werkzeug.exceptions.BadRequestKeyError werkzeug.exceptions.BadRequestKeyError: 400 Bad Request: The browser (or proxy) sent a request that this server could not understand. KeyError: 'framework'

      Jetzt verstehen Sie den Umgang mit Abfragezeichenfolgen. Fahren wir mit dem nächsten Typ eingehender Daten fort.

      Verwenden von Formulardaten

      Formulardaten stammen aus einem Formular, das als POST-Abfrage an eine Route gesendet wurde. Anstatt die Daten in der URL anzuzeigen (außer in Fällen, in denen das Formular mit einer GET-Abfrage gesendet wird), werden die Formulardaten hinter den Kulissen an die App übergeben. Obwohl Sie die Formulardaten nicht einfach sehen können, die übergeben werden, kann Ihre App sie weiterhin lesen.

      Um dies zu demonstrieren, ändern Sie die Formularbeispielroute in app.py, um sowohl GET- als auch POST-Abfragen zu akzeptieren, und geben Sie ein Formular zurück:

      app.py

      # allow both GET and POST requests
      @app.route('/form-example', methods=['GET', 'POST'])
      def form_example():
          return '''
                    <form method="POST">
                        <div><label>Language: <input type="text" name="language"></label></div>
                        <div><label>Framework: <input type="text" name="framework"></label></div>
                        <input type="submit" value="Submit">
                    </form>'''
      

      Führen Sie dann die App aus und navigieren Sie zur URL:

      http://127.0.0.1:5000/form-example
      

      Der Browser sollte ein Formular mit zwei Eingabefeldern - einem für Sprache und einem für Framework - und eine Senden-Taste übergeben.

      Das Wichtigste, was Sie über dieses Formular wissen müssen, ist, dass es eine POST-Abfrage an dieselbe Route ausführt, die das Formular generiert hat. Die Schlüssel, die in der App gelesen werden, stammen alle aus den Namensattributen in unseren Formulareingaben. In diesem Fall sind Sprache und Framework die Namen der Eingaben, sodass Sie Zugriff auf die in der App haben.

      Innerhalb der Ansichtsfunktion müssen Sie überprüfen, ob die Abfragemethode GET oder POST ist. Wenn es sich um eine GET-Abfrage handelt, können Sie das Formular anzeigen. Wenn es sich um eine POST-Abfrage handelt, möchten Sie die eingehenden Daten verarbeiten.

      Ändern Sie die Route form-example in app.py mit dem folgenden Code:

      app.py

      # allow both GET and POST requests
      @app.route('/form-example', methods=['GET', 'POST'])
      def form_example():
          # handle the POST request
          if request.method == 'POST':
              language = request.form.get('language')
              framework = request.form.get('framework')
              return '''
                        <h1>The language value is: {}</h1>
                        <h1>The framework value is: {}</h1>'''.format(language, framework)
      
          # otherwise handle the GET request
          return '''
                 <form method="POST">
                     <div><label>Language: <input type="text" name="language"></label></div>
                     <div><label>Framework: <input type="text" name="framework"></label></div>
                     <input type="submit" value="Submit">
                 </form>'''
      

      Führen Sie dann die App aus und navigieren Sie zur URL:

      http://127.0.0.1:5000/form-example
      

      Füllen Sie das Feld Sprache mit dem Wert von Python und das Feld Framework mit dem Wert von Flask aus. Drücken Sie dann Senden.

      Der Browser sollte die folgende Nachricht anzeigen:

      Output

      The language value is: Python The framework value is: Flask

      Jetzt verstehen Sie den Umgang mit Formulardaten. Fahren wir mit dem nächsten Typ eingehender Daten fort.

      Verwenden von JSON-Daten

      JSON-Daten werden normalerweise von einem Prozess erstellt, der die Route aufruft.

      Ein Beispiel-JSON-Objekt sieht folgendermaßen aus:

      {
        "language": "Python",
        "framework": "Flask",
        "website": "Scotch",
        "version_info": {
          "python": "3.9.0",
          "flask": "1.1.2"
        },
        "examples": ["query", "form", "json"],
        "boolean_test": true
      }
      

      Diese Struktur kann die Übergabe von viel komplizierteren Daten im Gegensatz zu Abfragezeichenfolgen und Formulardaten ermöglichen. Im Beispiel sehen Sie verschachtelte JSON-Objekte und eine Anordnung von Elementen. Flask kann dieses Format von Daten verarbeiten.

      Ändern Sie die Route form-example in app.py, um POST-Abfragen zu akzeptieren und andere Abfragen wie GET zu ignorieren:

      app.py

      @app.route('/json-example', methods=['POST'])
      def json_example():
          return 'JSON Object Example'
      

      Im Gegensatz zu dem Webbrowser, der für Abfragezeichenfolgen und Formulardaten zum Senden eines JSON-Objekts in diesem Artikel verwendet wird, verwenden Sie Postman, um benutzerdefinierte Anforderungen an URLs zu senden.

      Hinweis: Wenn Sie Hilfe benötigen, um Postman für Abfragen zu navigieren, konsultieren Sie die offizielle Dokumentation.

      Fügen Sie in Postman die URL hinzu und ändern Sie den Typ in POST. Wechseln Sie auf der Registerkarte Body zu raw und wählen Sie JSON aus der Dropdown-Liste aus.

      Diese Einstellungen sind erforderlich, sodass Postman JSON-Daten richtig senden kann und Ihre Flask-App versteht, dass sie JSON empfängt:

      POST http://127.0.0.1:5000/json-example
      Body
      raw JSON
      

      Kopieren Sie als Nächstes das frühere JSON-Beispiel in die Texteingabe.

      Senden Sie die Abfrage und Sie sollten „Beispiel eines JSON-Objekts“ als Antwort erhalten. Das ist ziemlich antiklimatisch, aber zu erwarten, da der Code für die Verarbeitung der JSON-Datenantwort noch nicht geschrieben wurde.

      Um die Daten zu lesen, müssen Sie verstehen, wie Flask JSON-Daten in Python-Datenstrukturen übersetzt:

      • Alles, was ein Objekt ist, wird in ein Python-Diktat konvertiert. {"key": value "} in JSON entspricht somedict['key'], das in Python einen Wert zurückgibt.
      • Eine Anordnung in JSON wird in Python in eine Liste konvertiert. Da die Syntax die gleiche ist, ist hier eine Beispielliste: [1,2,3,4,5]
      • Die Werte in Anführungszeichen im JSON-Objekt werden Zeichenfolgen in Python.
      • Boolean wahr und falsch werden in Python zu Wahr und Falsch.
      • Abschließend werden Zahlen ohne Anführungszeichen in Python zu Zahlen.

      Arbeiten wir nun an dem Code, um die eingehenden JSON-Daten zu lesen.

      Zuerst weisen wir alles aus dem JSON-Objekt mit request.get_json() einer Variable zu.

      request.get_json() konvertiert das JSON-Objekt in Python-Daten. Weisen wir die eingehenden Abfragedaten den Variablen zu, und geben sie zurück, indem wir die folgenden Änderungen an der Route json-example vornehmen:

      app.py

      # GET requests will be blocked
      @app.route('/json-example', methods=['POST'])
      def json_example():
          request_data = request.get_json()
      
          language = request_data['language']
          framework = request_data['framework']
      
          # two keys are needed because of the nested object
          python_version = request_data['version_info']['python']
      
          # an index is needed because of the array
          example = request_data['examples'][0]
      
          boolean_test = request_data['boolean_test']
      
          return '''
                 The language value is: {}
                 The framework value is: {}
                 The Python version is: {}
                 The item at index 0 in the example list is: {}
                 The boolean value is: {}'''.format(language, framework, python_version, example, boolean_test)
      

      Beachten Sie, wie Sie auf Elemente zugreifen, die nicht auf der oberen Ebene sind. ['version']['python'] wird verwendet, da Sie ein verschachteltes Objekt eingeben. Und ['examples'][0] wird verwendet, um auf den 0. Index in der Anordnung der Beispiele zuzugreifen.

      Wenn das mit der Abfrage gesendete JSON-Objekt keinen Schlüssel hat, auf den in Ihrer Ansichtsfunktion zugegriffen wird, wird die Abfrage fehlschlagen. Wenn Sie nicht möchten, dass es fehlschlägt, wenn ein Schlüssel nicht vorhanden ist, müssen Sie überprüfen, ob der Schlüssel vorhanden ist, bevor Sie versuchen, darauf zuzugreifen.

      app.py

      # GET requests will be blocked
      @app.route('/json-example', methods=['POST'])
      def json_example():
          request_data = request.get_json()
      
          language = None
          framework = None
          python_version = None
          example = None
          boolean_test = None
      
          if request_data:
              if 'language' in request_data:
                  language = request_data['language']
      
              if 'framework' in request_data:
                  framework = request_data['framework']
      
              if 'version_info' in request_data:
                  if 'python' in request_data['version_info']:
                      python_version = request_data['version_info']['python']
      
              if 'examples' in request_data:
                  if (type(request_data['examples']) == list) and (len(request_data['examples']) > 0):
                      example = request_data['examples'][0]
      
              if 'boolean_test' in request_data:
                  boolean_test = request_data['boolean_test']
      
          return '''
                 The language value is: {}
                 The framework value is: {}
                 The Python version is: {}
                 The item at index 0 in the example list is: {}
                 The boolean value is: {}'''.format(language, framework, python_version, example, boolean_test)
      

      Führen Sie die App aus und senden Sie die Beispiel-JSON-Abfrage mit Postman. In der Antwort erhalten Sie die folgende Ausgabe:

      Output

      The language value is: Python The framework value is: Flask The Python version is: 3.9 The item at index 0 in the example list is: query The boolean value is: false

      Jetzt verstehen Sie die Verarbeitung von JSON-Objekten.

      Zusammenfassung

      In diesem Artikel haben Sie eine Flask-Anwendung mit drei Routen erstellt, die entweder Abfragezeichenfolgen, Formulardaten oder JSON-Objekte akzeptieren.

      Denken Sie auch daran, dass alle Ansätze die wiederkehrende Überlegung berücksichtigen mussten, ob ein Schlüssel ordnungsgemäß fehlschlägt, wenn ein Schlüssel fehlt.

      Warnung: ein Thema, das in diesem Artikel nicht behandelt wurde, war die Bereinigung von Benutzereingaben. Durch die Bereinigung von Benutzereingaben wird sichergestellt, dass von der Anwendung gelesene Daten nicht unerwartet fehlschlagen oder Sicherheitsmaßnahmen umgehen.

      Wenn Sie mehr über Flask erfahren möchten, lesen Sie unsere Themenseite zu Flask für Übungen und Programmierprojekte.



      Source link