Comment déboguer les scripts PHP? [fermé]

vous pouvez utiliser Firephp un add-on à firebug pour déboguer php dans le même environnement que javascript.

j'utilise aussi Xdebug mentionné précédemment pour le profilage de php.

C'est mon petit environnement de débogage:

error_reporting(-1);
assert_options(ASSERT_ACTIVE, 1);
assert_options(ASSERT_WARNING, 0);
assert_options(ASSERT_BAIL, 0);
assert_options(ASSERT_QUIET_EVAL, 0);
assert_options(ASSERT_CALLBACK, 'assert_callcack');
set_error_handler('error_handler');
set_exception_handler('exception_handler');
register_shutdown_function('shutdown_handler');

function assert_callcack($file, $line, $message) {
    throw new Customizable_Exception($message, null, $file, $line);
}

function error_handler($errno, $error, $file, $line, $vars) {
    if ($errno === 0 || ($errno & error_reporting()) === 0) {
        return;
    }

    throw new Customizable_Exception($error, $errno, $file, $line);
}

function exception_handler(Exception $e) {
    // Do what ever!
    echo '<pre>', print_r($e, true), '</pre>';
    exit;
}

function shutdown_handler() {
    try {
        if (null !== $error = error_get_last()) {
            throw new Customizable_Exception($error['message'], $error['type'], $error['file'], $error['line']);
        }
    } catch (Exception $e) {
        exception_handler($e);
    }
}

class Customizable_Exception extends Exception {
    public function __construct($message = null, $code = null, $file = null, $line = null) {
        if ($code === null) {
            parent::__construct($message);
        } else {
            parent::__construct($message, $code);
        }
        if ($file !== null) {
            $this->file = $file;
        }
        if ($line !== null) {
            $this->line = $line;
        }
    }
}

Xdebug et le plugin DBGp pour le Notepad++ pour la chasse aux bogues, FirePHP pour les trucs légers. Rapide et sale? Rien ne vaut dBug .

XDebug est essentiel pour le développement. Je l'installe avant toute autre extension. Il vous donne les traces de pile sur une erreur et vous pouvez activer le profilage facilement.

pour un aperçu rapide d'une structure de données Utiliser var_dump() . N'utilisez pas print_r() car vous devrez l'entourer de <pre> et il n'imprime qu'un var à la fois.

<?php var_dump(__FILE__, __LINE__, $_REQUEST); ?>

pour un véritable environnement de débogage le mieux que j'ai trouvé est Komodo IDE mais il coûte$.

PhpEd est vraiment bon. Vous pouvez entrer dans/sur/de fonctions. Vous pouvez exécuter du code ad-hoc, inspecter des variables, changer des variables. Il est incroyable.

1) j'utilise print_r (). Dans TextMate, j'ai un extrait de " pré " qui se développe pour cela:

echo "<pre>";
print_r();
echo "</pre>";

2) J'utilise Xdebug, mais je n'ai pas réussi à faire fonctionner L'interface graphique correctement sur mon Mac. Il imprime au moins une version lisible de la trace de pile.

j'ai utilisé le Zend Studio (5.5) , avec Zend Platform . Cela donne un bon débogage,des points de rupture / enjamber le code, etc. mais à un prix.

en toute honnêteté, une combinaison de print et print_r() pour imprimer les variables. Je sais que beaucoup préfèrent utiliser d'autres des méthodes plus avancées, mais je trouve cela plus facile à utiliser.

je dirai que je n'ai pas pleinement apprécié ceci jusqu'à ce que j'ai fait de la programmation de microprocesseur à Uni et n'ai pas été en mesure d'utiliser même cela.

Xdebug , par Derick Rethans, est très bon. Je l'ai utilisé il y a quelques temps et a trouvé qu'il n'était pas si facile à installer. Une fois que vous avez terminé, vous ne comprendrez pas comment vous avez géré sans elle: -)

il y a un bon article sur Zend Developer Zone (installer sur Linux ne semble pas plus facile) et même un plugin Firefox , que je n'ai jamais utilisé.

j'utilise Netbeans avec XDebug. Consultez - le sur son site web pour savoir comment le configurer. http://php.netbeans.org/

j'utilise Netbeans avec XDebug et le Easy Xdebug FireFox Add-on

l'ajout est essentiel lorsque vous déboguez des projets MVC, parce que la façon normale XDebug tourne dans Netbeans est d'enregistrer la session dbug via l'url. Avec L'ajout installé dans FireFox, vous définiriez les propriétés de votre projet Netbeans - > lancer Configuratuion - > avancé et sélectionnez "N'ouvrez pas le navigateur Web" vous pouvez maintenant définir vos points de rupture et commencer la session de débogage avec Ctrl-F5 comme d'habitude. Ouvrez FireFox et cliquez avec le bouton droit de la souris sur l'icône Add-on dans le coin inférieur droit pour commencer à surveiller les points de rupture. Lorsque le code atteint le point de rupture, il s'arrête et vous pouvez inspecter vos états variables et la pile d'appels.

le tampon de Sortie est très utile si vous ne voulez pas gâcher votre sortie. Je le fais dans un one-liner qui je peux commenter/décommenter à volonté

 ob_start();var_dump(); user_error(ob_get_contents()); ob_get_clean();

PhpEdit a un débogueur intégré, mais je finis généralement par utiliser echo (); et print_r (); à l'ancienne!!

pour les problèmes vraiment graveleux qui seraient trop longs à utiliser print_r / echo pour comprendre que j'utilise la fonctionnalité de débogage de mon IDE (PhpEd). Contrairement à d'autres IDEs que j'ai utilisé, PhpEd nécessite à peu près pas de configuration. la seule raison pour laquelle je ne l'utilise pas pour tous les problèmes que je rencontre est que c'est douloureusement lent. Je ne suis pas sûr que la lenteur soit spécifique à PhpEd ou à n'importe quel débogueur php. PhpEd n'est pas libre mais je crois qu'il utilise l'un des débogueurs open-source (comme XDebug mentionné précédemment), de toute façon. L'avantage avec PhpEd, encore une fois, c'est qu'il ne nécessite aucun montage que j'ai trouvé vraiment assez ennuyeux dans le passé.

débogage manuel est généralement plus rapide pour moi - var_dump() et debug_print_backtrace() sont tous les outils dont vous avez besoin pour armer votre logique.

Eh bien, dans une certaine mesure, cela dépend de l'endroit où les choses vont vers le sud. C'est la première chose que j'essaie d'isoler, et ensuite j'utiliserai echo/print_r() si nécessaire.

NB: vous savez que vous pouvez passer true comme second argument à print_r () et qu'il retournera la sortie au lieu de l'imprimer? Par exemple:

echo "<pre>".print_r($var, true)."</pre>";

j'utilise souvent CakePHP quand les Rails ne sont pas possibles. Pour déboguer les erreurs, je trouve habituellement le error.log dans le dossier tmp et je l'empile dans le terminal avec la commande...

tail -f app/tmp/logs/error.log

cela vous donne d'exécuter le dialogue de gâteau de ce qui se passe, ce qui est assez pratique, si vous voulez produire quelque chose à lui mid code que vous pouvez utiliser.

$this->log('xxxx');

cela peut généralement vous donner une bonne idée de ce qui se passe/mal.

print_r (debug_backtrace ());

ou quelque chose comme ça :-)

Komodo IDE fonctionne bien avec xdebug, même pour le débogage remore. Il nécessite un minimum de configuration. Tout ce dont vous avez besoin est une version de php que Komodo peut utiliser localement pour passer à travers le code sur un point de rupture. Si vous avez le script importé dans le projet komodo, alors vous pouvez définir les points de rupture avec un clic de souris juste comment vous le définiriez dans eclipse pour déboguer un programme java. Débogage à distance est évidemment plus difficile de l'obtenir pour fonctionner correctement ( vous pourriez avoir à la carte url distante avec un script php dans votre espace de travail) qu'une configuration de débogage locale qui est assez facile à configurer si vous êtes sur un MAC ou un bureau linux.

Nusphere est aussi un bon débogueur pour php nusphère

il y a beaucoup de techniques de débogage PHP qui peuvent vous sauver d'innombrables heures en codant. Une technique de débogage efficace mais basique consiste simplement à activer le reporting des erreurs. Une autre technique un peu plus avancée consiste à utiliser des instructions d'impression, qui peuvent aider à repérer les bogues plus insaisissables en affichant ce qui va réellement sur l'écran. PHPeclipse est un plug-in Eclipse qui peut mettre en évidence les erreurs syntaxiques courantes et peut être utilisé en conjonction avec un débogueur pour définir les points de rupture.

display_errors = Off
error_reporting = E_ALL 
display_errors = On

et également utilisé

error_log();
console_log();

+1 pour print_r(). L'utiliser pour vider le contenu d'un objet ou d'une variable. Pour le rendre plus lisible, faites-le avec une pré-étiquette pour que vous n'ayez pas besoin de voir la source.

echo '<pre>';
print_r($arrayOrObject);

aussi var_dump ($thing) - c'est très utile pour voir le type de sous-titres

dans un environnement de production, j'enregistre les données pertinentes dans le journal des erreurs du serveur avec error_log().

j'utilise Zend studio pour eclipse avec le débogueur intégré. C'est toujours lent comparé au débogage avec eclipse pdt avec xdebug. Espérons qu'ils vont résoudre ces problèmes, la vitesse s'est améliorée au cours des dernières versions, mais il faut encore 2 à 3 secondes pour passer au-dessus. La barre d'outils de Zend firefox facilite vraiment les choses (déboguer la page suivante, la page actuelle, etc.). De plus, il fournit un profileur qui comparera votre code et fournira des diagrammes à secteurs, le temps d'exécution, etc.

la plupart des bogues peuvent être trouvés facilement par simplement var_dump dans certaines variables clés, mais cela dépend évidemment du type d'application que vous développez.

pour des algorithmes plus complexes, les fonctions step/Break Point/watch sont très utiles (si elles ne sont pas nécessaires)

PHP DBG

le débogueur PHP Stepthrough interactif mis en œuvre comme un module SAPI qui peut vous donner le contrôle complet sur l'environnement sans affecter la fonctionnalité ou les performances de votre code. Il s'agit d'une plate-forme de débogage légère, puissante, facile à utiliser pour PHP 5.4+ et elle est livrée avec PHP 5.6.

:

• Débogage Progressif
• Points De Rupture Flexibles (Méthode De Classe, Fonction, Fichier:Ligne, Adresse, Opcode)
• accès facile à PHP avec eval intégré ()
• accès facile au Code D'exécution actuel
• userland API
• SAPI Agnostiques Facilement Intégré
• prise en charge du fichier de Configuration PHP
• JIT Super Globals-Set Your Own!!
• Facultatif readline Soutien - Confortable Terminal de l'Opération
• Débogage à Distance de Soutien - Livré Java GUI
• Opération Facile

voir les captures d'écran:

page D'accueil: http://phpdbg.com/

erreur PHP - amélioration du rapport D'erreur pour PHP

c'est très facile d'utiliser une bibliothèque (en fait un fichier) pour déboguer vos scripts PHP.

La seule chose que vous devez faire est d'inclure un fichier comme ci-dessous (au début de votre code):

require('php_error.php');
\php_error\reportErrors();

alors toutes les erreurs vous donneront des informations telles que backtrace, contexte de code, arguments de fonction, serveur les variables, etc. Par exemple:

Caractéristiques comprennent:

• trivial à utiliser, c'est juste un fichier
• erreurs affichées dans le navigateur pour les requêtes normales et ajaxy
• les requêtes AJAX sont mises en pause, vous permettant de les relancer automatiquement
• rend les erreurs aussi strictes que possible (encourage la qualité du code, et tend à améliorer la performance)
• fragments de code à travers l'ensemble de la trace de la pile
• fournit plus d'informations (tels que les signatures de fonction)
• corrige quelques messages d'erreur qui sont tout simplement erronés
• syntaxe highlighting
• est joli!
• customisation
• allumer et éteindre manuellement
• exécuter des sections spécifiques sans rapport d'erreur
• ignorer les fichiers vous permettant d'éviter de mettre en évidence le code dans votre suivi de pile
• dossiers d'application; ceux-ci sont classés par ordre de priorité quand une erreur frappe!

page d'Accueil: http://phperror.net/

GitHub: https://github.com/JosephLenton/PHP-Error

ma fourchette (avec corrections supplémentaires): https://github.com/kenorb-contrib/PHP-Error

DTrace

si votre système supporte DTrace dynamic tracing (installé par défaut sur OS X) et que votre PHP est compilé avec les sondes DTrace activées ( --enable-dtrace ) qui devraient être par défaut, cette commande peut vous aider à déboguer le script PHP sans délai:

sudo dtrace -qn 'php*:::function-entry { printf("%Y: PHP function-entry:\t%s%s%s() in %s:%d\n", walltimestamp, copyinstr(arg3), copyinstr(arg4), copyinstr(arg0), basename(copyinstr(arg1)), (int)arg2); }'

ainsi donné, l'alias suivant a été ajouté à vos fichiers rc (par ex. ~/.bashrc , ~/.bash_aliases ):

alias trace-php='sudo dtrace -qn "php*:::function-entry { printf(\"%Y: PHP function-entry:\t%s%s%s() in %s:%d\n\", walltimestamp, copyinstr(arg3), copyinstr(arg4), copyinstr(arg0), basename(copyinstr(arg1)), (int)arg2); }"'

vous pouvez tracer votre script avec un alias facile à retenir: trace-php .

voici le script plus avancé de dtrace, il suffit de le sauvegarder dans dtruss-php.d , le rendre exécutable ( chmod +x dtruss-php.d ) et courir:

#!/usr/sbin/dtrace -Zs
# See: https://github.com/kenorb/dtruss-lamp/blob/master/dtruss-php.d

#pragma D option quiet

php*:::compile-file-entry
{
    printf("%Y: PHP compile-file-entry:\t%s (%s)\n", walltimestamp, basename(copyinstr(arg0)), copyinstr(arg1));
}

php*:::compile-file-return
{
    printf("%Y: PHP compile-file-return:\t%s (%s)\n", walltimestamp, basename(copyinstr(arg0)), basename(copyinstr(arg1)));
}

php*:::error
{
    printf("%Y: PHP error message:\t%s in %s:%d\n", walltimestamp, copyinstr(arg0), basename(copyinstr(arg1)), (int)arg2);
}

php*:::exception-caught
{
    printf("%Y: PHP exception-caught:\t%s\n", walltimestamp, copyinstr(arg0));
}

php*:::exception-thrown
{
    printf("%Y: PHP exception-thrown:\t%s\n", walltimestamp, copyinstr(arg0));
}

php*:::execute-entry
{
    printf("%Y: PHP execute-entry:\t%s:%d\n", walltimestamp, basename(copyinstr(arg0)), (int)arg1);
}

php*:::execute-return
{
    printf("%Y: PHP execute-return:\t%s:%d\n", walltimestamp, basename(copyinstr(arg0)), (int)arg1);
}

php*:::function-entry
{
    printf("%Y: PHP function-entry:\t%s%s%s() in %s:%d\n", walltimestamp, copyinstr(arg3), copyinstr(arg4), copyinstr(arg0), basename(copyinstr(arg1)), (int)arg2);
}

php*:::function-return
{
    printf("%Y: PHP function-return:\t%s%s%s() in %s:%d\n", walltimestamp, copyinstr(arg3), copyinstr(arg4), copyinstr(arg0), basename(copyinstr(arg1)), (int)arg2);
}

php*:::request-shutdown
{
    printf("%Y: PHP request-shutdown:\t%s at %s via %s\n", walltimestamp, basename(copyinstr(arg0)), copyinstr(arg1), copyinstr(arg2));
}

php*:::request-startup
{
    printf("%Y, PHP request-startup:\t%s at %s via %s\n", walltimestamp, basename(copyinstr(arg0)), copyinstr(arg1), copyinstr(arg2));
}

^{page d'Accueil: dtruss-lampe sur GitHub}

Voici l'usage simple:

1. Run: sudo dtruss-php.d .
2. Sur un autre terminal, exécutez: php -r "phpinfo();" .

pour tester cela, vous pouvez aller à n'importe quel docroot avec index.php et exécuter PHP builtin server par:

php -S localhost:8080

après cela, vous pouvez accéder au site à http://localhost:8080 / (ou choisissez le port qui vous convient). De là, accédez à quelques pages pour voir la sortie trace.

Note: Dtrace est disponible sur OS X par défaut, sur Linux vous avez probablement besoin de dtrace4linux ou vérifiez pour d'autres alternatives .

voir: utilisant PHP et DTrace à php.net

SystemTap

alternativement vérifier le traçage SystemTap en installant le paquet de développement SystemTap SDT (par exemple yum install systemtap-sdt-devel ).

voici un exemple de script ( all_probes.stp ) pour tracer tous les points de sonde PHP statiques tout au long de la durée d'un script PHP en cours D'exécution avec SystemTap:

probe process("sapi/cli/php").provider("php").mark("compile__file__entry") {
    printf("Probe compile__file__entry\n");
    printf("  compile_file %s\n", user_string($arg1));
    printf("  compile_file_translated %s\n", user_string($arg2));
}
probe process("sapi/cli/php").provider("php").mark("compile__file__return") {
    printf("Probe compile__file__return\n");
    printf("  compile_file %s\n", user_string($arg1));
    printf("  compile_file_translated %s\n", user_string($arg2));
}
probe process("sapi/cli/php").provider("php").mark("error") {
    printf("Probe error\n");
    printf("  errormsg %s\n", user_string($arg1));
    printf("  request_file %s\n", user_string($arg2));
    printf("  lineno %d\n", $arg3);
}
probe process("sapi/cli/php").provider("php").mark("exception__caught") {
    printf("Probe exception__caught\n");
    printf("  classname %s\n", user_string($arg1));
}
probe process("sapi/cli/php").provider("php").mark("exception__thrown") {
    printf("Probe exception__thrown\n");
    printf("  classname %s\n", user_string($arg1));
}
probe process("sapi/cli/php").provider("php").mark("execute__entry") {
    printf("Probe execute__entry\n");
    printf("  request_file %s\n", user_string($arg1));
    printf("  lineno %d\n", $arg2);
}
probe process("sapi/cli/php").provider("php").mark("execute__return") {
    printf("Probe execute__return\n");
    printf("  request_file %s\n", user_string($arg1));
    printf("  lineno %d\n", $arg2);
}
probe process("sapi/cli/php").provider("php").mark("function__entry") {
    printf("Probe function__entry\n");
    printf("  function_name %s\n", user_string($arg1));
    printf("  request_file %s\n", user_string($arg2));
    printf("  lineno %d\n", $arg3);
    printf("  classname %s\n", user_string($arg4));
    printf("  scope %s\n", user_string($arg5));
}
probe process("sapi/cli/php").provider("php").mark("function__return") {
    printf("Probe function__return: %s\n", user_string($arg1));
    printf(" function_name %s\n", user_string($arg1));
    printf("  request_file %s\n", user_string($arg2));
    printf("  lineno %d\n", $arg3);
    printf("  classname %s\n", user_string($arg4));
    printf("  scope %s\n", user_string($arg5));
}
probe process("sapi/cli/php").provider("php").mark("request__shutdown") {
    printf("Probe request__shutdown\n");
    printf("  file %s\n", user_string($arg1));
    printf("  request_uri %s\n", user_string($arg2));
    printf("  request_method %s\n", user_string($arg3));
}
probe process("sapi/cli/php").provider("php").mark("request__startup") {
    printf("Probe request__startup\n");
    printf("  file %s\n", user_string($arg1));
    printf("  request_uri %s\n", user_string($arg2));
    printf("  request_method %s\n", user_string($arg3));
}

Usage:

stap -c 'sapi/cli/php test.php' all_probes.stp

Voir: à l'Aide de SystemTap avec PHP DTrace Statique Sondes à php.net

en fonction de la question j'aime une combinaison de error_reporting (E_ALL) mélangée avec des tests d'écho (pour trouver la ligne/le fichier fautif l'erreur s'est produite initalement; vous savez que ce n'est pas toujours la ligne/le fichier que php vous dit droit?), IDE accolade correspondante (pour résoudre "Parse error: syntax error, unexpected $end"), et print_r(); exit; dumps (les programmeurs d'afficher la source ;p).

vous ne pouvez pas non plus battre phpdebug (cochez sourceforge) avec "memory_get_usage ();" et "memory_get_peak_usage ();" pour trouver les zones de problèmes.

les débogueurs intégrés où vous pouvez regarder les valeurs de la variable changer pendant que vous marchez à travers le code sont vraiment cool. Ils nécessitent cependant une configuration logicielle sur le serveur et une certaine configuration sur le client. Tous deux nécessitent un entretien périodique pour maintenir en bon état de fonctionnement.

Un print_r est facile à écrire et est garanti pour fonctionner dans toute l'installation.

Habituellement, je trouve créer une fonction de journal personnalisé capable d'enregistrer sur le fichier, stocker des informations de débogage, et éventuellement réimprimer sur un pied de page commun.

vous pouvez également outrepasser la classe D'Exception commune, de sorte que ce type de débogage est semi-automatisé.