Débogage 101 : votre premier point d'arrêt et le traçage des variables dans VS Code

Dans cet article, nous aborderons tous les outils de débogage disponibles dans l' IDE Microsoft Visual Studio Code.

Les sections suivantes seront abordées:

• Points d’arrêt (Breakpoints)
• Fenêtre de surveillance (Watch Window)
• Pile d’appels (Call Stack)

Commençons par découvrir les prérequis nécessaires pour le débogage!

Prérequis

Il existe deux plugins (extensions) permettant le débogage d’ObjectScript

Le premier plugin fait partie de l’ InterSystems ObjectScript Extension Pack. Le second, Serenji, est un plugin autonome qui propose un éditeur, un gestionnaire de fichiers ainsi que des fonctionnalités de débogage. Les deux plugins peuvent être installés depuis la boutique d’extensions. Pour l'activqtion de ses fonctionnalités principales, Serenji nécessite une licence. Dans cet article, nous utiliserons l’InterSystems ObjectScript Extension Pack afin de réduire la courbe d’apprentissage. Une fois les bases maîtrisées, vous pourrez envisager l’achat d’une licence payante pour Serenji.

Vous avez besoin de: 

1. La version la plus récente de l' IDE Microsoft Visual Studio Code 
2. Le plugin InterSystems ObjectScript Extension Pack installé (après avoir installé Visual Studio Code)
3. Une instance InterSystems IRIS. vous pouvez choisir entre la version Docker ou le kit d’installation (vous devez être inscrit dans l’écosystème de la communauté Developer Community)

Pour savoir comment connecter votre IRIS à Microsoft Visual Studio Code IDE, consultez ici.

Configuration de la fonction de débogage

Normalement, le fichier de configuration est généré automatiquement au démarrage du débogage. Il se présente sous la forme suivante:
 

{
    "configurations": [
       
    {
        "type": "objectscript",
        "request": "launch",
        "name": "ObjectScript Run current routine",
        "program": "${file}"
    }
    ]
 
}

Où type correspond au langage du code en cours de débogage, request correspond à l'option de démarrage du débogage (launch - démarre et exécute le code ou attach - se connecte au code déjà en cours d'exécution), name correspond à l'identifiant de débogage, program correspond au nom de la classe et de la méthode en cours de débogage (dans cette configuration, un fichier ouvert sera récupéré). 

Point d’arrêt (Breakpoint)

Tout code de programme est exécuté de haut en bas, ligne par ligne. Lors du débogage, il est important de comprendre l'état du programme à un moment donné, y compris les valeurs des variables locales et globales, les ouvertures pour l'ouverture et fermetures de fichiers, les connexions Web, etc.

Le point d'arrêt est un outil de débogage qui vous permet de suspendre l'exécution du programme à une ligne spécifique afin d'identifier les changements indésirables dans l'état du programme. Il est très simple de déboguer dans Visual Studio Code. Supposons que nous ayons le code suivant:
 

Class Test.MyFile Extends %RegisteredObject
{

ClassMethod TestVar() As %Integer
{
    set randomNum = $RANDOM(10)
    return randomNum
}

ClassMethod MyMethod() As %Integer
{
    set randomNum = ..TestVar()
    set numVar = 2
    set numDivision = randomNum / numVar

    return numDivision
}
}

Nous devons comprendre la valeur stockée dans la variable x dans la méthode MyMethod(). Elle est renvoyée par la méthode TestVar(). Nous définissons un point d'arrêt avant d'effectuer l'opération arithmétique au moyen de cette variable à la ligne 15 et cliquons sur le bouton Déboguer. Si un point d'arrêt n'est pas défini, le débogage exécutera tout simplement le code sans afficher quoi que ce soit dans la console.

Nous pouvons voir la valeur d'une variable donnée immédiatement après avoir lancé le débogage! Très pratique. Ensuite, nous pouvons parcourir l'ensemble du programme ligne par ligne en appuyant sur le bouton Step into ou sur la touche F11.

 

Super! Nous connaissons désormais les valeurs des variables à chaque étape de l'exécution du code.

Nous pouvons parcourir les variables dans une boucle de la même manière. Prenons le code suivant:
 

Class Test.MyFile Extends %RegisteredObject
{

ClassMethod LoopMethod() As %List
{

    set objList = $LB("string", 1, {"name":1})
    for i=1:1:$LL(objList){
        set item = $LG(objList, i)
    }
    
    return objList
}

}

Définissons un point d'arrêt au démarrage de la méthode et commençons le débogage. Ensuite, à l'aide du bouton « Step into » du panneau de débogage situé en haut de l'IDE, nous descendons dans le programme et observons les valeurs attribuées à la variable item. Nous voyons également les valeurs de toutes les autres variables dans le programme, y compris la variable itérative i, qui dans ce cas est égale à 2.

 
Ainsi, en avançant dans la boucle, vous pouvez suivre la valeur qui sera attribuée à la variable item à chaque étape de la boucle.

Watch window

Nous pouvons également surveiller l'état d'une variable pendant le débogage en l'ajoutant à la surveillance. En mode de surveillance, nous pouvons appliquer des méthodes à une variable et mesurer son état à chaque itération. Prenons par exemple le code suivant:
 

Class Test.MyFile Extends %RegisteredObject
{

ClassMethod WatchAVariable() As %List
{
    set list = ""
    set randomNum = $RANDOM(100)
    for int=randomNum:randomNum:100000{
        set list = list _$LB(int)
    }

    return list
}
}

Et nous allons écrire trois méthodes pour la variable list:

 
Nous souhaitons suivre la longueur de la liste: $LL(list), le dernier nombre ajouté : $LG(list, -1), ainsi que sa racine carrée : $LG(list, -1) ** 0.5.

 
En définissant des fonctions dans la fenêtre pour surveiller, nous pouvons voir des informations de débogage détaillées! De plus, la fenêtre des variables affiche toujours les valeurs des variables itératives int et l'étape de boucle. Très pratique!

Fenêtre de pile d'appels

Vous remarquerez la fenêtre « Call Stack » tout en bas. Cette fenêtre affiche l'ordre des appels de fonction dans votre code. Dans notre situation courante, nous avons deux éléments: la boucle et l'affectation des variables WatchVariable+7 et WatchVariable+6, respectivement. Mais tout ici est assez explicite. Ajoutons un peu plus de logique:
 

Class Test.MyFile Extends %RegisteredObject
{

ClassMethod RandomlyChangeVar() As %Integer
{
    return $RANDOM(100)
}

ClassMethod WatchAVariable() As %List
{

    set list = ""
    set randomNum = $RANDOM(100)
    for int=randomNum:randomNum:100000{
        set list = list _$LB(int)
        if $LG(list, -1) ** 0.5 > 10{
            set int = int + ..RandomlyChangeVar()
        }
    }
    return list
}


}  

Nous avons ajouté une nouvelle méthode, RandomlyChangeVar(), qui modifie la variable int suivante si la racine carrée du dernier nombre est supérieure à 10. Nous effectuons une boucle jusqu'à ce que l'état des variables satisfasse la condition logique:

 

Notez les valeurs de la fonction racine carrée et l'ordre des appels de fonction dans la pile d'appels. Dès que la racine carrée a dépassé 10, la fonction RandomlyChangeVar() a été immédiatement appelée! De plus, en mesurant la longueur de la liste, nous avons pu suivre le nombre d'étapes de boucle nécessaires pour atteindre la condition logique souhaitée. Cela permet de suivre facilement l'ordre et les conditions d'appel de plusieurs fonctions, quelle que soit la complexité de la logique.

Et voilà ! Vous êtes désormais un spécialiste du débogage ObjectScript dans VSCode.

Dans cet article, nous avons examiné en détail la fonctionnalité de débogage dans VSCode. Nous avons défini notre premier point d'arrêt et suivi les valeurs des variables.