Riferimento - Cosa significa questo errore in PHP?

2012-10-07 php oop debugging warnings

Cos'è questo?

Questa è una serie di risposte su avvisi, errori e avvisi che potresti incontrare durante la programmazione di PHP e non hai idea di come risolverli. Questo è anche un Wiki della comunità, quindi tutti sono invitati a partecipare aggiungendo e mantenendo questo elenco.

Perchè è questo?

Domande come "Intestazioni già inviate" o "Chiamare un membro di un non-oggetto" vengono visualizzate frequentemente su Stack Overflow. La causa principale di queste domande è sempre la stessa. Quindi le risposte a queste domande in genere le ripetono e quindi mostrano all'OP quale linea cambiare nel loro caso particolare. Queste risposte non aggiungono alcun valore al sito perché si applicano solo al codice particolare del PO. Altri utenti con lo stesso errore non possono leggere facilmente la soluzione perché sono troppo localizzati. È triste perché una volta compresa la causa principale, correggere l'errore è banale. Quindi, questo elenco cerca di spiegare la soluzione in modo generale da applicare.

Cosa dovrei fare qui?

Se la tua domanda è stata contrassegnata come duplicata di questa, trova il tuo messaggio di errore di seguito e applica la correzione al tuo codice. Le risposte di solito contengono ulteriori collegamenti per indagare nel caso in cui non dovrebbe essere chiaro dalla sola risposta generale.

Se vuoi contribuire, aggiungi il tuo messaggio di errore "preferito", avviso o avviso, uno per risposta, una breve descrizione del significato (anche se evidenzia solo i termini nella loro pagina di manuale), una possibile soluzione o approccio di debug e un elenco di domande e risposte esistenti che hanno valore. Inoltre, sentiti libero di migliorare qualsiasi risposta esistente.

La lista

Vedi anche:

Answers

Errore irreversibile: chiamata a una funzione membro ... su un non oggetto

Si verifica con un codice simile a xyz->method() cui xyz non è un oggetto e pertanto tale method non può essere chiamato.

Questo è un errore fatale che interromperà lo script (inoltra l'avviso di compatibilità: diventerà un errore irreversibile a partire da PHP 7).

Molto spesso questo è un segno che nel codice mancano i controlli per le condizioni di errore. Convalida che un oggetto sia effettivamente un oggetto prima di chiamarne i metodi.

Un esempio tipico sarebbe

// ... some code using PDO
$statement = $pdo->prepare('invalid query', ...);
$statement->execute(...);

Nell'esempio sopra, la query non può essere preparata e prepare() assegnerà false a $statement . Il tentativo di chiamare il metodo execute() comporterà quindi l'errore irreversibile perché false è un "non oggetto" perché il valore è un valore booleano.

Scopri perché la tua funzione ha restituito un valore booleano anziché un oggetto. Ad esempio, controllare l'oggetto $pdo per l'ultimo errore che si è verificato. I dettagli su come eseguire il debug dipenderanno da come vengono gestiti gli errori per la particolare funzione / oggetto / classe in questione.

Se anche il $pdo ->prepare non $pdo funzionando, l'oggetto handle del database $pdo non è stato passato nell'ambito corrente . Trova dove è stato definito. Quindi passarlo come parametro, archiviarlo come proprietà o condividerlo tramite l'ambito globale.

Un altro problema potrebbe essere la creazione condizionale di un oggetto e il tentativo di chiamare un metodo esterno a quel blocco condizionale. Per esempio

if ($someCondition) {
    $myObj = new MyObj();
}
// ...
$myObj->someMethod();

Tentando di eseguire il metodo al di fuori del blocco condizionale, l'oggetto potrebbe non essere definito.

Domande correlate:

Avvertenza: mysql_fetch_array () prevede che il parametro 1 sia una risorsa, dato booleano

Innanzitutto:

Per favore, non usare le funzioni mysql_* nel nuovo codice . Non sono più mantenuti e sono ufficialmente deprecati . Vedi la scatola rossa ? Scopri invece le dichiarazioni preparate e usa PDO o MySQLi : questo articolo ti aiuterà a decidere quale. Se scegli DOP, ecco un buon tutorial .


Ciò accade quando si tenta di recuperare i dati dal risultato di mysql_query ma la query non è riuscita.

Questo è un avvertimento e non fermerà lo script, ma renderà il tuo programma sbagliato.

Devi controllare il risultato restituito da mysql_query da

$res = mysql_query($sql);
if (!$res) {
   die(mysql_error());
}
// after checking, do the fetch

Domande correlate:

Errori correlati:

Altre funzioni mysql* che prevedono anche una risorsa risultato MySQL come parametro produrranno lo stesso errore per lo stesso motivo.

Avviso: impossibile modificare le informazioni dell'intestazione - intestazioni già inviate

Succede quando lo script tenta di inviare un'intestazione HTTP al client ma in precedenza era già stato generato, il che ha comportato che le intestazioni fossero già inviate al client.

Questo è un E_WARNING e non fermerà lo script.

Un tipico esempio potrebbe essere un file modello come questo:

<html>
    <?php session_start(); ?>
    <head><title>My Page</title>
</html>
...

La funzione session_start() tenterà di inviare al client intestazioni con il cookie di sessione. Ma PHP ha già inviato le intestazioni quando ha scritto l'elemento <html> nel flusso di output. Dovresti spostare session_start() in alto.

Puoi risolverlo passando attraverso le righe prima del codice che attiva l'Avvertimento e controlla dove viene emesso. Sposta qualsiasi codice di invio dell'intestazione prima di quel codice.

Un output spesso trascurato sono le nuove righe dopo la chiusura di PHP ?> . È considerata una pratica standard omettere ?> Quando è l'ultima cosa nel file. Allo stesso modo, un'altra causa comune per questo avviso è quando l'apertura <?php ha uno spazio vuoto, una linea o un carattere invisibile prima di esso, facendo sì che il server web invii le intestazioni e lo spazio bianco / newline quindi quando PHP inizia l'analisi non sarà in grado di inviare qualsiasi intestazione.

Se il tuo file contiene più di un blocco di codice <?php ... ?> , Non dovresti avere spazi tra di loro. (Nota: potresti avere più blocchi se avessi il codice che è stato costruito automaticamente)

Assicurati inoltre di non avere segni di ordine di byte nel tuo codice, ad esempio quando la codifica dello script è UTF-8 con BOM.

Domande correlate:

Errore di analisi: errore di sintassi, T_XXX imprevisto

Succede quando hai un token T_XXX in un posto inaspettato, parentesi sbilanciate (superflue), uso di tag brevi senza attivarlo in php.ini e molti altri.

Domande correlate:

Per ulteriore aiuto, consultare:

Errore di analisi: errore di sintassi, T_PAAMAYIM_NEKUDOTAYIM imprevisto

L'operatore di risoluzione dell'ambito è anche chiamato "Paamayim Nekudotayim" dall'ebraico פעמיים נקודתיים. che significa "doppio colon".

Questo errore si verifica in genere se si inserisce inavvertitamente :: nel codice.

Domande correlate:

Documentazione:

Errore irreversibile: dimensione della memoria consentita di XXX byte esaurita (tentativo di allocare XXX byte)

Memoria insufficiente per eseguire lo script. PHP ha raggiunto il limite di memoria e interrompe l'esecuzione. Questo errore è fatale, lo script si interrompe. Il valore del limite di memoria può essere configurato nel file php.ini o usando ini_set('memory_limit', '128 M'); nello script (che sovrascriverà il valore definito in php.ini ). Lo scopo del limite di memoria è impedire a un singolo script PHP di inghiottire tutta la memoria disponibile e di arrestare l'intero server Web.

La prima cosa da fare è ridurre al minimo la quantità di memoria necessaria per lo script. Ad esempio, se stai leggendo un file di grandi dimensioni in una variabile o stai recuperando molti record da un database e li stai archiviando tutti in un array, questo potrebbe usare molta memoria. Modificare il codice per leggere invece il file riga per riga o recuperare i record del database uno alla volta senza memorizzarli tutti in memoria. Ciò richiede un po 'di consapevolezza concettuale di ciò che sta accadendo dietro le quinte e quando i dati sono archiviati in memoria rispetto ad altrove.

Se questo errore si è verificato quando lo script non stava eseguendo un lavoro ad alta intensità di memoria, è necessario controllare il codice per vedere se c'è una perdita di memoria. La funzione memory_get_usage è tua amica.

Domande correlate:

Errore irreversibile: utilizzo di $ this quando non nel contesto dell'oggetto

$this è una variabile speciale in PHP che non può essere assegnata. Se si accede in un contesto in cui non esiste, viene visualizzato questo errore irreversibile.

Questo errore può verificarsi:

  1. Se un metodo non statico viene chiamato staticamente. Esempio:

    class Foo {
       protected $var;
       public function __construct($var) {
           $this->var = $var;
       }
    
       public static function bar () {
           // ^^^^^^
           echo $this->var;
           //   ^^^^^
       }
    }
    
    Foo::bar();
    

    Come risolvere: rivedere di nuovo il codice, $this può essere utilizzato solo in un contesto di oggetto e non deve mai essere utilizzato in un metodo statico. Inoltre, un metodo statico non dovrebbe accedere alla proprietà non statica. Utilizzare self::$static_property per accedere alla proprietà statica.

  2. Se il codice di un metodo di classe è stato copiato in una normale funzione o solo nell'ambito globale e mantenendo $this variabile speciale.
    Come risolvere: rivedere il codice e sostituire $this con una variabile di sostituzione diversa.

Domande correlate:

  1. Chiama il metodo non statico come statico: PHP Errore irreversibile: utilizzo di $ this quando non nel contesto dell'oggetto
  2. Copia su codice: errore irreversibile: utilizzo di $ this quando non nel contesto dell'oggetto
  3. Tutte le domande "Utilizzo di $ this quando non nel contesto dell'oggetto" su Stackoverflow

Errore irreversibile: impossibile utilizzare il valore restituito dalla funzione nel contesto di scrittura

Questo di solito accade quando si utilizza una funzione direttamente con empty .

Esempio:

if (empty(is_null(null))) {
  echo 'empty';
}

Questo perché empty è un costrutto di linguaggio e non una funzione, non può essere chiamato con un'espressione come argomento nelle versioni di PHP precedenti alla 5.5. Prima di PHP 5.5, l'argomento di empty() deve essere una variabile , ma un'espressione arbitraria (come un valore di ritorno di una funzione) è consentita in PHP 5.5+.

empty , nonostante il suo nome, in realtà non controlla se una variabile è "vuota". Al contrario, controlla se non esiste una variabile o == false . Le espressioni (come is_null(null) nell'esempio) saranno sempre considerate esistenti, quindi qui empty sta solo verificando se è uguale a falso. Puoi sostituire empty() qui con ! , ad esempio if (!is_null(null)) , o confrontare esplicitamente con false, ad esempio if (is_null(null) == false) .

Domande correlate:

Avviso: indice indefinito

Succede quando si tenta di accedere a un array tramite una chiave che non esiste nell'array.

Un esempio tipico di un avviso di Undefined Index sarebbe ( demo )

$data = array('foo' => '42', 'bar');
echo $data['spinach'];
echo $data[1];

Sia gli spinach che 1 non esistono nell'array, provocando l'attivazione di E_NOTICE .

La soluzione è assicurarsi che l'indice o l'offset esistano prima di accedere a tale indice. Ciò può significare che è necessario correggere un bug nel programma per assicurarsi che tali indici esistano quando previsto. Oppure può significare che è necessario verificare se gli indici esistono usando array_key_exists o isset :

$data = array('foo' => '42', 'bar');
if (array_key_exists('spinach', $data)) {
    echo $data['spinach'];
}
else {
    echo 'No key spinach in the array';
}

Se hai un codice come:

<?php echo $_POST['message']; ?>
<form method="post" action="">
    <input type="text" name="message">
    ...

quindi $_POST['message'] non verrà impostato quando questa pagina viene caricata per la prima volta e si otterrà l'errore sopra riportato. Solo quando il modulo viene inviato e questo codice viene eseguito una seconda volta, esiste l'indice di array. In genere si verifica questo con:

if ($_POST)  ..  // if the $_POST array is not empty
// or
if ($_SERVER['REQUEST_METHOD'] == 'POST') ..  // page was requested with POST

Domande correlate:

MySQL: hai un errore nella sintassi SQL; controlla il manuale corrispondente alla versione del tuo server MySQL per la sintassi corretta da usare vicino ... alla linea ...

Questo errore è spesso causato perché hai dimenticato di sfuggire correttamente ai dati passati a una query MySQL.

Un esempio di cosa non fare (la "cattiva idea"):

$query = "UPDATE `posts` SET my_text='{$_POST['text']}' WHERE id={$_GET['id']}";
mysqli_query($db, $query);

Questo codice potrebbe essere incluso in una pagina con un modulo da inviare, con un URL come http://example.com/edit.php?id=10 (per modificare il post n ° 10)

Cosa succederà se il testo inviato contiene virgolette singole? $query finirà con:

$query = "UPDATE `posts` SET my_text='I'm a PHP newbie' WHERE id=10';

E quando questa query viene inviata a MySQL, si lamenterà che la sintassi è sbagliata, perché nel mezzo c'è una virgoletta singola aggiuntiva.

Per evitare tali errori, DEVI sempre sfuggire ai dati prima dell'uso in una query.

Anche l'escape dei dati prima dell'uso in una query SQL è molto importante perché, in caso contrario, lo script sarà aperto alle iniezioni di SQL. Un'iniezione SQL può causare l'alterazione, la perdita o la modifica di un record, una tabella o un intero database. Questo è un problema di sicurezza molto serio!

Documentazione:

Attenzione: restrizione open_basedir in vigore

Questo avviso può essere visualizzato con varie funzioni correlate all'accesso ai file e alle directory. Segnala un problema di configurazione.

Quando appare, significa che è stato proibito l'accesso ad alcuni file.

L'avvertimento stesso non rompe nulla, ma molto spesso uno script non funziona correttamente se viene impedito l'accesso ai file.

La correzione è normalmente per cambiare la configurazione di PHP , la relativa impostazione si chiama open_basedir .

A volte vengono utilizzati nomi di file o directory errati, la correzione è quindi quella di utilizzare quelli giusti.

Domande correlate:

Non si vede niente. La pagina è vuota e bianca.

Conosciuto anche come White Page Of Death o White Screen Of Death . Ciò accade quando la segnalazione degli errori è disattivata e si è verificato un errore irreversibile (spesso errore di sintassi).

Se hai attivato la registrazione degli errori, troverai il messaggio di errore concreto nel tuo registro degli errori. Questo di solito si trova in un file chiamato "php_errors.log", in una posizione centrale (ad es. /var/log/apache2 su molti ambienti Linux) o nella directory dello script stesso (a volte usato in un ambiente di hosting condiviso).

A volte potrebbe essere più semplice abilitare temporaneamente la visualizzazione degli errori. La pagina bianca visualizzerà quindi il messaggio di errore. Fai attenzione perché questi errori sono visibili a tutti coloro che visitano il sito web.

Questo può essere fatto facilmente aggiungendo nella parte superiore dello script il seguente codice PHP:

ini_set('display_errors', 1); error_reporting(~0);

Il codice attiverà la visualizzazione degli errori e imposterà il reporting al massimo livello.

Poiché ini_set() viene eseguito in fase di runtime, non ha effetti sugli errori di analisi / sintassi. Tali errori verranno visualizzati nel registro. Se vuoi visualizzarli anche nell'output (ad es. In un browser) devi impostare la direttiva display_startup_errors su true . Fallo in php.ini o in .htaccess o con qualsiasi altro metodo che influisce sulla configurazione prima del runtime .

È possibile utilizzare gli stessi metodi per impostare le direttive log_errors e error_log per scegliere la propria posizione del file di registro.

Guardando nel registro o usando il display, si otterrà un messaggio di errore molto migliore e la riga di codice in cui si interrompe lo script.

Domande correlate:

Errori correlati:

Avviso: utilizzo della costante non definita XXX - presupposto "XXX"

o, in PHP 7.2 o versioni successive:

Avvertenza: utilizzo della costante non definita XXX - presupposto "XXX" (ciò genererà un errore in una versione futura di PHP)

Questo avviso si verifica quando un token viene utilizzato nel codice e sembra essere una costante, ma una costante con quel nome non è definita.

Una delle cause più comuni di questo avviso è la mancata citazione di una stringa utilizzata come chiave di matrice associativa.

Per esempio:

// Wrong
echo $array[key];

// Right
echo $array['key'];

Un'altra causa comune è un segno $ (dollaro) mancante davanti a un nome di variabile:

// Wrong
echo varName;

// Right
echo $varName;

O forse hai sbagliato a scrivere qualche altra costante o parola chiave:

// Wrong
$foo = fasle;

// Right
$foo = false;

Può anche essere un segno che manca un'estensione o libreria PHP necessaria quando si tenta di accedere a una costante definita da quella libreria.

Domande correlate:

Avviso: variabile non definita

Succede quando si tenta di utilizzare una variabile che non era stata precedentemente definita.

Un esempio tipico sarebbe

foreach ($items as $item) {
    // do something with item
    $counter++;
}

Se non hai definito $counter prima, il codice sopra attiverà l'avviso.

Il modo corretto sarebbe quello di impostare la variabile prima di usarla, anche se è solo una stringa vuota come

$counter = 0;
foreach ($items as $item) {
    // do something with item
    $counter++;
}

Avviso: proprietà non definita

Questo errore significa più o meno la stessa cosa, ma si riferisce a una proprietà di un oggetto. Riutilizzando l'esempio sopra, questo codice genererebbe l'errore perché la proprietà counter non è stata impostata.

$obj = new stdclass;
$obj->property = 2342;
foreach ($items as $item) {
    // do something with item
    $obj->counter++;
}

Domande correlate:

Errore irreversibile: chiamata alla funzione non definita XXX

Succede quando si tenta di chiamare una funzione non ancora definita. Cause comuni includono estensioni mancanti e include, dichiarazione di funzione condizionale, funzione in una dichiarazione di funzione o errori di battitura semplici.

Esempio 1 - Dichiarazione di funzione condizionale

$someCondition = false;
if ($someCondition === true) {
    function fn() {
        return 1;
    }
}
echo fn(); // triggers error

In questo caso, fn() non verrà mai dichiarato perché $someCondition non è vero.

Esempio 2 - Funzione nella dichiarazione di funzione

function createFn() 
{
    function fn() {
        return 1;
    }
}
echo fn(); // triggers error

In questo caso, fn verrà dichiarato solo dopo createFn() chiamato createFn() . Si noti che le successive chiamate a createFn() attiveranno un errore relativo alla redeclaration di una funzione esistente.

Puoi anche vedere questo per una funzione integrata di PHP. Prova a cercare la funzione nel manuale ufficiale e controlla a quale "estensione" (modulo PHP) appartiene e quali versioni di PHP lo supportano.

In caso di un'estensione mancante, installare tale estensione e abilitarla in php.ini. Fai riferimento alle Istruzioni di installazione nel Manuale PHP per l'estensione in cui appare la tua funzione. Potresti anche essere in grado di abilitare o installare l'estensione usando il tuo gestore pacchetti (ad es. apt in Debian o Ubuntu, yum in Red Hat o CentOS), o un pannello di controllo in un ambiente di hosting condiviso.

Se la funzione è stata introdotta in una versione più recente di PHP da ciò che si sta utilizzando, è possibile trovare collegamenti a implementazioni alternative nel manuale o nella relativa sezione dei commenti. Se è stato rimosso da PHP, cerca informazioni sul perché, poiché potrebbe non essere più necessario.

In caso di inclusioni mancanti, assicurarsi di includere il file che dichiara la funzione prima di chiamare la funzione.

In caso di errori di battitura, correggere l'errore di battitura.

Domande correlate:

Avviso: [funzione] : impossibile aprire il flusso: [motivo]

Succede quando si chiama un file di solito include , require o fopen e PHP non è riuscito a trovare il file o non dispone dell'autorizzazione sufficiente per caricare il file.

Questo può accadere per una serie di motivi:

  • il percorso del file è errato
  • il percorso del file è relativo
  • includere il percorso è sbagliato
  • le autorizzazioni sono troppo restrittive
  • SELinux è in vigore
  • e tanti altri ...

Un errore comune è di non usare un percorso assoluto. Questo può essere facilmente risolto usando un percorso completo o costanti magiche come __DIR__ o dirname(__FILE__) :

include __DIR__ . '/inc/globals.inc.php';

o:

require dirname(__FILE__) . '/inc/globals.inc.php';

Garantire che venga utilizzato il percorso corretto è un passo nella risoluzione di questi problemi, questo può anche essere correlato a file inesistenti, diritti del filesystem che impediscono l'accesso o restrizioni basate su openir dallo stesso PHP.

Il modo migliore per risolvere rapidamente questo problema è seguire l'elenco di controllo per la risoluzione dei problemi riportato di seguito.

Domande correlate:

Errori correlati:

Errore irreversibile: impossibile ripetere la dichiarazione della classe [nome classe]

Errore irreversibile: Impossibile ripetere [nome funzione]

Ciò significa che stai usando due volte lo stesso nome di funzione / classe e devi rinominarne uno, oppure perché hai usato require o include dove dovresti usare require_once o include_once .

Quando una classe o una funzione viene dichiarata in PHP, è immutabile e non può essere successivamente dichiarata con un nuovo valore.

Considera il seguente codice:

class.php

<?php

class MyClass
{
    public function doSomething()
    {
        // do stuff here
    }
}

index.php

<?php

function do_stuff()
{
   require 'class.php';
   $obj = new MyClass;
   $obj->doSomething();
}

do_stuff();
do_stuff();

La seconda chiamata a do_stuff() produrrà l'errore sopra. Cambiando require a require_once , possiamo essere certi che il file che contiene la definizione di MyClass verrà caricato solo una volta, e sarà evitata l'errore.

Errore di analisi: errore di sintassi, T_ENCAPSED_AND_WHITESPACE imprevisto

Questo errore si verifica spesso quando si tenta di fare riferimento a un valore di array con una chiave tra virgolette per l'interpolazione all'interno di una stringa tra virgolette doppie quando l'intero costrutto variabile complessa non è racchiuso in {} .

Il caso di errore:

Ciò comporterà Unexpected T_ENCAPSED_AND_WHITESPACE :

echo "This is a double-quoted string with a quoted array key in $array['key']";
//---------------------------------------------------------------------^^^^^

Possibili correzioni:

In una stringa tra virgolette doppie, PHP consentirà di utilizzare le stringhe di chiavi dell'array non quotate e non emetterà un E_NOTICE . Quindi quanto sopra potrebbe essere scritto come:

echo "This is a double-quoted string with an un-quoted array key in $array[key]";
//------------------------------------------------------------------------^^^^^

L'intera variabile di array complessa e le chiavi possono essere racchiuse tra {} , nel qual caso devono essere quotate per evitare un E_NOTICE . La documentazione di PHP raccomanda questa sintassi per variabili complesse.

echo "This is a double-quoted string with a quoted array key in {$array['key']}";
//--------------------------------------------------------------^^^^^^^^^^^^^^^
// Or a complex array property of an object:
echo "This is a a double-quoted string with a complex {$object->property->array['key']}";

Naturalmente, l'alternativa a una qualsiasi delle precedenti è concatenare la variabile array invece di interpolarla:

echo "This is a double-quoted string with an array variable". $array['key'] . " concatenated inside.";
//----------------------------------------------------------^^^^^^^^^^^^^^^^^^^^^

Per riferimento, consultare la sezione Analisi delle variabili nella pagina del manuale delle stringhe PHP

Avvertenza: [funzione] prevede che il parametro 1 sia una risorsa, valore booleano

(Una variante più generale di Warning: mysql_fetch_array () prevede che il parametro 1 sia una risorsa, dato booleano )

Le risorse sono un tipo in PHP (come stringhe, numeri interi o oggetti). Una risorsa è un blob opaco con nessun valore intrinsecamente significativo. Una risorsa è specifica e definita da un determinato insieme di funzioni o estensioni PHP. Ad esempio, l'estensione Mysql definisce due tipi di risorse :

Esistono due tipi di risorse utilizzate nel modulo MySQL. Il primo è l'identificatore di collegamento per una connessione al database, il secondo una risorsa che contiene il risultato di una query.

L'estensione cURL definisce altri due tipi di risorse :

... una maniglia cURL e una maniglia multipla cURL.

Quando var_dump ed i valori si presentano così:

$resource = curl_init();
var_dump($resource);

resource(1) of type (curl)

Questo è tutto ciò che la maggior parte delle risorse sono, un identificatore numerico ( (1) ) di un certo tipo ( (curl) ).

Trasportate queste risorse e le passate a funzioni diverse per le quali una tale risorsa significa qualcosa. In genere queste funzioni allocano determinati dati in background e una risorsa è solo un riferimento che usano per tenere traccia di questi dati internamente.


L'errore " ... prevede che il parametro 1 sia risorsa, valore booleano " è in genere il risultato di un'operazione non controllata che avrebbe dovuto creare una risorsa, ma invece ha restituito false . Ad esempio, la funzione fopen ha questa descrizione:

Valori di restituzione

Restituisce una risorsa del puntatore del file in caso di successo o FALSE in caso di errore.

Quindi in questo codice, $fp sarà una resource(x) of type (stream) o false :

$fp = fopen(...);

Se non si controlla se l'operazione fopen esito positivo o negativo e quindi se $fp è una risorsa valida o false e si passa $fp a un'altra funzione che prevede una risorsa, è possibile che si verifichi l'errore sopra riportato:

$fp   = fopen(...);
$data = fread($fp, 1024);

Warning: fread() expects parameter 1 to be resource, boolean given

È sempre necessario verificare l'errore del valore restituito delle funzioni che stanno tentando di allocare una risorsa e potrebbero non riuscire :

$fp = fopen(...);

if (!$fp) {
    trigger_error('Failed to allocate resource');
    exit;
}

$data = fread($fp, 1024);

Errori correlati:

Errore di analisi: errore di sintassi, T_VARIABLE imprevisto

Possibile scenario

Non riesco a trovare dove il mio codice è andato storto. Ecco il mio errore completo:

Errore di analisi: errore di sintassi, T_VARIABLE imprevisto sulla riga x

Quello che sto provando

$sql = 'SELECT * FROM dealer WHERE id="'$id.'"';

Risposta

Errore di analisi: un problema con la sintassi del programma, ad esempio lasciare un punto e virgola fuori dalla fine di un'istruzione o, come nel caso precedente, mancare il . operatore. L'interprete interrompe l'esecuzione del programma quando rileva un errore di analisi.

In parole semplici questo è un errore di sintassi, nel senso che c'è qualcosa nel tuo codice che impedisce di essere analizzato correttamente e quindi in esecuzione.

Quello che dovresti fare è controllare attentamente le righe intorno a dove si trova l'errore per eventuali errori semplici.

Questo messaggio di errore indica che nella riga x del file, l'interprete PHP si aspettava di vedere una parentesi aperta ma invece ha riscontrato qualcosa chiamato T_VARIABLE . Quella cosa T_VARIABLE è chiamata token . È il modo in cui l'interprete PHP esprime le diverse parti fondamentali dei programmi. Quando l'interprete legge in un programma, traduce ciò che hai scritto in un elenco di token. Ovunque metti una variabile nel tuo programma, c'è un token T_VARIABLE nell'elenco degli interpreti.

Buona lettura: elenco di token parser

Quindi assicurati di abilitare almeno E_PARSE nel tuo php.ini . Errori di analisi non dovrebbero esistere negli script di produzione.

Ho sempre raccomandato di aggiungere la seguente dichiarazione, durante la codifica:

error_reporting(E_ALL);

Segnalazione errori PHP

Inoltre, è una buona idea usare un IDE che ti farà conoscere errori di analisi durante la digitazione. Puoi usare:

  1. NetBeans (un bel pezzo di bellezza, software libero) (il migliore secondo me)
  2. PhpStorm (lo zio Gordon ama questo: P, piano a pagamento, contiene software proprietario e gratuito)
  3. Eclipse (la bella e la bestia, software libero)

Domande correlate:

Avviso: offset stringa non inizializzato: *

Come indica il nome, si verifica questo tipo di errore, quando molto probabilmente si sta tentando di scorrere o trovare un valore da un array con una chiave inesistente.

Consideralo, stai provando a mostrare ogni lettera da $string

$string = 'ABCD'; 
for ($i=0, $len = strlen($string); $i <= $len; $i++){
    echo "$string[$i] \n"; 
}

L'esempio sopra genererà ( demo online ):

A
B
C
D
Notice: Uninitialized string offset: 4 in XXX on line X

E, non appena lo script termina con l'eco di D , otterrai l'errore, perché all'interno del ciclo for() , hai detto a PHP di mostrarti il ​​carattere dalla prima alla quinta stringa di 'ABCD' , che esiste, ma dal momento che ciclo inizia a contare da 0 e echi D dal momento in cui raggiunge a 4 , viene generato un errore di offset.

Errori simili:

Avvertenza: divisione per zero

Il messaggio di avviso "Divisione per zero" è una delle domande più frequenti tra i nuovi sviluppatori PHP. Questo errore non causerà un'eccezione, pertanto alcuni sviluppatori a volte sopprimono l'avviso aggiungendo l'operatore di soppressione dell'errore @ prima dell'espressione. Per esempio:

$value = @(2 / 0);

Ma, come con qualsiasi avviso, l'approccio migliore sarebbe quello di rintracciare la causa dell'avviso e risolverlo. La causa dell'avvertimento verrà da qualsiasi istanza in cui si tenta di dividere per 0, una variabile uguale a 0 o una variabile che non è stata assegnata (perché NULL == 0) perché il risultato sarà "indefinito".

Per correggere questo avviso, dovresti riscrivere la tua espressione per verificare che il valore non sia 0, se lo è, fai qualcos'altro. Se il valore è zero, non dovresti dividere, oppure dovresti cambiare il valore in 1 e quindi dividere in modo che la divisione si traduca nell'equivalente di aver diviso solo per la variabile aggiuntiva.

if ( $var1 == 0 ) { // check if var1 equals zero
    $var1 = 1; // var1 equaled zero so change var1 to equal one instead
    $var3 = ($var2 / $var1); // divide var1/var2 ie. 1/1
} else {
    $var3 = ($var2 / $var1); // if var1 does not equal zero, divide
}

Domande correlate:

Standard rigorosi: il metodo non statico [<class> :: <method>] non deve essere chiamato staticamente

Si verifica quando si tenta di chiamare un metodo non statico su una classe poiché era statico e si ha anche il flag E_STRICT nelle impostazioni error_reporting() .

Esempio :

class HTML {
   public function br() {
      echo '<br>';
   }
}

HTML::br() o $html::br()

Puoi effettivamente evitare questo errore non aggiungendo E_STRICT a error_reporting() , ad es

error_reporting(E_ALL & ~E_STRICT);

poiché come per PHP 5.4.0 e versioni successive, E_STRICT è incluso in E_ALL [ ref ]. Ma questo non è auspicabile. La soluzione è definire la funzione statica desiderata come static effettiva:

public static function br() {
  echo '<br>';
}

o chiama la funzione in modo convenzionale:

$html = new HTML();
$html->br();

Domande correlate :

Errore di analisi: errore di sintassi, imprevisto '['

Questo errore si presenta in due variatori:

Variazione 1

$arr = [1, 2, 3];

Questa sintassi di inizializzazione dell'array è stata introdotta solo in PHP 5.4; genererà un errore parser nelle versioni precedenti. Se possibile, aggiorna la tua installazione o usa la vecchia sintassi:

$arr = array(1, 2, 3);

Vedi anche questo esempio dal manuale.

Variazione 2

$suffix = explode(',', 'foo,bar')[1];

I risultati della funzione di dereferenziazione dell'array sono stati introdotti anche in PHP 5.4. Se non è possibile eseguire l'aggiornamento, è necessario utilizzare una variabile (temporanea):

$parts = explode(',', 'foo,bar');
$suffix = $parts[1];

Vedi anche questo esempio dal manuale.

Il codice non viene eseguito / ciò che appare come parti del mio codice PHP vengono emesse

Se non vedi alcun risultato dal tuo codice PHP e / o stai vedendo parti del tuo output letterale di codice sorgente PHP nella pagina web, puoi essere abbastanza sicuro che il tuo PHP non verrà effettivamente eseguito. Se usi Visualizza sorgente nel tuo browser, probabilmente vedrai l'intero file di codice sorgente PHP così com'è. Poiché il codice PHP è incorporato nei <?php ?> , Il browser proverà a interpretarli come tag HTML e il risultato potrebbe apparire alquanto confuso.

Per eseguire effettivamente i tuoi script PHP, devi:

  • un web server che esegue il tuo script
  • per impostare l'estensione del file su .php, altrimenti il ​​web server non la interpreterà come tale *
  • per accedere al tuo file .php tramite il web server

* A meno che non lo riconfiguri, tutto può essere configurato.

Quest'ultimo è particolarmente importante. È sufficiente fare doppio clic sul file per aprirlo nel browser utilizzando un indirizzo come:

file://C:/path/to/my/file.php

Questo sta bypassando completamente qualsiasi server Web che potresti avere in esecuzione e il file non viene interpretato. Devi visitare l'URL del file sul tuo server web, probabilmente qualcosa del tipo:

http://localhost/my/file.php

Puoi anche verificare se stai utilizzando tag aperti brevi <? invece di <?php e la tua configurazione di PHP ha disattivato i tag di apertura brevi.

Vedi anche che il codice PHP non viene eseguito, invece il codice mostra sulla pagina

Avviso: conversione da array a stringa

Questo accade semplicemente se provi a trattare un array come una stringa:

$arr = array('foo', 'bar');

echo $arr;  // Notice: Array to string conversion
$str = 'Something, ' . $arr;  // Notice: Array to string conversion

Un array non può semplicemente essere echo 'o concatenato con una stringa, perché il risultato non è ben definito. PHP utilizzerà la stringa "Array" al posto dell'array e attiverà l'avviso per sottolineare che probabilmente non è quello che era previsto e che dovresti controllare qui il tuo codice. Probabilmente vuoi qualcosa del genere invece:

echo $arr[0];  // displays foo
$str = 'Something ' . join(', ', $arr); //displays Something, foo, bar

O esegui il loop dell'array:

foreach($arr as $key => $value) {
    echo "array $key = $value";
    // displays first: array 0 = foo
    // displays next:  array 1 = bar
}

Se questo avviso appare da qualche parte che non ti aspetti, significa che una variabile che pensavi fosse una stringa è in realtà un array. Ciò significa che hai un bug nel tuo codice che rende questa variabile un array invece della stringa che ti aspetti.

Avviso: tentativo di ottenere la proprietà dell'errore non oggetto

Succede quando si tenta di accedere a una proprietà di un oggetto mentre non è presente alcun oggetto.

Un esempio tipico per un avviso senza oggetto sarebbe

$users = json_decode('[{"name": "hakre"}]');
echo $users->name; # Notice: Trying to get property of non-object

In questo caso, $users è un array (quindi non un oggetto) e non ha proprietà.

Questo è simile all'accesso a un indice o chiave di un array inesistente (vedere Avviso: indice indefinito ).

Questo esempio è molto semplificato. Molto spesso tale avviso segnala un valore di ritorno non controllato, ad esempio quando una libreria restituisce NULL se un oggetto non esiste o solo un valore non oggetto imprevisto (ad esempio in un risultato Xpath, strutture JSON con formato imprevisto, XML con formato imprevisto ecc. ) ma il codice non verifica tale condizione.

Poiché questi non oggetti vengono spesso elaborati più avanti, spesso si verifica un errore irreversibile in seguito alla chiamata di un metodo oggetto su un non oggetto (consultare: Errore irreversibile: chiamata a una funzione membro ... su un non oggetto ) che interrompe il script.

Può essere facilmente evitato controllando le condizioni di errore e / o che una variabile corrisponde a un'aspettativa. Ecco un avviso con un esempio DOMXPath :

$result  = $xpath->query("//*[@id='detail-sections']/div[1]");
$divText = $result->item(0)->nodeValue; # Notice: Trying to get property of non-object

Il problema sta accedendo alla proprietà nodeValue (campo) del primo elemento mentre non è stato verificato se esiste o meno nella raccolta $result . Invece paga rendere il codice più esplicito assegnando variabili agli oggetti su cui il codice opera:

$result  = $xpath->query("//*[@id='detail-sections']/div[1]");
$div     = $result->item(0);
$divText = "-/-";
if (is_object($div)) {
    $divText = $div->nodeValue;
}
echo $divText;

Errori correlati:

Avviso: offset stringa illegale 'XXX'

Ciò accade quando si tenta di accedere a un elemento dell'array con la sintassi della parentesi quadra, ma lo si fa su una stringa e non su un array, quindi l'operazione chiaramente non ha senso .

Esempio:

$var = "test";
echo $var["a_key"];

Se ritieni che la variabile debba essere un array, vedi da dove viene e risolvi il problema.

Avviso: mysql_connect (): accesso negato per l'utente 'nome' @ 'host'

Questo avviso viene visualizzato quando ci si connette a un server MySQL / MariaDB con credenziali non valide o mancanti (nome utente / password). Quindi questo non è in genere un problema di codice, ma un problema di configurazione del server.

  • Vedere la pagina di manuale su mysql_connect("localhost", "user", "pw") per esempi.

  • Verifica di aver effettivamente utilizzato un $username $password e $password .

    • Non è raro che tu ottenga l'accesso senza password - che è ciò che è accaduto quando è stato visualizzato l'avvertimento: (using password: NO) .
    • Solitamente solo il server di test locale consente di connettersi con il nome utente root , nessuna password e il nome del database di test .

    • Puoi verificare se sono davvero corretti utilizzando il client della riga di comando:
      mysql --user="username" --password="password" testdb

    • Nome utente e password fanno distinzione tra maiuscole e minuscole e gli spazi bianchi non vengono ignorati. Se la tua password contiene meta caratteri come $ , scappa o inserisci la password tra virgolette singole .

    • La maggior parte dei provider di hosting condiviso predice gli account mysql in relazione all'account utente unix (a volte solo prefissi o suffissi numerici extra). Vedi i documenti per un modello o documentazione e CPanel o qualsiasi altra interfaccia per l'impostazione di una password.

    • Consulta il manuale di MySQL su Aggiunta di account utente tramite la riga di comando. Quando sei connesso come utente amministratore puoi inviare una query come:
      CREATE USER 'username'@'localhost' IDENTIFIED BY 'newpassword';

    • Oppure utilizza Adminer o WorkBench o qualsiasi altro strumento grafico per creare, controllare o correggere i dettagli dell'account.

    • Se non riesci a correggere le tue credenziali, chiedere a Internet di "per favore aiuto" non avrà alcun effetto. Solo tu e il tuo fornitore di hosting avete le autorizzazioni e l'accesso sufficiente per diagnosticare e correggere le cose.

  • Verifica di poter raggiungere il server database, utilizzando il nome host fornito dal tuo provider:
    ping dbserver.hoster.example.net

    • Controlla questo da una console SSH direttamente sul tuo server web. Il test dal client di sviluppo locale al server di hosting condiviso è raramente significativo.

    • Spesso si desidera solo che il nome del server sia "localhost" , che normalmente utilizza un socket denominato locale quando disponibile. Altre volte puoi provare "127.0.0.1" come fallback.

    • Se il tuo server MySQL / MariaDB è in ascolto su una porta diversa, usa "servername:3306" .

    • Se fallisce, allora c'è forse un problema con il firewall. (Off-topic, non una domanda di programmazione. Non è possibile alcuna supposizione remota.)

  • Quando si usano costanti come ad es. DB_USER o DB_PASSWORD , verificare che siano effettivamente definiti .

    • Se ricevi un "Warning: Access defined for 'DB_USER'@'host'" e un "Notice: use of undefined constant 'DB_PASS'" , questo è il tuo problema.

    • Verifica che il tuo esempio xy/db-config.php stato effettivamente incluso e quant'altro.

  • Verificare che le autorizzazioni GRANT impostate correttamente.

    • Non è sufficiente avere una coppia username + password .

    • Ogni account MySQL / MariaDB può avere un insieme di autorizzazioni.

    • Questi possono limitare a quali database è consentito connettersi, da quale client / server potrebbe provenire la connessione e quali query sono consentite.

    • Pertanto, l'avviso "Accesso negato" potrebbe anche essere visualizzato per le chiamate mysql_query , se non si dispone delle autorizzazioni per SELECT da una tabella specifica o INSERT / UPDATE e più comunemente DELETE qualsiasi cosa.

    • È possibile adattare le autorizzazioni dell'account quando si è connessi per client della riga di comando utilizzando l' account admin con una query come:
      GRANT ALL ON yourdb.* TO 'username'@'localhost';

  • Se l'avviso viene visualizzato per primo con Warning: mysql_query(): Access denied for user ''@'localhost' allora potresti avere una coppia account / password preconfigurata php.ini .

    • Verifica che mysql.default_user= e mysql.default_password= abbiano valori significativi.

    • Spesso questa è una configurazione del provider. Quindi contatta il loro supporto per disallineamenti.

  • Trova la documentazione del tuo provider di hosting condiviso:

  • Si noti che è anche possibile aver esaurito il pool di connessioni disponibili . Riceverai avvisi di accesso negato per troppe connessioni simultanee. (Devi esaminare l'installazione. Questo è un problema di configurazione del server fuori tema, non una domanda di programmazione.)

  • La versione del tuo client libmysql potrebbe non essere compatibile con il server database. Normalmente i server MySQL e MariaDB possono essere raggiunti con PHP compilati nel driver. Se si dispone di un'impostazione personalizzata o di una versione PHP obsoleta e di un server di database molto più recente o significativamente obsoleto, la mancata corrispondenza della versione potrebbe impedire le connessioni. (No, devi investigare te stesso. Nessuno può indovinare la tua configurazione).

Più riferimenti:

A proposito, probabilmente non vorrai più usare le funzioni mysql_* . I nuovi arrivati ​​spesso migrano su mysqli , che tuttavia è altrettanto noioso. Invece leggi su DOP e dichiarazioni preparate .
$db = new PDO("mysql:host=localhost;dbname=testdb", "username", "password");

Errore irreversibile: [TraitA] e [TraitB] definiscono la stessa proprietà ([$ x]) nella composizione di [ClassC]

Si verifica quando una classe tenta di use più tratti , in cui due o più di questi tratti hanno definito una proprietà con lo stesso nome e con la proprietà con valori iniziali diversi.

Esempio:

<?php
trait TraitA
{
    public $x = 'a';
}
trait TraitB
{
    public $x = 'b';
}
class ClassC
{
    use TraitA, TraitB;
}

Problematico: sebbene sia possibile risolvere conflitti tra metodi concorrenti , al momento non esiste una sintassi che risolva un conflitto tra due proprietà concorrenti. L'unica soluzione in questo momento è il refactoring ; cioè, evitare un conflitto tra i nomi di proprietà che produce un errore fatale.


Domande correlate:

Avvertenza: function () prevede che il parametro X sia booleano (o intero, stringa, ecc.)

Se un tipo errato di parametro viene passato a una funzione - e PHP non può convertirlo automaticamente - viene emesso un avviso. Questo avviso identifica quale parametro è il problema e quale tipo di dati è previsto. La soluzione: modificare il parametro indicato con il tipo di dati corretto.


Ad esempio questo codice:

echo substr(["foo"], 23);

Risultati in questo output:

Avviso PHP: substr () prevede che il parametro 1 sia stringa, array fornito

Errore HTTP 500 - Errore interno del server

Il codice di stato HTTP 500 e il tipico avviso Apache o browser è un messaggio molto ampio. Non è l'errore vero. Per capire se si tratta di un errore di configurazione del server web ( .htaccess ) o di un errore irreversibile di PHP, devi guardare error.log .

In genere è possibile trovare il file webserver error.log in:

  • /var/log/apache2 su server Linux, spesso usato per host locali e virtuali.
  • /var/www/_user12345_/logs o simili sui piani di hosting condiviso.
    Di solito c'è una directory logs/ accanto a ogni cartella htdocs/ .
  • C:\xampp\apache\logs\error.log per le distribuzioni WAMP / XAMPP di Apache + PHP.
  • In alternativa, basta usare una funzione di ricerca dei file per individuare qualsiasi cosa chiamata "error.log".
    Oppure guarda nel tuo httpd.conf Apache e la sua direttiva ErrorLog .
  • /var/log/nginx/nginx_error.log per NGINX .
  • C:\inetpub\logs\LogFiles per IIS .

È un file di testo. Cerca la voce che corrisponde maggiormente al tempo di errore e utilizza la parte significativa del messaggio di errore (da "Errore PHP: ..." fino a "in linea ...") per ulteriori ricerche su Google.

[Mon 22:10] [:error] [pid 12345] [client 127.0.0.1] FastCGI: server "/fcgi/p73" stderr: PHP message: PHP Error: Unfiltered input variable $_JSON['pokestop_lng'] in filyfile.php on line 845 PHP Error: Unfiltered input variable $_JSON['pokestop_lng'] in filyfile.php on line 845

Per le configurazioni FPM spesso vedrai solo errori PHP fatali qui. Considerando che le precedenti configurazioni mod_php (hosting condiviso) spesso si mescolano in avvertimenti e avvisi (che di solito vale anche la pena ispezionare).

Se non configurato per utilizzare il sistema o il meccanismo di registrazione di Apache, potresti anche consultare il file error.log di PHP . Generalmente è più semplice lasciare le impostazioni predefinite e abilitare error_display + error_reporting per rivelare l'errore concreto. Dopotutto, la pagina HTTP 500 è solo una variante dello schermo bianco della morte di PHP .

Guarda anche:

Avviso: count (): il parametro deve essere un array o un oggetto che implementa Countable

Spiega da sé; il parametro passato alla funzione count() deve essere qualcosa che è numerabile, di solito un array.

Il probabile problema è che è stato passato un valore scalare come una stringa o un numero intero o un oggetto che non implementa l'interfaccia Countable . L'uso di var_dump() sulla variabile in questione può mostrare se questo è il caso.

Errore irreversibile: l'oggetto della classe Chiusura non può essere convertito in una stringa

Significa che non stai eseguendo la tua funzione anonima (o una chiusura).

Verrà generato un errore per questo esempio utilizzando le funzioni freccia:

echo $fn = fn($x = 42) => $x;

O per qualsiasi funzione anonima

echo function($x = 42) { return $x; };

Per risolvere questo errore è necessario eseguire la chiusura.

echo $fn = (fn($x = 42) => $x)(30); // take notice of the 2 sets of brackets

echo (function($x = 42) { return $x; })(30);

Questo tipo di sintassi si chiama IIFE ed è stato aggiunto in PHP 7 .

Obsoleto: la sintassi di accesso all'offset di array e stringhe con parentesi graffe è obsoleta

È possibile accedere agli offset di stringa e agli elementi dell'array mediante parentesi graffe {} prima di PHP 7.4.0:

$string = 'abc';
echo $string{0};  // a

$array = [1, 2, 3];
echo $array{0};  // 1

Questo è stato deprecato da PHP 7.4.0 e genera un avviso:

Obsoleto: la sintassi di accesso all'offset di array e stringhe con parentesi graffe è obsoleta

È necessario utilizzare parentesi quadre [] per accedere agli offset di stringa e agli elementi dell'array:

$string = 'abc';
echo $string[0];  // a

$array = [1, 2, 3];
echo $array[0];  // 1

L' RFC per questa modifica si collega a uno script PHP che tenta di risolvere questo problema meccanicamente.

Errore irreversibile: costante di classe non definita

Questo errore indica che hai tentato di utilizzare una costante di classe che non esiste. A differenza di altri avvisi e avvertenze "non definiti", questo è un errore fatale e interromperà immediatamente lo script.

La prima cosa da controllare dovrebbero essere gli errori tipografici. Verificare che la costante sia definita nella classe e che venga chiamata utilizzando lo spazio dei nomi appropriato. Conferma anche che sono stati inclusi tutti i file appropriati per risolvere la costante.

Related