eclipse - Comment déboguez-vous les scripts PHP?

Translate

Comment déboguez-vousPHPdes scripts?

Je connais le débogage de base tel que l'utilisation du rapport d'erreurs. Le débogage du point d'arrêt dansPHPEclipseest également très utile.

Quel est lemeilleur(en termes de rapidité et de facilité) pour déboguer dans phpStorm ou tout autre IDE?

This question and all comments follow the "Attribution Required."

Toutes les réponses

Translate

EssayerEclipse PDTpour configurer un environnement Eclipse doté de fonctionnalités de débogage comme vous l'avez mentionné. La possibilité d'entrer dans le code est un bien meilleur moyen de déboguer que l'ancienne méthode de var_dump et d'imprimer à divers points pour voir où votre flux va mal. Quand tout le reste échoue et tout ce que j'ai c'est SSH et vim je restevar_dump()/die()pour trouver où le code va vers le sud.

La source
Pat
Translate

Vous pouvez utiliser Firephp un module complémentaire de Firebug pour déboguer php dans le même environnement que javascript.

J'utilise aussiXdebugmentionné précédemment pour le profilage de php.

La source
Translate

Voici 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;
        }
    }
}
La source
Regina Lee
Translate

Xdebug et le plugin DBGp pour Notepad ++ pour la recherche de bogues lourds, FirePHP pour les trucs légers. Rapide et sale? Rien ne batdBug.

La source
Translate

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

Pour un aperçu rapide d'une structure de données, utilisezvar_dump(). Ne pas utiliserprint_r()parce que tu devras l'entourer de<pre>et il n'imprime qu'une variable à la fois.

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

Pour un véritable environnement de débogage, le meilleur que j'ai trouvé estIDE de Komodomais cela coûte $$.

La source
Ann Lee
Translate

PhpEd est vraiment bon. Vous pouvez entrer / sur / hors des fonctions. Vous pouvez exécuter du code ad hoc, inspecter des variables, modifier des variables. C'est étonnant.

La source
Translate

1) J'utilise print_r (). Dans TextMate, j'ai un extrait de 'pre' qui se développe comme suit:

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

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

La source
Monroe Lee
Translate

J'ai utilisé leStudio Zend (5,5), ensemble avecPlateforme Zend. Cela donne un débogage approprié, des points d'arrêt / un dépassement du code, etc., mais à un prix.

La source
Truda Lee
Translate

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 méthodes plus avancées, mais je trouve que c'est la plus simple à utiliser.

Je dirai que je n'ai pas pleinement apprécié cela jusqu'à ce que je fasse de la programmation par microprocesseur à l'Uni et que je n'étais même pas capable de l'utiliser.

La source
Alfred Lee
Translate

Xdebug, par Derick Rethans, est très bien. Je l'ai utilisé il y a quelque temps et j'ai 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 cela :-)

Il y a un bon article surZone de développement Zend(l'installation sur Linux ne semble pas plus simple) et même unPlugin Firefox, que je n'ai jamais utilisé.

La source
Setlla Lee
Translate

J'utilise Netbeans avec XDebug. Consultez-le sur son site Web pour obtenir des documents sur la façon de le configurer.http://php.netbeans.org/

La source
Henry Lee
Translate

J'utilise Netbeans avec XDebug et leModule complémentaire Easy XDebug FireFox

L'add-on est essentiel lorsque vous déboguez des projets MVC, car la manière normale de faire fonctionner XDebug dans Netbeans consiste à enregistrer la session dbug via l'url. Avec le module complémentaire installé dans FireFox, vous définiriez les propriétés de votre projet Netbeans -> Exécutez la configuration -> Avancé et sélectionnez "Ne pas ouvrir le navigateur Web" Vous pouvez maintenant définir vos points d'arrêt et démarrer la session de débogage avec Ctrl-F5 comme d'habitude . Ouvrez FireFox et cliquez avec le bouton droit sur l'icône du module complémentaire dans le coin inférieur droit pour démarrer la surveillance des points d'arrêt. Lorsque le code atteint le point d'arrêt, il s'arrête et vous pouvez inspecter vos états variables et la pile d'appels.

La source
Woodrow Lee
Translate

La mise en mémoire tampon de sortie est très utile si vous ne voulez pas gâcher votre sortie. Je fais cela en une seule ligne que je peux commenter / décommenter à volonté

 ob_start();var_dump(); user_error(ob_get_contents()); ob_get_clean();
La source
Queena Lee
Translate

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

La source
Ira Lee
Translate

Pour les problèmes vraiment graves qui prendraient trop de temps à utiliser print_r / echo pour comprendre que j'utilise la fonction de débogage de mon IDE (PhpEd). Contrairement aux autres IDE que j'ai utilisés, PhpEd ne nécessite pratiquement aucune configuration. la seule raison pour laquelle je ne l'utilise pas pour les problèmes que je rencontre est que c'estdouloureusementlent. Je ne suis pas sûr que la lenteur soit spécifique à PhpEd ou à tout débogueur php. PhpEd n'est pas gratuit mais je pense qu'il utilise de toute façon l'un des débogueurs open source (comme XDebug mentionné précédemment). L'avantage avec PhpEd, encore une fois, est qu'il ne nécessite aucune configuration que j'ai trouvée vraiment assez fastidieuse dans le passé.

La source
Oscar Lee
Translate

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

La source
Giles Lee
Translate

Eh bien, dans une certaine mesure, cela dépend de la direction vers le sud. C'est la première chose que j'essaye d'isoler, puis 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>";
La source
Samuel Lee
Translate

J'utilise souvent CakePHP lorsque Rails n'est pas possible. Pour déboguer les erreurs, je trouve généralement leerror.logdans le dossier tmp et le queue dans le terminal avec la commande ...

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

Cela vous donne un dialogue en cours d'exécution à partir du gâteau de ce qui se passe, ce qui est très pratique, si vous voulez y envoyer quelque chose au milieu du code, vous pouvez utiliser.

$this->log('xxxx');

Cela peut généralement vous donner une bonne idée de ce qui se passe / ne va pas.

La source
Heloise Lee
Translate

print_r (debug_backtrace ());

ou quelque chose comme ça :-)

La source
Betsy Lee
Translate

Komodo IDE fonctionne bien avec xdebug, même pour le débogage remore. Il nécessite une configuration minimale. Tout ce dont vous avez besoin est une version de php que Komodo peut utiliser localement pour parcourir le code sur un point d'arrêt. Si vous avez le script importé dans le projet komodo, vous pouvez définir des points d'arrêt en un clic de souris comme vous le feriez dans eclipse pour le débogage d'un programme java. Le débogage à distance est évidemment plus délicat pour le faire fonctionner correctement (vous devrez peut-être mapper l'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 .

La source
Haley Lee
Translate

Nusphere est également un bon débogueur pour phpnusphère

La source
Paula Lee
Translate

Il existe de nombreuses techniques de débogage PHP qui peuvent vous faire gagner d'innombrables heures lors du codage. Une technique de débogage efficace mais basique consiste simplement à activer le rapport d'erreur. Une autre technique légèrement plus avancée consiste à utiliser des instructions d'impression, qui peuvent aider à identifier les bogues les plus insaisissables en affichant ce qui se passe réellement à l'écran. PHPeclipse est un plug-in Eclipse qui peut mettre en évidence les erreurs de syntaxe courantes et peut être utilisé en conjonction avec un débogueur pour définir des points d'arrêt.

display_errors = Off
error_reporting = E_ALL 
display_errors = On

et aussi utilisé

error_log();
console_log();
La source
Diana Lee
Translate

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

La source
Nicola Lee
Translate

j'utilise zend studio pour eclipse avec le débogueur intégré. C'est encore lent par rapport au débogage avec eclipse pdt avec xdebug. Espérons qu'ils résoudront ces problèmes, la vitesse s'est améliorée par rapport aux versions récentes, mais il faut encore 2-3 secondes pour franchir les étapes. La barre d'outils de zend firefox facilite vraiment les choses (déboguer la page suivante, la page actuelle, etc.). En outre, il fournit un profileur qui évaluera votre code et fournira des camemberts, le temps d'exécution, etc.

La source
Martha Lee
Translate

La plupart des bogues peuvent être trouvés facilement envar_dumpcertaines des variables clés, mais cela dépend évidemment du type d'application que vous développez.

Pour un algorithme plus complexe, les fonctions step / breakpoint / watch sont très utiles (sinon nécessaires)

La source
Translate

PHP DBG

Le débogueur PHP interactif Stepthrough implémenté en tant que module SAPI qui peut vous donner un contrôle complet sur l'environnement sans affecter les fonctionnalités ou les performances de votre code. Il vise à être une plate-forme de débogage légère, puissante et facile à utiliser pour PHP 5.4+ et elle est livrée prête à l'emploi avec PHP 5.6.

Les caractéristiques comprennent:

  • Débogage progressif
  • Points d'arrêt flexibles (méthode de classe, fonction, fichier: ligne, adresse, opcode)
  • Accès facile à PHP avec eval () intégré
  • Accès facile au code en cours d'exécution
  • API Userland
  • SAPI Agnostic - Facilement intégré
  • Prise en charge des fichiers de configuration PHP
  • JIT Super Globals - Définissez le vôtre !!
  • Assistance readline en option - Fonctionnement confortable du terminal
  • Prise en charge du débogage à distance - Interface graphique Java fournie
  • Opération facile

Voir les captures d'écran:

PHP DBG - Stepthrough Debugging - screenshot

PHP DBG - Stepthrough Debugging - screenshot

Page d'accueil:http://phpdbg.com/

Erreur PHP- Meilleur rapport d'erreurs pour PHP

C'est une bibliothèque très facile à utiliser (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();

Ensuite, toutes les erreurs vous donneront des informations telles que la traçabilité, le contexte du code, les arguments de fonction, les variables de serveur, etc. Par exemple:

PHP Error | Improve Error Reporting for PHP - screenshot of backtrace PHP Error | Improve Error Reporting for PHP - screenshot of backtrace PHP Error | Improve Error Reporting for PHP - screenshot of backtrace

Les fonctionnalités incluent:

  • simple à utiliser, ce n'est qu'un fichier
  • erreurs affichées dans le navigateur pour les requêtes normales et ajaxy
  • Les requêtes AJAX sont mises en pause, ce qui vous permet de les réexécuter automatiquement
  • rend les erreurs aussi strictes que possible (encourage la qualité du code et tend à améliorer les performances)
  • extraits de code sur toute la trace de la pile
  • fournit plus d'informations (telles que les signatures de fonctions complètes)
  • corrige certains messages d'erreur qui sont tout simplement faux
  • coloration syntaxique
  • est jolie!
  • personnalisation
  • allumer et éteindre manuellement
  • exécuter des sections spécifiques sans rapport d'erreurs
  • ignorer les fichiers vous permettant d'éviter de mettre du code en surbrillance dans votre trace de pile
  • fichiers d'application; ceux-ci sont prioritaires lorsqu'une erreur survient!

Page d'accueil:http://phperror.net/

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

Ma fourchette (avec des correctifs supplémentaires):https://github.com/kenorb-contrib/PHP-Error

DTrace

Si votre système prend en chargeTraçage dynamique DTrace(installé par défaut sur OS X) et votre PHP est compilé avec les sondes DTrace activées (--enable-dtrace) qui devrait être par défaut, cette commande peut vous aider à déboguer le script PHP en un rien de temps:

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); }'

Donc, étant donné que l'alias suivant a été ajouté à votrercfichiers (par exemple~/.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 un script dtrace plus avancé, enregistrez-le simplement dansdtruss-php.d, rendez-le exécutable (chmod +x dtruss-php.d) et courir:

#!/usr/sbin/dtrace -Zs
# See: /out/aHR0cHM6Ly9naXRodWIuY29tL2tlbm9yYi9kdHJ1c3MtbGFtcA==/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:lampe-dtrusssur GitHub

Voici une utilisation simple:

  1. Courir:sudo dtruss-php.d.
  2. Sur une autre exécution de terminal:php -r "phpinfo();".

Pour tester cela, vous pouvez accéder à n'importe quel docroot avecindex.phpet exécutez le serveur intégré PHP en:

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 à certaines pages pour voir la sortie de trace.

Remarque: Dtrace est disponible sur OS X par défaut, sous Linux, vous aurez probablement besoindtrace4linuxou recherchez un autrealternatives.

Voir:Utilisation de PHP et DTracesur php.net


SystemTap

Vous pouvez également vérifier le traçage SystemTap en installant le package de développement SystemTap SDT (par exempleyum install systemtap-sdt-devel).

Voici un exemple de script (all_probes.stp) pour tracer tous les points de sonde statiques PHP de base pendant toute 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:Utilisation de SystemTap avec des sondes statiques PHP DTracesur php.net

La source
April Lee
Translate

+1 pour print_r (). Utilisez-le pour vider le contenu d'un objet ou d'une variable. Pour le rendre plus lisible, faites-le avec une balise pré afin de ne pas avoir 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-éléments

La source
Bess Lee
Translate

En fonction du problème, j'aime une combinaison de rapport d'erreur (E_ALL) mélangée à des tests d'écho (pour trouver la ligne / le fichier incriminé dans lequel l'erreur s'est produite initialement; vous SAVEZ que ce n'est pas toujours la ligne / le fichier que php vous dit correct?), IDE accolade correspondant (pour résoudre "Erreur d'analyse: erreur de syntaxe, problèmes inattendus de $ end"), et print_r (); sortie; dumps (les vrais programmeurs voient la source; p).

Vous ne pouvez pas non plus battre phpdebug (vérifiez sourceforge) avec "memory_get_usage ();" et "memory_get_peak_usage ();" pour trouver les zones problématiques.

La source
Duke Lee
Translate

Les débogueurs intégrés où vous pouvez observer les valeurs de changement de variable au fur et à mesure que vous parcourez le code sont vraiment cool. Cependant, ils nécessitent une configuration logicielle sur le serveur et une certaine configuration sur le client. Tous deux nécessitent un entretien périodique pour rester en bon état de fonctionnement.

Un print_r est facile à écrire et il est garanti de fonctionner dans n'importe quelle configuration.

La source
Rose Lee
Translate

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

Vous pouvez également remplacer la classe Exception commune, de sorte que ce type de débogage soit semi-automatisé.

La source