Lliçons de PHP: Mostra els errors i la manipulació d’errors

PHP és avui el llenguatge de programació web més popular del servidor, per la qual cosa és important saber com resoldre els errors que es puguin produir quan s’executa el vostre codi PHP..


En aquest article, analitzarem els conceptes bàsics sobre com fer el maneig d’errors a PHP, mitjançant les funcions integrades, l’escriptura de funcions de controlador d’errors personalitzades i amb la gestió d’errors excepcionals..

Tipus d’errors en PHP

Hi ha dos tipus fonamentals d’errors en el programari:

  • Errors interns: Aquests són els errors de lògica del vostre codi. Aquests programes es poden prevenir en gran mesura mitjançant una acurada programació.
  • Errors externs: Es tracta d’errors relacionats amb les interaccions amb el món fora del vostre codi (per exemple, en no obrir un fitxer o base de dades, la connexió de xarxa es deixa caure, no es pot carregar un determinat mòdul PHP, etc.). Aquests errors sempre es produiran, però es pot pal·liar el seu impacte. Com millor prepareu el vostre codi per a aquests errors externs, assumint el mínim possible quan s’execute el vostre codi, menys aquests errors afectaran negativament el vostre programa..

Maneres de tractar els errors de PHP

Un cop es produeixen errors i els detectem, hi ha quatre maneres fonamentals d’afrontar-los:

  • Mostra l’error: Això permet que es mostri l’error al desenvolupador i / o usuari quan s’executa el programa.
  • Registre l’error: Això permet emmagatzemar i revisar els errors des d’un fitxer de registre textual.
  • Actua sobre l’error: El tipus d’acció necessària serà diferent per a cada situació del programa.
  • Ignora l’error: Això sempre s’ha d’evitar.

En aquest article ens centrarem en la visualització, registre i maneig d’errors. Un cop sàpigues com gestionar els errors, podràs actuar amb facilitat.

Visualització d’errors i configuració d’informes d’errors

Segons si estem executant codi en producció o en desenvolupament, potser voldríem activar o desactivar els informes de certs tipus d’errors.

Hi ha diferents ubicacions on podem controlar quins tipus d’error s’han de notificar:

  • Al fitxer php.ini
  • Al fitxer .htaccess del servidor web
  • Des del vostre propi codi PHP.

Podeu trobar una descripció completa dels valors de configuració d’error PHP. Aquestes són les opcions més rellevants amb el seu valor predeterminat:

Opcions per mostrar errors de PHP

Hi ha quatre opcions possibles per mostrar errors de PHP:

  • error_reporting: Estableix el nivell d’informes d’errors. El valor per defecte és: “E_ALL & ~ E_NOTICE & ~ E_STRICT & ~ E_DEPRECATED “, és a dir, aquesta configuració no mostra errors de nivell E_NOTICE, E_STRICT i E_DEPRECATED.
  • display_errors: Configureu-la com a “ON” (el valor predeterminat és “OFF”) si voleu imprimir errors a la pantalla.
  • log_errors: Indica si s’hauria de fer o no l’anàlisi de errors; el valor predeterminat està “activat”.
  • cadena error_log: Estableix el nom del fitxer on s’han de registrar els errors de script

Anem a veure com podem utilitzar aquestes opcions de configuració.

Durant el desenvolupament, potser voldríem convertir tots els informes d’errors des de php.ini:

1
2
display_errors = activat

error_reporting = E_ALL

Podríem fer el mateix amb el nostre codi PHP durant el temps d’execució trucant a la funció error_reporting ():

1error_reporting (E_ALL);

Per activar el registre d’errors i registrar els errors al nostre propi fitxer de registre específic (en lloc del fitxer de registre d’errors per defecte, que sol ser el fitxer de registre d’errors del servidor web o el fitxer syslog), podríem configurar PHP amb:

1
2
log_errors = activat

error_log = “/tmp/php-error.log”

Ara podeu registrar errors mitjançant el vostre codi PHP:

1error_log ( “Aquest codi té errors!” );

Nivells d’error incorporats

Actualment, PHP té 15 constants d’error predefinides, cadascuna amb el seu número d’identificació (màscara de bit). Es tracta de tipus d’error integrats que PHP o vostè, el desenvolupador, poden desencadenar quan es produeixi un error. Podeu decidir quins tipus d’error voleu informar, com veurem a la següent secció.

Aquests són els tipus d’error PHP integrats:

TipusDescripció

E_ERRORErrors fatals en temps d’execució
E_WARNINGAvisos en temps d’execució (errors no fatals)
E_PARSEErrors d’analisi del temps de compilació
E_NOTICEAvisos en temps d’execució
E_CORE_ERRORErrors mortals que es produeixen durant l’inici inicial de PHP
E_CORE_WARNINGEls avisos (errors no fatals) que es produeixen durant l’inici inicial del PHP
E_COMPILE_ERRORErrors fatals en el temps de compilació
E_COMPILE_WARNINGAvisos en temps de compilació (errors no fatals)
E_USER_ERRORMissatge d’error generat per l’usuari
E_USER_WARNINGMissatge d’avís generat per l’usuari
E_USER_NOTICEMissatge d’avís generat per l’usuari
E_STRICTPermet tenir PHP suggereix canvis al vostre codi que garanteixin la millor interoperabilitat i compatibilitat de reenviament del vostre codi
E_RECOVERABLE_ERRORError fatal que es pot capturar
E_DEPRECATEDAvisos en temps d’execució
E_USER_DEPRECATEDMissatge d’avís generat per l’usuari
E_ALLTots els errors i avisos, segons es suporten

A continuació, es mostren alguns exemples de codi d’aquestes constants d’error que s’estan desencadenant:

1
2
3
4
5
6
7
8
9
10
11
12
13
// E_ERRORNonExistingFunction ();

// E_WARNING

$ fh = fopen (‘fitxer inexistent’, ‘r’);

// E_NOTICE

$ x = $ y + 5; // $ y no està definit

// E_USER_ERROR

if ($ divisor == 0) {

trigger_error (“No es pot dividir per zero”, E_USER_ERROR); // error desencadenat pel desenvolupador

}

Creació de gestors d’errors personalitzats

Ara que podem configurar PHP per dir-li quins tipus d’errors cal informar, hem de ser capaços de gestionar diferents tipus d’error a la nostra manera. No és prou bo mostrar missatges d’error de PHP estàndard.

Volem gestionar l’error i mostrar els nostres propis missatges quan es produeixi un error. Per això, podem utilitzar la funció set_error_handler ().

Aquí teniu una funció de maneig d’errors personalitzada molt senzilla:

1
2
3
4
5
6
7
8
9
10
// funció del controlador d’errorserror errorHandler ($ errno, $ errstr) {

ressò “Error: [$ errno] $ errstr”;

}

// administrador d’errors establert

set_error_handler (“errorHandler”);

// desencadenar un error

eco ($ foo); // variable indefinida!

Així, quan es produeix un error, la funció personalitzada del controlador d’errors s’anomena amb un argument de número d’error i un argument de cadena d’error. Aquests dos arguments es passen de la trucada set_error_handler () a la nostra funció.

Hi ha més arguments que podríem utilitzar, com aviat veurem, però la sortida de l’execució d’aquest codi seria:

1Error: [8] Variable sense definir: foo

Anem a veure com podria semblar una funció de maneig d’errors personalitzats una mica menys simple. Aquest gestor d’errors ha de ser capaç de detectar els tipus d’error i decidir quines accions cal dur a terme i / o quin missatge d’error mostrar.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
function errorHandler ($ errno, $ errstr, $ errfile, $ errline) {

commuta ($ errno) {

cas E_NOTICE:

cas E_USER_NOTICE:

cas E_DEPRECATED:

cas E_USER_DEPRECATED:

cas E_STRICT:

ressò (“Error STRICT $ errstr a $ errfile: $ errline n”);

trencar;

cas E_WARNING:

cas E_USER_WARNING:

ressò (“ADVERTIMENT error $ errstr a $ errfile: $ errline n”);

trencar;

cas E_ERROR:

cas E_USER_ERROR:

cas E_RECOVERABLE_ERROR:

sortir (“Error FATAL $ errstr a $ errfile: $ errline n”);

predeterminat:

sortir (“Error desconegut a $ errfile: $ errline n”);

}

}

set_error_handler (“errorHandler”);

$ foo = fals;

if (! $ foo) {

trigger_error (“El valor $ foo ha de ser cert”, E_USER_NOTICE);

}

Tingueu en compte com agrupem el maneig de certs tipus d’error mitjançant la funcionalitat de caiguda de les instruccions case-case.

La sortida seria com:

1Error de STRICT El valor $ foo és cert a /tmp/test.php:32

Ara podeu gestionar diferents tipus d’errors de manera diferent (o el mateix) i mostrar també un missatge d’error personalitzat. Per descomptat, una funció de maneig d’errors personalitzada real hauria de ser capaç de fer molt més amb els errors i possiblement actuar sobre ells d’una manera específica i sensata.

És important mantenir la vostra funció de maneig d’errors personalitzada senzilla i robusta per assegurar-vos que no hi hagi errors dins d’aquesta mateixa funció, ja que no s’informarà. Hi ha diverses biblioteques PHP que us poden ajudar a crear un tractament més avançat d’errors.

Ús de les excepcions de PHP

La versió 5 de PHP va introduir una altra manera de gestionar els errors: les excepcions.

El maneig d’excepcions s’utilitza per canviar el flux normal d’un programa en execució si es produeix una condició d’error especificada. És un mètode més integrat en la sintaxi del llenguatge per gestionar errors que no pas escriure funcions de maneig d’errors personalitzades.

Les excepcions són representades a PHP per la classe Exception. Les excepcions es plantegen mitjançant la sintaxi “throw” i es poden agafar mitjançant un bloc de sintaxi “try / catch”. Qualsevol codi en què es produeixi un error d’Eexcepció hauria d’estar situat al bloc “try”, que pot ser seguit d’un bloc “catch” per gestionar l’error. A mesura que les Excepcions llançades augmenten la pila de codis, també es poden manejar amb altres blocs “catch” del vostre codi.

Això és el que sembla la sintaxi Exception:

1
2
3
4
5
6
7
8
9
10
11
12
try {// llançar errors al try-block

// si es produeix un error, podem llançar una excepció

llançar una nova excepció (“això és un error.”);

}

catch (Excepció $ e) {// atrapar els llançaments al bloc de captura

// fer alguna cosa amb l’objecte d’excepció, p. mostrar el seu missatge

eco “Missatge d’error:”. $ e->getMessage ();

}

Què sortiria:

1Missatge d’error: es tracta d’un error.

Després de llançar un objecte Exception, podem accedir a aquestes funcions de membres:

  • getMessage () rep el missatge Excepció
  • getPrevious () retorna Excepció anterior
  • obtenir el codi() obté el codi Excepció
  • getFile () obté el fitxer en què s’ha produït l’excepció
  • getLine () obté la línia en què es va produir l’Excepció
  • getTrace () obté el rastre de la pila
  • getTraceAsString () obté la traça de pila com una cadena
  • __toString () és una representació en cadena de l’Excepció
  • __clone () clona l’Excepció

Aquí hi ha un altre exemple de maneig d’excepcions:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
$ file = ‘/tmp/foo.txt’;

prova {

// comproveu si el fitxer existeix i es pot escriure

if (! file_exists ($ file) ||! is_writable ($ file)) {

// si no: llançar una excepció

llançar una nova excepció (“Fitxer”. fitxer $. “no trobat o no escrit”.);

eco (“arribarà el codi aquí?”); // no si abans es llançava una excepció

}

}

captura (Excepció $ e) {

eco “Missatge d’error:”. $ e->getMessage ();

tornar fals;

}

Si teniu aquest codi sense crear el fitxer primer, veureu aquest error:

1Missatge d’error: El fitxer /tmp/foo.txt no es troba o no es pot escriure.

Les excepcions augmenten la pila de codis, de manera que podem tenir instruccions de llançament múltiples en diferents blocs de codi i encara manejar-les amb gràcia. Tanmateix, qualsevol excepció que es llanci, però no s’atraparà, generarà un error E_FATAL amb el missatge “Excepció incompleta”.

Un exemple:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
$ foo = 10;

prova {

if (és_numèric ($ foo)) {

if ($ foo > 5) {

llançar una nova excepció (“nombre massa alt”); // això es llençarà

}

}

més {

llançar una nova excepció (“no és un tipus de número”);

}

}

captura (Excepció $ e) {

eco “Missatge d’error:”. $ e->getMessage (). ‘a la línia:’. $ e->getLine ();

// tornar fals;

}

Tingueu en compte que hem anomenat “$ e->getLine () ”funció de l’objecte Exception per obtenir el número de línia quan es va llançar l’Excepció.

És possible nidificar diversos blocs de tipus try-throw-catch entre si. D’aquesta manera, podeu especificar quin error de excepció es gestiona on (d’una manera neta i senzilla) al punt del vostre codi on tingui més sentit. Recordeu-vos de posar sempre un codi que llanci dins d’un bloc “proveu”.

Gestors d’excepcions personalitzats

Fins ara hem estat utilitzant la classe Excepció integrada, però també podem escriure el nostre propi gestor d’excepcions personalitzat ampliant la classe Excepció integrada. Això és útil quan volem substituir les funcions de membre integrades o afegir funcions de membre noves. Podeu veure diversos exemples de codi en profunditat aquí.

Diferència entre errors i excepcions estàndard

El maneig d’errors estàndard és la manera més antiga de gestionar els errors en PHP. El maneig d’excepcions només està disponible des de PHP 5 en endavant i requereix utilitzar una estructura de programació orientada a objectes.

Totes dues es poden utilitzar al costat de l’altre. De fet, qualsevol excepció que es llanci, però no s’atraparà, generarà un error E_FATAL amb el missatge “Excepció incompleta”.

Amb l’exemple de codi de funció set_error_handler () que es mostra a continuació, podríem fins i tot gestionar tots els errors estàndard com a excepció:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
set_error_handler (funció ($ errno, $ errstr, $ errfile, $ errline) {

if (error_reporting ()) {

llançar ErrorException nou ($ errstr, 0, $ errno, $ errfile, $ errline);

}

});

prova {

// E_WARNING

$ fh = fopen (‘fitxer inexistent’, ‘r’);

}

captura (Excepció $ e) {

eco “Missatge d’error:”. $ e->getMessage ();

tornar fals;

}

Paraula final

Espero que aquesta ràpida introducció en el maneig d’errors PHP hagi ajudat a comprendre aquesta part important del desenvolupament. Ara haureu de saber mostrar i registrar els errors i gestionar-los de les diverses maneres que PHP ho fa possible, ja sigui amb una funció de maneig d’errors personalitzada o mitjançant un tractament d’excepcions..

Jeffrey Wilson Administrator
Sorry! The Author has not filled his profile.
follow me