Au-delà de l’enregistrement : conditions, boucles et variables dans les scripts

Les macros qui enregistrent puis reproduisent des actions constituent le moyen le plus simple d’automatiser les tâches répétitives. Elles possèdent toutefois une caractéristique fondamentale : elles exécutent exactement les mêmes opérations à chaque fois. Or, le travail réel exige de nombreuses décisions qui modifient le comportement selon la situation, par exemple « si le stock est nul, passer une commande » ou « si le total dépasse le budget, afficher un avertissement ». L’enregistrement seul ne permet pas de gérer ces décisions.

C’est là qu’interviennent les « scripts ». Ils permettent d’intégrer à vos automatisations les éléments fondamentaux de la programmation : les conditions (« si… alors… »), les boucles (répétitions) et les variables (des conteneurs qui mémorisent des valeurs). Le mot « programmation » peut sembler intimidant, mais ces éléments ne font que formaliser nos décisions quotidiennes et leur principe n’a rien de difficile. Cet article présente clairement les trois piliers des scripts, l’étape suivante après l’enregistrement.

Conditions (IF/ELSE) : lui faire prendre des décisions

Une condition est un mécanisme qui permet d’exécuter un traitement précis uniquement lorsqu’une condition donnée est remplie. Le bloc IF exécute son contenu seulement si la condition est vraie, tandis que ELSE prend en charge tous les autres cas. Il est ainsi possible d’exprimer une action telle que : « Si le mot “Erreur” apparaît à l’écran, prévenir la personne responsable ; sinon, passer directement à l’étape suivante. »

Une condition peut porter sur une valeur affichée à l’écran, la couleur d’un pixel précis ou encore un nombre stocké dans une variable. L’être humain accomplit inconsciemment toute une séquence : « regarder l’écran, évaluer la situation, puis décider de l’action suivante ». Les conditions servent précisément à intégrer cette prise de décision à l’automatisation. Une fois écrites, l’ordinateur prendra correctement la décision à votre place, à chaque exécution.

Boucles (LOOP) : lui faire répéter des opérations

Une boucle est un mécanisme qui répète plusieurs fois le même traitement. Cela ressemble au réglage du « nombre de lectures » d’une macro, mais les boucles des scripts sont bien plus souples. Vous pouvez non seulement définir un nombre précis, comme « répéter 10 fois », mais aussi répéter selon la situation : « jusqu’à ce qu’il n’y ait plus de lignes dans la liste » ou « jusqu’à ce qu’une condition donnée soit remplie ».

La véritable puissance des boucles apparaît lors du traitement de grandes quantités de données. Il suffit d’entourer le traitement d’un seul élément par une boucle pour le transformer en traitement de tous les éléments d’une liste. Qu’il y en ait 100 ou 1 000, vous n’écrivez le traitement que pour un seul élément ; la boucle parcourt automatiquement tous les autres. Une tâche manuelle qui prendrait plusieurs heures ne demande ainsi qu’une seule écriture, puis il ne reste plus qu’à attendre. C’est à ce stade que l’automatisation ne fait plus gagner quelques minutes, mais plusieurs heures.

Variables : mémoriser des valeurs

Une variable est une « boîte » qui permet de mémoriser temporairement une valeur au cours d’un traitement. Compteur (numéro de l’itération), nom de fichier, valeur numérique lue à l’écran, résultat intermédiaire d’un calcul : une fois placées dans des variables, ces valeurs peuvent être réutilisées lors des étapes suivantes. Par exemple, un traitement comme « lire la valeur d’une cellule dans une variable, puis la reporter dans une autre feuille si elle dépasse 10 000 » s’effectue en combinant variables et branchements conditionnels.

Lorsque variables, branchements conditionnels et boucles sont réunis, les possibilités de l’automatisation s’élargissent considérablement. « Lire des données (variables), adapter le traitement selon leur contenu (branchements conditionnels) et l’appliquer à tous les éléments (boucles) » : cette seule combinaison permet de couvrir une grande partie des tâches professionnelles. C’est la porte d’entrée vers une « automatisation intelligente », inaccessible avec un simple enregistrement-relecture.

Créer une « automatisation qui ne s’arrête pas » grâce à la gestion des erreurs

Une fois que vous maîtrisez les branchements conditionnels, les boucles et les variables, l’étape suivante consiste à apprendre la « gestion des erreurs ». Sur une longue période d’exploitation, des imprévus finissent toujours par se produire : coupure momentanée du réseau, fichier censé s’ouvrir introuvable, affichage différent de l’ordinaire… Sans aucune mesure prévue, le script s’arrête alors complètement. Si l’exécution se déroule sans surveillance pendant la nuit, le travail risque de rester interrompu jusqu’au lendemain matin.

C’est là qu’intervient le mécanisme de gestion des erreurs TRY/CATCH. Il permet de définir le comportement suivant : « Même si un échec se produit dans le bloc TRY, le traitement ne s’arrête pas entièrement ; il bascule vers les actions écrites dans le bloc CATCH, comme consigner l’erreur, envoyer une notification ou ignorer uniquement l’élément concerné avant de passer au suivant. » On obtient ainsi une automatisation robuste qui traite tous les autres éléments jusqu’au bout, même si l’un d’eux échoue. Autrement dit, on apprend au script à réagir comme le ferait naturellement une personne : « En cas d’échec, le consigner d’abord, puis continuer. »

Connaître les commandes SCR les plus utilisées

Les scripts SCR de makuroku proposent les commandes fréquemment utilisées dans le travail quotidien. Il n’est pas nécessaire de toutes les apprendre d’un coup, mais savoir ce qu’elles permettent de faire aide à imaginer que « ceci aussi pourrait être automatisé ». Voici quelques commandes représentatives.

• • FIND_IMAGE / WAIT_IMAGE : rechercher un élément à l’écran par son image ou attendre son apparition
• • IF / ELSE / LOOP : branchements conditionnels et répétitions
• • SET / ADD / SUB : affectation de valeurs aux variables et calculs
• • READ_FILE / WRITE_FILE : lecture et écriture de fichiers
• • HTTP_GET / POST : communication avec des services externes
• • NOTIFY / PROMPT : affichage de notifications et demande de saisie à l’utilisateur

En combinant ces fonctions, vous pouvez créer des automatisations avancées, largement hors de portée d’un simple enregistrement, comme « lire des données depuis un fichier, adapter le traitement selon certaines conditions, envoyer le résultat à un service externe et signaler la fin de l’opération ». De plus, le rôle de chaque commande reste simple, ce qui les rend faciles à apprendre. Il suffit d’enrichir progressivement votre boîte à outils en commençant par les commandes dont vous avez besoin.

Exemples d’automatisations réalisables avec des scripts

En combinant des branchements conditionnels, des boucles, des variables et la gestion des erreurs, il devient possible de créer des automatisations largement hors de portée d’un simple enregistrement. Examinons quelques exemples concrets. Prenons la tâche suivante : « ouvrir un par un tous les fichiers d’un dossier, vérifier leur contenu et déplacer dans un autre dossier uniquement ceux qui répondent aux critères ». Elle peut être réalisée en parcourant tous les fichiers avec une boucle, puis en les triant à l’aide de conditions. Un tri qui prendrait une heure manuellement peut être terminé en quelques minutes une fois le script écrit.

Autre exemple : la surveillance consistant à « récupérer régulièrement des données sur un site Web, les comparer à la valeur précédente et envoyer une notification en cas de changement » est également un domaine où les scripts excellent. Les données sont récupérées par communication HTTP, comparées à la valeur précédente enregistrée dans une variable, puis une condition déclenche une notification en cas de changement. En combinant ce processus à une exécution planifiée, vous obtenez un système de surveillance qui ne laisse passer aucun changement sans aucune intervention de votre part.

Ce type d’automatisation peut sembler difficile au premier abord, mais chacun de ses éléments — boucles, branchements conditionnels, variables, communication et notifications — est simple. La difficulté consiste à « tout comprendre d’un seul coup », et non à « combiner les éléments un par un ». Commencez par les conditions, puis passez aux boucles, et élargissez progressivement vos connaissances à partir des éléments dont vous avez besoin. Sans même vous en rendre compte, vous serez bientôt capable de créer vous-même des automatisations très avancées.

L’important est de ne pas chercher à écrire immédiatement un script parfait. Commencez par créer une version minimale qui fonctionne, exécutez-la réellement, puis corrigez peu à peu les points problématiques. makuroku dispose d’une fonction de débogage qui met en évidence en temps réel la ligne en cours d’exécution. Vous pouvez ainsi améliorer le script tout en vérifiant visuellement « où vous en êtes et ce qui se passe ». Essayer, corriger, puis réessayer : cette répétition est le moyen le plus rapide de maîtriser les scripts.

Conseils pour préserver la lisibilité des scripts

Un script n’est pas terminé une fois écrit : il est souvent relu et modifié par la suite. En veillant dès le départ à sa « lisibilité », vous faciliterez grandement le travail de votre futur vous. Voici quelques conseils. Commencez par donner aux variables des noms explicites. Au lieu de « x » ou « a », utilisez des noms comme « montant total » ou « nom du fichier cible », qui indiquent clairement leur contenu. Vous pourrez ainsi comprendre immédiatement l’objectif du traitement lorsque vous relirez le script.

Ajoutez ensuite des commentaires à chaque bloc de traitement. De simples notes comme « récupération des données à partir d’ici » ou « vérification du montant ici » suffisent à rendre le déroulement général du script plus facile à suivre. Il est également utile de diviser les traitements complexes en plusieurs petits scripts. Un ensemble de scripts courts répartis par fonction est plus facile à modifier et à réutiliser qu’un seul script immense. Pour créer un script durable, écrivez-le en vous demandant : « Mon futur moi pourra-t-il le lire et le comprendre ? »

Méthode de débogage des scripts

Lorsque vous écrivez un script, il arrive inévitablement qu’il ne fonctionne pas comme prévu. Le « débogage » consiste alors à rechercher calmement la cause du problème. Son principe fondamental est de déterminer « jusqu’où tout fonctionne correctement et à partir de quel point le comportement diffère de ce qui était prévu ». makuroku permet de mettre en évidence en temps réel la ligne en cours d’exécution et propose une sortie PRINT affichant les valeurs intermédiaires à l’écran. Vous pouvez ainsi rechercher la cause tout en vérifiant visuellement « où vous en êtes et ce qui se passe ».

Pour déboguer efficacement, commencez par diviser le traitement en petites sections, puis vérifiez leur fonctionnement une par une. Si vous essayez de tout terminer d’un seul coup, il devient difficile de savoir où se situe le problème. Écrivez progressivement, exécutez fréquemment votre script et ne passez à la suite qu’après avoir confirmé que tout fonctionne correctement. Cette répétition méthodique est finalement le moyen le plus rapide et le plus fiable de créer un script. Même lorsqu’une erreur survient, le débogage n’a rien d’effrayant si vous la considérez comme un indice indiquant « ce qu’il faut corriger ».

Ordre recommandé pour apprendre les scripts

Voici un ordre indicatif pour apprendre les différents éléments d’un script. Commencez bien sûr par les branchements conditionnels (IF/ELSE). Les décisions du type « si…, alors… » constituent la base de toute automatisation. Passez ensuite aux boucles (LOOP). Les traitements répétitifs sont extrêmement efficaces lorsqu’il faut manipuler de grandes quantités de données. La maîtrise de ces deux éléments suffit déjà à automatiser de nombreuses tâches qui restaient hors de portée d’un simple enregistrement.

Viennent ensuite les variables. Le mécanisme permettant de mémoriser des valeurs offre, lorsqu’il est associé aux conditions et aux boucles, des traitements beaucoup plus flexibles. Une fois arrivé à ce stade, apprenez la gestion des erreurs (TRY/CATCH). Pour un fonctionnement autonome de longue durée, il est indispensable que le processus ne s’arrête pas en cas d’échec en cours d’exécution. Enfin, il suffit d’apprendre selon vos besoins les commandes spécialisées adaptées à votre objectif, comme la manipulation de fichiers, les communications HTTP ou l’OCR.

L’important est de ne pas essayer de tout apprendre en une seule fois. Lorsque, dans votre travail réel, vous vous dites « ce serait pratique de pouvoir faire cela », recherchez la fonctionnalité correspondante et essayez-la. Cette manière « d’apprendre par nécessité » est finalement celle qui permet de retenir le mieux. Plutôt que de lire un manuel dans l’ordre depuis le début, vous développerez des compétences plus concrètes en automatisant les tâches qui se présentent à vous et en assimilant les éléments nécessaires au fur et à mesure.

Les scripts peuvent sembler difficiles au premier abord, mais chacun de leurs éléments est simple et vous finirez forcément par les maîtriser en les apprenant étape par étape. Une fois ces notions acquises, l’éventail des tâches que vous pourrez automatiser s’élargira considérablement. Commencez par un enregistrement, puis faites vos premiers pas dans l’univers des scripts en y ajoutant une seule condition.

Passer en douceur de l’enregistrement au script

Les personnes qui trouvent que « les scripts ont l’air difficiles » doivent justement savoir qu’il n’est pas nécessaire de partir d’une page blanche. Dans makuroku, vous pouvez d’abord enregistrer vos opérations depuis la GUI, puis convertir la macro en un script SCR modifiable. Vous disposez donc dès le départ d’une structure fonctionnelle. Il ne reste ensuite qu’à modifier les parties nécessaires, par exemple en entourant d’un LOOP la section à répéter ou en ajoutant IF à l’endroit où une décision doit être prise.

De plus, la syntaxe est vérifiée pendant la saisie, ce qui permet de signaler immédiatement les erreurs d’écriture. Une fonction de débogage met également en évidence en temps réel la ligne en cours d’exécution afin que vous puissiez voir d’un coup d’œil « où en est le traitement ». Grâce à ces aides, la transition de l’enregistrement au script est progressive. Commencez par créer la structure grâce à l’enregistrement, puis ajoutez petit à petit des conditions et des boucles : avec cette méthode, même une personne sans expérience en programmation peut créer elle-même une automatisation pratique. Avec makuroku, vous pouvez essayer gratuitement toutes ces fonctionnalités.