Sto eseguendo uno script PHP e continuo a ricevere errori come:

Avviso: variabile non definita: my_variable_name in C: \ wamp \ www \ mypath \ index.php sulla riga 10

Avviso: indice indefinito: my_index C: \ wamp \ www \ mypath \ index.php sulla riga 11

Le righe 10 e 11 si presentano così:

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

Qual è il significato di questi messaggi di errore?

Perché appaiono all'improvviso? Usavo questo script da anni e non ho mai avuto problemi.

Come li risolvo?

_{Questa è una domanda di riferimento generale a cui le persone possono collegarsi come duplicati, invece di dover spiegare più e più volte il problema. Ritengo che ciò sia necessario perché la maggior parte delle risposte del mondo reale su questo tema sono molto specifiche.}

_{Discussione Meta correlata:}

• _{Cosa si può fare per le domande ripetitive?}
• _{Le "domande di riferimento" hanno senso?}

Avviso: variabile non definita

Dalla vasta saggezza del manuale PHP :

Affidarsi al valore predefinito di una variabile non inizializzata è problematico nel caso in cui si includa un file in un altro che utilizza lo stesso nome di variabile. È anche un grave rischio per la sicurezza con register_globals attivato. L' errore di livello E_NOTICE viene emesso in caso di utilizzo di variabili non inizializzate, tuttavia non nel caso di aggiunta di elementi all'array non inizializzato. Il costrutto del linguaggio isset () può essere utilizzato per rilevare se una variabile è già stata inizializzata. Inoltre e più ideale è la soluzione di empty () poiché non genera un messaggio di avviso o errore se la variabile non è inizializzata.

A partire dal documentazione di PHP :

Non viene generato alcun avviso se la variabile non esiste. Ciò significa che empty () è essenzialmente l'equivalente conciso di ! Isset ($ var) || $ var == false .

Questo significa che si potrebbe usare solamente empty()per determinare se è impostata la variabile, e in aggiunta si controlla la variabile sulla base dei seguenti, 0, 0.0, "", "0", null, falseo [].

Esempio:

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

Prova lo snippet sopra riportato nell'editor PHP online di 3v4l.org

Sebbene PHP non richieda una dichiarazione di variabile, la raccomanda per evitare alcune vulnerabilità di sicurezza o bug in cui si dimenticherebbe di dare un valore a una variabile che verrà utilizzata in seguito nello script. Ciò che PHP fa nel caso di variabili non dichiarate è emettere un errore di livello molto basso,E_NOTICE , che non è nemmeno riportato per impostazione predefinita, ma il Manuale consiglia di consentire durante lo sviluppo.

Modi per affrontare il problema:

1. Consigliato: dichiarare le variabili, ad esempio quando si tenta di aggiungere una stringa a una variabile non definita. Oppure usa isset()/ !empty() per verificare se sono stati dichiarati prima di fare riferimento a loro, come 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'] : '';

   Questo è diventato molto più pulito a partire da PHP 7.0, ora puoi usare l' operatore null coales :

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

2. Imposta un gestore errori personalizzato per E_NOTICE e reindirizza i messaggi lontano dall'output standard (forse su un file di registro):

   set_error_handler('myHandlerForMinorErrors', E_NOTICE | E_STRICT)

3. Disabilita E_NOTICE dai rapporti. Un modo rapido per escludere E_NOTICEè:

   error_reporting( error_reporting() & ~E_NOTICE )

4. Sopprimere l'errore con l' operatore @ .

Nota: si consiglia vivamente di implementare solo il punto 1.

Avviso: indice indefinito / offset indefinito

Questo avviso appare quando tu (o PHP) provi ad accedere a un indice indefinito di un array.

Modi per affrontare il problema:

1. Controlla se l'indice esiste prima di accedervi. Per questo puoi usare isset()o 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'] : '';

2. Il costrutto del linguaggio list()può generare questo quando tenta di accedere a un indice di array che non esiste:

   list($a, $b) = array(0 => 'a');
   //or
   list($one, $two) = explode(',', 'test string');

Per accedere a due elementi dell'array vengono utilizzate due variabili, tuttavia esiste un solo elemento dell'array, indice 0, quindi questo genererà:

Avviso: offset non definito: 1

$_POST/ $_GET/ $_SESSIONvariabile

Le note sopra appaiono spesso quando si lavora con $_POST, $_GETo $_SESSION. Per $_POSTe $_GETdevi solo verificare se l'indice esiste o meno prima di usarli. Perché $_SESSIONdevi assicurarti di aver iniziato la sessione session_start()e che esista anche l'indice.

Si noti inoltre che tutte e 3 le variabili sono superglobali e maiuscole.

Relazionato:

• Avviso: variabile non definita
• Avviso: indice indefinito

Prova questi

Q1: questo avviso indica che $ varname non è definito nell'ambito corrente dello script.

D2: L'uso delle condizioni isset (), empty () prima di utilizzare qualsiasi variabile sospetta funziona bene.

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

Oppure, come soluzione rapida e sporca:

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

Nota sulle sessioni:

• Quando si utilizzano le sessioni, session_start();è necessario essere inseriti in tutti i file utilizzando le sessioni.

• http://php.net/manual/en/features.sessions.php

Operatore di visualizzazione degli errori@

Per le notifiche indesiderate e ridondanti, è possibile utilizzare l' @operatore dedicato per » nascondere « i messaggi variabili / di indice non definiti.

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

• Questo di solito è scoraggiato. I nuovi arrivati ​​tendono ad abusarne.
• È molto inappropriato per il codice all'interno della logica dell'applicazione (ignorando le variabili non dichiarate dove non si dovrebbe), ad esempio per i parametri delle funzioni o nei loop.
• C'è un rialzo sopra il isset?:o ??super-soppressione comunque. Le comunicazioni possono ancora essere registrate. E si possono risorgere @avvisi nascosti con:set_error_handler("var_dump");
  • Inoltre, non dovresti usare / raccomandare abitualmente if (isset($_POST["shubmit"]))nel tuo codice iniziale.
  • I nuovi arrivati ​​non individueranno tali errori di battitura. Ti priva solo di avvisi di PHP per questi casi. Aggiungi @o issetsolo dopo aver verificato la funzionalità.

  • Correggi prima la causa. Non gli avvisi.

• @è principalmente accettabile per i parametri $_GET/ $_POSTinput, in particolare se sono opzionali .

E poiché questo copre la maggior parte di tali domande, espandiamo sulle cause più comuni:

$_GET/ $_POST/ $_REQUESTinput non definito

• La prima cosa da fare quando si incontra un indice / offset indefinito è controllare gli errori di battitura:
  $count = $_GET["whatnow?"];

  • È un nome chiave previsto e presente in ogni richiesta di pagina?
  • I nomi delle variabili e le indicazioni di array fanno distinzione tra maiuscole e minuscole in PHP.

• In secondo luogo, se l'avviso non ha una causa ovvia, utilizzare var_dumpo print_rper verificare tutti gli array di input per il loro contenuto corrente:

  var_dump($_GET);
  var_dump($_POST);
  //print_r($_REQUEST);

  Entrambi riveleranno se il tuo script è stato invocato con il diritto o con qualsiasi parametro.

• In alternativa o utilizzare inoltre il browser devtools ( F12) e ispezionare la scheda di rete per richieste e parametri:

  

  I parametri POST e l'ingresso GET verranno visualizzati separatamente.

• Per i $_GETparametri puoi anche dare un'occhiata a QUERY_STRINGin

  print_r($_SERVER);

  PHP ha alcune regole per fondere nomi di parametri non standard nei superglobali. Anche Apache potrebbe riscrivere. In questo modo puoi anche esaminare $_COOKIESle intestazioni di richiesta HTTP non elaborate e altre fornite .

• Più ovviamente guarda la barra degli indirizzi del tuo browser per i parametri GET :

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

  Le name=valuecoppie dopo il ?punto interrogativo sono i parametri della tua query (GET). Quindi questo URL potrebbe solo produrre $_GET["id"]e $_GET["sort"].

• Infine controlla il tuo <form>e le<input> dichiarazioni, se ti aspetti un parametro ma non ne ricevi nessuno.

  • Assicurarsi che ogni input richiesto abbia un <input name=FOO>
  • L' attributo id=o title=non è sufficiente.
  • Una method=POSTforma dovrebbe popolare $_POST.
  • Considerando che un method=GET(o tralasciandolo) produrrebbe $_GETvariabili.
  • È anche possibile che un modulo venga fornito action=script.php?get=paramtramite $ _GET e i method=POSTcampi rimanenti in $ _POST a fianco.
  • Con le moderne configurazioni PHP (≥ 5.6) è diventato possibile (non di moda) $_REQUEST['vars']riutilizzarlo, il che mescola i parametri GET e POST.

• Se stai utilizzando mod_rewrite, allora dovresti controllare sia l' access.logabilitazione che la RewriteLogdeterminazione dei parametri assenti.

$_FILES

• Gli stessi controlli di integrità si applicano ai caricamenti di file e $_FILES["formname"].
• Inoltre controlla enctype=multipart/form-data
• Così come method=POSTnella tua <form>dichiarazione.
• Vedi anche: PHP Errore indice indefinito $ _FILES?

$_COOKIE

• L' $_COOKIEarray non viene mai popolato subito dopo setcookie(), ma solo su qualsiasi richiesta HTTP di follow-up.
• Inoltre, il loro timeout di validità potrebbe essere un vincolo per sottodomini o percorsi individuali e l'utente e il browser possono semplicemente rifiutarli o eliminarli.

Generalmente a causa della "cattiva programmazione" e della possibilità di errori adesso o dopo.

1. Se si tratta di un errore, eseguire prima un'assegnazione corretta alla variabile: $ varname = 0;
2. Se in realtà è definito solo a volte, provalo: if (isset($varname))prima di usarlo
3. Se è perché l'hai scritto male, correggilo
4. Forse persino girare gli avvisi nelle tue impostazioni PHP

Significa che stai testando, valutando o stampando una variabile a cui non hai ancora assegnato nulla. Significa che hai un refuso o devi prima verificare che la variabile sia stata inizializzata su qualcosa. Controlla i tuoi percorsi logici, potrebbe essere impostato in un percorso ma non in un altro.

Non volevo disabilitare la notifica perché è utile, ma volevo evitare troppe battiture.

La mia soluzione era questa funzione:

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

Quindi, se voglio fare riferimento a $ name ed echo se esiste, scrivo semplicemente:

<?=ifexists('name')?>

Per gli elementi dell'array:

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

Nella pagina se voglio fare riferimento a $ _REQUEST ['nome']:

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

Il modo migliore per ottenere la stringa di input è:

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

Questo one-liner è quasi equivalente a:

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

Se vuoi assolutamente il valore di stringa , proprio come:

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

È perché la variabile '$ user_location' non viene definita. Se si utilizza un ciclo if all'interno del quale si dichiara la variabile '$ user_location', è necessario disporre anche di un ciclo else e definire lo stesso. Per esempio:

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

Il codice sopra creerà un errore poiché Il ciclo if non è soddisfatto e nel ciclo else '$ user_location' non è stato definito. A PHP è stato comunque chiesto di fare eco alla variabile. Quindi per modificare il codice è necessario effettuare le seguenti operazioni:

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

In risposta a "" Perché appaiono all'improvviso? Usavo questo script da anni e non ho mai avuto problemi. "

È molto comune per la maggior parte dei siti operare sotto la segnalazione di errori "predefinita" di "Mostra tutti gli errori, ma non" avvisi "e" obsoleto "". Questo sarà impostato in php.ini e si applicherà a tutti i siti sul server. Ciò significa che tali "avvisi" utilizzati negli esempi verranno soppressi (nascosti) mentre altri errori, considerati più critici, verranno mostrati / registrati.

L'altra impostazione critica è che gli errori possono essere nascosti (ad es display_errors impostati su "off" o "syslog").

Ciò che è accaduto in questo caso è che o è error_reportingstato modificato per mostrare anche gli avvisi (come da esempi) e / o che le impostazioni sono state modificate display_errorssullo schermo (anziché eliminarle / registrarle).

Perché sono cambiati?

La risposta ovvia / più semplice è che qualcuno ha regolato una di queste impostazioni in php.ini o una versione aggiornata di PHP ora utilizza un php.ini diverso da prima. Questo è il primo posto dove cercare.

Tuttavia è anche possibile sovrascrivere queste impostazioni

• .htconf (configurazione del server web, inclusi vhosts e sotto-configurazioni) *
• .htaccess
• nel codice php stesso

e ognuno di questi potrebbe anche essere stato modificato.

C'è anche l'ulteriore complicazione che la configurazione del server web può abilitare / disabilitare le direttive .htaccess, quindi se hai delle direttive in .htaccess che improvvisamente iniziano / smettono di funzionare, devi verificarlo.

.

Sommario

• Controllare error_reportinge le display_errorsdirettive php in php.ini non sono cambiate o che non si sta utilizzando un php.ini diverso da prima.
• Le direttive check error_reportinge display_errorsphp in .htconf (o vhosts ecc.) Non sono cambiate
• Le direttive check error_reportinge display_errorsphp in .htaccess non sono cambiate
• Se si dispone della direttiva in .htaccess, verificare se sono ancora consentiti nel file .htconf
• Finalmente controlla il tuo codice; possibilmente una biblioteca non correlata; per vedere se le direttive php error_reportinge display_errorssono state impostate lì.

la soluzione rapida è assegnare la variabile a null nella parte superiore del codice

$user_location = null;

Ho usato per maledire questo errore, ma può essere utile ricordarti di sfuggire all'input dell'utente.

Ad esempio, se pensavi che fosse intelligente, codice abbreviato:

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

...Pensa di nuovo! Una soluzione migliore è:

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

(Uso una html()funzione personalizzata per sfuggire ai personaggi, il tuo chilometraggio può variare)

In PHP 7.0 è ora possibile utilizzare l'operatore Null coalescing:

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

Equivale a:

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

PHP manuale PHP 7.0

Uso sempre la funzione utile exst () che dichiara automaticamente le variabili.

Il tuo codice sarà -

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

In un linguaggio molto semplice .
L'errore è che stai usando una variabile $user_locationche non è stata definita da te in precedenza e non ha alcun valore. Quindi ti consiglio di dichiarare questa variabile prima di usarla , ad esempio:

perché non mantenere le cose semplici?

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

?>

PERCHÉ STA SUCCEDENDO?

Nel tempo, PHP è diventato un linguaggio più incentrato sulla sicurezza. Le impostazioni che erano disattivate per impostazione predefinita ora sono attivate per impostazione predefinita. Un esempio perfetto di questo è E_STRICT, che è diventato attivo di default a partire da PHP 5.4.0 .

Inoltre, secondo la documentazione di PHP, per impostazione predefinita, E_NOTICEè disabilitato in php.ini. I documenti PHP consigliano di attivarlo per scopi di debug . Tuttavia, quando scarico PHP dal repository Ubuntu - e dallo stack di Windows di BitNami - vedo qualcos'altro.

; 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

Si noti che in error_reportingrealtà è impostato sul valore di produzione per impostazione predefinita, non sul valore "predefinito" per impostazione predefinita. Questo è un po 'confuso e non è documentata al di fuori di php.ini, così ho non convalidato questo su altre distribuzioni.

Per rispondere alla tua domanda, tuttavia, questo errore viene visualizzato ora quando non è stato visualizzato prima perché:

1. Hai installato PHP e le nuove impostazioni predefinite sono in qualche modo scarsamente documentate ma non le escludono E_NOTICE.

2. E_NOTICEavvisi come variabili indefinite e indici indefiniti aiutano effettivamente a rendere il codice più pulito e sicuro. Posso dirti che, anni fa, mantenere E_NOTICEabilitato mi ha costretto a dichiarare le mie variabili. Ha reso MOLTO più facile da imparare in C, se non dichiarare le variabili è molto più fastidioso.

Cosa posso fare al riguardo?

1. Disattiva E_NOTICEcopiando il "Valore predefinito" E_ALL & ~E_NOTICE & ~E_STRICT & ~E_DEPRECATEDe sostituendolo con ciò che è attualmente non commentato dopo l'accesso uguale error_reporting =. Riavvia Apache o PHP se usi CGI o FPM. Assicurati di modificare il "giusto" php.ini. Quello corretto sarà Apache se si esegue PHP con Apache, fpm o php-fpm se si esegue PHP-FPM, cgi se si esegue PHP-CGI, ecc. Questo non è il metodo consigliato, ma se si dispone di un codice legacy che sta per essere estremamente difficile da modificare, quindi potrebbe essere la soluzione migliore.

2. Disattiva E_NOTICEa livello di file o cartella. Questo potrebbe essere preferibile se hai un codice legacy ma vuoi fare le cose nel modo "giusto" altrimenti. Per fare ciò, dovresti consultare Apache2, Nginx o qualunque sia il tuo server preferito. In Apache, useresti php_valueall'interno di <Directory>.

3. Riscrivi il tuo codice per essere più pulito. Se devi farlo mentre ti sposti in un ambiente di produzione o non vuoi che qualcuno veda i tuoi errori, assicurati di disabilitare qualsiasi visualizzazione degli errori e di registrare solo i tuoi errori (vedi display_errorse log_errorsin php.ini e le impostazioni del tuo server) .

Espandere sull'opzione 3: questo è l'ideale. Se puoi seguire questa strada, dovresti. Se inizialmente non stai seguendo questa strada, considera di spostarla alla fine testando il codice in un ambiente di sviluppo. Mentre ci sei, sbarazzati di ~E_STRICTe ~E_DEPRECATEDvedere cosa potrebbe andare storto in futuro. Vedrai MOLTI errori sconosciuti, ma ti impedirà di avere problemi spiacevoli quando dovrai aggiornare PHP in futuro.

COSA SIGNIFICANO GLI ERRORI?

Undefined variable: my_variable_name- Ciò si verifica quando una variabile non è stata definita prima dell'uso. Quando lo script PHP viene eseguito, internamente assume solo un valore nullo. Tuttavia, in quale scenario dovresti controllare una variabile prima che fosse definita? In definitiva, questo è un argomento per "codice sciatto". Come sviluppatore, posso dirti che mi piace quando vedo un progetto open source in cui le variabili sono definite in alto nei loro ambiti come possono essere definite. Rende più facile dire quali variabili verranno visualizzate in futuro e facilita la lettura / apprendimento del codice.

function foo()
{
    $my_variable_name = '';

    //....

    if ($my_variable_name) {
        // perform some logic
    }
}

Undefined index: my_index- Ciò si verifica quando si tenta di accedere a un valore in un array e non esiste. Per evitare questo errore, eseguire un controllo condizionale.

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

Un'altra opzione è dichiarare un array vuoto nella parte superiore della funzione. Questo non è sempre possibile.

$my_array = array(
    'my_index' => ''
);

//...

$my_array['my_index'] = 'new string';

(suggerimento aggiuntivo)

• Quando ho riscontrato questi e altri problemi, ho usato NetBeans IDE (gratuito) e mi ha dato una serie di avvisi e avvisi. Alcuni offrono suggerimenti molto utili. Questo non è un requisito e non uso più gli IDE, tranne che per progetti di grandi dimensioni. Sono più una vimpersona in questi giorni :).

indice indefinito significa ad esempio in un array richiesto per indice di array non disponibile

<?php 

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

?>

variabile non definita significa che hai utilizzato una variabile completamente non esistente o che non è definita o inizializzata da quel nome, ad esempio

<?php print_r($myvar); ?>

offset non definito significa che nell'array è stata richiesta la chiave inesistente. E la soluzione per questo è controllare prima dell'uso

php> echo array_key_exists(1, $myarray);

Riguardo a questa parte della domanda:

Perché appaiono all'improvviso? Usavo questo script da anni e non ho mai avuto problemi.

Nessuna risposta definita, ma ecco alcune possibili spiegazioni del perché le impostazioni possono "improvvisamente" cambiare:

1. Hai aggiornato PHP a una versione più recente che può avere altri valori predefiniti per segnalazione errori, errori display o altre impostazioni pertinenti.

2. Hai rimosso o introdotto del codice (possibilmente in una dipendenza) che imposta le impostazioni pertinenti in fase di esecuzione utilizzando ini_set()o error_reporting()(cercale nel codice)

3. Hai modificato la configurazione del server web (supponendo qui apache): le .htaccessconfigurazioni di file e vhost possono anche manipolare le impostazioni php.

4. Di solito gli avvisi non vengono visualizzati / segnalati (vedere il manuale di PHP ), quindi è possibile che durante l'impostazione del server, il file php.ini non possa essere caricato per qualche motivo (permessi dei file ??) e tu fossi sulle impostazioni predefinite . In seguito, il 'bug' è stato risolto (per caso) e ora PU load caricare il file php.ini corretto con error_reporting impostato per mostrare le notifiche.

Se lavori con le classi devi assicurarti di fare riferimento alle variabili dei membri usando $this:

class Person
{
    protected $firstName;
    protected $lastName;

    public function setFullName($first, $last)
    {
        // Correct
        $this->firstName = $first;

        // Incorrect
        $lastName = $last;

        // Incorrect
        $this->$lastName = $last;
    }
}

Un altro motivo per cui verrà lanciato un avviso di indice indefinito sarebbe che una colonna è stata omessa da una query del database.

Vale a dire:

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

Quindi provando ad accedere a più colonne / righe all'interno di un ciclo.

Vale a dire:

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

o in un whileciclo:

while( $row = fetching_function($query) ) {

    echo $row['col1'];
    echo "<br>";
    echo $row['col2']; // undefined index thrown
    echo "<br>";
    echo $row['col3']; // undefined index thrown

}

Qualcos'altro che va notato è che su un sistema operativo * NIX e Mac OS X, le cose fanno distinzione tra maiuscole e minuscole.

Consulta le seguenti domande e risposte in pila:

• I nomi delle tabelle in MySQL fanno distinzione tra maiuscole e minuscole?

• nomi di tabella mysql con distinzione tra maiuscole e minuscole nelle query

• MySql - Problema con distinzione tra maiuscole e minuscole delle tabelle in server diversi

L'uso di un ternario è semplice, leggibile e pulito:

Pre PHP 7
Assegna una variabile al valore di un'altra variabile se è impostata, altrimenti assegnanull(o qualunquevalore predefinito sia necessario):

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

PHP 7+
Lo stesso ad eccezione dell'utilizzo di Null Coalescing Operator . Non è più necessario chiamare isset()poiché è incorporato e non è necessario fornire la variabile da restituire poiché si presume che restituisca il valore della variabile da verificare:

$newVariable = $thePotentialData ?? null;

Entrambi interromperanno le comunicazioni dalla domanda del PO ed entrambi sono esattamente l'equivalente di:

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

 
Se non è necessario impostare una nuova variabile, è possibile utilizzare direttamente il valore restituito del ternario, ad esempio con echo argomenti della funzione, ecc.

Eco:

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

Funzione:

$foreName = getForeName(isset($userId) ? $userId : null);

function getForeName($userId)
{
    if ($userId === null) {
        // Etc
    }
}

Quanto sopra funzionerà allo stesso modo con le matrici, comprese le sessioni, ecc., Sostituendo la variabile che viene controllata con ad esempio:
$_SESSION['checkMe']
o comunque siano necessari molti livelli di profondità, ad esempio:
$clients['personal']['address']['postcode']

soppressione:

È possibile sopprimere gli Avvisi PHP con @o ridurre il livello di segnalazione degli errori, ma non risolve il problema , semplicemente interrompe la sua segnalazione nel registro degli errori. Ciò significa che il tuo codice ha ancora tentato di utilizzare una variabile non impostata, il che può significare che qualcosa non funziona come previsto, a seconda di quanto sia cruciale il valore mancante.

Dovresti davvero controllare questo problema e gestirlo in modo appropriato, o servendo un messaggio diverso o anche semplicemente restituendo un valore null per tutto il resto per identificare lo stato preciso.

Se ti interessa solo che l'avviso non si trovi nel registro degli errori, come opzione potresti semplicemente ignorare il registro degli errori.

Una causa comune di una variabile non esistente dopo l' invio di un modulo HTML è che l'elemento del modulo non è contenuto in un <form>tag:

Esempio: elemento non contenuto all'interno di <form>

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

Esempio: elemento ora contenuto nel file <form>

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

Probabilmente hai usato la vecchia versione di PHP fino ad ora e ora PHP aggiornato è il motivo per cui funzionava senza errori fino ad ora da anni. fino a PHP4 non si sono verificati errori se si utilizza la variabile senza definirla, ma a partire da PHP5 in poi genera errori per codici come quelli menzionati in questione.

Quando si ha a che fare con i file, sono richiesti un enctype corretto e un metodo POST, che attiveranno un avviso sull'indice indefinito se uno dei due non è incluso nel modulo.

Il manuale afferma la seguente sintassi di base:

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

?>

Riferimento:

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

Ho fatto una domanda al riguardo e mi è stato riferito a questo post con il messaggio:

Questa domanda ha già una risposta qui:

"Avviso: variabile non definita", "Avviso: indice non definito" e "Avviso: offset non definito" utilizzando PHP

Sto condividendo la mia domanda e soluzione qui:

Questo è l'errore:

La riga 154 è il problema. Questo è quello che ho nella riga 154:

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

Penso che il problema sia che sto scrivendo se le condizioni per la variabile $city, che non è la chiave ma il valore in $key => $city. Innanzitutto, potresti confermare se questa è la causa dell'avvertimento? Secondo, se questo è il problema, perché non riesco a scrivere una condizione basata sul valore? Deve essere con la chiave di cui ho bisogno per scrivere la condizione?

AGGIORNAMENTO 1: Il problema è che durante l'esecuzione $citiesCounterArray[$key], a volte $keycorrisponde a una chiave che non esiste $citiesCounterArraynell'array, ma che non è sempre il caso in base ai dati del mio loop. Ciò di cui ho bisogno è impostare una condizione in modo che se$key esiste nell'array, eseguire il codice, altrimenti, saltarlo.

AGGIORNAMENTO 2: Ecco come l'ho corretto usando array_key_exists():

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

Questi errori si verificano ogni volta che utilizziamo una variabile non impostata.

Il modo migliore per gestirli è impostare la segnalazione degli errori durante lo sviluppo.

Per impostare la segnalazione errori su:

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

Sui server di produzione, la segnalazione degli errori è disattivata, pertanto non vengono visualizzati questi errori.

Sul server di sviluppo, tuttavia, possiamo impostare la segnalazione degli errori.

Per eliminare questo errore, vediamo il seguente esempio:

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

È possibile inizializzare le variabili NULLprima di assegnare i loro valori o utilizzarli.

Quindi, possiamo modificare il codice come:

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

Ciò non disturberà alcuna logica del programma e non produrrà Avviso anche se $testnon ha valore.

Quindi, in pratica, è sempre meglio impostare la segnalazione errori su ON per lo sviluppo.

E correggi tutti gli errori.

E in produzione, la segnalazione degli errori dovrebbe essere disattivata.

Questi avvisi sono perché non hai la variabile utilizzata definede la my_indexchiave non era presente nella $my_arrayvariabile.

Quelle notifiche sono state attivate ogni volta, perché il tuo code non è corretto, ma probabilmente non hai avuto la segnalazione degli avvisi.

Risolvi i bug:

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

Un altro modo per farlo uscire:

ini_set("error_reporting", false)

In PHP hai bisogno di pugno per definire la variabile dopo che puoi usarla.
Possiamo verificare che la variabile sia definita o non in modo molto efficiente !.

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

}

Spiegazione semplice

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