Où dois-je utiliser isset () et! Empty ()

J'ai lu quelque part que la isset()fonction traite une chaîne vide comme TRUE, par conséquent, ce isset()n'est pas un moyen efficace de valider les entrées de texte et les zones de texte à partir d'un formulaire HTML.

Vous pouvez donc utiliser empty()pour vérifier qu'un utilisateur a tapé quelque chose.

1. Est-il vrai que la isset()fonction traite une chaîne vide comme TRUE?

2. Alors dans quelles situations dois-je utiliser isset()? Dois-je toujours utiliser !empty()pour vérifier s'il y a quelque chose?

Par exemple au lieu de

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

Utiliser ceci

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

isset vs! vide

FTA:

"isset () vérifie si une variable a une valeur comprenant (False, 0 ou chaîne vide), mais pas NULL. Renvoie TRUE si var existe; FALSE sinon.

D'autre part, la fonction empty () vérifie si la variable a une valeur vide chaîne vide, 0, NULL ou False. Renvoie FALSE si var a une valeur non vide et non nulle. "

De la manière la plus générale:

• issetteste si une variable (ou un élément d'un tableau, ou une propriété d'un objet) existe (et n'est pas nulle)
• empty teste si une variable (...) contient des données non vides.

Pour répondre à la question 1 :

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

donne

boolean true

Parce que la variable $strexiste.

Et question 2 :

Vous devez utiliser isset pour déterminer si une variable existe ; par exemple, si vous obtenez des données sous forme de tableau, vous devrez peut-être vérifier si une clé est définie dans ce tableau.
Pensez à $_GET/ $_POST, par exemple.

Maintenant, travailler sur sa valeur, quand on sait qu'il y a une telle valeur: c'est le travail de empty.

Aucun des deux n'est un bon moyen de vérifier les entrées valides.

• isset() n'est pas suffisant car - comme cela a déjà été noté - il considère qu'une chaîne vide est une valeur valide.
• ! empty() n'est pas suffisant non plus car il rejette «0», qui pourrait être une valeur valide.

L'utilisation isset()combinée avec une vérification d'égalité par rapport à une chaîne vide est le strict minimum dont vous avez besoin pour vérifier qu'un paramètre entrant a une valeur sans créer de faux négatifs:

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

Mais par "strict minimum", je veux dire exactement cela. Tout ce que le code ci-dessus fait est de déterminer s'il y a une valeur pour $_GET['gender']. Il ne détermine pas si la valeur de $_GET['gender']est valide (par exemple, l'une de ).("Male", "Female","FileNotFound")

Pour cela, voir la réponse de Josh Davis .

issetest destiné à être utilisé uniquement pour les variables et pas uniquement pour les valeurs, ce qui isset("foobar")entraînera une erreur. Depuis PHP 5.5, emptyprend en charge à la fois les variables et les expressions.

Donc, votre première question devrait plutôt être si issetrenvoie true pour une variable contenant une chaîne vide. Et la réponse est:

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

Les tableaux de comparaison de types dans le manuel de PHP sont très pratiques pour de telles questions.

issetvérifie essentiellement si une variable a une valeur autre que null puisque les variables non existantes ont toujours la valeur null . emptyest une sorte de compteur issetmais traite également la valeur entière 0et la valeur de chaîne "0"comme vides. (Encore une fois, jetez un œil aux tableaux de comparaison de types .)

Si vous avez un $ _POST ['param'] et supposez qu'il est de type chaîne, alors

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

est identique à

!empty($_POST['param'])

isset () n'est pas un moyen efficace de valider les entrées de texte et les zones de texte à partir d'un formulaire HTML

Vous pouvez réécrire cela comme "isset () n'est pas un moyen de valider l'entrée." Pour valider l'entrée, utilisez l' extension de filtre PHP . filter_has_var()vous dira si la variable existe alors filter_input()qu'elle filtrera et / ou purifiera réellement l'entrée.

Notez que vous n'avez pas à utiliser filter_has_var()avant filter_input()et si vous demandez une variable qui n'est pas définie, filter_input()elle retournera simplement null.

Quand et comment utiliser:

1. isset ()

Vrai pour 0, 1, chaîne vide, une chaîne contenant une valeur, vrai, faux

False pour null

par exemple

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

2. Vide

False pour 1, une chaîne contenant une valeur, true

Vrai pour null, chaîne vide, 0, faux par exemple

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

isset est utilisé pour déterminer si une instance de quelque chose existe, c'est-à-dire si une variable a été instanciée ... il n'est pas concerné par la valeur du paramètre ...

Pascal MARTIN ... +1 ...

empty () ne génère pas d'avertissement si la variable n'existe pas ... par conséquent, isset () est préférable lors du test de l'existence d'une variable lorsque vous avez l'intention de la modifier ...

Il emptysuffit d' utiliser :

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

De plus, si vous voulez une valeur entière, cela peut également valoir la peine de le vérifier intval($variable) !== FALSE.

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

Je suis venu ici à la recherche d'un moyen rapide de vérifier si une variable contient du contenu. Aucune des réponses ici n'a fourni une solution complète, alors la voici:

Il suffit de vérifier si l'entrée est ''ou null, car:

La demande d'URL .../test.php?var=entraîne$_GET['var'] = ''

La demande d'URL .../test.phpentraîne$_GET['var'] = null

isset()renvoie falseuniquement lorsque la variable existe et n'est pas définie sur null, donc si vous l'utilisez, vous obtiendrez truedes chaînes vides ( '').

empty()considère à la fois nullet ''vide, mais il considère également '0'vide, ce qui pose un problème dans certains cas d'utilisation.

Si vous voulez traiter '0'comme vide, utilisez empty(). Sinon, utilisez la vérification suivante:

$var .'' !== ''évalue falseuniquement pour les entrées suivantes:

• ''
• null
• false

J'utilise la vérification suivante pour filtrer également les chaînes avec uniquement des espaces et des sauts de ligne:

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

J'utilise ce qui suit pour éviter les avis, cela vérifie si le var est déclaré sur GET ou POST et avec le préfixe @, vous pouvez vérifier en toute sécurité s'il n'est pas vide et éviter l'avis si le var n'est pas défini:

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

isset () est utilisé pour vérifier si la variable est définie avec la valeur ou non et Empty () est utilisé pour vérifier si une variable donnée est vide ou non.

isset () renvoie true lorsque la variable n'est pas nulle alors que Empty () retourne true si la variable est une chaîne vide.

    $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';
    }

Source: Php.net

isset () teste si une variable est définie et non nulle:

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

empty () peut retourner true lorsque la variable est définie sur certaines valeurs:

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 vide () vs is_null ()

! vide fera l'affaire. si vous avez seulement besoin de vérifier que les données existent ou non, utilisez isset autre vide peut gérer d'autres validations

<?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}

?>