Modo migliore per controllare la variabile per stringa nulla o vuota?

Poiché PHP è un linguaggio dinamico qual è il modo migliore per verificare se un campo fornito è vuoto?

Voglio garantire che:

1. null è considerata una stringa vuota
2. una stringa solo spazio bianco è considerata vuota
3. che "0" non è considerato vuoto

Questo è quello che ho finora:

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

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

Ci deve essere un modo più semplice per farlo?

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

Vecchio post ma qualcuno potrebbe averne bisogno come me;)

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

sostituisci $strcon la tua variabile. NULLed ""entrambi restituiscono 0 quando si utilizza strlen.

Usa la funzione empty () di PHP. Le seguenti cose sono considerate vuote

"" (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)

Per ulteriori dettagli, controllare la funzione vuota

Accetterò umilmente se sbaglio, ma ho testato da solo e ho scoperto che quanto segue funziona per testare sia le variabili con valore stringa (0) "" che NULL:

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

Che potrebbe anche essere invertito per verificare il successo in quanto tale:

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

Fai attenzione ai falsi negativi della trim()funzione: esegue un cast-to-string prima del taglio e quindi restituirà ad esempio "Array" se gli passi un array vuoto. Questo potrebbe non essere un problema, a seconda di come elabori i tuoi dati, ma con il codice che fornisci, un campo denominato question[]potrebbe essere fornito nei dati POST e apparire come una stringa non vuota. Invece, suggerirei:

$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

Non esiste un modo migliore, ma poiché si tratta di un'operazione che di solito si esegue abbastanza spesso, è meglio automatizzare il processo.

La maggior parte dei framework offre un modo per rendere semplice l'analisi degli argomenti. Puoi costruire il tuo oggetto per quello. Esempio rapido e sporco:

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 usa questo tipo di zucchero in maniera massiccia.

Ma stai parlando di più di questo, con il tuo "// Gestisci l'errore qui". Stai mescolando 2 lavori: ottenere i dati ed elaborarli. Questo non è affatto lo stesso.

Esistono altri meccanismi che è possibile utilizzare per convalidare i dati. Ancora una volta, i framework possono mostrarti le migliori pratiche.

Crea oggetti che rappresentano i dati del tuo modulo, quindi allega i processi e torna a esso. Sembra molto più lavoro che hackerare uno script PHP veloce (ed è la prima volta), ma è riutilizzabile, flessibile e molto meno soggetto a errori poiché la convalida dei moduli con il solito PHP tende a diventare rapidamente codice spaguetti.

Questo controlla array e stringhe:

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

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

per essere più robusto (tabulazione, ritorno ...), definisco:

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");
}

fonti:

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

Quando si desidera verificare se viene fornito un valore per un campo, quel campo può essere un string, un arrayo non definito. Quindi, è sufficiente quanto segue

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

empty () funzionava per questo, ma il comportamento di empty () è cambiato più volte. Come sempre, i documenti php sono sempre la migliore fonte di comportamento esatto e i commenti su quelle pagine di solito forniscono una buona cronologia delle modifiche nel tempo. Se vuoi verificare la mancanza di proprietà dell'oggetto, un metodo molto difensivo al momento è:

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