In dove dovrei usare isset () e! Empty ()

Ho letto da qualche parte che la isset()funzione tratta una stringa vuota come TRUE, quindi isset()non è un modo efficace per convalidare input di testo e caselle di testo da un modulo HTML.

Quindi puoi usare empty()per verificare che un utente abbia digitato qualcosa.

1. È vero che la isset()funzione tratta una stringa vuota come TRUE?

2. Allora in quali situazioni dovrei usare isset()? Devo sempre usare !empty()per controllare se c'è qualcosa?

Ad esempio invece di

if(isset($_GET['gender']))...

Usando questo

if(!empty($_GET['gender']))...

isset vs.! vuoto

FTA:

"isset () controlla se una variabile ha un valore che include (False, 0 o stringa vuota), ma non NULL. Restituisce TRUE se var esiste; FALSE altrimenti.

D'altra parte la funzione empty () controlla se la variabile ha un valore vuoto stringa vuota, 0, NULL o False. Restituisce FALSE se var ha un valore non vuoto e diverso da zero. "

Nel modo più generale:

• issetverifica se esiste una variabile (o un elemento di un array o una proprietà di un oggetto) (e non è nulla)
• empty verifica se una variabile (...) contiene alcuni dati non vuoti.

Per rispondere alla domanda 1 :

$str = '';
var_dump(isset($str));

dà

boolean true

Perché la variabile $stresiste.

E domanda 2 :

Dovresti usare isset per determinare se esiste una variabile ; per esempio, se stai ottenendo alcuni dati come array, potresti dover controllare se una chiave è impostata in quell'array.
Pensa a $_GET/ $_POST, per esempio.

Ora, lavorare sul suo valore, quando sai che esiste un tale valore: questo è il lavoro di empty.

Nessuno dei due è un buon modo per verificare la validità di input.

• isset() non è sufficiente perché - come già notato - considera un valore valido una stringa vuota.
• ! empty() non è nemmeno sufficiente perché rifiuta "0", che potrebbe essere un valore valido.

L'uso isset()combinato con un controllo di uguaglianza su una stringa vuota è il minimo indispensabile per verificare che un parametro in entrata abbia un valore senza creare falsi negativi:

if( isset($_GET['gender']) and ($_GET['gender'] != '') )
{
  ...
}

Ma per "minimo indispensabile", intendo esattamente questo. Tutto ciò che il codice precedente fa è determinare se esiste un valore per $_GET['gender']. Esso non determinare se il valore $_GET['gender']è valido (per esempio, uno ).("Male", "Female","FileNotFound")

Per questo, vedi la risposta di Josh Davis .

issetè inteso per essere utilizzato solo per le variabili e non solo per i valori, quindi isset("foobar")solleverà un errore. A partire da PHP 5.5, emptysupporta sia le variabili che le espressioni.

Quindi la tua prima domanda dovrebbe essere piuttosto se issetrestituisce true per una variabile che contiene una stringa vuota. E la risposta è:

$var = "";
var_dump(isset($var));

Le tabelle di confronto dei tipi nel manuale di PHP sono molto utili per queste domande.

issetfondamentalmente controlla se una variabile ha un valore diverso da null poiché le variabili non esistenti hanno sempre il valore null . emptyè una specie di controparte, issetma tratta anche il valore intero 0e il valore della stringa "0"come vuoti. (Di nuovo, dai un'occhiata alle tabelle di confronto dei tipi .)

Se hai un $ _POST ['param'] e presumi che sia di tipo stringa, allora

isset($_POST['param']) && $_POST['param'] != '' && $_POST['param'] != '0'

è identico a

!empty($_POST['param'])

isset () non è un modo efficace per convalidare input di testo e caselle di testo da un modulo HTML

Puoi riscriverlo in quanto "isset () non è un modo per convalidare l'input". Per convalidare l'input, usa l' estensione del filtro di PHP . filter_has_var()ti dirà se la variabile esiste mentre filter_input()effettivamente filtrerà e / o disinfetterà l'input.

Nota che non devi usare filter_has_var()prima di filter_input()e se chiedi una variabile che non è impostata, filter_input()tornerà semplicemente null.

Quando e come usare:

1. è impostato()

Vero per 0, 1, stringa vuota, una stringa contenente un valore, vero, falso

Falso per null

per esempio

$status = 0
if (isset($status)) // True
$status = null 
if (isset($status)) // False

2. Vuoto

False per 1, una stringa contenente un valore, true

Vero per null, stringa vuota, 0, falso ad es

$status = 0
if(empty($status)) // true
$status = 1
if(empty($status)) // False

isset viene utilizzato per determinare se esiste un'istanza di qualcosa, ovvero se una variabile è stata istanziata ... non è interessata al valore del parametro ...

Pascal MARTIN ... +1 ...

empty () non genera un avviso se la variabile non esiste ... quindi, isset () è preferibile quando si verifica l'esistenza di una variabile quando si intende modificarla ...

L'utilizzo emptyè sufficiente:

if(!empty($variable)){
    // Do stuff
}

Inoltre, se desideri un valore intero, potrebbe valere la pena verificarlo intval($variable) !== FALSE.

isset($variable) === (@$variable !== null)
empty($variable) === (@$variable == false)

Sono venuto qui alla ricerca di un modo rapido per verificare se una variabile ha contenuto in essa. Nessuna delle risposte qui ha fornito una soluzione completa, quindi eccola qui:

È sufficiente verificare se l'ingresso è ''o null, perché:

Richiedi .../test.php?var=risultati URL in$_GET['var'] = ''

Richiedi .../test.phprisultati URL in$_GET['var'] = null

isset()restituisce falsesolo quando la variabile esiste e non è impostata su null, quindi se la usi otterrai truestringhe vuote ( '').

empty()considera entrambi nulle ''vuoti, ma considera anche '0'vuoti, il che è un problema in alcuni casi d'uso.

Se vuoi trattare '0'come vuoto, usa empty(). Altrimenti utilizzare il seguente controllo:

$var .'' !== ''restituisce falsesolo per i seguenti input:

• ''
• null
• false

Uso il seguente controllo per filtrare anche le stringhe con solo spazi e interruzioni di riga:

function hasContent($var){
    return trim($var .'') !== '';
}

Uso quanto segue per evitare avvisi, questo controlla se la var è dichiarata su GET o POST e con il prefisso @ puoi tranquillamente controllare se non è vuoto ed evitare l'avviso se la var non è impostata:

if( isset($_GET['var']) && @$_GET['var']!='' ){
    //Is not empty, do something
}

isset () viene utilizzato per verificare se la variabile è impostata con il valore o meno e Empty () viene utilizzato per verificare se una data variabile è vuota o meno.

isset () restituisce true quando la variabile non è nulla mentre Empty () restituisce true se la variabile è una stringa vuota.

    $var = '';
// Evaluates to true because $var is empty
if ( empty($var) ) {
echo '$var is either 0, empty, or not set at all';
}
// Evaluates as true because $var is set
if ( isset($var) ) {
 echo '$var is set even though it is empty';
    }

Fonte: Php.net

isset () verifica se una variabile è impostata e non nulla:

http://us.php.net/manual/en/function.isset.php

empty () può restituire true quando la variabile è impostata su determinati valori:

http://us.php.net/manual/en/function.empty.php

<?php

$the_var = 0;

if (isset($the_var)) {
  echo "set";
} else {
  echo "not set";
}

echo "\n";

if (empty($the_var)) {
  echo "empty";
} else {
  echo "not empty";
}
?>

isset () vs empty () vs is_null ()

! vuoto farà il trucco. se hai bisogno solo di controllare che i dati esistano o meno, usa isset altro vuoto può gestire altre convalide

<?php
$array = [ "name_new" => "print me"];

if (!empty($array['name'])){
   echo $array['name'];
}

//output : {nothing}

////////////////////////////////////////////////////////////////////

$array2 = [ "name" => NULL];

if (!empty($array2['name'])){
   echo $array2['name'];
}

//output : {nothing}

////////////////////////////////////////////////////////////////////

$array3 = [ "name" => ""];

if (!empty($array3['name'])){
   echo $array3['name'];
}

//output : {nothing}  

////////////////////////////////////////////////////////////////////

$array4 = [1,2];

if (!empty($array4['name'])){
   echo $array4['name'];
}

//output : {nothing}

////////////////////////////////////////////////////////////////////

$array5 = [];

if (!empty($array5['name'])){
   echo $array5['name'];
}

//output : {nothing}

?>