Navigation
 Startseite
 Fachbücher
 Forum
 Webmaster News
 Script Newsletter
 Kontakt
 Script Installation
 Php
 Php Tutorials
 Impressum

Community-Bereich
 kostenlos Registrieren
 Anmelden
 Benutzerliste

Script Datenbank
 Script Archiv
 Script Top 20
 Screenshots
 Testberichte

Suche
 

Unsere Php Scripts
 Counter Script
 Umfrage Script
 Bilder Upload Script
 Terminverwaltung
 Simple PHP Forum
 RSS Grabber

Script Mods
 phpBB Adsense Mode

Tools und Generatoren
 .htpasswd Generator
 md5 Generator
 base64 Generator
 ICQ Generator
 Colorpicker
 Unix timestamp Tool
 TLD Liste
 Webkatalog‑Verzeichnis

Partner
 Sprüche Treff

Artfiles.de
Bietet Serviceorientierte Internetdienstleistungen...
https://www.Artfiles.de
Hosterplus.de
Bekommen Sie Speicherplatz (Webspace), Domains und...
https://www.Hosterplus.de
 
 
 

Eingabe filtern/schützen

Sie befinden sich: Home > Php Tutorial > Eingabe filtern/schützen

Eingabe filtern/schützen


Eintrag am:  29.12.2022
Hits / Besucher:  1212
Sprache:  Deutsch
Kategorie:  Einsteiger Tutorials...
Tutorial Art:  eigenes
Eingetragen von   schubertmedia schubertmedia
 
Beschreibung

filter_input() ist eine PHP-Funktion, die dazu dient, ein Eingabe-Element aus einer externen Quelle zu filtern. Diese ist eine sehr mächtige Funktion, um die Eingabe vor Mysql Injection oder Cross-Site-Scripting-Lücke zu schützen.

Die Syntax der Funktion lautet wie folgt:

filter_input (INPUT_TYPE, VARIABLE_NAME, FILTER_TYPE, FILTER_OPTIONS);

Erklärung der Syntax:

  • INPUT_TYPE: Das ist eine Konstante, die den Ort der externen Quelle spezifiziert, aus der das Eingabe-Element geholt werden soll. Der Wert kann entweder INPUT_GET, INPUT_POST, INPUT_COOKIE, INPUT_SERVER, INPUT_ENV oder INPUT_SESSION sein.

  • VARIABLE_NAME: Dies ist der Name der Variablen, aus der das Eingabe-Element geholt werden soll.

  • FILTER_TYPE: Dies ist der Filter, der verwendet werden soll, um das Eingabe-Element zu filtern. Es kann ein vordefinierter oder ein benutzerdefinierter Filtertyp sein. Eine ausführliche Auflistung der Filtertypen finden Sie unten.

  • FILTER_OPTIONS: Dies sind die Optionen, die an den Filter angehängt werden können. Diese Optionen sind abhängig vom angegebenen Filtertyp.

Die Rückgabewerte der Funktion sind entweder der gefilterte Wert des Eingabe-Elements oder false, wenn das Eingabe-Element nicht gefiltert werden konnte.

Was sind die Eingabetypen von filter_input()?

  • INPUT_GET – Diese Eingabe-Typ stellt eine Variable, die aus einem GET-Anfrage (GET-Parameter) abgerufen wird.

  • INPUT_POST – Dieser Eingabe-Typ stellt eine Variable, die aus einer POST-Anfrage (Formular-Eingabe) abgerufen wird.

  • INPUT_COOKIE – Dieser Eingabe-Typ stellt eine Variable, die aus einem Cookie gelesen wird.

  • INPUT_SERVER – Dieser Eingabe-Typ stellt eine Variable, die aus einem Server-Array abgerufen wird.

  • INPUT_ENV – Dieser Eingabe-Typ stellt eine Variable, die aus den Umgebungsvariablen abgerufen wird.

Was für Filtertypen gibt es von der PHP Funktion: filter_input()?

Es gibt unterschiedliche Filter-Arten: Validierungsfilter, Bereinigungsfilter, Filter-Flags und Andere Filter, welche nachfolgen mithilfe von fiktiven Code-Beispielen erklärt werden.

  • Validierungsfilter:
    • FILTER_VALIDATE_BOOLEAN: Dieser Filter überprüft, ob eine Eingabe einen booleschen Wert enthält. Es wird entweder TRUE oder FALSE zurückgegeben.

      Beispiel:
      <?php
      
      /**
      * Prüfen ob die Variable "isAdult" im $_POST gesetzt ist
      */
      $isAdult = filter_input(INPUT_POST, 'isAdult', FILTER_VALIDATE_BOOLEAN);

      /**
      * Prüfen ob die Variable "isAdult" einen gültigen Boolean Wert enthält
      */
      if ($isAdult === true) {
      echo "Sie sind ein Erwachsener";
      } else {
      echo "Sie sind kein Erwachsener";
      }
      ?>
      Erklärung: Ich prüfe, ob die Variable „isAdult“ im $_POST gesetzt ist. Wenn dies der Fall ist, wird diese Variable in einen Boolean Wert konvertiert. Anschließend wird überprüft, ob der Boolean Wert richtig ist. Wenn dies der Fall ist, wird ein Satz ausgegeben, dass ich ein Erwachsener bin. Andernfalls wird ein Satz ausgegeben, dass ich kein Erwachsener bin.


    • FILTER_VALIDATE_EMAIL: Dieser Filter überprüft, ob eine Eingabe eine gültige E-Mail-Adresse enthält. Wenn die E-Mail-Adresse gültig ist, wird TRUE zurückgegeben.

      Beispiel:
      <?php
      
      $email = filter_input(INPUT_POST, 'email', FILTER_VALIDATE_EMAIL);

      if ($email) {
      echo 'E-Mail-Adresse ist gültig.';
      } else {
      echo 'E-Mail-Adresse ist ungültig.';
      }
      ?>
      Erklärung: In diesem Beispiel verwendet der Code die PHP-Funktion filter_input, um eine E-Mail-Adresse über das INPUT_POST-Element zu überprüfen. Der Filter, der verwendet wird, ist FILTER_VALIDATE_EMAIL, was bedeutet, dass die E-Mail-Adresse auf ein gültiges Format überprüft wird. Wenn die E-Mail-Adresse gültig ist, wird die Nachricht „E-Mail-Adresse ist gültig.“ ausgegeben. Wenn nicht, wird die Nachricht „E-Mail-Adresse ist ungültig.“ ausgegeben.


    • FILTER_VALIDATE_FLOAT: Dieser Filter überprüft, ob eine Eingabe eine gültige Fließkommazahl enthält. Wenn die Eingabe gültig ist, wird der Wert als Fließkommazahl zurückgegeben.

      Beispiel:
      <?php
      
      $float_value = filter_input(INPUT_POST, 'float_value', FILTER_VALIDATE_FLOAT);

      if ($float_value !== false) {
      echo "Der Wert ist eine gültige Fließkommazahl: $float_value";
      } else {
      echo 'Der Wert ist keine gültige Fließkommazahl';
      }
      ?>

      Erklärung: In diesem Code wird die PHP-Funktion filter_input verwendet, um einen Wert einzugeben, der als Eingabe-Typ INPUT_POST definiert ist. Der Filter, der auf den eingegebenen Wert angewendet wird, ist FILTER_VALIDATE_FLOAT, was bedeutet, dass der Wert auf eine gültige Fließkommazahl überprüft wird. Wenn der Wert gültig ist, wird er in der Variablen $float_value gespeichert und eine Nachricht ausgegeben, die besagt, dass der Wert eine gültige Fließkommazahl ist. Andernfalls wird eine Nachricht ausgegeben, die besagt, dass der Wert keine gültige Fließkommazahl ist.

    • FILTER_VALIDATE_INT: Dieser Filter überprüft, ob eine Eingabe einen gültigen Integer-Wert enthält. Wenn die Eingabe gültig ist, wird der Wert als Integer zurückgegeben.

      Beispiel:
      <?php
      
      $int = filter_input(INPUT_POST, 'myint', FILTER_VALIDATE_INT);

      if ($int !== false) {
      echo "Die Variable ist eine gültige Ganzzahl";
      } else {
      echo "Die Variable ist keine gültige Ganzzahl";
      }
      ?>

      Erklärung: In diesem Beispiel wird die Funktion filter_input verwendet, um eine Variable vom Typ INPUT_POST zu validieren. Dabei wird der Filter FILTER_VALIDATE_INT verwendet, um zu überprüfen, ob der Wert der Variable eine gültige Ganzzahl ist. 

      Ist der Wert der Variable gültig, gibt die Funktion filter_input den Wert als Ganzzahl zurück. In diesem Fall wird eine Meldung ausgegeben, die besagt, dass die Variable eine gültige Ganzzahl ist. Ist die Variable hingegen nicht gültig, wird die Funktion false zurückgeben. In diesem Fall wird eine Meldung ausgegeben, die besagt, dass die Variable keine gültige Ganzzahl ist.

    • FILTER_VALIDATE_IP: Dieser Filter überprüft, ob eine Eingabe eine gültige IP-Adresse enthält. Wenn die Eingabe gültig ist, wird die IP-Adresse als String zurückgegeben.

      Beispiel:

      <?php
      
      if (filter_input(INPUT_POST, 'IP_Adresse', FILTER_VALIDATE_IP)) {
      echo "Die IP-Adresse ist gültig!";
      } else {
      echo "Die IP-Adresse ist nicht gültig!";
      }
      ?>

      Erklärung: In dem oben genannten PHP-Code wird die Funktion filter_input mit dem Filter FILTER_VALIDATE_IP und dem Eingabe-Typ INPUT_POST verwendet. Mit dieser Funktion wird überprüft, ob eine bestimmte IP-Adresse gültig ist. Wenn dies der Fall ist, wird eine entsprechende Meldung ausgegeben, andernfalls wird eine andere Meldung ausgegeben.

    • FILTER_VALIDATE_REGEXP: Dieser Filter überprüft, ob eine Eingabe einer angegebenen regulären Expression entspricht. Wenn die Eingabe gültig ist, wird TRUE zurückgegeben.

      Beispiel:
      <?php
      
      $name = filter_input(INPUT_POST, 'name', FILTER_VALIDATE_REGEXP,
      array("options"=>array("regexp"=>"/[A-Za-z]+\s[A-Za-z]+/")));

      if ($name === false) {
      echo 'Der Name ist ungültig.';
      } else {
      echo 'Der Name ist gültig.';
      }
      ?>

      Erklärung: In diesem Beispiel filtert die PHP-Funktion filter_input, die den Eingabe-Typ INPUT_POST verwendet, die Eingabe des Benutzers mit dem Filter: FILTER_VALIDATE_REGEXP. Der Filter überprüft, ob die Eingabe des Benutzers dem regulären Ausdruck „[A-Za-z] + \s [A-Za-z] + /“ entspricht. Wenn die Eingabe des Benutzers dem regulären Ausdruck entspricht, wird der Name als gültig angesehen. Andernfalls wird der Name als ungültig angesehen.

    • FILTER_VALIDATE_URL: Dieser Filter überprüft, ob eine Eingabe eine gültige URL enthält. Wenn die Eingabe gültig ist, wird die URL als String zurückgegeben.

      Beispiel:
      <?php
      
      $url = filter_input(INPUT_POST, 'url', FILTER_VALIDATE_URL);
      if ($url) {
      echo "Die URL ist gültig";
      } else {
      echo "Die URL ist ungültig";
      }
      ?>

      Erklärung: In diesem Beispiel verwendet man die PHP-Funktion filter_input, um die Eingabe, die über INPUT_POST empfangen wurde, mit FILTER_VALIDATE_URL zu validieren. Wenn die Eingabe gültig ist, wird die Nachricht „Die URL ist gültig“ ausgegeben. Andernfalls wird die Nachricht „Die URL ist ungültig“ ausgegeben.

  • Bereinigungsfilter:
    • FILTER_SANITIZE_EMAIL: Dieser Filter entfernt alle ungültigen Zeichen aus einer E-Mail-Adresse.

      Beispiel:
      <?php
      

      /**
      * Beispiel für die Verwendung von filter_input mit
      * dem Filter: FILTER_SANITIZE_EMAIL und dem Eingabe-Typ: INPUT_POST
      */

      /**
      * Eingabe-Typ (INPUT_POST) aus der HTML-Formularfeld-Eingabe
      */
      $email = filter_input(INPUT_POST, 'email', FILTER_SANITIZE_EMAIL);

      /**
      * Prüfen ob eine Eingabe erfolgte
      */
      if ($email) {

      /**
      * Prüfen ob die Eingabe eine gültige E-Mail-Adresse ist
      */
      if (filter_var($email, FILTER_VALIDATE_EMAIL)) {
      // E-Mail-Adresse ist gültig
      echo 'Ihre E-Mail-Adresse ('.$email.') ist gültig';
      } else {
      /** E-Mail-Adresse ist ungültig */
      echo 'Ihre E-Mail-Adresse ('.$email.') ist ungültig';
      }
      } else {
      /** Keine Eingabe */
      echo 'Bitte geben Sie Ihre E-Mail-Adresse ein.';
      }
      ?>

      Erklärung: In diesem Beispiel wird die Funktion filter_input verwendet, um die E-Mail-Adresse eines Benutzers, die als INPUT_POST über ein HTML-Formularfeld übermittelt wird, zu validieren.  Zunächst wird die Variable $email mit der Funktion filter_input initialisiert. filter_input verwendet Filter: FILTER_SANITIZE_EMAIL und den Eingabe-Typ: INPUT_POST, um die E-Mail-Adresse zu überprüfen. Anschließend wird geprüft, ob eine Eingabe erfolgte. Wenn eine Eingabe vorhanden ist, wird filter_var verwendet, um zu überprüfen, ob die E-Mail-Adresse gültig ist. Wenn die E-Mail-Adresse gültig ist, wird eine entsprechende Nachricht angezeigt. Ist die E-Mail-Adresse ungültig, wird eine entsprechende Fehlermeldung angezeigt. Wenn keine Eingabe erfolgt, wird eine entsprechende Aufforderung angezeigt.
    • FILTER_SANITIZE_ENCODED: Dieser Filter entfernt alle Zeichen, die nicht als URL-codierte Zeichen gelesen werden können.

      Beispiel:
      <?php
      

      /**
      * Erhalten der Variablenwert aus der URL
      */
      $name = filter_input(INPUT_GET, 'name', FILTER_SANITIZE_ENCODED);

      /**
      * Prüfen, ob der Wert gesetzt ist
      */
      if ($name !== null) {
      /** Wenn ja, entkodieren und ausgeben */
      echo urldecode($name);
      }
      ?>

      Erklärung: In diesem PHP-Code wird ein Variablenwert aus der URL erhalten und dann überprüft, ob der Wert gesetzt ist. Falls ja, wird er encodiert und dann ausgegeben. Dazu wird die Funktion filter_input verwendet, mit dem Filter: FILTER_SANITIZE_ENCODED und dem Eingabe-Typ INPUT_GET. Diese Funktion erhält als Parameter den Eingabe-Typ, den Variablenwert und den Filter. Der Variablenwert wird dann auf den Filter überprüft und als Ergebnis zurückgegeben. In diesem Fall sorgt der Filter dafür, dass alle Zeichen, die nicht zu einer korrekten URL-Codierung gehören, entfernt werden. Anschließend wird der encodiert Wert ausgegeben.


    • FILTER_SANITIZE_NUMBER_FLOAT: Dieser Filter entfernt alle Zeichen, die nicht als Fließkommazahl gelesen werden können.

      Beispiel:
      <?php
      
      /**
      * Beispiel für filter_input mit FILTER_SANITIZE_NUMBER_FLOAT
      * und INPUT_POST
      */

      /**
      * Prüfen ob ein Formular eingereicht wurde
      */
      if(isset($_POST['submit'])){
      /** Eingabe-Wert aus dem Formular aufnehmen */
      $price = filter_input(INPUT_POST, 'price', FILTER_SANITIZE_NUMBER_FLOAT);

      /** Nach sanitize-Filterung überprüfen,
      ob ein gültiger Wert erhalten wurde */
      if($price){
      /** Der Wert wurde sicher aufgenommen
      und kann nun verwendet werden */
      echo "Der Preis ist " . $price;
      } else {
      /** Der Wert war nicht gültig */
      echo "Bitte geben Sie einen gültigen Preis ein.";
      }
      }
      ?>

      Erklärung: In diesem PHP-Code wird überprüft, ob ein Formular eingereicht wurde. Wenn ja, wird der Eingabe-Wert aus dem Formular mit der filter_input() Funktion aufgenommen. Dazu wird die Eingabe-Art INPUT_POST verwendet und der Filter: FILTER_SANITIZE_NUMBER_FLOAT angewendet, um den eingegebenen Wert zu sanitieren. Anschließend wird überprüft, ob ein gültiger Wert erhalten wurde. Wenn ja, wird der Wert ausgegeben, ansonsten wird eine Fehlermeldung ausgegeben.

    • FILTER_SANITIZE_NUMBER_INT: Dieser Filter entfernt alle Zeichen, die nicht als Integer gelesen werden können.

      Beispiel:
      <?php
      
      /**
      * Beispiel für die Verwendung der filter_input-Funktion mit
      * dem Filter FILTER_SANITIZE_NUMBER_INT und dem
      * Eingabe-Typ INPUT_POST
      */

      /**
      * Prüfen, ob das Formular abgeschickt wurde
      */
      if(isset($_POST['submit'])) {

      /** Variable für die Größe des Formulars */
      $formSize = $_POST['formSize'];

      /** Filterung der Eingabe */
      $cleanFormSize = filter_input(INPUT_POST, 'formSize', FILTER_SANITIZE_NUMBER_INT);

      /** Prüfen, ob die Filterung erfolgreich war */
      if($cleanFormSize !== false) {
      /** Wenn ja, nutze die gefilterte Eingabe */
      echo "Die Größe des Formulars beträgt: ".$cleanFormSize;
      } else {
      /** Wenn nein, gib eine Fehlermeldung aus */
      echo "Die Eingabe war ungültig!";
      }
      }
      ?>

      Erklärung: Der PHP-Code prüft, ob das Formular abgeschickt wurde. Wenn ja, wird die Variable für die Größe des Formulars aus der Eingabe genommen und in eine gefilterte Variable gespeichert. Dazu wird die filter_input-Funktion verwendet, mit dem Filter: FILTER_SANITIZE_NUMBER_INT und dem Eingabe-Typ INPUT_POST. Wenn die Filterung erfolgreich war, wird die gefilterte Eingabe ausgegeben. Wenn nicht, wird eine Fehlermeldung ausgegeben.

    • FILTER_SANITIZE_SPECIAL_CHARS: Dieser Filter wandelt alle Sonderzeichen in HTML-Entitäten um.

      Beispiel:
      <?php
      
      /**
      * Beispiel für filter_input mit dem Filter:
      * FILTER_SANITIZE_SPECIAL_CHARS und dem Eingabe-Typ: INPUT_POST
      */

      if (isset($_POST['username'])) {
      /** Eingabe-Typ INPUT_POST wird verwendet */
      $username = filter_input(INPUT_POST, 'username', FILTER_SANITIZE_SPECIAL_CHARS);
      /** Spezialzeichen werden entfernt */
      echo $username;
      } else {
      echo 'Bitte gib einen Benutzernamen ein.';
      }
      ?>

      Erklärung: In diesem PHP-Code wird geprüft, ob ein Benutzername per POST-Methode übertragen wurde. Falls ja, wird das Filter_input()-Argument verwendet, um Spezialzeichen zu entfernen. Der Eingabe-Typ INPUT_POST und der Filter: FILTER_SANITIZE_SPECIAL_CHARS werden übergeben, um dies zu erreichen. Schließlich wird der Benutzername ausgegeben. Falls kein Benutzername übertragen wurde, wird eine entsprechende Meldung ausgegeben.



    • FILTER_SANITIZE_STRING: Dieser Filter entfernt alle Tags, ungültige Zeichen und entfernt auch Whitespace-Zeichen.

      Beispiel:
      <?php
      

      /** Eingabeparameter definieren */
      $type = INPUT_POST;
      $name = 'username';
      $filter = FILTER_SANITIZE_STRING;
      $options = array(
      'options' => array(
      'default' => '',
      ),
      );

      /** Eingabeparameter verarbeiten */
      $username = filter_input($type, $name, $filter, $options);

      /** Verarbeiteten Eingabeparameter ausgeben */
      echo $username;

      ?>

      Erklärung: In dem oben stehenden PHP-Code wird die Funktion filter_input verwendet, um einen Eingabeparameter zu bearbeiten. Der Eingabeparameter, der bearbeitet wird, ist der Post-Parameter „username“. Der Filter, der auf den Parameter angewendet wird, ist FILTER_SANITIZE_STRING. Außerdem wird ein Standardwert für den Parameter definiert, falls kein Wert vorhanden ist. Nachdem der Eingabeparameter bearbeitet wurde, wird er ausgegeben.

    • FILTER_SANITIZE_URL: Dieser Filter entfernt alle Zeichen, die nicht in einer URL vorkommen.

      Beispiel:
      <?php
      
      /**
      * Erstellen Sie eine Variable, die den Wert festhält,
      * den der Benutzer eingegeben hat
      */
      $user_input = $_GET['url'];

      /**
      * Sanitize die URL mit der filter_input()-Funktion
      */
      $sanitized_url = filter_input(INPUT_GET, 'url', FILTER_SANITIZE_URL);

      //Überprüfen Sie den neuen Wert
      if ($sanitized_url === false) {
      /** Fehler: Der Wert konnte nicht sanitiert werden */
      echo 'Der eingegebene Wert konnte nicht sanitiert werden.';
      } else {
      /** Der Wert wurde erfolgreich sanitiert */
      echo 'Der eingegebene Wert wurde erfolgreich sanitiert: ' . $sanitized_url;
      }

      ?>

       

      Erklärung: In diesem Beispiel werden wir die PHP-Funktion filter_input() verwenden, um die URL, die der Benutzer eingegeben hat, zu sanitieren. Zuerst erstellen wir eine Variable, die den Wert speichert, den der Benutzer in dem GET-Parameter „url“ eingegeben hat. Dann sanitieren wir diesen Wert mit der filter_input()-Funktion. Dazu übergeben wir ihr den Eingabe-Typ INPUT_GET, den Namen des GET-Parameters „url“ und den Filter: FILTER_SANITIZE_URL. Wenn das Sanitize erfolgreich war, wird ein String zurückgegeben, der den sanitierten Wert enthält. Wenn das Sanitize fehlschlägt, wird false zurückgegeben. Am Ende überprüfen wir den neuen Wert, und wenn er erfolgreich sanitiert wurde, geben wir den sanitierten Wert aus.


  • Andere Filter:
    • FILTER_UNSAFE_RAW: Dieser Filter gibt die Eingabe unverändert zurück.

      Beispiel:
      <?php
      

      /**
      * Die Eingabedaten aus dem Formular abfragen
      */
      $input_data = filter_input(INPUT_POST, 'input_data', FILTER_UNSAFE_RAW);

      /**
      * Überprüfen, ob die Eingabe vorhanden und gültig ist
      */
      if ($input_data !== NULL && $input_data !== FALSE) {
      /** Eingabe verarbeiten */
      // ...
      } else {
      /** Fehlermeldung anzeigen */
      echo 'Es ist ein Fehler aufgetreten.';
      }
      ?>

      Erklärung: Dieser PHP-Code verwendet die Funktion filter_input(), um Eingabedaten aus einem Formular abzufragen. Diese Funktion akzeptiert als erstes Argument den Eingabe-Typ (hier INPUT_POST für das Abfragen von Daten, die per POST-Methode übermittelt wurden) und das zweite Argument ist der Name des Eingabefelds, aus dem die Daten abgerufen werden sollen. Das dritte Argument ist der Filter, der auf die Eingaben angewendet werden soll, hier FILTER_UNSAFE_RAW, der die Eingabe nicht überprüft und unverändert zurückgibt.  Der Code überprüft anschließend, ob die Eingabe vorhanden und gültig ist. Wenn die Bedingung erfüllt ist, wird die Eingabe verarbeitet. Wenn nicht, wird eine Fehlermeldung angezeigt.

    • FILTER_CALLBACK: Dieser Filter führt eine Funktion auf der Eingabe aus. Die Funktion muss als Parameter übergeben werden.

      Beispiel:
      <?php
      

      /**
      * Eingabe-Werte in einer Variablen speichern
      */
      $input_post = $_POST['input_value'];

      /**
      * Filter-Callback-Funktion definieren
      */
      $filter_callback = function ($value) {
      /** Nur Zahlen oder Strings erlauben */
      if (is_numeric($value) || is_string($value)) {
      return $value;
      }
      return false;
      };

      /**
      * Filter-Input mit Filter-Callback und Eingabe-Typ
      */
      $filtered_input = filter_input(INPUT_POST, 'input_value',
      FILTER_CALLBACK, array('options' => $filter_callback));

      /**
      * Prüfen, ob Filter-Input einen Wert hat
      */
      if ($filtered_input !== false) {
      /** Filter-Input-Wert verarbeiten */
      echo $filtered_input;
      }

      ?>

      Erklärung: Dieser Code verwendet die PHP-Funktion filter_input() mit dem Filter: FILTER_CALLBACK und dem Eingabe-Typ INPUT_POST. Dadurch wird ein Wert, der über ein Formular an die Skript-Seite gesendet wird, gefiltert. 

      Zunächst wird der über das Formular gesendete Wert in einer Variablen gespeichert. Anschließend wird eine Filter-Callback-Funktion definiert, in der festgelegt wird, dass nur Zahlen oder Strings erlaubt sind. Wenn entweder eine Zahl oder ein String übergeben wird, wird der Wert zurückgegeben. Wird etwas anderes übergeben, wird false zurückgegeben. 

      Als Nächstes wird filter_input() verwendet, um den über das Formular gesendeten Wert zu filtern. Dabei wird der Eingabe-Typ INPUT_POST, der Filter: FILTER_CALLBACK und die Filter-Callback-Funktion als Optionen übergeben. Der gefilterte Wert wird in einer Variablen gespeichert. 

      Zuletzt wird überprüft, ob der gefilterte Wert einen Wert hat (nicht gleich false ist), und wenn ja, wird der gefilterte Wert ausgegeben.



  • Filter-Flags:
    • FILTER_FLAG_ALLOW_OCTAL: Dieser Flag erlaubt es, Oktalzahlen als Eingaben zu akzeptieren.

      Beispiel:
      <?php
      

      /**
      * Eingabe-Typ definieren
      */
      $input_type = INPUT_POST;

      /**
      * Filter definieren
      */
      $filter = FILTER_FLAG_ALLOW_OCTAL;

      /**
      * Variablenname der Eingabe
      */
      $var_name = 'octal_input';

      /**
      * Octal-Wert aus dem POST-Array lesen
      */
      $octal_input = filter_input($input_type, $var_name, $filter);

      /**
      * Prüfen, ob ein gültiger Octal-Wert übergeben wurde
      */
      if ($octal_input !== false) {
      /** Octal-Wert ausgeben */
      echo 'Der übergebene Wert ist: ' . $octal_input;
      } else {
      /** Fehlermeldung ausgeben */
      echo 'Es wurde kein gültiger Octal-Wert übergeben.';
      }
      ?>

      Erklärung: Der obige PHP-Code verwendet die PHP-Funktion filter_input, um einen Octal-Wert aus dem POST-Array zu lesen. Zuerst wird der Eingabe-Typ als INPUT_POST definiert, welcher dann als Parameter der filter_input-Funktion übergeben wird. Als Nächstes definieren wir den Filter als FILTER_FLAG_ALLOW_OCTAL, um sicherzustellen, dass nur Octal-Werte akzeptiert werden. Anschließend wird der Variablenname der Eingabe als „octal_input“ definiert. Dieser Name wird dann auch als zweiter Parameter der filter_input-Funktion übergeben. Der letzte Parameter ist der definierte Filter. Dann wird der Octal-Wert aus dem POST-Array gelesen und in der Variablen $octal_input gespeichert. Nachdem der Wert gelesen wurde, wird überprüft, ob ein gültiger Octal-Wert übergeben wurde. Wenn ja, wird der Wert ausgegeben. Wenn nicht, wird eine Fehlermeldung ausgegeben.

    • FILTER_FLAG_ALLOW_HEX: Dieser Flag erlaubt es, Hexadezimale Eingaben zu akzeptieren.

      Beispiel:
      <?php
      

      /**
      * Filter-Optionen definieren
      */
      $filteroptions = array(
      'flags' => FILTER_FLAG_ALLOW_HEX
      );

      /**
      * Eingabetyp festlegen
      */
      $inputtype = INPUT_POST;

      /**
      * Filter-Input-Funktion ausführen
      */
      $hexstr = filter_input($inputtype, 'hexstr',
      FILTER_SANITIZE_STRING, $filteroptions);

      /**
      * Filter-Ergebnis ausgeben
      */
      echo $hexstr;

      /**
      * Beispiel-Eingabe
      */
      $_POST['hexstr'] = 'ABCDEF0123456789';

      /**
      * Ausgabe: ABCDEF0123456789
      */
      ?>

      Erklärung:  Der oben gezeigte PHP-Code verwendet die filter_input-Funktion, um eine Eingabe auf bestimmte Filterkriterien zu überprüfen. Der Filter, der verwendet wird, ist FILTER_FLAG_ALLOW_HEX, was bedeutet, dass die Eingabe nur hexadezimale Zeichen enthalten darf. Der Eingabe-Typ, der verwendet wird, ist INPUT_POST, was bedeutet, dass die Eingabe über den POST-Request erfolgen muss. Zunächst werden die Filteroptionen definiert, in diesem Fall mit dem Filter-Flag FILTER_FLAG_ALLOW_HEX. Dann wird der Eingabe-Typ festgelegt, in diesem Fall INPUT_POST. Anschließend wird die filter_input-Funktion ausgeführt, in der der Eingabe-Typ, der Parametername des POST-Requests (hexstr) und die Filteroptionen übergeben werden. Das Ergebnis der filter_input-Funktion wird in der Variablen $hexstr gespeichert und schließlich mit echo ausgegeben. Als Beispiel wird die Variable $_POST['hexstr'] mit dem Wert „ABCDEF0123456789“ definiert. Dieser Wert wird durch die filter_input-Funktion überprüft und als Ergebnis wird derselbe Wert ausgegeben: „ABCDEF0123456789“.

    • FILTER_FLAG_STRIP_BACKTICK: Dieser Flag entfernt alle Backticks (`) aus der Eingabe.

      Beispiel:
      <?php
      
      /**
      * Beispiel für die Verwendung von filter_input mit dem Filter
      * FILTER_FLAG_STRIP_BACKTICK und dem Eingabe-Typ INPUT_POST
      */

      /**
      * Erstellen eines Arrays, das die POST-Variablen enthält
      */
      $_POST = array('name' => '`John Doe`');

      /**
      * Verwendung von filter_input mit dem Filter:
      * FILTER_FLAG_STRIP_BACKTICK und dem Eingabe-Typ INPUT_POST
      */
      $name = filter_input(INPUT_POST, 'name', FILTER_FLAG_STRIP_BACKTICK);

      /**
      * Ausgabe des Ergebnis
      */
      echo $name;
      /**
      * Ausgabe: John Doe
      */
      ?>

      Erklärung: In diesem Beispiel wird die PHP-Funktion filter_input() verwendet, um die POST-Variablen zu filtern. Die Funktion akzeptiert drei Parameter: den Eingabe-Typ, den Variablennamen und den Filter. Im Beispiel wird der Eingabe-Typ auf INPUT_POST gesetzt, der Variablenname auf 'name' und der Filter auf FILTER_FLAG_STRIP_BACKTICK. Der FILTER_FLAG_STRIP_BACKTICK-Filter wird verwendet, um die Backticks (`) aus dem eingegebenen Text zu entfernen.  Zuerst wird ein Array erstellt, das die POST-Variablen enthält. Dann wird die filter_input()-Funktion verwendet, um die POST-Variable „name“ zu filtern. Der gefilterte Wert wird in der Variablen $name gespeichert und schließlich wird der gefilterte Wert ausgegeben.

    • FILTER_FLAG_STRIP_LOW: Dieser Flag entfernt alle niedrigwertigen ASCII-Zeichen aus der Eingabe.

      Beispiel:
      <?php
      
      /**
      * Beispiel für filter_input mit dem Filter: FILTER_FLAG_STRIP_LOW
      * und dem Eingabe-Typ INPUT_POST
      */
      $name = filter_input(INPUT_POST, 'name', FILTER_FLAG_STRIP_LOW);

      /**
      * Beispielformular
      */
      echo '<form action="process.php" method="post">';
      echo '<input type="text" name="name" value="LOW\x20STRIP">';
      echo '<input type="submit" value="Absenden">';
      echo '</form>';

      /**
      * In der process.php
      */

      /**
      * Der Name-Wert, der aus dem Formular übergeben wird,
      * wird mit dem filter_input-Befehl überprüft
      */
      $name = filter_input(INPUT_POST, 'name', FILTER_FLAG_STRIP_LOW);

      /**
      * Der Wert $name enthält jetzt den übergebenen Wert "LOW STRIP"
      * ohne die unteren Leerzeichen, also "LOWSTRIP"
      */
      echo $name;
      /**
      * Ausgabe: LOWSTRIP
      */
      ?>

      Erklärung: Der obige PHP-Code verwendet die filter_input-Funktion, um den Inhalt eines Formularfelds zu überprüfen. Der Filter, der verwendet wird, ist FILTER_FLAG_STRIP_LOW, der dafür sorgt, dass alle unteren Leerzeichen entfernt werden. Der Eingabe-Typ, den wir übergeben, ist INPUT_POST, da das Formular über das HTTP-POST-Protokoll übertragen wird.

      Zuerst wird das HTML-Formular erstellt, das ein Textinput-Feld enthält, das den Namen „name“ hat und den Wert „LOW\x20STRIP“ enthält. Dieser Wert enthält ein unteres Leerzeichen, das mit dem Backslash „\“ escapted ist.

      Dann wird der filter_input-Befehl verwendet, um den Inhalt des Formularfelds zu überprüfen. Der Name-Wert, der aus dem Formular übergeben wird, wird überprüft und der Filter: FILTER_FLAG_STRIP_LOW wird verwendet, um alle unteren Leerzeichen zu entfernen. Der Wert $name enthält jetzt den übergebenen Wert „LOW STRIP“ ohne die unteren Leerzeichen, also „LOWSTRIP“.

    • FILTER_FLAG_STRIP_HIGH: Dieser Flag entfernt alle hochwertigen ASCII-Zeichen aus der Eingabe.

      Beispiel:
      <?php 

      /**
      * Hole den Inhalt aus dem Formular-Feld
      * mit dem Namen "message"
      */
      $message = filter_input(INPUT_POST, 'message', FILTER_FLAG_STRIP_HIGH);

      /**
      * Prüfen, ob der Inhalt leer ist
      */
      if (!empty($message)) {
      /** Wenn der Inhalt nicht leer ist, wird er verarbeitet */
      echo "Ihre Nachricht wurde erfolgreich gesendet";
      } else {
      /** Wenn der Inhalt leer ist, wird eine
      Fehlermeldung ausgegeben */
      echo "Bitte geben Sie eine Nachricht ein";
      }
      ?>

      Erklärung: Der oben gezeigte PHP-Code verwendet die Funktion filter_input(), um den Inhalt aus dem Formularfeld mit dem Namen „message“ zu holen. Der Eingabetyp ist INPUT_POST, was bedeutet, dass der Inhalt aus dem Formularfeld kommt. Mit dem Filter: FILTER_FLAG_STRIP_HIGH kann man alle Zeichen ersetzen, die als „hoch“ markiert sind. Wenn der Inhalt nicht leer ist, wird er verarbeitet und die Nachricht wird erfolgreich gesendet, andernfalls wird eine Fehlermeldung ausgegeben.

    • FILTER_FLAG_NO_ENCODE_QUOTES: Dieser Flag verhindert, dass Anführungszeichen in HTML-Entitäten umgewandelt werden.

      Beispiel:
      <?php 
      /**
      * Beispiel für filter_input mit Filter:
      * FILTER_FLAG_NO_ENCODE_QUOTES und INPUT_POST
      */
      $input = filter_input(INPUT_POST, 'inputArray', FILTER_FLAG_NO_ENCODE_QUOTES);
      if($input){
      /** Verarbeitung des übergebenen Strings */
      echo $input;
      }
      ?>

      <form action="<?php echo htmlspecialchars($_SERVER["PHP_SELF"]);?>" method="post">
      <input type="text" name="inputArray" value="This 'string' should not be encoded">
      <input type="submit" value="Senden">
      </form>

      Erklärung: Dieser PHP-Code verwendet die „filter_input“-Funktion, um einen Wert über das HTML-Formular abzufragen. Die Funktion filtert den Wert über den Filter „FILTER_FLAG_NO_ENCODE_QUOTES“ und gibt den Wert des „INPUT_POST“-Parameters „inputArray“ zurück. Der Filter „FILTER_FLAG_NO_ENCODE_QUOTES“ verhindert, dass Anführungszeichen in der Eingabe automatisch encodiert werden. Wenn ein Wert über das Formular gesendet wird, wird er in der Variablen $input gespeichert und die Verarbeitung des Strings beginnt. Am Ende wird der gesendete Wert ausgegeben.

    • FILTER_FLAG_ENCODE_LOW: Dieser Flag wandelt alle niedrigwertigen ASCII-Zeichen in HTML-Entitäten um.

      Beispiel:
      <?php
      
      /**
      * Beispiel für die filter_input() Funktion mit dem Filter:
      * FILTER_FLAG_ENCODE_LOW und dem Eingabe-Typ INPUT_POST
      */

      /**
      * Prüfen, ob ein Formular abgesendet wurde
      */
      if (isset($_POST['submit'])) {
      /** Eingaben aus dem Formular in einer
      Variable speichern */
      $name = $_POST['name'];

      /** Nutzen der filter_input() Funktion,
      um die Variable $name zu filtern */
      $name = filter_input(INPUT_POST, 'name', FILTER_FLAG_ENCODE_LOW);

      // Ausgabe der gefilterten Variable
      echo "Hallo $name";
      }
      ?>

      Erklärung: Der oben stehende PHP-Code prüft, ob ein Formular abgesendet wurde, indem überprüft wird, ob die Variable $_POST['submit'] existiert. Wenn das der Fall ist, wird der Inhalt des Formulars in einer Variable mit dem Namen $name gespeichert.

      Anschließend wird die Funktion filter_input() verwendet, um diese Variable zu filtern. Die Funktion filter_input() verwendet drei Parameter: Den Eingabe-Typ INPUT_POST, den Wert der Variable, die gefiltert werden soll und den Filter: FILTER_FLAG_ENCODE_LOW. Der Filter FILTER_FLAG_ENCODE_LOW kodiert alle Zeichen in der Variablen in einen Low-Level-Format.

      Zuletzt wird die gefilterte Variable ausgegeben, indem der Wert der Variable in eine Ausgabe-Zeichenfolge eingesetzt wird.

    • FILTER_FLAG_ENCODE_HIGH: Dieser Flag wandelt alle hochwertigen ASCII-Zeichen in HTML-Entitäten um.

      Beispiel:
      <?php
      
      /**
      * filter_input mit dem Filter: FILTER_FLAG_ENCODE_HIGH
      * und dem Eingabe-Typ: INPUT_POST
      */

      /** Ein Beispielformular erstellen */
      echo '<form action="test.php" method="POST">';
      echo '<input type="text" name="test" value="test text" />';
      echo '<input type="submit" value="Submit" />';
      echo '</form>';

      /**
      * Wenn der Submit Button geklickt wird, wird das Absenden
      * der Formular-Daten an die test.php Datei übergeben
      */
      if(isset($_POST['submit'])){

      /** Den Inhalt des Formular-Elements mit
      dem Namen 'test' aufnehmen */
      $input_text = filter_input(INPUT_POST, 'test', FILTER_FLAG_ENCODE_HIGH);

      // Den encoded Text ausgeben
      echo $input_text;

      /** Ergebnis: test%20text */
      }
      ?>

      Erklärung: In diesem Beispiel wird die PHP-Funktion filter_input mit dem Filter: FILTER_FLAG_ENCODE_HIGH und dem Eingabe-Typ INPUT_POST verwendet. Diese Funktion ermöglicht es, ein Formular aufzunehmen und den Inhalt, der über das Formular gesendet wird, zu filtern.

      Zuerst wird ein einfaches HTML-Formular erstellt, das ein Textfeld und einen Submit-Button enthält. Wenn der Submit-Button geklickt wird, werden die Formular-Daten an die test.php-Datei übergeben. Dann wird die Funktion filter_input verwendet, um den Inhalt des Formulars mit dem Namen 'test' aufzunehmen. Der Filter: FILTER_FLAG_ENCODE_HIGH codiert den Inhalt, bevor er an die test.php-Datei übergeben wird. Der encoded Text wird dann ausgegeben.

    • FILTER_FLAG_ENCODE_AMP: Dieser Flag wandelt das &-Zeichen in eine HTML-Entität um.

      Beispiel: 
      <?php
      

      /**
      * Ein Array mit POST-Variablen erstellen
      */
      $post_variables = [
      "name" => "John Smith",
      "email" => "john@example.com",
      "message" => "Hello there! & I want to say hi"
      ];

      /**
      * Filter-Einstellungen festlegen
      */
      $filter_options = [
      "options" => [
      "flags" => FILTER_FLAG_ENCODE_AMP
      ]
      ];

      /**
      * Den POST-Wert "message" über
      * die filter_input-Funktion filtern
      */
      $filtered_message = filter_input(INPUT_POST, "message", FILTER_SANITIZE_STRING, $filter_options);

      /**
      * Ausgabe des gefilterten POST-Werts
      */
      echo $filtered_message;

      /**
      * Ausgabe: Hello there! &amp; I want to say hi
      */

      Erklärung: In diesem Beispiel wird die filter_input-Funktion verwendet, um POST-Variablen zu filtern. Zunächst wird ein Array mit drei POST-Variablen erstellt. Danach werden die Filter-Einstellungen festgelegt, die verwendet werden sollen. Der FILTER_FLAG_ENCODE_AMP-Flag gibt an, dass spezielle Zeichen (wie Ampersands) in HTML-Entities umgewandelt werden sollen. Nachdem alle Einstellungen festgelegt sind, wird der POST-Wert „message“ über die filter_input-Funktion gefiltert.

      Die Funktion nimmt drei Argumente an: den Eingabe-Typ (hier INPUT_POST), den Namen der Variablen („message“) und den gewünschten Filter (hier FILTER_SANITIZE_STRING). Als letztes Argument können die Filter-Optionen übergeben werden, die oben definiert wurden. Als Ergebnis wird der gefilterte POST-Wert „message“ ausgegeben. Da der FILTER_FLAG_ENCODE_AMP-Flag gesetzt wurde, wird das Ampersand-Zeichen in eine HTML-Entität umgewandelt, sodass die Ausgabe wie folgt lautet: „Hello there! &amp; I want to say hi“.

 

Tags:

 

Artikel hinzufügen bei: