Comment imprimer les informations de débogage de trace en PHP

Cet article vous présentera comment imprimer des informations de suivi et de débogage en PHP. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il sera utile à tout le monde.

Pour la plupart des langages compilés, tels que C, Java et C#, nous pouvons facilement effectuer le débogage des points d'arrêt, mais PHP doit être installé XDebug et une configuration complexe dans le L'éditeur peut atteindre des capacités de débogage de point d'arrêt.

Cependant, s'il s'agit simplement de débogage et de visualisation du traçage de la pile, PHP nous a en fait préparé deux fonctions, ce qui nous permet de voir très facilement l'état d'appel du programme lorsqu'il est en cours d'exécution.

debug_backtrace()

Comme vous pouvez le voir dans le sens littéral de cette méthode, cela signifie déboguer le backtrace, et ce qui est renvoyé est un tableau d'informations de backtrace.

function a_test($str)
{
    echo "Hi: $str", PHP_EOL;
    var_dump(debug_backtrace());
}

var_dump(debug_backtrace());

a_test("A");

// Hi: A/Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php:7:
// array(1) {
//   [0] =>
//   array(4) {
//     'file' =>
//     string(93) "/Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php"
//     'line' =>
//     int(12)
//     'function' =>
//     string(6) "a_test"
//     'args' =>
//     array(1) {
//       [0] =>
//       string(1) "A"
//     }
//   }
// }

Cette méthode doit être appelée dans une fonction. Il n'y aura aucun contenu lorsqu'elle est utilisée en dehors de la méthode de fonction. À en juger par le contenu, il génère __FILE__, __LINE__, __FUNCTION__, $argv et d'autres informations sur cette fonction. En fait, cela est lié à la fonction qui imprime actuellement cette ligne.

Bien sûr, nous pouvons également imbriquer quelques couches supplémentaires de fonctions pour voir quel est le contenu imprimé.

function b_test(){
    c_test();
}

function c_test(){
    a_test("b -> c -> a");
}

b_test();

// Hi: b -> c -> a
// /Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php:7:
// array(3) {
//   [0] =>
//   array(4) {
//     'file' =>
//     string(93) "/Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php"
//     'line' =>
//     int(37)
//     'function' =>
//     string(6) "a_test"
//     'args' =>
//     array(1) {
//       [0] =>
//       string(11) "b -> c -> a"
//     }
//   }
//   [1] =>
//   array(4) {
//     'file' =>
//     string(93) "/Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php"
//     'line' =>
//     int(33)
//     'function' =>
//     string(6) "c_test"
//     'args' =>
//     array(0) {
//     }
//   }
//   [2] =>
//   array(4) {
//     'file' =>
//     string(93) "/Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php"
//     'line' =>
//     int(40)
//     'function' =>
//     string(6) "b_test"
//     'args' =>
//     array(0) {
//     }
//   }
// }

Oui, l'ordre de sortie du tableau est l'ordre d'exécution d'une pile. b_test() est appelé en premier, il est donc en bas de la pile, et la sortie correspondante est le dernier élément du tableau.

est également utilisé de la même manière dans les cours. Lorsque

class A{
    function test_a(){
        $this->test_b();
    }
    function test_b(){
        var_dump(debug_backtrace());
    }
}

$a = new A();
$a->test_a();

// /Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php:90:
// array(2) {
//   [0] =>
//   array(7) {
//     'file' =>
//     string(93) "/Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php"
//     'line' =>
//     int(87)
//     'function' =>
//     string(6) "test_b"
//     'class' =>
//     string(1) "A"
//     'object' =>
//     class A#1 (0) {
//     }
//     'type' =>
//     string(2) "->"
//     'args' =>
//     array(0) {
//     }
//   }
//   [1] =>
//   array(7) {
//     'file' =>
//     string(93) "/Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php"
//     'line' =>
//     int(95)
//     'function' =>
//     string(6) "test_a"
//     'class' =>
//     string(1) "A"
//     'object' =>
//     class A#1 (0) {
//     }
//     'type' =>
//     string(2) "->"
//     'args' =>
//     array(0) {
//     }
//   }
// }

est utilisé dans une classe, il y aura un champ d'objet supplémentaire dans l'élément du tableau, qui affiche des informations sur la classe où se trouve cette méthode.

La déclaration de fonction de debug_backtrace() est :

debug_backtrace ([ int $options = DEBUG_BACKTRACE_PROVIDE_OBJECT [, int $limit = 0 ]] ) : array

Il y a deux constantes qui peuvent être définies dans $options. DEBUG_BACKTRACE_PROVIDE_OBJECT indique s'il faut remplir l'index de "objet"

<. 🎜>DEBUG_BACKTRACE_IGNORE_ARGS si Ignorer l'index "args", y compris tous les paramètres de fonction/méthode, peut économiser la surcharge de mémoire. $limits peut être utilisé pour limiter le nombre de trames de pile renvoyées. La valeur par défaut est 0 pour renvoyer toutes les piles.

debug_backtrace() et la méthode debug_print_backtrace() présentées ci-dessous prennent en charge le code dans les fichiers require/include et eval(). Lors de l'intégration d'un fichier, le chemin d'accès au fichier intégré sera affiché. essayer.

debug_print_backtrace()

Cette méthode peut également être vue à partir du nom. Elle imprimera directement le contenu du backtrace. Sa déclaration de fonction est la même que debug_backtrace(), mais $options est par défaut DEBUG_BACKTRACE_IGNORE_ARGS, ce qui signifie qu'il imprime uniquement le numéro de fichier et de ligne où l'appel est effectué.

function a() {
    b();
}

function b() {
    c();
}

function c(){
    debug_print_backtrace();
}

a();

#0  c() called at [/Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php:144]
#1  b() called at [/Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php:140]
#2  a() called at [/Users/zhangyue/MyDoc/博客文章/dev-blog/php/202004/source/PHP打印跟踪调试信息.php:151]

De plus, cette fonction n'a pas besoin d'utiliser var_dump() ou print_r() pour la sortie, et elle sera sortie si vous utilisez cette fonction directement. Cela nous permet de déboguer très rapidement et facilement.

Par exemple, dans les grands frameworks tels que Laravel, lorsque le contrôleur a besoin d'afficher les informations de la pile, nous pouvons utiliser debug_print_backtrace() pour afficher rapidement la situation actuelle des appels de pile. Si debug_backtrace() ne spécifie pas $options, il occupera une très grande capacité mémoire ou ne pourra pas être affiché complètement.

Résumé

Les deux fonctions présentées aujourd'hui peuvent nous aider de manière flexible à déboguer le code ou à comprendre la situation d'appel d'un framework. Bien sûr, dans des circonstances formelles, il est toujours recommandé d'utiliser la prise en charge de l'éditeur Xdebug plus pour le débogage des points d'arrêt, car nous ne pouvons pas voir les modifications des variables à l'aide des méthodes debug_backtrace().

Code de test :

https://github.com/zhangyue0503/dev-blog/blob/master/php/202004/source/PHP%E6%89%93%E5%8D%B0%E8%B7%9F%E8%B8%AA%E8%B0%83%E8%AF%95%E4%BF%A1%E6%81%AF.php

Apprentissage recommandé :

Tutoriel vidéo php

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!