Comment déboguer-vous des scripts PHP?

voix
405

Comment déboguer-vous PHP scripts?

Je suis conscient de débogage de base telles que l' utilisation du rapport d'erreurs. Le débogage point d' arrêt dans PHPEclipse est également tout à fait utile.

Quel est le meilleur (en termes de rapide et facile) façon de déboguer dans PHPStorm ou tout autre IDE?

Créé 04/08/2008 à 00:18
source utilisateur
Dans d'autres langues...                            


30 réponses

voix
145

Essayez Eclipse PDT à installer un environnement Eclipse qui a le débogage des fonctionnalités comme vous l' avez mentionné. La capacité à entrer dans le code est une bien meilleure façon de déboguer alors l'ancienne méthode de var_dump et imprimer à différents endroits pour voir où votre flux va mal. Quand tout le reste échoue cependant et tout ce que j'ai est SSH et je vim encore var_dump()/ die()pour trouver où le code va vers le sud.

Créé 04/08/2008 à 00:28
source utilisateur

voix
80

Vous pouvez utiliser FirePHP un add-on à Firebug pour déboguer php dans le même environnement que javascript.

Je l' utilise aussi Xdebug mentionné plus haut pour le profilage php.

Créé 05/08/2008 à 18:22
source utilisateur

voix
38

Ceci 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;
        }
    }
}
Créé 29/06/2009 à 14:40
source utilisateur

voix
32

Xdebug et le plug - in DBGp pour Notepad ++ pour la chasse lourde bug devoir, FirePHP pour des trucs légers. Rapide et sale? Rien ne vaut Dbug .

Créé 15/09/2008 à 21:23
source utilisateur

voix
26

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

Pour un coup d' œil à une utilisation de la structure de données var_dump(). Ne pas utiliser print_r()parce que vous devrez entourer avec <pre>et il imprime un seul var à la fois.

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

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

Créé 22/08/2008 à 16:43
source utilisateur

voix
19

PhpED est vraiment bon. Vous pouvez entrer dans / sur / de fonctions. Vous pouvez exécuter du code ad hoc, inspecter les variables, les variables de changement. C'est étonnant.

Créé 05/02/2009 à 10:16
source utilisateur

voix
17

1) J'utilise print_r (). Dans TextMate, j'ai un extrait de « pré » qui se développe à ceci:

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

2) J'utilise Xdebug, mais n'ont pas été en mesure d'obtenir l'interface graphique pour travailler à droite sur mon Mac. Il imprime au moins une version lisible de la trace de la pile.

Créé 07/08/2008 à 01:25
source utilisateur

voix
16

En toute honnêteté, une combinaison d'impression 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 cela plus facile à utiliser.

Je dirai que je ne l'ai pas apprécier pleinement ce que je l'ai fait un peu de programmation à microprocesseur Uni et n'a pas été en mesure d'utiliser cette même.

Créé 04/08/2008 à 22:28
source utilisateur

voix
16

Je l' ai utilisé le Zend Studio (5.5) , en collaboration avec Zend Platform . Cela donne le débogage approprié, des points d' arrêt / enjambant le code etc., mais à un prix.

Créé 04/08/2008 à 00:20
source utilisateur

voix
14

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

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

Créé 04/08/2008 à 22:07
source utilisateur

voix
11

Je l' utilise avec Netbeans XDebug et facile XDebug FireFox Add-on

L'add-on est essentiel lors du débogage des projets MVC, parce que la façon normale XDebug fonctionne dans Netbeans est d'enregistrer la session DBUG via l'URL. Avec le module complémentaire installé dans FireFox, vous définissez vos propriétés du projet Netbeans -> Exécuter configuratuion -> Avancé et sélectionnez « Ne pas ouvrir le navigateur Web » Vous pouvez maintenant définir vos points de rupture et démarrer la session de débogage avec Ctrl-F5 comme d'habitude . Ouvrez FireFox et cliquez droit sur l'icône Add-on dans le coin inférieur droit de commencer à surveiller pour des points d'arrêt. Lorsque le code atteint le point d'arrêt, il arrêtera et vous pouvez vérifier vos états variables et la pile des appels.

Créé 09/07/2010 à 04:14
source utilisateur

voix
11

Je l' utilise avec Netbeans XDebug. Check it out sur son site Web pour docs sur la façon de le configurer. http://php.netbeans.org/

Créé 26/08/2008 à 16:04
source utilisateur

voix
10

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

 ob_start();var_dump(); user_error(ob_get_contents()); ob_get_clean();
Créé 22/10/2008 à 10:16
source utilisateur

voix
9

PHPEdit a construit dans le débogueur, mais je finissent généralement à l'aide d'écho (); et print_r (); à l'ancienne !!

Créé 17/09/2008 à 11:14
source utilisateur

voix
8

Pour les problèmes vraiment graveleux qui serait trop de temps à utiliser print_r / echo pour comprendre que j'utiliser la fonction de débogage de mon IDE (PhpED). Contrairement à d' autres environnements de développement que j'ai utilisé, PhpED nécessite à peu près aucune installation. la seule raison pour laquelle je ne l' utilise pas pour tout problème que je rencontre est qu'il est douloureusement lent. Je ne suis pas sûr que la lenteur est spécifique à PhpED ou tout débogueur PHP. PhpED est pas libre , mais je crois qu'il utilise l' un des débogueurs open source (comme mentionné précédemment) XDebug de toute façon. L'avantage avec PhpED, encore une fois, est qu'il ne nécessite aucune configuration que j'ai trouvé vraiment assez ennuyeux dans le passé.

Créé 22/08/2008 à 16:33
source utilisateur

voix
4

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

Créé 22/08/2008 à 16:36
source utilisateur

voix
3

J'utilise souvent CakePHP lorsque Rails est impossible. Pour déboguer les erreurs que je trouve habituellement le error.logdans le dossier tmp et la queue dans le terminal avec la commande ...

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

Il donne de vous dialogue en cours d'exécution du gâteau de ce qui se passe, ce qui est assez pratique, si vous voulez quelque chose de sortie à elle mi code que vous pouvez utiliser.

$this->log('xxxx');

Ceci peut vous donner une bonne idée de ce qui se passe / mal.

Créé 10/05/2010 à 10:29
source utilisateur

voix
3

Eh bien, dans une certaine mesure cela dépend de l'endroit où les choses vont au sud. C'est la première chose que j'essaie d'isoler, puis je vais utiliser l'écho / print_r () si nécessaire.

NB: Vous les gars savent que vous pouvez passer vrai comme second argument print_r () et il retournera la sortie au lieu de l'impression? Par exemple:

echo "<pre>".print_r($var, true)."</pre>";
Créé 18/09/2008 à 04:17
source utilisateur

voix
2

Il existe de nombreuses techniques de débogage de PHP qui peut vous sauver d'innombrables heures lors du codage. Une technique de débogage efficace, mais de base est de simplement tourner sur les rapports d'erreur. Une autre technique un peu plus avancée consiste à utiliser des instructions d'impression, ce qui peut aider à repérer les bugs les plus insaisissables en affichant ce qui se passe réellement sur l'écran. PHPEclipse est un plug-in qui peut mettre en évidence des erreurs de syntaxe communes Eclipse 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 également utilisé

error_log();
console_log();
Créé 01/10/2015 à 11:16
source utilisateur

voix
2

Nusphere est aussi un bon débogueur pour php nusphere

Créé 29/05/2012 à 13:43
source utilisateur

voix
2

Komodo IDE fonctionne bien avec xdebug, même pour le débogage remore. Il a besoin minimum de configuration. Tout ce que vous avez besoin est une version de php qui Komodo peut utiliser localement pour parcourir le code sur un point d'arrêt. Si vous avez importé le script dans le projet Komodo, vous pouvez définir des points d'arrêt avec un clic de souris juste comment vous définiriez l'intérieur Eclipse pour le débogage d'un programme java. Le débogage à distance est évidemment plus difficile à obtenir pour fonctionner correctement (vous pourriez avoir à faire correspondre l'url à distance avec un script php dans votre espace de travail) d'une configuration de débogage local qui est assez facile à configurer si vous êtes sur un Mac ou un ordinateur de bureau Linux .

Créé 22/08/2008 à 16:44
source utilisateur

voix
2

print_r (debug_backtrace ());

ou quelque chose comme ça :-)

Créé 04/08/2008 à 00:32
source utilisateur

voix
1

PHP DBG

Le Débogueur PHP Interactive Stepthrough mis en œuvre en tant que module SAPI qui peut vous donner un contrôle total sur l'environnement sans nuire à la fonctionnalité ou la performance de votre code. Il vise à être un simple léger, puissant, utiliser la plate-forme de la mise au point pour PHP 5.4+ et c'est expédié hors de la boîte avec PHP 5.6.

inclut des fonctionnalités:

  • Stepthrough Debugging
  • Les points d'arrêt flexibles (Méthode de classe, Fonction, Fichier: Ligne, Adresse, Opcode)
  • Un accès facile à PHP intégré avec eval ()
  • Accès facile à l'heure actuelle exécution de code
  • API Userland
  • SAPI Agnostique - Facilement intégré
  • Configuration PHP File Support
  • JIT super Globals - Définissez vos propres !!
  • Soutien en option readline - Opération Terminal confortable
  • Support débogage à distance - GUI Java fournis
  • Opération facile

Voir les captures d'écran:

PHP DBG - Stepthrough Debugging - capture d'écran

PHP DBG - Stepthrough Debugging - capture d'écran

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

Erreur PHP - L' amélioration des rapports d'erreur pour PHP

Ceci est très facile à utiliser la 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();

Ensuite, toutes les erreurs vous donner des informations telles que backtrace, le contexte de code, les arguments de la fonction, les variables du serveur, etc. Par exemple:

Erreur PHP |  Améliorer les rapports d'erreur pour PHP - capture d'écran de backtrace Erreur PHP |  Améliorer les rapports d'erreur pour PHP - capture d'écran de backtrace Erreur PHP |  Améliorer les rapports d'erreur pour PHP - capture d'écran de backtrace

Les fonctionnalités incluent:

  • trivial à utiliser, il est juste un fichier
  • les erreurs affichées dans le navigateur pour les demandes normales et ajaxy
  • les requêtes AJAX sont mis en pause, vous permettant de les exécuter automatiquement nouveau
  • fait des erreurs aussi strictes que possible (encourage la qualité du code, et tend à améliorer les performances)
  • des extraits de code à travers toute trace de pile
  • fournit plus d'informations (telles que les signatures fonctions complètes)
  • corrige quelques messages d'erreur qui sont tout simplement faux
  • la coloration syntaxique
  • semble assez!
  • personnalisation
  • activer manuellement le désactiver
  • exécuter des sections spécifiques sans rapport d'erreurs
  • ignorer les fichiers vous permettant d'éviter le code mettant en lumière dans votre trace de la pile
  • fichiers d'application; ceux-ci sont en priorité lorsque survient une erreur!

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

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

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

DTrace

Si votre système prend en charge le suivi 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 script PHP sans 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é l'alias suivant a été ajouté dans vos rc fichiers (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 facile à retenir alias: trace-php.

Voici script DTrace plus avancé, enregistrez dans dtruss-php.d, le rendre exécutable ( chmod +x dtruss-php.d) et exécutez:

#!/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 à GitHub

Voici l'utilisation simple:

  1. Run: sudo dtruss-php.d.
  2. Sur une autre course terminal: php -r "phpinfo();".

Pour tester cela, vous pouvez aller à tout docroot avec index.phpet exécuter PHP serveur par builtin:

php -S localhost:8080

Après cela , vous pouvez accéder au site à l' adresse http: // localhost: 8080 / (ou choisir ce port est pratique pour vous). De l' accès il des pages pour voir la sortie de trace.

Remarque: DTrace est disponible sur OS X par défaut, sur Linux , vous devez probablement dtrace4linux ou vérifier d'autres solutions de rechange .

Voir: en utilisant PHP et DTrace à php.net


SystemTap

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

Voici exemple de script ( all_probes.stp) pour tracer tous les points de sonde statique 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 PHP DTrace sondes statiques à php.net

Créé 21/03/2016 à 12:34
source utilisateur

voix
1

La plupart des bogues peuvent être trouvés facilement par simple var_dumping certaines des variables clés, mais cela dépend évidemment de ce genre d'application que vous développez.

Pour des algorithmes plus complexes les fonctions étape / / watch point d'arrêt sont très utiles (voire nécessaire)

Créé 10/05/2010 à 10:18
source utilisateur

voix
1

j'utilise studio zend pour Eclipse avec le construit en débogueur. Son rapport reste lent à débogage avec Eclipse TPD avec xdebug. Espérons qu'ils vont corriger ces problèmes, la vitesse est améliorée au cours des dernières versions, mais encore enjamber les choses prend 2-3 secondes. La barre d'outils Firefox zend fait vraiment les choses faciles (debug page suivante, page en cours, etc.). il fournit également un profileur qui comparera votre code et fournir camemberts, temps d'exécution, etc.

Créé 17/08/2008 à 19:38
source utilisateur

voix
1

Dans un environnement de production, je me connecte les données pertinentes au journal des erreurs du serveur avec error_log ().

Créé 15/08/2008 à 05:23
source utilisateur

voix
1

1 pour print_r (). Utilisez-le pour vider le contenu d'un objet ou variable. Pour le rendre plus lisible, le faire avec une étiquette avant que vous ne avez pas besoin de voir la source.

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

var_dump également ($ thing) - ce qui est très utile pour voir le type de subthings

Créé 05/08/2008 à 01:49
source utilisateur

voix
0

En général, je trouve créer une fonction de journal personnalisé en mesure d'enregistrer le fichier, les informations de débogage magasin, et éventuellement ré-imprimer sur un pied de page commun.

Vous pouvez également remplacer commune classe d'exception, de sorte que ce type de mise au point est semi-automatique.

Créé 22/10/2008 à 09:46
source utilisateur

voix
0

Les débogueurs intégrés où vous pouvez regarder les valeurs de changement de variable que vous entrez dans le code sont vraiment cool. Ils ne nécessitent cependant la configuration du logiciel sur le serveur et une certaine quantité de configuration sur le client. Les deux qui 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 une configuration.

Créé 22/08/2008 à 21:10
source utilisateur

voix
0

En fonction du problème que j'aime une combinaison de error_reporting (E_ALL) mélangé à des tests d'écho (pour trouver la ligne incriminée / déposer l'erreur est survenue dans initally, vous savez que c'est pas toujours la ligne / fichier php vous est dit?), Correspondant brace IDE (pour résoudre "Parse error: syntax error, $ end inattendu" questions), et print_r (); Sortie; dépotoirs (programmeurs réels voir la source; p).

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

Créé 06/08/2008 à 16:46
source utilisateur

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more