Besserer Weg, um Variablen auf null oder leere Zeichenfolge zu überprüfen?

Da PHP eine dynamische Sprache ist, wie kann am besten überprüft werden, ob ein bereitgestelltes Feld leer ist?

Ich möchte sicherstellen, dass:

1. null wird als leere Zeichenfolge betrachtet
2. Eine Zeichenfolge, die nur aus Leerzeichen besteht, wird als leer betrachtet
3. dass "0" nicht als leer betrachtet wird

Das habe ich bisher:

$question = trim($_POST['question']);

if ("" === "$question") {
    // Handle error here
}

Es muss einen einfacheren Weg geben, dies zu tun?

// Function for basic field validation (present and neither empty nor only white space
function IsNullOrEmptyString($str){
    return (!isset($str) || trim($str) === '');
}

Alter Beitrag, aber jemand könnte ihn so brauchen wie ich;)

if (strlen($str) == 0){
do what ever
}

durch $strdeine Variable ersetzen . NULLund ""beide geben bei Verwendung 0 zurück strlen.

Verwenden Sie die leere () Funktion von PHP. Die folgenden Dinge gelten als leer

"" (an empty string)
0 (0 as an integer)
0.0 (0 as a float)
"0" (0 as a string)
NULL
FALSE
array() (an empty array)
$var; (a variable declared, but without a value)

Für weitere Details überprüfen Sie die leere Funktion

Ich werde demütig akzeptieren, wenn ich falsch liege, aber ich habe es selbst getestet und festgestellt, dass das Folgende zum Testen von Variablen mit Zeichenfolgen (0) "" und NULL funktioniert:

if ( $question ) {
  // Handle success here
}

Was auch umgekehrt werden könnte, um den Erfolg als solchen zu testen:

if ( !$question ) {
  // Handle error here
}

Hüten Sie sich vor falschen Negativen aus der trim()Funktion - sie führt vor dem Zuschneiden eine Umwandlung in einen String durch und gibt daher z. B. "Array" zurück, wenn Sie ein leeres Array übergeben. Dies ist möglicherweise kein Problem, je nachdem, wie Sie Ihre Daten verarbeiten. Mit dem von Ihnen angegebenen Code kann jedoch ein Feld mit dem Namen question[]in den POST-Daten angegeben werden und scheint eine nicht leere Zeichenfolge zu sein. Stattdessen würde ich vorschlagen:

$question = $_POST['question'];

if (!is_string || ($question = trim($question))) {
    // Handle error here
}

// If $question was a string, it will have been trimmed by this point

Es gibt keinen besseren Weg, aber da es sich um eine Operation handelt, die Sie normalerweise häufig ausführen, sollten Sie den Prozess besser automatisieren.

Die meisten Frameworks bieten eine Möglichkeit, das Parsen von Argumenten zu einer einfachen Aufgabe zu machen. Sie können dafür ein eigenes Objekt erstellen. Schnelles und schmutziges Beispiel:

class Request
{

    // This is the spirit but you may want to make that cleaner :-)
    function get($key, $default=null, $from=null)
    {
         if ($from) :
             if (isset(${'_'.$from}[$key]));
                return sanitize(${'_'.strtoupper($from)}[$key]); // didn't test that but it should work
         else
             if isset($_REQUEST[$key])
                return sanitize($_REQUEST[$key]);

         return $default;
    }

    // basics. Enforce it with filters according to your needs
    function sanitize($data)
    {
          return addslashes(trim($data));
    }

    // your rules here
    function isEmptyString($data)
    {
        return (trim($data) === "" or $data === null);
    }


    function exists($key) {}

    function setFlash($name, $value) {}

    [...]

}

$request = new Request();
$question= $request->get('question', '', 'post');
print $request->isEmptyString($question);

Symfony verwendet diese Art von Zucker massiv.

Aber Sie sprechen über mehr als das, mit Ihrem "// Fehler hier behandeln". Sie mischen zwei Jobs: Abrufen und Verarbeiten der Daten. Das ist überhaupt nicht dasselbe.

Es gibt andere Mechanismen, mit denen Sie Daten validieren können. Auch hier können Frameworks Ihnen die besten Praktiken zeigen.

Erstellen Sie Objekte, die die Daten Ihres Formulars darstellen, hängen Sie dann Prozesse an und greifen Sie darauf zurück. Es klingt viel mehr Arbeit als das Hacken eines schnellen PHP-Skripts (und es ist das erste Mal), aber es ist wiederverwendbar, flexibel und viel weniger fehleranfällig, da die Formularvalidierung mit normalem PHP schnell zu Spaguetti-Code wird.

Dieser überprüft Arrays und Strings:

function is_set($val) {
  if(is_array($val)) return !empty($val);

  return strlen(trim($val)) ? true : false;
}

Um robuster zu sein (Tabellierung, Rückgabe…), definiere ich:

function is_not_empty_string($str) {
    if (is_string($str) && trim($str, " \t\n\r\0") !== '')
        return true;
    else
        return false;
}

// code to test
$values = array(false, true, null, 'abc', '23', 23, '23.5', 23.5, '', ' ', '0', 0);
foreach ($values as $value) {
    var_export($value);
    if (is_not_empty_string($value)) 
        print(" is a none empty string!\n");
    else
        print(" is not a string or is an empty string\n");
}

Quellen:

• https://www.php.net/manual/en/function.is-string.php
• https://www.php.net/manual/en/function.trim.php

Wenn Sie überprüfen möchten, ob für ein Feld ein Wert angegeben ist, kann dieses Feld a string, an arrayoder undifined sein. Das Folgende ist also genug

function isSet($param)
{
    return (is_array($param) && count($param)) || trim($param) !== '';
}

empty () hat früher dafür gearbeitet, aber das Verhalten von empty () hat sich mehrmals geändert. Wie immer sind die PHP-Dokumente immer die beste Quelle für genaues Verhalten, und die Kommentare auf diesen Seiten bieten normalerweise einen guten Verlauf der Änderungen im Laufe der Zeit. Wenn Sie nach fehlenden Objekteigenschaften suchen möchten, ist derzeit eine sehr defensive Methode:

if (is_object($theObject) && (count(get_object_vars($theObject)) > 0)) {