Ik gebruik een PHP-script en blijf fouten ontvangen zoals:

Opmerking: niet-gedefinieerde variabele: my_variable_name in C:\wamp\www\mypath\index.php op regel 10

Opmerking: Undefined index: my_index C:\wamp\www\mypath\index.php op regel 11

Lijn 10 en 11 zien er als volgt uit:

echo "My variable value is: " . $my_variable_name;
echo "My index value is: " . $my_array["my_index"];

Wat is de betekenis van deze foutmeldingen?

Waarom verschijnen ze ineens? Ik gebruikte dit script al jaren en ik heb nooit problemen gehad.

Hoe los ik ze op?

_{Dit is een algemene referentievraag waar mensen naar kunnen linken als duplicaat, in plaats van het probleem steeds opnieuw te moeten uitleggen. Ik denk dat dit nodig is omdat de meeste echte antwoorden over dit onderwerp heel specifiek zijn.}

_{Verwante metadiscussie:}

_{Wat kan er gedaan worden aan repetitieve vragen?}

_{Hebben referentievragen zin?}

Antwoord 1, autoriteit 100%

Opmerking: niet-gedefinieerde variabele

Van de enorme wijsheid van de PHP-handleiding :

Vertrouwen op de standaardwaarde van een niet-geïnitialiseerde variabele is problematisch in het geval van het opnemen van een bestand in een ander bestand dat dezelfde variabelenaam gebruikt. Het is ook een groot beveiligingsrisico met register_globals ingeschakeld. E_NOTICE-niveaufout is opgetreden bij het werken met niet-geïnitialiseerde variabelen, maar niet bij het toevoegen van elementen aan de niet-geïnitialiseerde array. isset() taalconstructie kan worden gebruikt om te detecteren of een variabele is al geïnitialiseerd. Aanvullend en ideaal is de oplossing van empty() aangezien het geen waarschuwing of foutmelding als de variabele niet is geïnitialiseerd.

Van PHP-documentatie:

Er wordt geen waarschuwing gegenereerd als de variabele niet bestaat. Dat betekent
empty() is in wezen het beknopte equivalent van !isset($var) || $var
== false.

Dit betekent dat u alleen empty() kunt gebruiken om te bepalen of de variabele is ingesteld, en bovendien wordt de variabele vergeleken met het volgende: 0, 0.0, "", "0", NULL, false of [].

Voorbeeld:

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

Test het bovenstaande fragment in de 3v4l.org online PHP-editor

Hoewel PHP geen variabele declaratie vereist, raadt het dit wel aan om beveiligingsproblemen of bugs te vermijden waarbij men zou vergeten een waarde te geven aan een variabele die later in het script zal worden gebruikt. Wat PHP doet in het geval van niet-aangegeven variabelen is een zeer lage fout, E_NOTICE, een fout die niet eens standaard wordt gerapporteerd, maar de handleiding adviseert toe te staan tijdens de ontwikkeling.

Manieren om met het probleem om te gaan:

Aanbevolen: declareer je variabelen, bijvoorbeeld wanneer je een string probeert toe te voegen aan een ongedefinieerde variabele. Of gebruik isset() / !empty() om te controleren of ze zijn gedeclareerd voordat ze verwijzen hen, zoals in:

//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'] : '';

Dit is veel schoner geworden vanaf PHP 7.0, nu kun je de null coalesce-operator gebruiken :

// Null coalesce operator - No need to explicitly initialize the variable.
$value = $_POST['value'] ?? '';

Stel een aangepaste fout-handler in voor E_NOTICE en stuur de berichten weg van de standaarduitvoer (misschien naar een logbestand):
```
set_error_handler('myHandlerForMinorErrors', E_NOTICE | E_STRICT)
```
E_NOTICE uitschakelen voor rapportage. Een snelle manier om alleen E_NOTICE uit te sluiten is:
```
error_reporting( error_reporting() & ~E_NOTICE )
```
Onderdruk de fout met de @ operator.

Opmerking: het wordt sterk aanbevolen om alleen punt 1 te implementeren.

Opmerking: Ongedefinieerde index / Ongedefinieerde offset

Deze melding verschijnt wanneer u (of PHP) probeert toegang te krijgen tot een ongedefinieerde index van een array.

Manieren om met het probleem om te gaan:

Controleer of de index bestaat voordat u deze opent. Hiervoor kunt u isset() of 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'] : '';

De taalconstructie list() kan dit genereren wanneer het probeert toegang te krijgen tot een array-index die niet bestaat:
```
list($a, $b) = array(0 => 'a');
//or
list($one, $two) = explode(',', 'test string');
```

Twee variabelen worden gebruikt om toegang te krijgen tot twee array-elementen, maar er is slechts één array-element, index 0, dus dit genereert:

Opmerking: Ongedefinieerde offset: 1

`$_POST` / `$_GET` / `$_SESSION` variabele

De bovenstaande mededelingen verschijnen vaak bij het werken met $_POST, $_GET of $_SESSION. Voor $_POST en $_GET hoef je alleen maar te controleren of de index bestaat of niet voordat je ze gebruikt. Voor $_SESSION moet je ervoor zorgen dat de sessie is gestart met session_start() en dat de index ook bestaat.

Houd er rekening mee dat alle 3 de variabelen superglobalen zijn en in hoofdletters zijn.

Gerelateerd:

Antwoord 2, autoriteit 14%

Probeer deze

Q1: deze melding betekent dat $varname niet is
gedefinieerd bij de huidige reikwijdte van de
schrift.

Q2: Het gebruik van isset(), empty() voorwaarden voor het gebruik van een verdachte variabele werkt goed.

// 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'];
}

Of, als een snelle en vuile oplossing:

// not the best solution, but works
// in your php setting use, it helps hiding site wide notices
error_reporting(E_ALL ^ E_NOTICE);

Opmerking over sessies:

Als je sessies gebruikt, moet session_start(); in alle bestanden worden geplaatst die sessies gebruiken.
http://php.net/manual/en/features.sessions .php

Antwoord 3, autoriteit 6%

Foutweergave `@` operator

Voor ongewenste en overbodige kennisgevingen kan men de speciale @ operator om ongedefinieerde variabele/indexberichten te verbergen .

$var = @($_GET["optional_param"]);

Dit wordt meestal afgeraden. Nieuwkomers hebben de neiging om het veel te veel te gebruiken.
Het is zeer ongepast voor code diep in de applicatielogica (niet-gedeclareerde variabelen negeren waar dat niet zou moeten), b.v. voor functieparameters of in lussen.
Er is echter een voordeel ten opzichte van de isset?: of ?? super-onderdrukking. Meldingen kunnen nog steeds worden gelogd. En men kan @-verborgen mededelingen weer tot leven wekken met: set_error_handler("var_dump");
- Bovendien moet u gewoonlijk if (isset($_POST["shubmit"])) niet gebruiken/aanbevelen in uw oorspronkelijke code.
- Nieuwkomers zullen dergelijke typefouten niet opmerken. Het berooft je gewoon van PHP-kennisgevingen voor diezelfde gevallen. Voeg @ of isset alleen toe na verificatie van de functionaliteit.
- Verhelp eerst de oorzaak. Niet de mededelingen.
@ is voornamelijk acceptabel voor $_GET/$_POST invoerparameters, met name als ze optioneel zijn.

En aangezien dit de meeste van dergelijke vragen dekt, gaan we dieper in op de meest voorkomende oorzaken:

`$_GET` / `$_POST` / `$_REQUEST` ongedefinieerde invoer

Het eerste wat u doet als u een ongedefinieerde index/offset tegenkomt, is controleren op typefouten:
$count = $_GET["whatnow?"];
- Is dit een verwachte sleutelnaam en aanwezig op elk paginaverzoek?
- Variabelenamen en array-indices zijn hoofdlettergevoelig in PHP.
Ten tweede, als de melding geen duidelijke oorzaak heeft, gebruik dan var_dump of print_r om alle invoerarrays voor hun huidige inhoud:
```
var_dump($_GET);
var_dump($_POST);
//print_r($_REQUEST);
```
Beide zullen onthullen of uw script is aangeroepen met de juiste of enige parameters.
Alternatief of gebruik daarnaast uw browser devtools (F12) en controleer het netwerktabblad op verzoeken en parameters:

POST-parameters en GET-invoer worden afzonderlijk weergegeven.
Voor $_GET parameters kun je ook een kijkje nemen in de QUERY_STRING binnen
```
print_r($_SERVER);
```
PHP heeft enkele regels om samenvloeien niet-standaard parameternamen naar de superglobalen. Apache kan ook wat herschrijven.
Je kunt op die manier ook de geleverde onbewerkte $_COOKIES en andere HTTP-verzoekheaders bekijken.
Kijk natuurlijk in de adresbalk van je browser voor GET-parameters:

http://example.org/script.php?id=5&sort=desc

De name=value-paren na het ? vraagteken zijn uw query-parameters (GET). Deze URL kan dus mogelijk alleen $_GET["id"] en $_GET["sort"] opleveren.
Controleer ten slotte uw <form> en <input> declaraties, als u een parameter verwacht maar er geen ontvangt.
- Zorg ervoor dat elke vereiste invoer een <input name=FOO>
- Het kenmerk id= of title= is niet voldoende.
- Een method=POST-formulier moet $_POST invullen.
- Terwijl een method=GET (of het weglaten ervan) $_GET-variabelen zou opleveren.
- Het is ook mogelijk voor een formulier om action=script.php?get=param in te voeren via $_GET en de overige method=POST-velden in $_POST ernaast.
- Met moderne PHP-configuraties (? 5.6) is het haalbaar (niet modieus) ) om $_REQUEST['vars'] opnieuw te gebruiken, wat GET en POST parameters.
Als u mod_rewrite gebruikt, moet u zowel de access.log controleren als de RewriteLog om ontbrekende parameters te achterhalen.

`$_FILES`

Dezelfde gezondheidscontroles zijn van toepassing op bestandsuploads en $_FILES["formname"].
Controleer bovendien op enctype=multipart/form-data
Zoals method=POST in uw <form>-aangifte.
Zie ook: PHP Undefined indexfout $_FILES?

`$_COOKIE`

De $_COOKIE-array wordt nooit direct na setcookie() ingevuld, maar alleen bij elk volgend HTTP-verzoek.
Bovendien loopt hun geldigheid af, ze kunnen worden beperkt tot subdomeinen of individuele paden, en gebruiker en browser kunnen ze gewoon weigeren of verwijderen.

Antwoord 4, autoriteit 4%

Over het algemeen vanwege “slechte programmering”, en een kans op fouten nu of later.

Als het een vergissing is, maak dan eerst een juiste toewijzing aan de variabele: $varname=0;
Als het echt alleen soms wordt gedefinieerd, test het dan: if (isset($varname)), voordat je het gebruikt
Als het komt omdat je het verkeerd hebt gespeld, corrigeer dat dan gewoon
Misschien zelfs de waarschuwingen uitzetten in je PHP-instellingen

Antwoord 5, autoriteit 4%

Het betekent dat je een variabele test, evalueert of afdrukt waaraan je nog niets hebt toegewezen. Het betekent dat je een typefout hebt gemaakt, of dat je eerst moet controleren of de variabele op iets is geïnitialiseerd. Controleer uw logische paden, het kan in het ene pad zijn ingesteld, maar niet in het andere.

Antwoord 6, autoriteit 3%

Ik wilde de melding niet uitschakelen omdat het handig is, maar ik wilde te veel typen vermijden.

Mijn oplossing was deze functie:

function ifexists($varname)
{
  return(isset($$varname)?$varname:null);
}

Dus als ik wil verwijzen naar $name en echo als die bestaat, schrijf ik gewoon:

<?=ifexists('name')?>

Voor array-elementen:

function ifexistsidx($var,$index)
{
  return(isset($var[$index])?$var[$index]:null);
}

In pagina als ik wil verwijzen naar $_REQUEST[‘name’]:

<?=ifexistsidx($_REQUEST,'name')?>

Antwoord 7, autoriteit 2%

De beste manier om invoer string te krijgen is:

$value = filter_input(INPUT_POST, 'value');

Deze oneliner is bijna gelijk aan:

if (!isset($_POST['value'])) {
    $value = null;
} elseif (is_array($_POST['value'])) {
    $value = false;
} else {
    $value = $_POST['value'];
}

Als je absoluut een tekenreeks waarde wilt, zoals:

$value = (string)filter_input(INPUT_POST, 'value');

Antwoord 8, autoriteit 2%

Het komt omdat de variabele ‘$user_location’ niet gedefinieerd wordt. Als je een if-lus gebruikt waarin je de variabele ‘$user_location’ declareert, dan moet je ook een else-lus hebben en deze definiëren. Bijvoorbeeld:

$a=10;
if($a==5) { $user_location='Paris';} else { }
echo $user_location;

De bovenstaande code zal een fout veroorzaken omdat er niet aan de if-lus wordt voldaan en in de else-lus ‘$user_location’ niet is gedefinieerd. Toch werd PHP gevraagd om de variabele uit te echoën. Dus om de code te wijzigen moet je het volgende doen:

$a=10;
if($a==5) { $user_location='Paris';} else { $user_location='SOMETHING OR BLANK'; }
echo $user_location;

Antwoord 9, autoriteit 2%

Als antwoord op “”Waarom verschijnen ze ineens? Ik gebruikte dit script al jaren en ik heb nooit problemen gehad.”

Het is heel gebruikelijk dat de meeste sites werken met de “standaard” foutrapportage van “Alle fouten weergeven, maar niet ‘kennisgevingen’ en ‘verouderd'”. Dit wordt ingesteld in php.ini en is van toepassing op alle sites op de server. Dit betekent dat de “meldingen” die in de voorbeelden worden gebruikt, worden onderdrukt (verborgen), terwijl andere fouten, die als kritischer worden beschouwd, worden weergegeven/opgenomen.

De andere kritische instelling is dat de fouten verborgen kunnen worden (d.w.z. display_errors ingesteld op “off” of “syslog”).

Wat er in dit geval is gebeurd, is dat ofwel de error_reporting is gewijzigd om ook meldingen weer te geven (zoals in de voorbeelden) en/of dat de instellingen zijn gewijzigd in display_errors op het scherm (in plaats van ze te onderdrukken/te loggen).

Waarom zijn ze veranderd?

Het voor de hand liggende/eenvoudigste antwoord is dat iemand een van deze instellingen in php.ini heeft aangepast, of dat een geüpgradede versie van PHP nu een andere php.ini gebruikt dan voorheen. Dat is de eerste plaats om te kijken.

Het is echter ook mogelijk om deze instellingen te overschrijven in

.htconf (webserverconfiguratie, inclusief vhosts en subconfiguraties)*
.htaccess
in php-code zelf

en elk van deze had ook kunnen worden gewijzigd.

Er is ook de extra complicatie dat de webserverconfiguratie .htaccess-richtlijnen kan in-/uitschakelen, dus als u richtlijnen in .htaccess hebt die plotseling beginnen/stoppen met werken, moet u dat controleren.

(.htconf / .htaccess gaan ervan uit dat u als apache draait. Als u de opdrachtregel uitvoert, is dit niet van toepassing; als u IIS of een andere webserver gebruikt, moet u die configuraties dienovereenkomstig controleren)

Samenvatting

Controleer error_reporting en display_errors php-richtlijnen in php.ini is niet gewijzigd, of dat je geen andere php.ini gebruikt dan voorheen.
Controleer of de php-richtlijnen error_reporting en display_errors in .htconf (of vhosts enz.) niet zijn gewijzigd
Controleer error_reporting en display_errors php-richtlijnen in .htaccess zijn niet gewijzigd
Als je een richtlijn in .htaccess hebt, controleer dan of ze nog steeds zijn toegestaan in het .htconf-bestand
Controleer ten slotte je code; mogelijk een niet-gerelateerde bibliotheek; om te zien of de php-richtlijnen error_reporting en display_errors daar zijn ingesteld.

Antwoord 10, autoriteit 2%

de snelle oplossing is om uw variabele toe te wijzen aan null bovenaan uw code

$user_location = null;

Antwoord 11

Vroeger vervloekte ik deze fout, maar het kan handig zijn om je eraan te herinneren dat je de gebruikersinvoer moet onthouden.

Als je dit bijvoorbeeld slim vond, korte code:

// Echo whatever the hell this is
<?=$_POST['something']?>

…Denk nog eens na! Een betere oplossing is:

// If this is set, echo a filtered version
<?=isset($_POST['something']) ? html($_POST['something']) : ''?>

(Ik gebruik een aangepaste functie html() om tekens te escapen, uw kilometerstand kan variëren)

Antwoord 12

Ik gebruik altijd een eigen handige functie exst() die automatisch variabelen declareert.

Uw code wordt –

$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_string($t)) $t = trim($t);
    return $t;
}

Antwoord 13

In PHP 7.0 is het nu mogelijk om de Null-coalescentie-operator te gebruiken:

echo "My index value is: " . ($my_array["my_index"] ?? '');

Is gelijk aan:

echo "My index value is: " . (isset($my_array["my_index"]) ? $my_array["my_index"] : '');

PHP-handleiding PHP 7.0

Antwoord 14

In een zeer Eenvoudige Taal.
De fout is dat u een variabele $user_location gebruikt die niet eerder door u is gedefinieerd en die geen elke waarde Dus ik raad je aan om declareren deze variabele voordat gebruik het, bijvoorbeeld:

$user_location = '';
Of
$user_location = 'Los Angles';

Dit is een veel voorkomende fout waarmee u te maken kunt krijgen. Maak u dus geen zorgen, declareer gewoon de variabele en Enjoy Coding.

Antwoord 15

WAAROM GEBEURT DIT?

In de loop van de tijd is PHP een meer op beveiliging gerichte taal geworden. Instellingen die voorheen standaard waren uitgeschakeld, zijn nu standaard ingeschakeld. Een perfect voorbeeld hiervan is E_STRICT, die standaard werd ingeschakeld vanaf PHP 5.4.0.

Bovendien, volgens de PHP-documentatie, is E_NOTICE standaard uitgeschakeld in php.ini. PHP-documenten raden aan in te schakelen voor foutopsporingsdoeleinden. Wanneer ik echter PHP download van de Ubuntu-repository en van de Windows-stack van BitNami, zie ik iets anders.

; 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

Merk op dat error_reporting eigenlijk standaard is ingesteld op de productiewaarde, niet standaard op de “standaard” waarde. Dit is enigszins verwarrend en is niet gedocumenteerd buiten php.ini, dus ik heb dit niet gevalideerd voor andere distributies.

Om uw vraag te beantwoorden, maar deze fout verschijnt nu terwijl deze niet eerder verscheen, omdat:

Je hebt PHP geïnstalleerd en de nieuwe standaardinstellingen zijn enigszins slecht gedocumenteerd, maar sluiten E_NOTICE niet uit.
E_NOTICE-waarschuwingen zoals ongedefinieerde variabelen en ongedefinieerde indexen helpen in feite om uw code schoner en veiliger te maken. Ik kan je vertellen dat, jaren geleden, het ingeschakeld houden van E_NOTICE me dwong om mijn variabelen te declareren. Het maakte het VEEL gemakkelijker om C te leren, waar het niet veel vervelender is om variabelen te declareren.

WAT KAN IK ER AAN DOEN?

Schakel E_NOTICE uit door de “Standaardwaarde” E_ALL & ~E_NOTICE & ~E_STRICT & ~E_DEPRECATED en vervangen door wat momenteel niet is becommentarieerd na het gelijkteken in error_reporting =. Start Apache of PHP opnieuw als u CGI of FPM gebruikt. Zorg ervoor dat u de “juiste” php.ini bewerkt. De juiste is Apache als je PHP met Apache gebruikt, fpm of php-fpm als je PHP-FPM gebruikt, cgi als je PHP-CGI gebruikt, enz. Dit is niet de aanbevolen methode, maar als je oude code hebt buitengewoon moeilijk te bewerken zijn, dan is dit misschien de beste keuze.
Schakel E_NOTICE uit op bestands- of mapniveau. Dit kan de voorkeur hebben als je wat verouderde code hebt, maar anders de dingen op de “juiste” manier wilt doen. Om dit te doen, moet u Apache2, Nginx of wat dan ook uw favoriete server raadplegen. In Apache zou je php_value in <Directory> gebruiken.
Herschrijf je code om schoner te zijn. Als u dit moet doen terwijl u naar een productieomgeving verhuist of niet wilt dat iemand uw fouten ziet, zorg er dan voor dat u de weergave van fouten uitschakelt en alleen uw fouten vastlegt (zie display_errors en log_errors in php.ini en uw serverinstellingen).

Om optie 3 uit te breiden: Dit is het ideaal. Als je deze route kunt gaan, zou je dat moeten doen. Als je deze route in eerste instantie niet volgt, overweeg dan om deze route uiteindelijk te verplaatsen door je code te testen in een ontwikkelomgeving. Terwijl je toch bezig bent, verwijder ~E_STRICT en ~E_DEPRECATED om te zien wat er in de toekomst mis kan gaan. Je zult VEEL onbekende fouten zien, maar het zal voorkomen dat je onaangename problemen krijgt als je in de toekomst PHP moet upgraden.

WAT BETEKENEN DE FOUTEN?

Undefined variable: my_variable_name – Dit gebeurt wanneer een variabele niet is gedefinieerd voor gebruik. Wanneer het PHP-script wordt uitgevoerd, neemt het intern gewoon een null-waarde aan. In welk scenario zou u echter een variabele moeten controleren voordat deze werd gedefinieerd? Uiteindelijk is dit een argument voor “slordige code”. Als ontwikkelaar kan ik je vertellen dat ik het geweldig vind als ik een open source-project zie waarin variabelen zo hoog in hun bereik worden gedefinieerd als ze kunnen worden gedefinieerd. Het maakt het gemakkelijker om te zien welke variabelen in de toekomst zullen verschijnen en maakt het gemakkelijker om de code te lezen/leren.

function foo()
{
    $my_variable_name = '';
    //....
    if ($my_variable_name) {
        // perform some logic
    }
}

Undefined index: my_index – Dit gebeurt wanneer u probeert toegang te krijgen tot een waarde in een array en deze bestaat niet. Voer een voorwaardelijke controle uit om deze fout te voorkomen.

// 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;

Een andere optie is om een lege array bovenaan je functie te declareren. Dit is niet altijd mogelijk.

$my_array = array(
    'my_index' => ''
);
//...
$my_array['my_index'] = 'new string';

(extra tip)

Toen ik deze en andere problemen tegenkwam, gebruikte ik NetBeans IDE (gratis) en het gaf me een groot aantal waarschuwingen en mededelingen. Sommigen van hen bieden zeer nuttige tips. Dit is geen vereiste en ik gebruik geen IDE’s meer, behalve voor grote projecten. Ik ben tegenwoordig meer een vim persoon :).

Antwoord 16

waarom houden we het niet simpel?

<?php
error_reporting(E_ALL); // making sure all notices are on
function idxVal(&$var, $default = null) {
         return empty($var) ? $var = $default : $var;
  }
echo idxVal($arr['test']);         // returns null without any notice
echo idxVal($arr['hey ho'], 'yo'); // returns yo and assigns it to array index, nice
?>

Antwoord 17

undefined index betekent in een array die je hebt aangevraagd voor bijvoorbeeld niet-beschikbare array-index

<?php 
$newArray[] = {1,2,3,4,5};
print_r($newArray[5]);
?>

niet-gedefinieerde variabele betekent dat u een volledig niet bestaande variabele hebt gebruikt of die bijvoorbeeld niet met die naam is gedefinieerd of geïnitialiseerd

<?php print_r($myvar); ?>

undefined offset betekent in de array dat u om een niet-bestaande sleutel hebt gevraagd. En de
oplossing hiervoor is controleren voor gebruik

php> echo array_key_exists(1, $myarray);

Antwoord 18

Over dit deel van de vraag:

Waarom verschijnen ze ineens? Ik gebruikte dit script al jaren en ik heb nooit problemen gehad.

Geen definitieve antwoorden, maar hier zijn enkele mogelijke verklaringen waarom instellingen ‘plotseling’ kunnen veranderen:

Je hebt PHP geüpgraded naar een nieuwere versie die andere standaardwaarden kan hebben voor error_reporting, display_errors of andere relevante instellingen.
Je hebt code verwijderd of geïntroduceerd (mogelijk in een afhankelijkheid) die tijdens runtime relevante instellingen instelt met behulp van ini_set() of error_reporting() (zoek naar deze in de code)
Je hebt de configuratie van de webserver gewijzigd (ervan uitgaande dat hier apache is): .htaccess-bestanden en vhost-configuraties kunnen ook php-instellingen manipuleren.
Meestal worden meldingen niet weergegeven / gerapporteerd (zie PHP-handleiding)
dus het is mogelijk dat bij het instellen van de server het php.ini-bestand om de een of andere reden niet kon worden geladen (bestandsrechten??) en dat u de standaardinstellingen had. Later is de ‘bug’ (per ongeluk) opgelost en nu KAN het het juiste php.ini-bestand laden met de error_reporting ingesteld om meldingen weer te geven.

Antwoord 19

Het gebruik van een ternair is eenvoudig, leesbaar en overzichtelijk:

Pre PHP 7
Wijs een variabele toe aan de waarde van een andere variabele als deze is ingesteld, wijs anders NULL toe (of welke standaard-waarde je ook nodig hebt):

$newVariable = isset($thePotentialData) ? $thePotentialData : null;

PHP 7+
Hetzelfde, behalve het gebruik van Null Coalescing Operator . Het is niet langer nodig om isset() aan te roepen omdat dit is ingebouwd, en het is niet nodig om de variabele op te geven om te retourneren, omdat wordt aangenomen dat deze de waarde retourneert van de variabele die wordt gecontroleerd:

$newVariable = $thePotentialData ?? null;

Beide zullen de kennisgevingen van de OP-vraag stoppen, en beide zijn het exacte equivalent van:

if (isset($thePotentialData)) {
    $newVariable = $thePotentialData;
} else {
    $newVariable = null;
}

Als u geen nieuwe variabele hoeft in te stellen, kunt u direct de geretourneerde waarde van de ternaire gebruiken, zoals met echo, functieargumenten, enz:

Echo:

echo 'Your name is: ' . isset($name) ? $name : 'You did not provide one';

Functie:

$foreName = getForeName(isset($userId) ? $userId : null);
function getForeName($userId)
{
    if ($userId === null) {
        // Etc
    }
}

Het bovenstaande werkt precies hetzelfde met arrays, inclusief sessies enz., waarbij de variabele die wordt gecontroleerd wordt vervangen door bijvoorbeeld:
$_SESSION['checkMe']
of hoeveel niveaus diep je ook nodig hebt, bijvoorbeeld:
$clients['personal']['address']['postcode']

Onderdrukking:

Het is mogelijk om de PHP-kennisgevingen te onderdrukken met @ of uw foutrapportageniveau te verlagen, maar het verhelpt het probleem niet, het stopt gewoon dat het wordt gerapporteerd in de foutenlogboek. Dit betekent dat je code nog steeds probeerde een variabele te gebruiken die niet was ingesteld, wat al dan niet kan betekenen dat iets niet werkt zoals bedoeld – afhankelijk van hoe cruciaal de ontbrekende waarde is.

Je zou dit probleem echt moeten controleren en op de juiste manier moeten behandelen, ofwel een ander bericht dienend, of zelfs gewoon een null-waarde moeten retourneren voor al het andere om de precieze status te identificeren.

Als je er alleen maar om geeft dat de melding niet in het foutenlogboek staat, dan kun je als optie het foutenlogboek gewoon negeren.

Antwoord 20

Als je met klassen werkt, moet je ervoor zorgen dat je verwijst naar lidvariabelen met behulp van $this:

class Person
{
    protected $firstName;
    protected $lastName;
    public function setFullName($first, $last)
    {
        // Correct
        $this->firstName = $first;
        // Incorrect
        $lastName = $last;
        // Incorrect
        $this->$lastName = $last;
    }
}

Antwoord 21

Een andere reden waarom een niet-gedefinieerde indexmelding wordt gegenereerd, is dat een kolom is weggelaten uit een databasequery.

D.w.z.:

$query = "SELECT col1 FROM table WHERE col_x = ?";

Vervolgens proberen toegang te krijgen tot meer kolommen/rijen in een lus.

D.w.z.:

print_r($row['col1']);
print_r($row['col2']); // undefined index thrown

of in een while lus:

while( $row = fetching_function($query) ) {
    echo $row['col1'];
    echo "<br>";
    echo $row['col2']; // undefined index thrown
    echo "<br>";
    echo $row['col3']; // undefined index thrown
}

Iets anders dat moet worden opgemerkt, is dat op een *NIX OS en Mac OS X dingen hoofdlettergevoelig zijn.

Raadpleeg de volgende Q&A’s op Stack:

Antwoord 22

Deze fouten treden op wanneer we een variabele gebruiken die niet is ingesteld.

De beste manier om hiermee om te gaan, is door foutenrapportage in te stellen tijdens de ontwikkeling.

Om foutrapportage in te stellen op:

ini_set('error_reporting', 'on');
ini_set('display_errors', 'on');
error_reporting(E_ALL);

Op productieservers is foutrapportage uitgeschakeld, daarom krijgen we deze fouten niet.

Op de ontwikkelserver kunnen we echter foutrapportage inschakelen.

Om van deze fout af te komen, zien we het volgende voorbeeld:

if ($my == 9) {
 $test = 'yes';  // Will produce error as $my is not 9.
}
echo $test;

We kunnen de variabelen initialiseren tot NULL voordat we hun waarden toewijzen of gebruiken.

We kunnen de code dus wijzigen als:

$test = NULL;
if ($my == 9) {
 $test = 'yes';  // Will produce error as $my is not 9.
}
echo $test;

Dit verstoort de programmalogica niet en geeft geen melding, zelfs niet als $test geen waarde heeft.

Dus in principe is het altijd beter om foutrapportage AAN te zetten voor ontwikkeling.

En herstel alle fouten.

En bij productie moet de foutrapportage zijn uitgeschakeld.

Antwoord 23

Een veelvoorkomende oorzaak van een variabele die niet bestaat nadat een HTML-formulier is ingediend, is dat het formulierelement niet is opgenomen in een <form>-tag:

Voorbeeld: element dat niet in de <form>

staat

<form action="example.php" method="post">
    <p>
        <input type="text" name="name" />
        <input type="submit" value="Submit" />
    </p>
</form>
<select name="choice">
    <option value="choice1">choice 1</option>
    <option value="choice2">choice 2</option>
    <option value="choice3">choice 3</option>
    <option value="choice4">choice 4</option>
</select>

Voorbeeld: element dat zich nu in de <form>

bevindt

<form action="example.php" method="post">
    <select name="choice">
        <option value="choice1">choice 1</option>
        <option value="choice2">choice 2</option>
        <option value="choice3">choice 3</option>
        <option value="choice4">choice 4</option>
    </select>
    <p>
        <input type="text" name="name" />
        <input type="submit" value="Submit" />
    </p>
</form>

Antwoord 24

Waarschijnlijk gebruikte je tot nu toe een oude PHP-versie en nu heb je PHP geüpgraded, dat is de reden dat het tot nu toe jarenlang zonder fouten werkte.
tot PHP4 was er geen fout als je variabele gebruikt zonder deze te definiëren, maar vanaf PHP5 geeft het fouten voor codes zoals vermeld in kwestie.

Antwoord 25

Ik heb hier een vraag over gesteld en ik werd naar dit bericht verwezen met het bericht:

Deze vraag heeft hier al een antwoord:

Opmerking: Ongedefinieerde variabele , Opmerking: Ongedefinieerde index en Opmerking:
Ongedefinieerde offset met behulp van PHP

Ik deel mijn vraag en oplossing hier:

Dit is de fout:

Regel 154 is het probleem. Dit is wat ik heb in regel 154:

153    foreach($cities as $key => $city){
154        if(($city != 'London') && ($city != 'Madrid') && ($citiesCounterArray[$key] >= 1)){

Ik denk dat het probleem is dat ik if-voorwaarden schrijf voor de variabele $city, wat niet de sleutel is maar de waarde in $key => $city. Ten eerste, kunt u bevestigen of dat de oorzaak is van de waarschuwing? Ten tweede, als dat het probleem is, waarom kan ik dan geen voorwaarde schrijven op basis van de waarde? Moet het met de sleutel zijn die ik nodig heb om de voorwaarde te schrijven?

UPDATE 1: Het probleem is dat bij het uitvoeren van $citiesCounterArray[$key] de $key soms overeenkomt met een sleutel die niet bestaat in de $citiesCounterArray array, maar dat is niet altijd het geval op basis van de gegevens van mijn lus. Wat ik nodig heb is om een voorwaarde in te stellen zodat als $key in de array bestaat, dan de code uit te voeren, anders overslaan.

UPDATE 2: Zo heb ik het opgelost door array_key_exists() te gebruiken:

foreach($cities as $key => $city){
    if(array_key_exists($key, $citiesCounterArray)){
        if(($city != 'London') && ($city != 'Madrid') && ($citiesCounterArray[$key] >= 1)){

Antwoord 26

Als u gegevens naar de API verzendt, gebruikt u gewoon isset()

if(isset($_POST['param'])){
    $param = $_POST['param'];
} else {
#do something else
}

Als de fout het gevolg is van een sessie, zorg er dan voor dat je de sessie goed hebt gestart.

Antwoord 27

Bij het omgaan met bestanden zijn een juist enctype en een POST-methode vereist, die een ongedefinieerde indexmelding zullen activeren als een van beide niet in het formulier is opgenomen.

De handleiding vermeldt de volgende basissyntaxis:

HTML

<!-- The data encoding type, enctype, MUST be specified as below -->
<form enctype="multipart/form-data" action="__URL__" method="POST">
    <!-- MAX_FILE_SIZE must precede the file input field -->
    <input type="hidden" name="MAX_FILE_SIZE" value="30000" />
    <!-- Name of input element determines name in $_FILES array -->
    Send this file: <input name="userfile" type="file" />
    <input type="submit" value="Send File" />
</form>

PHP

<?php
// In PHP versions earlier than 4.1.0, $HTTP_POST_FILES should be used instead
// of $_FILES.
$uploaddir = '/var/www/uploads/';
$uploadfile = $uploaddir . basename($_FILES['userfile']['name']);
echo '<pre>';
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 "</pre>";
?>

Referentie:

http://php.net/manual/en /features.file-upload.post-method.php

Antwoord 28

Deze meldingen zijn omdat u de gebruikte variabele defined niet heeft en de sleutel my_index niet aanwezig was in de variabele $my_array.

Die meldingen werden elke keer geactiveerd, omdat je code niet correct is, maar waarschijnlijk had je de rapportage van meldingen niet ingeschakeld.

Los de bugs op:

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

Een andere manier om dit eruit te krijgen:

ini_set("error_reporting", false)

Antwoord 29

In PHP heb je vuist nodig om de variabele te definiëren, daarna kun je hem gebruiken.
We kunnen controleren of de variabele is gedefinieerd of niet op een zeer efficiënte manier!.

//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)){
}

Eenvoudige uitleg

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

“Opmerking: niet-gedefinieerde variabele”, “Opmerking: niet-gedefinieerde index”, en “Opmerking: niet-gedefinieerde offset” PHP gebruiken