Java 9 : À la découverte de JShell 2/3

Au cours de la première partie de cette suite d’articles, nous avons vu comment saisir du code dans JShell.
Nous allons maintenant voir comment s’effectue la gestion du code source.

Prêts ? Allons-y !

Gestion du code dans JShell

2.1 Historique de JShell

Lorsque vous entrez du code dans JShell, un ID unique lui est assigné. Cet ID commence à 1 et est incrémenté pour chaque commande saisie (que ce soit pour la saisie d’une expression, d’une variable, d’une méthode…).
Il en est de même pour le code chargé au démarrage de JShell. Comme nous l’avons vu lors du chapitre précédent, JShell charge un certain nombre de libraires au démarrage.
Pour chacun des ces imports, un ID unique lui est assigné.
Cet ID unique commence par $1 puis est incrémenté pour chaque code chargé ($2, $3…).
Vous remarquerez que l’ID commence par un $, cela permet de distinguer le code chargé au démarrage de celui saisi lors d’une session JShell.
Il existe un troisième type d’ID commençant par e. Ce type d’ID est réservé aux codes saisis dans JShell et qui sont tombés en erreur.

Il existe une commande interne permettant de lister l’ensemble du code chargé et saisi au cours d’une session. Il s’agit de la commande /list ! (Cela vous rappelle quelque chose ? Nous en avions déja parlé au cours de la première partie). En l’utilisant, vous aurez un affichage respectant la nomenclature suivante :

[ID] : [Code source]

Cette commande s’utilise ainsi :

• /list
• /list [ID]
• /list [Nom_Code]
• /list -start
• /list -all

/list : affiche l’ensemble du code actif entré dans la session en cours (hors code chargé au démarrage de JShell).

/list [ID] : affiche le code source correspondant à l’ID renseigné.

/list [Nom_Code] : affiche le code source correspondant au nom renseigné.

/list -start : affiche l’ensemble du code chargé au démarrage de JShell. Au démarrage d’une session, l’ensemble des imports préchargés par défaut sera affiché, et éventuellement le code que vous aurez vous-même voulu précharger (ce point sera expliqué en troisième partie, dans le chapitre Personnaliser le démarrage de JShell).

/list -all : liste l’ensemble du code actif, inactif, en erreur et préchargé, entré au cours d’une session JShell.

La capture ci-dessous vous montre l’usage de cette commande :

Si vous veniez, au cours d’une session JShell, à nommer une variable, une méthode ou encore un type avec le même nom, alors la commande /list vous affichera les différentes occurrences de ce nom avec le type correspondant :

Il existe une autre manière d’accéder à l’ensemble des commandes entrées dans JShell.
Il suffit pour cela d’entrer la commande /history :

Cette commande va vous afficher l’ensemble des commandes saisies depuis le début de la session en cours.

Cela peut paraître évident mais rappelons le, vous pouvez également accéder aux anciennes commandes saisies via les touches flèche haut et flèche bas de votre clavier.

2.1 Editer du code avec JShell

L’accès à l’historique des commandes saisies dans JShell est très pratique, notamment dans le cas où l’on souhaiterait modifier du code saisi. Afin de simplifier la navigation dans les lignes entrées, un certain nombre de raccourcis clavier ont été mis en place, en voici un résumé dans le tableau ci-dessous :

Entrée	Valider la ligne
Flèche gauche	Se déplacer à gauche dans la ligne
Flèche droite	Se déplacer à droite dans la ligne
Ctrl-A	Se déplacer en début de ligne
Ctrl-E	Se déplacer en fin de ligne
Alt-B	Se déplacer à gauche, mot par mot
Alt-F	Se déplacer à droite, mot par mot
Delete	Effacer les caractères après le curseur
Backspace	Effacer les caractères avant le curseur
Ctrl-k	Effacer les caractères situés entre le curseur et la fin de la ligne
Alt-D	Effacer le texte situé après le curseur
Ctrl-W	Effacer le texte situé avant le curseur
Ctrl-Y	Restaurer le texte dernièrement effacé

Ces raccourcis sont pratiques à utiliser sur du code court mais sur du code volumineux (création d’une méthode, d’une Classe…) cela peut très vite devenir fastidieux.
C’est la raison pour laquelle les créateurs de JShell ont mis en place un éditeur de texte, appelé JShell Edit Pad, qui permet de modifier son code de manière très simple.
Cet éditeur se lance à l’aide de la commande /edit.

Voyons comment l’utiliser :

• /edit
• /edit [ID]
• /edit [Nom_Code]

/edit : utilisé sans argument, la commande /edit affiche l’ensemble du code actif dans l’éditeur de texte.

/edit [ID] : affiche dans l’éditeur de texte le code correspondant à l’ID saisi.

/edit [Nom_Code] : affiche dans l’éditeur de texte le code correspondant au nom renseigné.

Voyons maintenant à quoi ressemble l’éditeur de texte.
Prenons l’exemple suivant :

Nous créons un entier x, un double y suivi d’une méthode appellée “addition”.
En saisissant la commande /edit nous obtenons l’affichage suivant :

Cela vous rappelle quelque chose ?

Et oui, il s’agit bien d’une interface Swing !
JShell Edit Pad est un éditeur développé en Swing, composé d’une Jframe contenant un JTextArea et trois Jbuttons.
Chaque morceau de code saisi dans l’invite de commande se termine par un ” ;” dans l’éditeur de texte.
Vous pouvez vous servir de l’éditeur pour ajouter/modifier du code, et valider l’ensemble avec le bouton Accept.

À partir de l’exemple précédent, nous allons ajouter une nouvelle méthode multiply() et modifier la valeur de la variable y :

Après avoir cliqué sur le bouton Accept, nous obtenons l’affichage suivant dans l’invite de commande :

JShell affiche dans l’invite de commande l’ensemble des modifications que nous venons d’effectuer dans JShell Edit Pad.

Remarque : lorsque vous modifiez/ajoutez du code via l’éditeur de texte, vérifiez bien que le texte saisi se termine par un ” ;”.

Pour retourner sur l’invite de commande, il faut quitter l’éditeur via le bouton “Exit”.

Si nous voulons seulement afficher la variable x dans JShell Edit Pad, il suffit de saisir la commande /edit x :

Nous obtenons le résultat suivant :

De la même manière, si nous voulons seulement modifier le texte d’ID 2 (correspondant à la variable y dans notre exemple), il suffit d’entrer la commande /edit 2 :

Nous obtenons comme résultat :

Dans la troisième partie, nous verrons qu’il est possible de modifier l’éditeur par défaut de JShell pour en mettre un autre (Notepad++…). D’ici là, voyons comment faire pour enregistrer l’ensemble du code saisi dans JShell.

2.3 Enregistrement du code source

Lorsque vous saisissez du code ou des commandes internes dans JShell, ceux-ci sont utilisables au cours de la session en cours. Lorsque vous fermez JShell et que vous ouvrez une nouvelle session, tout le code précédemment saisi est perdu.
Lorsque l’on veut tester un programme long au cours d’une session et y revenir ultérieurement, cela devient embêtant. Heureusement les créateurs de JShell ont pensé à tout. Une commande interne a été implémentée afin d’enregistrer dans un fichier l’ensemble du code saisi. Il s’agit de la commande /save.

Elle s’utilise ainsi :

• /save [file-path]
• /save -all [file-path]
• /save -history [file-path]
• /save -start [file-path]

/save [file-path] : sans argument, cette commande enregistre l’ensemble du code actif saisi au cours de la session, dans le fichier renseigné en second argument. Notez que le code saisi en erreur ainsi que les commandes internes ne sont pas enregistrées dans le fichier.

/save -all [file-path] : enregistre l’ensemble du code actif, en erreur et au démarrage, saisi au cours de la session, dans le fichier renseigné en second argument. Les commandes internes saisies ne sont quant à elles pas enregistrées.

/save -history [file-path] : enregistre l’ensemble du code et des commandes saisis au cours de la session, dans le fichier renseigné en second argument. Même les commandes internes sont enregistrées dans le fichier.

/save -start : enregistre l’ensemble du code lancé au démarrage de JShell.

L’exemple suivant vous montre comment utiliser la commande save :

Dans un premier temps, nous créons les variables x et y, ainsi qu’une méthode addition(). Ensuite, nous listons les variables créées à l’aide de la commande interne /list, puis nous finissons en créant un bout de code incorrect (affectation d’une String à une variable de type int).

Le code saisi dans JShell est enregistré dans différents fichiers, en fonction de l’option renseignée après la commande /save.
Comme vous pouvez le constater, les fichiers ont été renseignés avec l’extension .jsh. Ce n’est bien sûr pas une obligation vous pouvez saisir une extension différente (.txt…).

Dans l’exemple ci-dessous, le répertoire C:\Users\jawmo contient les fichiers suivants :

Voyons leur contenu, à commencer par le fichier save.jsh :

Le fichier save.jsh contient l’ensemble du code actif saisi dans la session en cours, séparé par des ” ;”. Il s’agit de la création des variables x, y et de la méthode addition().

Le contenu du fichier saveAll.jsh est le suivant :

Ce fichier possède davantage de contenu. Il contient l’ensemble des imports lancés au démarrage de JShell, la création des variables x, y ainsi que la méthode addition(), et enfin, il contient également le code erroné saisi (ici la création de la variable var).

Passons maintenant au fichier saveHistory.jsh :

Ce fichier contient le code de création des variables x, y, la méthode addition() et la variable ‘var’ en erreur. En plus du code, il contient également les commandes internes saisies dans la session en cours, en l’occurrence ici la commande /list ainsi que les différentes utilisations de la commande /save.

Pour finir, le contenu du fichier saveStart.jsh est le suivant :

Ce fichier ne contient que le code lancé par JShell au démarrage de la session, en l’occurrence ici les imports des différentes librairies.

Enregistrer dans un fichier les commandes et le code saisis au cours d’une session JShell sont très utile au cas où nous aurions besoin de les utiliser plus tard. Il serait encore plus pratique de pouvoir les charger dans une nouvelle session JShell, sans avoir à les copier/coller dans l’invite de commande ou via le JShell Editor Pad. Et bien cela est l’objet de la partie qui suit, allons-y !

2.4 Charger du code source dans JShell

Au cours du point précédent, nous avons saisi du code dans JShell, que nous avons ensuite enregistré dans différents fichiers.
Supposons maintenant qu’après avoir quitté notre session JShell, nous souhaiterions réutiliser le code précédemment saisi dans une nouvelle session. Cela est possible grâce à la commande /open [File_Path].
Cette commande va charger dans JShell l’ensemble du code et des commandes internes se trouvant dans le fichier [File_Path] fourni en option.

Vous vous souvenez du fichier save.jsh ? Il contenait le code de création des variables x, y et de la méthode addition(). Dans l’exemple qui suit, nous allons charger le contenu de ce fichier dans une nouvelle session JShell :

Après le lancement de JShell, les variables x et y ne sont pas reconnues. Nous chargeons le contenu du fichier save.jsh à l’aide de la commande /open C:\Users\jawmo\save.jsh puis nous vérifions l’existence des variables qui sont cette fois-ci bien reconnues, il en est de même pour la méthode addition().

La possibilité de charger du code dans JShell est très pratique lorsque l’on a besoin de tester du code volumineux, notamment pour charger plusieurs Interface, Classes,… venant d’un projet Java.

Il existe une autre façon de charger du code dans JShell. Il s’agit de la commande interne /reload.
Supposons qu’au cours d’une session JShell vous exécutiez un certain nombre de bouts de code, puis que vous quittiez votre session en oubliant d’enregistrer l’ensemble des sources dans un fichier.
La commande /reload, lancée depuis une nouvelle session JShell, va vous permettre de charger l’ensemble du code éxécuté lors de la précédente session.
Pour ce faire, il faut exécuter la commande /reload avec l’option -restore.
L’exemple suivant vous présente l’utilisation de cette commande :

Au cours de notre première session JShell nous créons deux variable, x et y, puis nous fermons notre session. Nous ouvrons ensuite une nouvelle session qui ne contient alors aucune variable connue. À l’aide de la commande /reload -restore, nous chargeons l’ensemble du code qui a été éxecuté au cours de la précédente session, c’est-à-dire la création des variables x et y. Après avoir lancé la commande, nous constatons que les variables x et y sont à présent bien reconnues.

Pour finir sur cette partie, voyons maintenant comment réinitialiser JShell.

2.5 Réinitialiser JShell

Au cours d’une session, vous pourriez être amené à vouloir la réinitialiser sans forcément avoir envie de fermer et rouvrir JShell. Il existe une commande interne pour cela, /reset.
Grâce à cette commande, tout le code saisi au cours de la session en cours sera effacé. Ceci peut être utile si vous souhaitez tester de nouvelles classes, créer de nouvelles variables, etc. tout en conservant les noms précédemment utilisés.
Dans l’exemple qui suit, nous partons d’une nouvelle session JShell dans laquelle nous créons les variables x et y. Nous réinitialisons ensuite JShell afin de réutiliser ces variables :

Conclusion

Au cours de cette deuxième partie, nous avons vu comment gérer le code que l’on saisit dans l’invite de commande, que ça soit pour gérer l’historique, éditer du code, enregistrer dans un fichier pour une utilisation ultérieure ou encore réinitialiser JShell.

Cette gestion du code peut toutefois être personnalisable selon notre besoin. Comment ? Cela fera l’objet de la troisième partie dans laquelle nous verrons comment modifier la configuration par défaut de JShell.

© SOAT
Toute reproduction interdite sans autorisation de l’auteur