Je lance un script PHP et continue à recevoir des erreurs telles que:
Remarque: Variable non définie: mon_variable_name dans C: \ wamp \ www \ mypath \ index.php sur la ligne 10
Remarque: Index indéfini: my_index C: \ wamp \ www \ mypath \ index.php sur la ligne 11
Les lignes 10 et 11 ressemblent à ceci:
echo "My variable value is: " . $my_variable_name; echo "My index value is: " . $my_array["my_index"];
Quelle est la signification de ces messages d’erreur?
Pourquoi apparaissent-ils tout d’un coup? J’avais l’habitude d’utiliser ce script depuis des années et je n’ai jamais eu de problème.
Comment puis-je les réparer?
Il s’agit d’une question de référence générale à laquelle les personnes peuvent accéder en double, au lieu d’avoir à expliquer le problème encore et encore. Je pense que cela est nécessaire car la plupart des réponses réelles sur ce sujet sont très spécifiques.
Méta discussion:
- Que peut-on faire à propos des questions répétitives?
- Les «questions de référence» ont-elles un sens?
De la grande sagesse du manuel PHP :
S’appuyer sur la valeur par défaut d’une variable non initialisée est problématique dans le cas de l’inclusion d’un fichier dans un autre qui utilise le même nom de variable. C’est aussi un risque majeur pour la sécurité avec register_globals activé. Une erreur de niveau E_NOTICE est émise en cas d’utilisation de variables non initialisées, mais pas dans le cas de l’ajout d’éléments au tableau non initialisé. La construction du langage isset () peut être utilisée pour détecter si une variable a déjà été initialisée. De plus, la solution de empty () est plus idéale car elle ne génère pas de message d’avertissement ou d’erreur si la variable n’est pas initialisée.
De la documentation PHP :
Aucun avertissement n’est généré si la variable n’existe pas. Cela signifie que empty () est essentiellement l’équivalent concis de ! Isset ($ var) || $ var == false .
Cela signifie que vous ne pouvez utiliser que empty()
pour déterminer si la variable est définie. De plus, elle vérifie la variable par rapport à 0,"",null
.
Exemple:
$o = []; @$var = ["",0,null,1,2,3,$foo,$o['myIndex']]; array_walk($var, function($v) { echo (!isset($v) || $v == false) ? 'true ' : 'false'; echo ' ' . (empty($v) ? 'true' : 'false'); echo "\n"; });
Testez l’extrait ci-dessus dans l’ éditeur en ligne de 3v4l.org
Bien que PHP ne nécessite pas de déclaration de variable, il le recommande pour éviter certaines vulnérabilités ou bogues de sécurité où l’on pourrait oublier de donner une valeur à une variable qui sera utilisée plus tard dans le script. Ce que PHP fait dans le cas de variables non déclarées, c’est une erreur de très faible niveau, E_NOTICE
, qui n’est même pas signalée par défaut, mais le Manuel conseille d’autoriser le développement.
Façons de traiter le problème:
Recommandé: Déclarez vos variables, par exemple lorsque vous essayez d’append une chaîne à une variable indéfinie. Ou utilisez isset()
/ !empty()
isset()
pour vérifier si elles sont déclarées avant de les référencer, comme dans:
//Initializing variable $value = ""; //Initialization value; Examples //"" When you want to append stuff later //0 When you want to add numbers later //isset() $value = isset($_POST['value']) ? $_POST['value'] : ''; //empty() $value = !empty($_POST['value']) ? $_POST['value'] : '';
Cela est devenu beaucoup plus propre à partir de PHP 7.0, maintenant vous pouvez utiliser l’ opérateur null coalesce :
// Null coalesce operator - No need to explicitly initialize the variable. $value = $_POST['value'] ?? '';
Définissez un gestionnaire d’erreur personnalisé pour E_NOTICE et redirigez les messages de la sortie standard (peut-être vers un fichier journal):
set_error_handler('myHandlerForMinorErrors', E_NOTICE | E_STRICT)
Désactiver E_NOTICE du reporting. Un moyen rapide d’exclure juste E_NOTICE
est:
error_reporting( error_reporting() & ~E_NOTICE )
Supprimez l’erreur avec l’ opérateur @ .
Remarque: il est fortement recommandé d’appliquer le point 1.
Cet avis apparaît lorsque vous (ou PHP) essayez d’accéder à un index non défini d’un tableau.
Façons de traiter le problème:
Vérifiez si l’index existe avant d’y accéder. Pour cela, vous pouvez utiliser isset()
ou array_key_exists()
:
//isset() $value = isset($array['my_index']) ? $array['my_index'] : ''; //array_key_exists() $value = array_key_exists('my_index', $array) ? $array['my_index'] : '';
La list()
construction de langage list()
peut générer ceci lorsqu’elle tente d’accéder à un index de tableau qui n’existe pas:
list($a, $b) = array(0 => 'a'); //or list($one, $two) = explode(',', 'test ssortingng');
Deux variables sont utilisées pour accéder à deux éléments de tableau, mais il n’ya qu’un seul élément de tableau, l’index 0
, ce qui générera:
Avis: Décalage non défini: 1
$_GET
$_POST
/ $_GET
/ $_SESSION
Les avis ci-dessus apparaissent souvent lorsque vous travaillez avec $_POST
, $_GET
ou $_SESSION
. Pour $_POST
et $_GET
vous suffit de vérifier si l’index existe ou non avant de les utiliser. Pour $_SESSION
vous devez vous assurer que la session a démarré avec session_start()
et que l’index existe également.
Notez également que les 3 variables sont des superglobales et sont en majuscules.
En relation:
Essayez ces
Q1: cette notification signifie que $ varname n’est pas défini dans la scope actuelle du script.
Q2: L’utilisation des conditions isset (), empty () avant d’utiliser une variable suspecte fonctionne bien.
// recommended solution for recent PHP versions $user_name = $_SESSION['user_name'] ?? ''; // pre-7 PHP versions $user_name = ''; if (!empty($_SESSION['user_name'])) { $user_name = $_SESSION['user_name']; }
Ou, comme solution rapide et sale:
// not the best solution, but works // in your php setting use, it helps hiding site wide notices error_reporting(E_ALL ^ E_NOTICE);
Note sur les sessions:
Lors de l’utilisation de sessions, session_start();
doit être placé dans tous les fichiers en utilisant des sessions.
@
Pour les notifications indésirables et redondantes, il est possible d’utiliser l’ opérateur @
dédié pour « masquer » les messages de variable / index non définis.
$var = @($_GET["optional_param"]);
isset?:
ou ??
super-suppression cependant. Les notifications peuvent toujours être enregistrées. Et on peut ressusciter les notices @
-hidden avec: set_error_handler("var_dump");
if (isset($_POST["shubmit"]))
dans votre code initial. @
ou isset
uniquement après avoir vérifié la fonctionnalité. Réparez d’abord la cause. Pas les avis.
@
est principalement acceptable pour les parameters d’entrée $_GET
/ $_POST
, en particulier s’ils sont optionnels . Et comme cela couvre la majorité de ces questions, développons les causes les plus courantes:
$_GET
/ $_POST
/ $_REQUEST
entrée non définie Lorsque vous rencontrez un index / offset indéfini, la première chose à faire est de vérifier les fautes de frappe:
$count = $_GET["whatnow?"];
Deuxièmement, si l’avis n’a pas de cause évidente, utilisez var_dump
ou print_r
pour vérifier tous les tableaux en entrée pour leur contenu actuel:
var_dump($_GET); var_dump($_POST); //print_r($_REQUEST);
Les deux révéleront si votre script a été invoqué avec le droit ou des parameters du tout.
Alternativey ou utiliser en outre votre navigateur devtools ( F12 ) et inspecter l’onglet réseau pour les demandes et parameters:
Les parameters POST et l’entrée GET seront affichés séparément.
Pour les parameters $_GET
, vous pouvez également jeter un coup d’œil à QUERY_STRING
dans
print_r($_SERVER);
PHP a des règles pour fusionner les noms de parameters non standard dans les superglobales. Apache pourrait aussi réécrire. Vous pouvez également consulter les données $_COOKIES
et les autres en-têtes de requête HTTP fournis.
Plus clairement, regardez la barre d’adresse de votre navigateur pour les parameters GET :
http://example.org/script.php?id=5&sort=desc
Le name=value
paires après le ?
point d’interrogation sont vos parameters de requête (GET). Ainsi, cette URL ne pourrait donner que $_GET["id"]
et $_GET["sort"]
.
Enfin, vérifiez vos déclarations
et , si vous attendez un paramètre mais n’en recevez aucun.
id=
ou title=
ne suffit pas. method=POST
formulaire method=POST
doit remplir $_POST
. method=GET
(ou la laisser) produirait des variables $_GET
. action=script.php?get=param
via $ _GET et les champs method=POST
restants dans $ _POST avec. $_REQUEST['vars']
, qui mappe les parameters GET et POST. Si vous utilisez mod_rewrite, vous devriez alors vérifier le access.log
et activer le RewriteLog
pour déterminer les parameters absents.
$_FILES
$_FILES["formname"]
. enctype=multipart/form-data
method=POST
dans votre déclaration
. $_COOKIE
$_COOKIE
n’est jamais renseigné juste après setcookie()
, mais uniquement sur toute requête HTTP de suivi. Cela signifie que vous testez, évaluez ou imprimez une variable à laquelle vous n’avez encore rien atsortingbué. Cela signifie que vous avez une faute de frappe ou que vous devez d’abord vérifier que la variable a été initialisée. Vérifiez vos chemins logiques, il peut être défini dans un chemin mais pas dans un autre.
Généralement à cause de “mauvaise programmation”, et une possibilité d’erreurs maintenant ou plus tard.
if (isset($varname))
, avant de l’utiliser Je ne voulais pas désactiver les remarques car elles sont utiles, mais je voulais éviter de trop taper.
Ma solution était cette fonction:
function ifexists($varname) { return(isset($$varname)?$varname:null); }
Donc, si je veux faire référence à $ name et echo si existe, j’écris simplement:
=ifexists('name')?>
Pour les éléments de tableau:
function ifexistsidx($var,$index) { return(isset($var[$index])?$var[$index]:null); }
Dans la page si je veux faire référence à $ _REQUEST [‘name’]:
=ifexistsidx($_REQUEST,'name')?>
La meilleure façon d’obtenir une chaîne d’ entrée est la suivante:
$value = filter_input(INPUT_POST, 'value');
Ce one-liner est presque équivalent à:
if (!isset($_POST['value'])) { $value = null; } elseif (is_array($_POST['value'])) { $value = false; } else { $value = $_POST['value']; }
Si vous voulez absolument une valeur de chaîne , comme:
$value = (ssortingng)filter_input(INPUT_POST, 'value');
C’est parce que la variable ‘$ user_location’ n’est pas définie. Si vous utilisez une boucle if à l’intérieur de laquelle vous déclarez la variable ‘$ user_location’, vous devez également avoir une autre boucle et définir la même chose. Par exemple:
$a=10; if($a==5) { $user_location='Paris';} else { } echo $user_location;
Le code ci-dessus créera une erreur car la boucle if n’est pas satisfaite et dans la boucle else ‘$ user_location’ n’a pas été définie. Il a néanmoins été demandé à PHP de faire écho à la variable. Donc, pour modifier le code, vous devez procéder comme suit:
$a=10; if($a==5) { $user_location='Paris';} else { $user_location='SOMETHING OR BLANK'; } echo $user_location;
En réponse à “” Pourquoi apparaissent-ils soudainement? J’ai utilisé ce script pendant des années et je n’ai jamais eu de problème. “
Il est très courant que la plupart des sites fonctionnent sous le “rapport d’erreurs” par défaut “Afficher toutes les erreurs, mais pas les notifications” et “obsolètes” “. Cela sera défini dans php.ini et s’appliquera à tous les sites du serveur. Cela signifie que les “notices” utilisées dans les exemples seront supprimées (masquées) tandis que les autres erreurs, considérées comme plus critiques, seront affichées / enregistrées.
L’autre paramètre critique est que les erreurs peuvent être masquées (ie display_errors
mis à “off” ou “syslog”).
Ce qui est arrivé dans ce cas, c’est que error_reporting
été modifié pour afficher également des avis (selon les exemples) et / ou que les parameters ont été modifiés en display_errors
à l’écran (au lieu de les supprimer / de les enregistrer).
Pourquoi ont-ils changé?
La réponse évidente / la plus simple est que quelqu’un a modifié l’un de ces parameters dans php.ini, ou qu’une version mise à jour de PHP utilise désormais un autre fichier php.ini. C’est le premier endroit à regarder.
Cependant, il est également possible de remplacer ces parameters dans
et n’importe lequel de ces éléments aurait également pu être modifié.
Il ya aussi la complication supplémentaire que la configuration du serveur Web peut activer / désactiver les directives .htaccess, donc si vous avez des directives dans .htaccess qui démarrent / arrêtent soudainement, vous devez vérifier cela.
(.htconf / .htaccess suppose que vous êtes en Apache. Si vous exécutez la ligne de commande, cela ne s’appliquera pas; si vous utilisez IIS ou un autre serveur Web, vous devrez vérifier ces configurations en conséquence)
Résumé
error_reporting
et display_errors
dans php.ini n’ont pas changé ou que vous n’utilisez pas un autre fichier php.ini auparavant. error_reporting
et display_errors
dans .htconf (ou vhosts, etc.) n’ont pas changé error_reporting
et display_errors
dans .htaccess n’ont pas changé error_reporting
et display_errors
ont été définies. la solution rapide consiste à assigner votre variable à null en haut de votre code
$user_location = null;
J’avais l’habitude de maudire cette erreur, mais il peut être utile de vous rappeler d’échapper à la saisie de l’utilisateur.
Par exemple, si vous pensiez que c’était intelligent, le code abrégé:
// Echo whatever the hell this is =$_POST['something']?>
… Réfléchissez encore! Une meilleure solution est:
// If this is set, echo a filtered version =isset($_POST['something']) ? html($_POST['something']) : ''?>
(J’utilise une fonction html()
personnalisée pour échapper des caractères, votre kilométrage peut varier)
J’utilise tous les temps une fonction utile exst () qui déclare automatiquement les variables.
Votre code sera –
$greeting = "Hello, ".exst($user_name, 'Visitor')." from ".exst($user_location); /** * Function exst() - Checks if the variable has been set * (copy/paste it in any place of your code) * * If the variable is set and not empty returns the variable (no transformation) * If the variable is not set or empty, returns the $default value * * @param mixed $var * @param mixed $default * * @return mixed */ function exst( & $var, $default = "") { $t = ""; if ( !isset($var) || !$var ) { if (isset($default) && $default != "") $t = $default; } else { $t = $var; } if (is_ssortingng($t)) $t = sortingm($t); return $t; }
Dans un langage très simple .
L’erreur est que vous utilisez une variable $user_location
qui n’est pas définie plus tôt et qui n’a aucune valeur. Je vous recommande donc de bien vouloir déclarer cette variable avant de l’ utiliser , par exemple:
$user_location = '';
Ou
$user_location = 'Los Angles';
C’est une erreur très courante que vous pouvez rencontrer. Ne vous inquiétez pas, déclarez simplement la variable et appréciez le codage .
En PHP 7.0, il est maintenant possible d’utiliser l’opérateur de coalescence Null:
echo "My index value is: " . ($my_array["my_index"] ?? '');
Égal à:
echo "My index value is: " . (isset($my_array["my_index"]) ? $my_array["my_index"] : '');
Manuel PHP PHP 7.0
pourquoi ne pas garder les choses simples?
Au fil du temps, PHP est devenu un langage plus axé sur la sécurité. Les parameters qui étaient désactivés par défaut sont maintenant activés par défaut. Un exemple parfait est E_STRICT
, qui a été activé par défaut à partir de PHP 5.4.0 .
De plus, selon la documentation PHP, par défaut, E_NOTICE
est désactivé dans php.ini. Les documents PHP recommandent de l’activer à des fins de débogage . Cependant, lorsque je télécharge PHP depuis le repository Ubuntu – et depuis la stack Windows de BitNami -, je vois autre chose.
; Common Values: ; E_ALL (Show all errors, warnings and notices including coding standards.) ; E_ALL & ~E_NOTICE (Show all errors, except for notices) ; E_ALL & ~E_NOTICE & ~E_STRICT (Show all errors, except for notices and coding standards warnings.) ; E_COMPILE_ERROR|E_RECOVERABLE_ERROR|E_ERROR|E_CORE_ERROR (Show only errors) ; Default Value: E_ALL & ~E_NOTICE & ~E_STRICT & ~E_DEPRECATED ; Development Value: E_ALL ; Production Value: E_ALL & ~E_DEPRECATED & ~E_STRICT ; http://php.net/error-reporting error_reporting = E_ALL & ~E_DEPRECATED & ~E_STRICT
Notez que error_reporting
est réellement défini sur la valeur de production par défaut, et non sur la valeur par défaut “default”. Ceci est quelque peu déroutant et n’est pas documenté en dehors de php.ini, donc je ne l’ ai pas validé sur d’autres dissortingbutions.
Pour répondre à votre question, cependant, cette erreur s’affiche dès qu’elle n’a pas été affichée auparavant car:
Vous avez installé PHP et les nouveaux parameters par défaut sont quelque peu mal documentés, mais n’excluez pas E_NOTICE
.
E_NOTICE
avertissements E_NOTICE
tels que les variables non définies et les index non définis aident à rendre votre code plus propre et plus sûr. Je peux vous dire qu’il y a des années, garder E_NOTICE
activé m’a obligé à déclarer mes variables. Cela rend beaucoup plus facile d’apprendre C, où la non-déclaration de variables est beaucoup plus grande d’une nuisance.
Désactivez E_NOTICE
en copiant la “Valeur par défaut” E_ALL & ~E_NOTICE & ~E_STRICT & ~E_DEPRECATED
et en la remplaçant par ce qui n’est pas commenté après le signe égal à error_reporting =
. Redémarrez Apache ou PHP si vous utilisez CGI ou FPM. Assurez-vous que vous éditez le “droit” php.ini. Le bon sera Apache si vous exécutez PHP avec Apache, fpm ou php-fpm si vous utilisez PHP-FPM, cgi si PHP-CGI est en cours d’exécution, etc. Ce n’est pas la méthode recommandée, mais si vous avez un code hérité qui va être extrêmement difficile à modifier, alors ce pourrait être votre meilleur pari.
Désactivez E_NOTICE
au niveau du fichier ou du dossier. Cela pourrait être préférable si vous avez un code hérité, mais que vous voulez faire les choses “autrement”. Pour ce faire, vous devez consulter Apache2, nginx ou tout autre serveur de votre choix. Dans Apache, vous utiliseriez php_value
dans
.
Réécrivez votre code pour qu’il soit plus propre. Si vous devez le faire en vous déplaçant vers un environnement de production ou si vous ne souhaitez pas que vos erreurs soient détectées, assurez-vous de désactiver l’affichage des erreurs et de ne log_errors
que vos erreurs (voir display_errors
et log_errors
dans php.ini et votre parameters du serveur).
Pour développer l’option 3: c’est l’idéal. Si vous pouvez aller dans cette voie, vous devriez. Si vous n’utilisez pas cette route initialement, envisagez de déplacer cette route éventuellement en testant votre code dans un environnement de développement. Pendant que vous y êtes, débarrassez-vous de ~E_STRICT
et de ~E_DEPRECATED
pour voir ce qui pourrait mal tourner à l’avenir. Vous allez voir BEAUCOUP d’erreurs inconnues, mais cela vous empêchera d’avoir des problèmes désagréables lorsque vous aurez besoin de mettre à niveau PHP à l’avenir.
Undefined variable: my_variable_name
– Cela se produit lorsqu’une variable n’a pas été définie avant utilisation. Lorsque le script PHP est exécuté, il prend simplement en interne une valeur nulle. Cependant, dans quel scénario devriez-vous vérifier une variable avant de la définir? En fin de compte, ceci est un argument pour “code bâclé”. En tant que développeur, je peux vous dire que je l’aime lorsque je vois un projet open source dans lequel les variables sont définies aussi haut que possible. Il est plus facile de savoir quelles variables vont apparaître dans le futur et facilite la lecture / apprentissage du code.
function foo() { $my_variable_name = ''; //.... if ($my_variable_name) { // perform some logic } }
Undefined index: my_index
– Cela se produit lorsque vous essayez d’accéder à une valeur dans un tableau et qu’il n’existe pas. Pour éviter cette erreur, effectuez une vérification conditionnelle.
// verbose way - generally better if (isset($my_array['my_index'])) { echo "My index value is: " . $my_array['my_index']; } // non-verbose ternary example - I use this sometimes for small rules. $my_index_val = isset($my_array['my_index'])?$my_array['my_index']:'(undefined)'; echo "My index value is: " . $my_index_val;
Une autre option consiste à déclarer un tableau vide en haut de votre fonction. Ce n’est pas toujours possible.
$my_array = array( 'my_index' => '' ); //... $my_array['my_index'] = 'new ssortingng';
vim
ces jours-ci :). indéfini signifie un index dans un tableau que vous avez demandé pour l’index de tableau indisponible, par exemple
variable non définie signifie que vous avez utilisé une variable complètement inexistante ou qui n’est pas définie ou initialisée par ce nom par exemple
undefined offset signifie dans le tableau que vous avez demandé une clé non existante. Et la solution pour cela est de vérifier avant utilisation
php> echo array_key_exists(1, $myarray);
En ce qui concerne cette partie de la question:
Pourquoi apparaissent-ils tout d’un coup? J’avais l’habitude d’utiliser ce script depuis des années et je n’ai jamais eu de problème.
Pas de réponses précises, mais voici quelques explications possibles sur les raisons pour lesquelles les parameters peuvent “subitement” changer:
Vous avez mis à niveau PHP vers une version plus récente qui peut avoir d’autres valeurs par défaut pour error_reporting, display_errors ou d’autres parameters pertinents.
Vous avez supprimé ou introduit du code (éventuellement dans une dépendance) qui définit les parameters pertinents à l’exécution à l’aide de ini_set()
ou error_reporting()
(recherchez-les dans le code)
Vous avez modifié la configuration du serveur Web (en supposant Apache ici): .htaccess
fichiers .htaccess
et les configurations vhost peuvent également manipuler les parameters php.
Habituellement, les notifications ne sont pas affichées / signalées (voir le manuel PHP ), il est donc possible que lors de la configuration du serveur, le fichier php.ini ne puisse pas être chargé pour une raison quelconque (permissions de fichier ??) et que vous utilisiez les parameters par défaut. . Plus tard, le ‘bug’ a été résolu (par accident) et maintenant, il est possible de charger le fichier php.ini correct avec l’ensemble error_reporting pour afficher les avis.
Si vous travaillez avec des classes, vous devez vous assurer que vous référencez les variables membres en utilisant $this
:
class Person { protected $firstName; protected $lastName; public function setFullName($first, $last) { // Correct $this->firstName = $first; // Incorrect $lastName = $last; // Incorrect $this->$lastName = $last; } }
Une autre raison pour laquelle une notification d’index non définie sera émise serait qu’une colonne a été omise d’une requête de firebase database.
C’est à dire:
$query = "SELECT col1 FROM table WHERE col_x = ?";
Ensuite, essayez d’accéder à plus de colonnes / lignes dans une boucle.
C’est à dire:
print_r($row['col1']); print_r($row['col2']); // undefined index thrown
ou dans une boucle while:
while( $row = fetching_function($query) ) { echo $row['col1']; echo "
"; echo $row['col2']; // undefined index thrown echo "
"; echo $row['col3']; // undefined index thrown }
Il faut également noter que sur un système d’exploitation * NIX et Mac OS X, les choses sont sensibles à la casse.
Consultez les questions et réponses suivantes sur Stack:
Les noms de table sont-ils sensibles à MySQL?
mysql noms de tables sensibles à la casse dans les requêtes
MySql – Problème sensible à la casse des tables sur différents serveurs
L’utilisation d’un ternaire est simple, lisible et propre:
Pré PHP 7
Atsortingbuez une variable à la valeur d’une autre variable si elle est définie, sinon atsortingbuez la valeur null
(ou la valeur par défaut dont vous avez besoin):
$newVariable = isset($thePotentialData) ? $thePotentialData : null;
PHP 7+
La même chose à l’exception de l’ opérateur Null Coalescing . Il n’est plus nécessaire d’appeler isset()
car il est intégré, et il n’est pas nécessaire de fournir la variable à renvoyer car il est supposé renvoyer la valeur de la variable en cours de vérification:
$newVariable = $thePotentialData ?? null;
Les deux vont arrêter les avis de la question OP, et les deux sont l’équivalent exact de:
if (isset($thePotentialData)) { $newVariable = $thePotentialData; } else { $newVariable = null; }
Si vous n’avez pas besoin de définir une nouvelle variable, vous pouvez directement utiliser la valeur renvoyée par ternary, par exemple avec echo
, les arguments de fonction, etc.:
Écho:
echo 'Your name is: ' . isset($name) ? $name : 'You did not provide one';
Fonction:
$foreName = getForeName(isset($userId) ? $userId : null); function getForeName($userId) { if ($userId === null) { // Etc } }
Ce qui précède fonctionnera de la même manière avec les tableaux, y compris les sessions, etc., en remplaçant la variable vérifiée par exemple par:
$_SESSION['checkMe']
ou peu importe le nombre de niveaux dont vous avez besoin, par exemple:
$clients['personal']['address']['postcode']
Suppression:
Il est possible de supprimer les Notices PHP avec @
ou de réduire votre niveau de rapport d’erreur, mais cela ne résout pas le problème , il arrête tout simplement d’être signalé dans le journal des erreurs. This means that your code still sortinged to use a variable that was not set, which may or may not mean something doesn’t work as intended – depending on how crucial the missing value is.
You should really be checking for this issue and handling it appropriately, either serving a different message, or even just returning a null value for everything else to identify the precise state.
If you just care about the Notice not being in the error log, then as an option you could simply ignore the error log.
Probably you were using old PHP version until and now upgraded PHP thats the reason it was working without any error till now from years. until PHP4 there was no error if you are using variable without defining it but as of PHP5 onwards it throws errors for codes like mentioned in question.
When dealing with files, a proper enctype and a POST method are required, which will sortinggger an undefined index notice if either are not included in the form.
The manual states the following basic syntax:
HTML
PHP
'; if (move_uploaded_file($_FILES['userfile']['tmp_name'], $uploadfile)) { echo "File is valid, and was successfully uploaded.\n"; } else { echo "Possible file upload attack!\n"; } echo 'Here is some more debugging info:'; print_r($_FILES); print "
"; ?>
Référence:
One common cause of a variable not existing after an HTML form has been submitted is the form element is not contained within a
tag:
Example: Element not contained within the
Example: Element now contained within the
I asked a question about this and I was referred to this post with the message:
Cette question a déjà une réponse ici:
“Notice: Undefined variable”, “Notice: Undefined index”, and “Notice: Undefined offset” using PHP
I am sharing my question and solution here:
This is the error:
Line 154 is the problem. This is what I have in line 154:
153 foreach($cities as $key => $city){ 154 if(($city != 'London') && ($city != 'Madrid') && ($citiesCounterArray[$key] >= 1)){
I think the problem is that I am writing if conditions for the variable $city
, which is not the key but the value in $key => $city
. First, could you confirm if that is the cause of the warning? Second, if that is the problem, why is it that I cannot write a condition based on the value? Does it have to be with the key that I need to write the condition?
UPDATE 1: The problem is that when executing $citiesCounterArray[$key]
, sometimes the $key
corresponds to a key that does not exist in the $citiesCounterArray
array, but that is not always the case based on the data of my loop. What I need is to set a condition so that if $key
exists in the array, then run the code, otherwise, skip it.
UPDATE 2: This is how I fixed it by using array_key_exists()
:
foreach($cities as $key => $city){ if(array_key_exists($key, $citiesCounterArray)){ if(($city != 'London') && ($city != 'Madrid') && ($citiesCounterArray[$key] >= 1)){
Those notices are because you don’t have the used variable defined
and my_index
key was not present into $my_array
variable.
Those notices were sortingggered every time, because your code
is not correct, but probably you didn’t have the reporting of notices on.
Solve the bugs:
$my_variable_name = "Variable name"; // defining variable echo "My variable value is: " . $my_variable_name; if(isset($my_array["my_index"])){ echo "My index value is: " . $my_array["my_index"]; // check if my_index is set }
Another way to get this out:
ini_set("error_reporting", false)
In PHP you need fist to define the variable after that you can use it.
We can check variable is defined or not in very efficient way!.
//If you only want to check variable has value and value has true and false value. //But variable must be defined first. if($my_variable_name){ } //If you want to check variable is define or undefine //Isset() does not check that variable has true or false value //But it check null value of variable if(isset($my_variable_name)){ }
Simple Explanation
//It will work with :- true,false,NULL $defineVarialbe = false; if($defineVarialbe){ echo "true"; }else{ echo "false"; } //It will check variable is define or not and variable has null value. if(isset($unDefineVarialbe)){ echo "true"; }else{ echo "false"; }