Macro-commandes et programmation dans le tableur

Introduction

Dans les leçons précédentes, le tableur a déjà été abordé comme outil d’automatisation des calculs, de structuration des feuilles, d’ergonomie, de contrôle et de sécurisation. Cette nouvelle étape va plus loin : il ne s’agit plus seulement d’écrire des formules dans des cellules, mais de mettre en œuvre des programmes au sein du tableur pour automatiser des tâches répétitives ou résoudre des problèmes de gestion.

Autrement dit, on passe d’une logique de calcul cellule par cellule à une logique de macro-commande et de programmation.

Cette leçon couvre donc exclusivement les éléments suivants du programme :

• La gestion des données du système d’information ;
• Gérer des données du système d’information ;
• Traiter des données via le tableur pour résoudre des problèmes ;
• Automatiser la résolution des problèmes de gestion ;
• Mettre en œuvre des programmes au sein du tableur ;
• Enregistrer une macro-commande ;
• Interpréter un programme répondant à un problème de gestion.

L’objectif n’est pas de devenir développeur, mais de comprendre comment le tableur peut exécuter une suite d’instructions simples, fiables et réutilisables dans un contexte professionnel.

Objectifs d’apprentissage

À l’issue de cette leçon, vous devez être capable de :

• comprendre ce qu’est une macro-commande dans un tableur ;
• distinguer une automatisation par formule d’une automatisation par programme ;
• expliquer l’intérêt de la programmation pour la gestion des données ;
• enregistrer une macro-commande simple ;
• repérer les principaux objets manipulés dans un tableur : classeur, feuille, cellule, plage, ligne, colonne ;
• lire et interpréter une procédure ou une fonction simple ;
• comprendre des instructions d’affectation, de calcul, de test et de boucle ;
• relier un programme à un problème de gestion concret.

1. Pourquoi programmer dans un tableur ?

1.1. Le tableur comme outil de traitement des données

Dans le système d’information, le tableur sert à traiter des données pour produire une information utile à la gestion. Il permet par exemple de :

• consolider des données commerciales ;
• calculer des montants de TVA ;
• préparer un suivi de trésorerie ;
• contrôler des écarts ;
• classer, filtrer ou reformater des données ;
• produire automatiquement des états simples.

Tant que le besoin reste limité, les formules suffisent. Mais dès qu’il faut répéter toujours la même suite d’actions, le travail manuel devient :

• lent ;
• source d’erreurs ;
• peu fiable ;
• difficile à reproduire à l’identique.

C’est là qu’intervient la macro-commande.

1.2. Qu’est-ce qu’une macro-commande ?

Une macro-commande est un ensemble d’instructions que le tableur exécute automatiquement.

Elle peut servir à :

• mettre en forme un tableau ;
• copier des données d’une feuille à une autre ;
• lancer une série de calculs ;
• effacer certaines zones puis recharger de nouvelles données ;
• produire un état standardisé.

En pratique, une macro peut être obtenue de deux façons :

1. par enregistrement : le tableur mémorise les actions réalisées par l’utilisateur ;
2. par écriture ou modification du code : l’utilisateur intervient dans le programme.

Dans le cadre du programme, il faut surtout savoir :

• enregistrer une macro-commande ;
• interpréter un programme répondant à un problème de gestion ;
• comprendre la logique de base de la programmation dans le tableur.

1.3. Pourquoi ne pas tout faire avec des formules ?

Les formules calculent des résultats dans les cellules. Elles sont très efficaces pour :

• sommer ;
• rechercher ;
• tester des conditions ;
• calculer automatiquement des indicateurs.

Mais elles ne pilotent pas facilement des actions comme :

• créer une nouvelle feuille ;
• renommer un onglet ;
• parcourir automatiquement 500 lignes ;
• effacer certaines cellules selon une condition ;
• afficher un message à l’utilisateur ;
• enchaîner plusieurs opérations sur plusieurs feuilles.

La programmation complète donc les formules. Elle permet d’automatiser le processus, pas seulement le calcul.

2. Les usages de la programmation dans les problèmes de gestion

2.1. Des besoins très concrets

Dans un contexte de gestion, une macro-commande peut répondre à des besoins simples et fréquents :

• préparer un tableau mensuel de suivi des ventes ;
• mettre à jour automatiquement une feuille de synthèse ;
• contrôler la présence de données obligatoires ;
• colorer les lignes en anomalie ;
• générer un récapitulatif par client ou par produit ;
• automatiser une tâche répétitive de clôture ou de reporting.

2.2. Exemples de problèmes de gestion adaptés à une macro

Exemple 1 : mise en forme d’un état de trésorerie

Chaque fin de semaine, un collaborateur :

• ouvre un fichier ;
• applique des largeurs de colonnes ;
• met les en-têtes en gras ;
• colore la ligne de total ;
• applique un format monétaire ;
• encadre le tableau.

Ces actions ne demandent aucune réflexion nouvelle : elles sont répétitives. Une macro enregistrée permet de les reproduire instantanément.

Exemple 2 : contrôle d’une liste de factures

Une feuille contient des factures avec :

• numéro ;
• date ;
• client ;
• montant ;
• statut.

On veut repérer automatiquement les lignes dont le montant est vide ou négatif. Une macro peut parcourir la liste, tester chaque ligne, puis surligner les anomalies.

Exemple 3 : création d’un état récapitulatif

Un service saisit des opérations dans une feuille brute. Une macro peut :

• effacer l’ancien récapitulatif ;
• recopier les nouvelles données ;
• lancer les calculs ;
• mettre en forme le tableau final.

3. Enregistrer une macro-commande

3.1. Principe

L’enregistrement d’une macro-commande consiste à demander au tableur de mémoriser les actions effectuées au clavier ou à la souris, afin de pouvoir les rejouer ensuite.

Le tableur transforme alors ces actions en instructions de programme.

C’est la manière la plus accessible d’entrer dans la programmation :

• on n’écrit pas d’abord le code ;
• on exécute les actions ;
• le tableur génère le programme correspondant.

3.2. Étapes générales

Les intitulés exacts varient selon le logiciel, mais la logique reste la même.

Étape 1 : préparer l’action à automatiser

Avant d’enregistrer, il faut savoir exactement ce que la macro devra faire.

Exemple :

• sélectionner la plage A1:E20 ;
• mettre les titres en gras ;
• appliquer une bordure ;
• formater les montants en euro.

Pourquoi cette préparation est-elle importante ? Parce que la macro enregistre les actions telles qu’elles sont faites. Si l’utilisateur hésite, se trompe ou réalise des actions inutiles, elles seront souvent enregistrées aussi.

Étape 2 : lancer l’enregistrement

On choisit l’option Enregistrer une macro.

Le tableur demande généralement :

• un nom de macro ;
• éventuellement un raccourci clavier ;
• un emplacement d’enregistrement.

Le nom doit être explicite :

• MiseEnFormeBalance
• ControleMontants
• PreparationEtatMensuel

Un bon nom facilite la maintenance et la compréhension.

Étape 3 : exécuter les actions

L’utilisateur réalise exactement les opérations à automatiser.

Exemple :

1. sélectionner la ligne des titres ;
2. appliquer le gras ;
3. centrer ;
4. colorer l’arrière-plan ;
5. sélectionner la colonne des montants ;
6. appliquer le format monétaire.

Étape 4 : arrêter l’enregistrement

Une fois les actions terminées, on clique sur Arrêter l’enregistrement.

La macro est alors mémorisée.

Étape 5 : tester la macro

Il faut vérifier :

• qu’elle se lance correctement ;
• qu’elle produit bien l’effet attendu ;
• qu’elle ne dépend pas d’une sélection accidentelle ;
• qu’elle reste utilisable dans des conditions normales.

3.3. Exemple simple d’enregistrement

Situation

On veut automatiser la mise en forme d’un tableau de ventes.

Actions à enregistrer

• sélectionner A1:D10 ;
• mettre une bordure ;
• mettre la ligne 1 en gras ;
• centrer les titres ;
• formater la colonne D en euro.

Résultat attendu

À chaque fois qu’un tableau de même structure est préparé, la macro applique immédiatement la présentation standard.

3.4. Limites de l’enregistrement

L’enregistrement est très utile, mais il a des limites :

• il produit souvent un code plus long que nécessaire ;
• il enregistre parfois des sélections inutiles ;
• il est moins souple si la taille du tableau change ;
• il ne « comprend » pas l’intention de l’utilisateur, il mémorise seulement ses actions.

C’est pourquoi il faut ensuite savoir interpréter le programme généré.

4. Mettre en œuvre des programmes au sein du tableur

4.1. De la macro enregistrée au programme

Une macro-commande n’est pas seulement une suite d’actions mémorisées : c’est aussi un programme.

Ce programme repose sur un langage de script ou de programmation intégré au tableur. Dans la pratique pédagogique, on rencontre souvent une logique de type VBA. Le programme officiel attend surtout :

• l’exécution ;
• la lecture ;
• la modification ou le complément de programmes simples.

Il ne s’agit donc pas d’un apprentissage informatique avancé, mais d’une compréhension fonctionnelle.

4.2. Les objets fondamentaux du tableur

Le programme précise qu’il faut se limiter aux objets fondamentaux. Il faut donc bien connaître les principaux éléments manipulés par le code.

Le classeur

C’est le fichier du tableur.

Il peut contenir plusieurs feuilles.

La feuille

C’est un onglet de travail du classeur.

Exemples :

• Ventes
• Clients
• Synthèse

La cellule

C’est l’unité de base repérée par une référence, par exemple A1.

La plage

C’est un ensemble de cellules.

Exemples :

• A1:A10
• B2:D8

La ligne et la colonne

Ce sont des regroupements horizontaux et verticaux de cellules.

4.3. Pourquoi parler de modèle d’objets ?

Un programme de tableur agit sur des objets.

Par exemple :

• ouvrir un classeur ;
• sélectionner une feuille ;
• modifier la valeur d’une cellule ;
• parcourir une plage ;
• effacer une ligne.

Le programme doit donc savoir sur quoi il agit.

Exemple d’idée :

• dans le classeur courant,
• sur la feuille Ventes,
• écrire dans la cellule E2,
• la formule ou la valeur voulue.

Cette logique est essentielle pour interpréter le code.

5. Procédure et fonction : deux formes de programme

5.1. La procédure

Une procédure exécute une suite d’actions.

Elle sert par exemple à :

• mettre en forme ;
• effacer ;
• recopier ;
• lancer des calculs ;
• afficher un message.

Elle agit, mais ne renvoie pas nécessairement une valeur.

Exemple conceptuel

Une procédure peut :

• lire les montants d’une liste ;
• calculer un total ;
• inscrire le total dans une cellule.

5.2. La fonction

Une fonction calcule et renvoie une valeur.

Elle ressemble davantage à une formule personnalisée.

Elle peut servir, par exemple, à :

• calculer une commission ;
• déterminer une catégorie de client ;
• renvoyer un statut selon un montant.

5.3. Différence essentielle

• Procédure : « fais ceci »
• Fonction : « calcule ceci et renvoie le résultat »

Dans le cadre du programme, il faut surtout savoir interpréter ces deux formes lorsqu’elles sont simples.

6. Lire un programme simple : les grandes familles d’instructions

Le programme mentionne plusieurs familles d’instructions. Il faut les reconnaître et comprendre leur rôle.

6.1. Affectation de valeurs, d’objets, de variables et de paramètres

L’affectation consiste à donner une valeur à un élément.

Exemples conceptuels :

• stocker le montant d’une cellule dans une variable ;
• mémoriser le nom d’un client ;
• définir la feuille sur laquelle on travaille.

Pourquoi c’est utile ?

Parce qu’un programme manipule souvent des valeurs intermédiaires.

Exemple :

• lire le montant en B2 ;
• le stocker ;
• calculer la TVA ;
• écrire le résultat en C2.

Sans affectation, le programme ne peut pas organiser ses calculs.

6.2. Instructions d’entrée, de calcul, de cumul et de sortie

Entrée

Le programme lit une information.

Exemples :

• lire la valeur d’une cellule ;
• demander une donnée à l’utilisateur.

Calcul

Le programme effectue une opération.

Exemples :

• montant TTC = montant HT + TVA ;
• remise = montant × taux.

Cumul

Le programme additionne progressivement.

Exemple :

• additionner les ventes de chaque ligne pour obtenir un total général.

Sortie

Le programme restitue le résultat.

Exemples :

• écrire le total en cellule G20 ;
• afficher un message ;
• alimenter une feuille de synthèse.

6.3. Tests : structures alternatives simples et imbriquées

Un test permet au programme de choisir entre plusieurs actions selon une condition.

Test simple

Exemple de logique :

• si le montant est négatif, alors colorer la cellule en rouge.

Test avec alternative

• si le montant est supérieur à 0, alors écrire « valide » ;
• sinon écrire « anomalie ».

Test imbriqué

On peut enchaîner plusieurs conditions.

Exemple :

• si montant < 0 → anomalie ;
• sinon si montant = 0 → à vérifier ;
• sinon → conforme.

Pourquoi c’est fondamental en gestion ?

Parce que beaucoup de règles de gestion reposent sur des conditions :

• seuil dépassé ou non ;
• facture payée ou impayée ;
• client actif ou inactif ;
• écart acceptable ou non.

6.4. Boucles : structures itératives

Une boucle permet de répéter une action plusieurs fois.

C’est l’un des intérêts majeurs de la programmation.

Exemple de logique

Parcourir toutes les lignes d’un tableau :

• lire la ligne 2 ;
• puis la ligne 3 ;
• puis la ligne 4 ;
• etc.

Pourquoi utiliser une boucle ?

Parce qu’un traitement identique doit souvent être appliqué à une série de données :

• vérifier 300 factures ;
• calculer une prime pour 50 salariés ;
• repérer les cellules vides dans une colonne ;
• cumuler les ventes par ligne.

Sans boucle, il faudrait répéter manuellement l’instruction pour chaque ligne.

7. Interpréter un programme répondant à un problème de gestion

7.1. Méthode d’analyse

Pour interpréter un programme simple, il faut suivre une démarche rigoureuse.

Étape 1 : identifier l’objectif général

Que cherche à faire le programme ?

• mettre en forme ?
• contrôler ?
• calculer ?
• transférer des données ?

Étape 2 : repérer les objets manipulés

Le programme agit sur quoi ?

• un classeur ;
• une feuille ;
• une plage ;
• une cellule ;
• une ligne.

Étape 3 : repérer les entrées

Quelles données lit-il ?

• contenu d’une cellule ;
• plage de données ;
• variable initialisée.

Étape 4 : repérer les traitements

Que fait-il sur ces données ?

• calcul ;
• cumul ;
• test ;
• mise en forme ;
• copie.

Étape 5 : repérer les sorties

Quel est le résultat ?

• écriture dans une cellule ;
• état produit ;
• alerte ;
• format appliqué.

7.2. Exemple 1 : totalisation d’une colonne

Problème de gestion

On veut totaliser les montants d’une liste de règlements et inscrire le résultat en bas du tableau.

Logique du programme

1. initialiser un total à 0 ;
2. parcourir les lignes ;
3. ajouter chaque montant au total ;
4. écrire le total dans une cellule finale.

Interprétation

• entrée : les montants de la colonne ;
• traitement : une boucle avec cumul ;
• sortie : le total écrit dans la feuille.

Intérêt

Le programme automatise un calcul répétitif et évite les oublis.

7.3. Exemple 2 : contrôle d’anomalies

Problème de gestion

Une liste de factures ne doit contenir aucun montant négatif.

Logique du programme

1. parcourir chaque ligne ;
2. lire le montant ;
3. si le montant est inférieur à 0, colorer la cellule ;
4. sinon ne rien faire.

Interprétation

• boucle : le programme examine toutes les lignes ;
• test : il compare chaque montant à 0 ;
• action : il met en évidence l’anomalie.

Intérêt

Le contrôle devient systématique et rapide.

7.4. Exemple 3 : calcul d’une commission

Problème de gestion

Un commercial reçoit :

• 0 % si les ventes sont nulles ou négatives ;
• 5 % si les ventes sont positives jusqu’à un seuil ;
• 8 % au-delà.

Logique du programme

Le programme lit le montant des ventes et applique des conditions successives.

Interprétation

On reconnaît ici une structure alternative imbriquée.

Intérêt

Le programme traduit une règle de gestion explicite.

8. Étude détaillée d’un cas simple

8.1. Situation

Une entreprise tient dans un tableur une liste de créances clients :

• colonne A : numéro de facture ;
• colonne B : nom du client ;
• colonne C : montant ;
• colonne D : date d’échéance ;
• colonne E : statut.

On souhaite automatiser un contrôle :

• si le montant est vide ou inférieur ou égal à 0, le statut doit devenir Anomalie ;
• sinon le statut doit devenir À suivre.

8.2. Ce que ferait l’utilisateur sans macro

Manuellement, il faudrait :

• aller ligne par ligne ;
• lire le montant ;
• décider du statut ;
• l’écrire en colonne E.

Sur quelques lignes, c’est faisable. Sur plusieurs centaines, c’est inefficace.

8.3. Ce que doit faire le programme

Le programme doit :

1. se placer sur la bonne feuille ;
2. identifier la dernière ligne utile ;
3. parcourir les lignes ;
4. lire le montant en colonne C ;
5. appliquer un test ;
6. écrire le statut en colonne E.

8.4. Lecture fonctionnelle du programme

Même sans détailler toute la syntaxe, on peut interpréter sa logique :

• une variable sert à repérer la ligne courante ;
• une boucle répète le traitement pour chaque ligne ;
• un test distingue les montants corrects des anomalies ;
• une écriture en cellule restitue le résultat.

8.5. Apport en gestion

Cette automatisation :

• fiabilise le contrôle ;
• homogénéise la décision ;
• réduit le temps de traitement ;
• facilite la revue des anomalies.

9. Bonnes pratiques pour enregistrer et utiliser une macro

9.1. Définir clairement le besoin

Avant toute automatisation, il faut formuler le besoin :

• quel problème de gestion veut-on résoudre ?
• quelles actions sont répétitives ?
• quelles données entrent dans le traitement ?
• quel résultat doit être produit ?

Une macro n’est utile que si elle répond à un besoin précis.

9.2. Simplifier les actions avant enregistrement

Il faut éviter :

• les clics inutiles ;
• les sélections approximatives ;
• les changements d’écran non nécessaires ;
• les hésitations pendant l’enregistrement.

Plus l’action est propre, plus la macro sera exploitable.

9.3. Tester sur un jeu de données simple

Comme vu dans la leçon précédente sur le contrôle des feuilles de calcul, il faut toujours tester l’automatisation sur un petit jeu de données :

• cas normal ;
• cellule vide ;
• montant nul ;
• valeur anormale.

Cela permet de vérifier que la logique du programme correspond bien à la règle de gestion.

9.4. Nommer clairement les macros

Un bon nom doit être :

• explicite ;
• court ;
• cohérent avec la fonction.

Exemples :

• ControleFactures
• MajSynthese
• FormatEtatTresorerie

9.5. Documenter l’usage

Dans un contexte professionnel, il faut pouvoir expliquer :

• ce que fait la macro ;
• sur quelle feuille elle agit ;
• quelles données elle attend ;
• quel résultat elle produit ;
• quelles précautions prendre avant exécution.

Cette documentation est essentielle pour la continuité du travail.

10. Erreurs fréquentes à éviter

10.1. Confondre formule et macro

Une formule calcule dans une cellule. Une macro pilote une suite d’actions.

Les deux sont complémentaires, mais ne remplissent pas le même rôle.

10.2. Enregistrer sans scénario précis

Si l’utilisateur improvise pendant l’enregistrement, la macro risque de :

• contenir des actions inutiles ;
• être difficile à réutiliser ;
• produire des résultats imprévus.

10.3. Oublier les cas particuliers

Un programme de gestion doit tenir compte de situations simples mais fréquentes :

• cellule vide ;
• valeur nulle ;
• donnée négative ;
• ligne incomplète.

10.4. Ne pas tester après enregistrement

Une macro non testée peut diffuser des erreurs rapidement sur un grand volume de données.

10.5. Croire qu’un programme « comprend » la gestion

Le programme n’interprète pas le métier. Il applique seulement les instructions données.

Si la règle de gestion est mal traduite, l’automatisation reproduira l’erreur plus vite, mais pas mieux.

11. Comment relier un programme à une règle de gestion

L’enjeu pédagogique principal est souvent là : interpréter un programme en le reliant à une logique de gestion.

11.1. Identifier la règle métier

Exemple :

• « Toute facture sans montant est en anomalie » ;
• « Toute ligne dont le total dépasse le plafond doit être signalée » ;
• « Le tableau de synthèse doit être réinitialisé avant import ».

11.2. Traduire la règle en opérations logiques

Exemple :

• lire la donnée ;
• tester la condition ;
• exécuter l’action correspondante.

11.3. Vérifier la cohérence

Il faut se demander :

• le programme traite-t-il toutes les lignes utiles ?
• le test correspond-il exactement à la règle ?
• la sortie est-elle exploitable ?

12. Mini-guides pas à pas

12.1. Guide : enregistrer une macro de mise en forme

1. Ouvrir le fichier.
2. Préparer le tableau à traiter.
3. Lancer Enregistrer une macro.
4. Donner un nom explicite.
5. Réaliser uniquement les actions utiles :
   • sélectionner la plage ;
   • mettre les titres en gras ;
   • appliquer les bordures ;
   • formater les montants.
6. Arrêter l’enregistrement.
7. Tester la macro sur un autre tableau similaire.
8. Vérifier que le résultat est conforme.

12.2. Guide : interpréter une procédure simple

1. Lire le nom de la procédure.
2. Repérer la feuille ou la plage visée.
3. Identifier les variables éventuelles.
4. Repérer si le programme :
   • lit,
   • calcule,
   • teste,
   • boucle,
   • écrit.
5. Formuler en français ce que fait la procédure.
6. Relier le tout au problème de gestion initial.

12.3. Guide : interpréter une fonction simple

1. Identifier l’entrée de la fonction.
2. Repérer la règle appliquée.
3. Identifier la valeur renvoyée.
4. Expliquer l’utilité de cette valeur dans la feuille ou dans un autre programme.

13. Points à retenir

• La programmation dans le tableur prolonge l’usage des formules pour automatiser des traitements plus complexes ou répétitifs.
• Une macro-commande est une suite d’instructions exécutées automatiquement.
• L’enregistrement d’une macro consiste à mémoriser des actions réalisées dans le tableur.
• Les objets fondamentaux à connaître sont : classeur, feuille, cellule, plage, ligne, colonne.
• Un programme simple peut contenir :
  • des affectations ;
  • des instructions d’entrée et de sortie ;
  • des calculs ;
  • des cumuls ;
  • des tests ;
  • des boucles.
• Une procédure réalise des actions ; une fonction renvoie une valeur.
• Interpréter un programme, c’est comprendre :
  • son objectif,
  • les données lues,
  • les traitements réalisés,
  • le résultat produit,
  • le lien avec la règle de gestion.

Mémo

Macro-commande

Suite d’actions automatisées dans le tableur.

Enregistrement d’une macro

Le tableur mémorise les actions de l’utilisateur et les traduit en programme.

Objets fondamentaux

• Classeur
• Feuille
• Cellule
• Plage
• Ligne
• Colonne

Familles d’instructions à reconnaître

• Affectation
• Entrée
• Calcul
• Cumul
• Sortie
• Test
• Boucle

Méthode d’interprétation

1. Quel est l’objectif ?
2. Quelles données sont lues ?
3. Quels objets sont manipulés ?
4. Y a-t-il un test ?
5. Y a-t-il une boucle ?
6. Quel résultat est produit ?

Conclusion

Dans la gestion des données du système d’information, le tableur n’est pas seulement un support de calcul : c’est aussi un outil de programmation légère. Grâce aux macro-commandes, il peut exécuter des tâches répétitives, fiabiliser des traitements et accélérer la résolution de problèmes de gestion.

L’essentiel, au niveau DCG, n’est pas de développer des applications complexes, mais de savoir :

• reconnaître quand une automatisation est utile ;
• enregistrer une macro-commande ;
• comprendre la logique d’un programme simple ;
• interpréter correctement une procédure ou une fonction appliquée à un besoin de gestion.

Cette compétence est précieuse, car elle se situe à la jonction de trois exigences professionnelles :

• la maîtrise des données ;
• la fiabilité des traitements ;
• l’efficacité opérationnelle.