Excel AI Blog: VBA Tutorials, Formula Tips & Automation Guides

Une requête HTTP lancée depuis Excel VBA renvoie deux choses, un code de statut et un bloc d'octets, et tout le reste vous incombe. Ce guide compare MSXML2.XMLHTTP, ServerXMLHTTP et WinHttpRequest, explique pourquoi un GET peut renvoyer les données de la veille, pourquoi un 404 ne déclenche jamais d'erreur, pourquoi un appel synchrone peut figer Excel, comment réparer les accents et le japonais illisibles avec ResponseBody et ADODB.Stream, et comment envoyer un POST JSON sans qu'il casse sur un Windows français ou allemand.

VBA n'a pas d'analyseur JSON intégré, et analyser du JSON avec Split, InStr ou des regex casse au premier guillemet imbriqué. Ce guide montre comment analyser du JSON en Excel VBA avec VBA-JSON (JsonConverter), comment les objets JSON deviennent des Dictionary et les tableaux des Collection qui commencent à 1, pourquoi lire une clé absente l'ajoute en silence, pourquoi null s'arrête sur l'erreur 94, pourquoi les identifiants longs et les dates ISO demandent de la vigilance, et comment aplatir un tableau d'enregistrements dans une feuille en une seule écriture. Il traite aussi de la construction d'un JSON fiable sur un Windows français ou allemand.

Le web scraping avec Excel VBA lit le HTML envoyé par le serveur, pas la page que vous voyez dans le navigateur, et ce seul fait explique la plupart des échecs. Ce guide montre comment savoir en dix secondes si une page peut être extraite, comment trouver la requête JSON derrière une page JavaScript, comment lire un tableau HTML avec XMLHTTP et htmlfile au lieu d'Internet Explorer, pourquoi des nombres extraits comme 1 234,56 ne sont pas encore des nombres, comment réparer un texte illisible dû à un meta charset, et quand Power Query À partir du web est le meilleur outil.

IsEmpty ne demande pas si une cellule semble vide : il demande si un Variant a déjà reçu une valeur. Ce guide montre pourquoi IsEmpty renvoie False pour une formule qui renvoie une chaîne vide, une espace ou une apostrophe seule, pourquoi il vaut toujours False pour une plage de plusieurs cellules ou une variable String, pourquoi une cellule vide est aussi égale à 0, comment comparer une cellule en erreur à une chaîne vide plante avec Type mismatch, et quel test utiliser pour chaque sens du mot vide.

VarType et TypeName lisent l'étiquette de type que porte une valeur VBA, et dans Excel cette étiquette est fixée par la cellule, pas par votre code. Ce guide couvre les constantes VarType et les chaînes TypeName, pourquoi un nombre entier dans une cellule est un Double, pourquoi un format monétaire ou de date change le type et peut arrondir vos valeurs, pourquoi VarType regarde à travers un Range jusqu'à sa valeur alors que TypeName nomme l'objet, le piège du tableau selon qu'il y a une ou plusieurs cellules, et comment vérifier ce que l'utilisateur a sélectionné.

Dans Excel VBA, Null ne vient presque jamais d'une cellule : une cellule vide est Empty. Null vient d'une propriété de plage dont les cellules ne sont pas d'accord, comme Font.Bold, NumberFormat ou RowHeight sur des cellules disparates, et des champs de base de données. Ce guide explique pourquoi If x = Null ne s'exécute jamais, pourquoi affecter Null à un Boolean ou à une String s'arrête sur l'erreur 94 Invalid use of Null, comment Null se propage à travers + mais pas à travers l'esperluette, et comment traiter une plage mixte comme une troisième réponse plutôt que comme un plantage.

Excel offre deux moyens distincts de placer une macro sur une touche : le raccourci des options de macro, enregistré dans le classeur et actif tant que ce fichier est ouvert, et Application.OnKey, défini par le code et valable pour toute la session Excel. Ce guide explique les deux, les codes de touches d'OnKey, pourquoi Ctrl+lettre remplace en silence les raccourcis d'Excel, pourquoi un raccourci Ctrl+Maj peut arrêter une macro juste après Workbooks.Open, pourquoi Ctrl+Alt est un piège sur les claviers AZERTY, et comment faire le ménage pour qu'une touche ne survive pas à son classeur.

Application.OnTime ne lance pas de minuteur : il dépose une réservation dans la file d'Excel, identifiée par une heure exacte et un nom de macro. Ce guide montre comment exécuter une macro à une heure donnée ou toutes les quelques minutes, pourquoi l'annulation échoue avec l'erreur 1004 si vous ne repassez pas exactement la même heure, pourquoi une réinitialisation du code laisse un minuteur impossible à arrêter, pourquoi fermer le classeur n'annule rien et pousse Excel à rouvrir le fichier, comment empêcher un planning répétitif de dériver, et quand préférer le Planificateur de tâches de Windows.

SendKeys n'appuie sur aucune touche : il dépose des frappes dans une file, et c'est la fenêtre qui a le focus au moment où elles sont lues qui les reçoit. Ce guide couvre la syntaxe et les codes de touches de SendKeys, pourquoi les touches envoyées à Excel ne prennent effet qu'une fois que votre macro rend la main (si bien que le code semble s'exécuter dans le désordre), pourquoi un 50% dans la chaîne appuie sur Alt, comment des frappes finissent dans la mauvaise fenêtre, l'effet de bord sur le Verr Num, les rares tâches pour lesquelles SendKeys convient, et l'appel du modèle objet à utiliser pour tout le reste.

Piloter PowerPoint depuis Excel en VBA, c'est travailler dans un second modèle objet où il n'y a pas de cellules, seulement des diapositives couvertes de formes mesurées en points. Ce guide montre comment créer une présentation, ajouter des diapositives, coller des graphiques et des plages Excel sous forme d'images, et remplir un modèle. Il explique aussi le piège dont personne ne vous parle : PowerPoint ne tourne qu'en un seul exemplaire, votre macro le partage donc avec les présentations que l'utilisateur a déjà ouvertes, et un Quit imprudent ferme aussi son travail.

Piloter Word depuis Excel en VBA, c'est passer à un modèle objet où un document est un long fil de texte et où un Range est une position de début et une position de fin, pas un bloc de cellules. Ce guide remplit un modèle Word à partir des données d'une feuille, colle un tableau Excel, enregistre en DOCX et en PDF, et corrige les trois échecs classiques : Range qui désigne le Range d'Excel, l'erreur 462 due à un ActiveDocument non qualifié, et la limite de 255 caractères de Rechercher et remplacer.

La liste sous Outils > Références est la liste des dépendances de votre projet VBA : elle est enregistrée dans le classeur et résolue de nouveau sur chaque PC qui l'ouvre. Ce guide explique ce que fait une référence, les quatre références par défaut, comment en ajouter une, pourquoi une seule bibliothèque MISSING fait échouer des lignes innocentes comme Left et Date avec Can't find project or library, comment la priorité des références décide de ce que signifie Range, et pourquoi un fichier qui voyage doit être développé avec des références mais livré sans.

Une variable globale VBA est une déclaration Public en tête d'un module standard, visible par toutes les procédures du projet. La déclarer est facile ; s'y fier ne l'est pas, car une globale ne vit que tant que le projet VBA reste chargé, et End, le bouton Réinitialiser, une erreur non gérée ou une modification du code l'effacent. Ce guide couvre Public, Global et Dim, les trois niveaux de portée, ce qui réinitialise une globale, le Dim local qui la masque en silence, et comment conserver une valeur après la fermeture du classeur.

Une variable Static VBA est déclarée dans une seule procédure mais garde sa valeur d'un appel à l'autre : une portée locale avec la durée de vie d'une variable de niveau module. Elle est donc idéale pour les compteurs, les bascules, les verrous anti-réentrance et les caches dont une seule procédure a besoin. Ce guide couvre le fonctionnement de Static, Static contre Dim et un Private de niveau module, Static Sub, pourquoi une Static n'oublie jamais un indicateur bloqué ni des données périmées, pourquoi toutes les cellules qui appellent une UDF partagent une même Static, et quand la promouvoir.

Un paramètre Optional permet d'appeler une Sub ou une Function VBA avec ou sans argument, avec une valeur par défaut quand l'appelant l'omet. Ce guide couvre les règles de déclaration, pourquoi un Optional typé ne distingue pas un argument omis d'un argument passé avec la valeur par défaut, quand utiliser plutôt un Variant avec IsMissing, comment sauter des arguments avec les arguments nommés, ParamArray pour un nombre quelconque de valeurs, et pourquoi Optional est le moyen de faire évoluer une procédure sans casser le code qui l'appelle déjà.

Renommer une feuille en VBA tient en une ligne, ws.Name = "New", mais un renommage est un refactoring : Excel réécrit chaque formule, nom défini et graphique qui pointe vers la feuille, et laisse cassée chaque chaîne de texte qui épelle l'ancien nom. Ce guide explique ce qui est mis à jour et ce qui ne l'est pas, les règles de nommage qui déclenchent l'erreur 1004, pourquoi une cellule de date donne un nom de feuille parfait en Allemagne et un plantage aux États-Unis, et comment renommer en masse sans collision.

En VBA, une feuille a trois états de visibilité, pas deux : visible, masquée et très masquée, que la boîte de dialogue Afficher ne sait même pas lister. Ce guide couvre la propriété Visible et ses trois constantes, pourquoi masquer la dernière feuille visible déclenche l'erreur 1004, pourquoi une feuille masquée continue de calculer et reste entièrement accessible depuis le code, comment afficher toutes les feuilles en une seule boucle, et pourquoi masquer relève de la présentation et non de la sécurité.

Excel n'a pas de méthode Exists pour les feuilles : chaque macro qui ajoute, renomme ou supprime par nom a donc besoin de sa propre vérification. Ce guide donne une fonction SheetExists fiable et explique les trois façons dont les versions habituelles échouent : interroger le mauvais classeur, chercher dans Worksheets alors qu'une feuille graphique porte déjà le nom, et passer un Variant qu'Excel lit comme un index. Il compare aussi les approches par boucle, On Error et Evaluate, et indique quand chacune est le bon choix.

Pour enregistrer une feuille, une plage ou un classeur entier en PDF depuis VBA, appelez ExportAsFixedFormat avec Type:=xlTypePDF et un chemin complet. Ce guide explique pourquoi un PDF n'est qu'une impression envoyée dans un fichier, pourquoi c'est donc votre mise en page qui décide du contenu du PDF, comment exporter plusieurs feuilles dans un seul fichier, et comment éviter l'erreur d'exécution 1004 que provoque un chemin incorrect.

PrintOut envoie une feuille, une plage, un groupe de feuilles ou un classeur entier à une imprimante depuis VBA, avec des arguments pour les copies, les plages de pages, l'aperçu et l'imprimante cible. Ce guide explique pourquoi PrintOut est l'extrémité papier du même circuit qui produit les PDF, comment tester sans gaspiller de papier, comment changer d'imprimante sans casser la configuration de l'utilisateur, et pourquoi imprimer en PDF est le mauvais outil.

L'objet PageSetup décide de ce qu'est une page imprimée ou exportée — zone d'impression, orientation, mise à l'échelle, marges, lignes de titre répétées, en-têtes et pieds de page. Ce guide explique pourquoi chaque impression et chaque PDF ne vaut que ce que vaut sa mise en page, la règle du Zoom qui fait vraiment fonctionner l'ajustement à une page de large, comment définir la zone d'impression à partir d'une plage, et comment PrintCommunication accélère un code de mise en page trop lent.

Me.Controls est la collection vivante de tous les contrôles d'un UserForm — vous la parcourez avec For Each, filtrez par type avec TypeName ou TypeOf, atteignez n'importe quel contrôle par son nom sous forme de chaîne, et ajoutez des contrôles pendant que le formulaire s'exécute. Ce guide montre le modèle de collection qui remplace vingt lignes nommées à la main par une seule boucle, comment éviter le mauvais type de contrôle en toute sécurité, et le moment où une boucle vaut mieux que des références nommées.

Un TextBox de UserForm renvoie toujours une String, même quand l'utilisateur a tapé un nombre ou une date — c'est la source de presque tous les bugs de TextBox. Ce guide explique pourquoi .Value est du texte, les deux façons dont l'arithmétique dessus échoue, la conversion sûre avec IsNumeric puis CDbl ou CLng, la différence entre .Text et .Value, le test du vide, et la validation en direct avec les événements Change et Exit.

Un Frame VBA est un conteneur qui possède les contrôles placés à l'intérieur, pas seulement une bordure avec une légende. Ce guide couvre la règle pour laquelle les Frame existent — rendre les boutons radio mutuellement exclusifs par groupe au lieu d'un seul groupe sur tout le formulaire — l'alternative GroupName, le fait qu'un Frame possède sa propre sous-collection Controls, l'activation ou le masquage d'une section entière d'un coup, et la chaîne Parent qui change la façon d'atteindre un contrôle.

Application.Run exécute une macro dont vous n'avez que le nom sous forme de chaîne, en décidant quelle procédure s'exécute pendant que le code tourne plutôt qu'au moment où vous l'écrivez. Ce guide couvre les formes instruction et fonction, le passage de 30 arguments positionnels au maximum, l'appel d'une macro dans un autre classeur ouvert, pourquoi un nom mal orthographié est une erreur d'exécution et non une erreur à la compilation, et la vraie raison d'être de la méthode — une table d'aiguillage qui associe des noms à des actions, le motif derrière les plugins, les macros pilotées par configuration, et un nom de macro stocké dans une cellule.

CallByName lit une propriété, écrit une propriété ou exécute une méthode sur un objet en utilisant le nom du membre sous forme de chaîne : c'est donc le code qui décide quel membre toucher pendant qu'il tourne. Ce guide couvre les quatre types d'appel VbGet, VbLet, VbSet et VbMethod, pourquoi choisir le mauvais déclenche l'erreur 438, le passage d'arguments, la règle du tout-public, et le motif pour lequel la fonction existe — appliquer une table de noms de propriétés et de valeurs à un contrôle ou une forme sans un long bloc d'affectations répétitives.

Evaluate exécute une expression de feuille de calcul Excel conservée sous forme de texte et vous en rend le résultat, en utilisant le moteur de calcul même dont se servent vos cellules, de sorte que vous pouvez calculer une formule construite à l'exécution. Ce guide couvre le raccourci entre crochets et pourquoi il n'est qu'Evaluate déguisé, la raison pour laquelle les crochets n'acceptent pas de variable là où Evaluate le peut, le test du variant Error renvoyé à l'aide d'IsError, la qualification de l'appel vers la bonne feuille, et quand recourir à Evaluate plutôt qu'à WorksheetFunction.

Application.FileDialog est le sélecteur intégré qui permet à une macro de demander un fichier ou un dossier à l'utilisateur au lieu de coder un chemin en dur. Ce guide traite les trois outils de demande de chemin comme une seule et même idée — ils renvoient une chaîne de chemin, ils n'ouvrent et n'enregistrent rien. Il couvre les quatre types de boîtes de dialogue (FilePicker, FolderPicker, SaveAs, Open), pourquoi .Show renvoie -1 pour une sélection et 0 pour une annulation plutôt que True ou False, la lecture du résultat dans la collection .SelectedItems indexée à partir de 1, l'autorisation de la sélection multiple, l'ajout de filtres de fichiers, et quand préférer le plus simple GetOpenFilename.

Application.GetOpenFilename est la façon en une ligne pour une macro de demander à l'utilisateur quel fichier utiliser, au lieu de coder un chemin en dur. Ce guide rend impossibles à manquer les deux faits qui piègent tout le monde — elle renvoie une chaîne de chemin et n'ouvre rien, et l'annulation renvoie le booléen False, si bien que la variable doit être déclarée Dim As Variant. Il couvre la syntaxe de FileFilter, la définition d'un filtre par défaut et d'un titre de boîte de dialogue, le renvoi d'un tableau de chemins indexé à partir de 1 avec MultiSelect, et en quoi elle diffère de l'objet FileDialog plus complet.

Application.GetSaveAsFilename affiche la boîte de dialogue Enregistrer sous et renvoie le chemin que l'utilisateur a choisi — mais elle n'enregistre rien, et c'est le fait qui surprend tout le monde. Ce guide est le miroir de GetOpenFilename — elle renvoie une chaîne de chemin et l'annulation renvoie le booléen False, si bien que la variable doit être déclarée Dim As Variant. Il couvre la suggestion d'un nom par défaut avec InitialFileName, le FileFilter, et le piège suivant — le vrai format du fichier vient de votre argument FileFormat de SaveAs, et non de l'extension que l'utilisateur a choisie, si bien qu'une incohérence produit un fichier qui ne s'ouvrira pas.

VBA ListBox affiche une liste d'options sur un UserForm et laisse l'utilisateur en choisir un ou plusieurs. Ce guide traite chaque contrôle de UserForm comme une seule idée : un objet vivant que vous lisez à travers ses propriétés, jamais la valeur elle-même. Il couvre le remplissage d'un ListBox en un coup avec .List = Range.Value plutôt que .AddItem dans une boucle, la lecture d'un choix unique avec .ListIndex et .Value, le piège numéro un selon lequel .Value passe à Null dès que MultiSelect est actif, si bien que vous devez parcourir .Selected(i), le vidage avec .Clear, et quand préférer un ListBox à un ComboBox.

VBA ComboBox est une liste déroulante sur un UserForm qui laisse l'utilisateur choisir un élément ou, par défaut, saisir le sien. Ce guide le présente comme un ListBox replié sur une seule ligne qui répond à deux questions à la fois : quel élément, lu avec .ListIndex, et quel texte, lu avec .Value. Il couvre le remplissage avec .List = Range.Value, la propriété .Style qui décide si la saisie est permise, le piège numéro un selon lequel un .Value non vide n'est pas la même chose qu'un choix valide, si bien que vous testez .ListIndex supérieur ou égal à 0, et quand un ComboBox l'emporte sur un ListBox.

VBA CheckBox est une bascule oui/non sur un UserForm dont vous lisez le .Value comme un Boolean, True ou False. Ce guide le présente comme le contrôle le plus simple qui soit, puis les deux choses qui surprennent : TripleState, qui ajoute un troisième .Value valant Null, si bien que If cb.Value déclenche un type mismatch, et la règle de regroupement de son cousin l'OptionButton, où chaque bouton radio d'un même conteneur forme un seul groupe exclusif tant que vous ne les séparez pas avec un Frame. Il couvre la lecture des cases, le câblage des boutons radio, et le fait de ne jamais simuler un groupe radio avec des cases à cocher.

VBA Exit For quitte une boucle For dès l'instant où vous avez trouvé ce que vous cherchiez, au lieu de dérouler chaque itération restante. Ce guide présente toute la famille Exit comme une seule idée : quitter tôt et proprement la structure courante. Il couvre Exit For et Exit Do pour les boucles, Exit Sub et Exit Function pour les procédures, la surprise numéro un selon laquelle Exit For ne quitte que la boucle la plus interne, pourquoi il n'existe ni Exit If ni Continue en VBA, le motif de la clause de garde qui remplace l'imbrication profonde, et pourquoi Exit est une porte propre hors d'un bloc tandis que End arrête toute la macro.

VBA GoTo fait sauter l'exécution vers une ligne étiquetée dans la même procédure, sans condition. Ce guide explique comment fonctionne la syntaxe du label et du saut, le seul endroit où GoTo a vraiment sa place aujourd'hui (On Error GoTo pour la gestion des erreurs), et pourquoi, pour le flux de contrôle ordinaire, c'est presque toujours le mauvais outil. Il couvre le piège du saut vers l'intérieur ou l'extérieur d'une boucle qui corrompt le compteur, pourquoi VBA n'a pas de Continue et comment on détourne GoTo pour le simuler, pourquoi vous ne pouvez pas faire un GoTo entre procédures, et les remplacements structurés (Exit, clauses de garde, boucles Do) qui se lisent mieux que n'importe quel saut.

VBA End arrête toute la macro d'un seul coup, en jetant chaque variable et en sautant tout nettoyage que vous aviez prévu, ce qui le rend bien plus destructeur qu'il n'en a l'air. Ce guide démêle quatre choses qui contiennent toutes le mot end mais font des travaux très différents : l'instruction End nue qui arrête tout, End Sub et End If qui ne font que fermer un bloc, Exit Sub qui revient d'une seule procédure, et Stop qui met en pause dans le débogueur. Il explique ce que End réinitialise vraiment, pourquoi il peut laisser ScreenUpdating désactivé ou les événements coupés, et pourquoi vous n'en voulez presque jamais.

VBA ReDim redimensionne un tableau dynamique à l'exécution, parce qu'un tableau VBA a une taille fixe dès l'instant où vous le Dim, à moins de laisser les crochets vides. Ce guide explique la seule décision qui gouverne les tableaux : taille fixe ou dynamique. Il couvre pourquoi Dim a() crée un tableau sans taille, comment ReDim lui en donne une, pourquoi un ReDim simple efface toutes les valeurs alors que ReDim Preserve conserve les données, la règle selon laquelle ReDim Preserve ne peut agrandir que la dernière dimension d'un tableau à deux dimensions, pourquoi vous ne pouvez pas faire un ReDim sur un tableau de taille fixe, ce que fait réellement Erase, et pourquoi agrandir un tableau élément par élément dans une boucle est lent.

VBA UBound renvoie l'indice valide le plus élevé d'un tableau et LBound renvoie le plus bas, parce qu'en VBA on ne compte pas un tableau, on lui demande sa taille. Ce guide explique pourquoi les tableaux VBA sont indexés à partir de zéro par défaut, si bien qu'un tableau de dix éléments va de l'indice 0 à 9, pourquoi ce décalage d'indice est le bug de boucle numéro un, pourquoi la boucle sûre est For i = LBound To UBound plutôt que 0 To UBound, comment calculer une vraie longueur avec UBound moins LBound plus un, comment obtenir la taille de chaque dimension d'un tableau 2D avec UBound tableau 2, et pourquoi UBound sur un tableau dynamique vide lève l'erreur 9.

Un tableau 2D VBA est un seul tableau adressé par deux indices, une grille de lignes et de colonnes, et non un tableau de tableaux. Ce guide explique le modèle mental d'une grille avec un indice de ligne et un indice de colonne, comment déclarer un tableau à deux dimensions avec Dim g lignes et colonnes, comment lire et écrire chaque cellule avec g ligne virgule colonne, et le fait le plus utile pour les développeurs Excel : lire Range.Value vous remet un tableau Variant à deux dimensions basé sur un, ce qui est la façon la plus rapide de traiter une feuille parce que vous ne touchez la feuille qu'une fois. Il couvre aussi l'écriture d'un tableau vers une plage en une seule fois, la limite de la dernière dimension de ReDim Preserve pour ajouter des lignes, et en quoi un tableau irrégulier de tableaux diffère d'un vrai tableau 2D.

VBA Set affecte une référence à une variable objet, parce qu'une variable objet est une étiquette qui pointe vers un objet, pas une boîte qui en contient un. Oubliez Set sur un objet et vous obtenez l'erreur d'exécution 91, Object variable or With block variable not set ; utilisez Set sur autre chose qu'un objet et vous obtenez l'erreur 424, Object required. Ce guide couvre le modèle mental de la référence contre la valeur, pourquoi Range, Worksheet et Dictionary ont besoin de Set alors qu'Integer et String n'en ont pas besoin, comment Set fait de deux variables des alias du même objet vivant, et comment lire les deux erreurs d'exécution les plus courantes de VBA.

VBA New construit une toute nouvelle instance d'un objet, si bien que Set d = New Dictionary crée un Dictionary neuf et vide. New relève de la liaison anticipée, qui exige une référence de bibliothèque mais offre IntelliSense et rapidité, tandis que CreateObject relève de la liaison tardive, qui n'exige aucune référence et reste portable d'une machine à l'autre. Ce guide couvre le modèle mental de New comme l'instant où un objet naît, quand choisir New plutôt que CreateObject, le piège du Dim As New où l'objet est créé paresseusement et se ressuscite en silence après que vous l'avez libéré, et pourquoi vous ne pouvez pas faire un New sur une Worksheet ou un Range.

VBA Nothing est l'état de référence vide, une variable objet qui ne pointe vers aucun objet, et toute variable objet commence sa vie à Nothing. Vous le testez avec If x Is Nothing, à l'aide de l'opérateur Is, parce qu'un simple = ne peut pas comparer des objets. Set x = Nothing libère la référence. Ce guide couvre le modèle mental de Nothing comme un pointeur vide, pourquoi la garde du Find qui a renvoyé Nothing est l'usage réel le plus courant, quand libérer vers Nothing compte réellement par opposition à quand ce n'est qu'un rituel inoffensif, et en quoi Nothing diffère d'Empty, de Null et de la chaîne vide.

VBA Round applique l'arrondi bancaire (arrondi au pair le plus proche), si bien que Round(2.5) vaut 2 et Round(3.5) vaut 4, ce qui contredit en silence le ROUND de la feuille de calcul qui arrondit les moitiés en s'éloignant de zéro. Ce guide couvre le modèle mental selon lequel les maths de VBA ne sont pas celles de la feuille, le bug numéro un d'un total de macro décalé d'un centime par rapport à la feuille, comment coller à la cellule avec Application.WorksheetFunction.Round, pourquoi Int et Fix tronquent au lieu d'arrondir et divergent sur les nombres négatifs, et quand l'arrondi bancaire est réellement le bon choix.

VBA Mod est un opérateur, pas une fonction, et il surprend deux fois : il arrondit ses deux opérandes à des entiers avant de diviser, et le résultat prend le signe du dividende, si bien que -7 Mod 3 vaut -1 alors que le MOD(-7,3) de la feuille vaut 2. Ce guide couvre le modèle mental du reste après division entière, le bug numéro un qui consiste à porter une formule MOD de la feuille directement dans VBA, les idiomes de la ligne sur N et du test de parité, comment construire un enveloppement toujours positif avec ((a Mod b) + b) Mod b, et pourquoi x Mod 0 lève l'erreur 11.

VBA Rnd renvoie un Single dans l'intervalle 0 à 1 et rejoue exactement la même séquence à chaque exécution de la macro, jusqu'à ce que vous appeliez Randomize une fois pour l'amorcer à partir de l'horloge du système. Ce guide couvre le modèle mental d'un générateur pseudo-aléatoire à graine, le bug numéro un d'un tirage aléatoire identique à chaque fois parce que Randomize manque, la bonne formule d'entier dans un intervalle Int((hi - lo + 1) * Rnd + lo), comment reproduire une séquence à dessein pour les tests, pourquoi Rnd n'est pas fait pour la sécurité, et quand RandBetween est le meilleur outil.

Déplacer une ligne en VBA, c'est couper et insérer, pas couper-coller. Rows(5).Cut Destination:=Rows(20) colle par-dessus la ligne 20 et la détruit en silence ; Rows(5).Cut puis Rows(20).Insert ouvre un espace et décale tout vers le bas pour ne rien perdre. Ce guide couvre le modèle mental d'un déplacement qui est un décalage, le bug de perte de données numéro un qui consiste à coller au lieu d'insérer, pourquoi le trou de la ligne source se referme et renumérote tout ce qui se trouve en dessous quand on déplace vers le bas, comment déplacer plusieurs lignes de bas en haut, et pourquoi les références suivent une ligne coupée au lieu de virer en #REF!.

Déplacer une colonne en VBA, c'est le même couper-insérer que déplacer une ligne, tourné de 90 degrés : Cut Destination:= colle par-dessus la colonne cible et la perd, tandis que couper puis Insert ouvre un espace et décale les colonnes vers la droite pour ne rien détruire. Ce guide couvre le fait de couper l'EntireColumn plutôt qu'une plage partielle, pourquoi le trou de la colonne source se referme et décale votre cible d'un cran vers la gauche, réordonner plusieurs colonnes par nom d'en-tête sans qu'elles atterrissent au mauvais endroit, et pourquoi les références suivent une colonne déplacée au lieu de virer en #REF!.

Range.Cut en VBA ramasse des cellules ; ensuite il existe exactement deux façons de les reposer qui font l'inverse l'une de l'autre. Cut Destination:= (un collage) les dépose par-dessus et écrase ; Destination.Insert ouvre un espace et décale. Ce guide couvre Cut face à Copy (un déplacement vide la source, une copie la laisse), les deux consommateurs d'une coupe, pourquoi vous réglez Application.CutCopyMode = False, pourquoi Cut refuse une plage multi-zone, et pourquoi les références de formule suivent une coupe au lieu de virer en #REF! comme à une suppression.

Rows.Group ne cache ni ne supprime rien ; il ajoute une bande à un plan (outline) réductible, et les données restent là, simplement repliables. Ce guide couvre le modèle mental du regroupement comme pli plutôt que masquage, le réglage SummaryRow qui décide du côté où atterrit le bouton de réduction et le détache en silence d'une ligne de total placée au-dessus, pourquoi on réduit par niveau avec ShowLevels plutôt qu'en touchant Hidden, et pourquoi ClearOutline vaut mieux qu'une boucle d'Ungroup quand on reconstruit.

Columns.Group replie des colonnes derrière un plan (outline) horizontal en haut de la feuille, le même pli que grouper des lignes tourné de 90 degrés. Ce guide couvre pourquoi on groupe la colonne entière et jamais une plage partielle, le réglage SummaryColumn qui place par défaut le bouton de réduction à droite du groupe et le détache d'une colonne de totaux à gauche, comment ShowLevels réduit les colonnes sur leur propre axe, et pourquoi grouper n'est pas le même outil que masquer une colonne ou régler sa largeur.

L'Outline est l'objet sur lequel s'appuie tout regroupement ; ShowLevels réduit et développe toute la feuille à un niveau donné en un seul appel, bien mieux qu'une boucle sur Hidden. Ce guide couvre le pilotage des deux axes avec ShowLevels, pourquoi AutoOutline a besoin de vraies formules de synthèse sous peine d'échouer avec l'erreur 1004, comment Subtotal crée d'un coup les groupes, le plan et les lignes SUBTOTAL mais s'empile à chaque re-lancement sauf si on retire d'abord, et comment ShowDetail développe un seul nœud tandis que ClearOutline est la réinitialisation propre.

Columns.Insert ne fait pas surgir une colonne vierge de nulle part ; il pousse les colonnes existantes vers la droite et réécrit les formules qui pointaient dedans, si bien qu'Insert est en réalité un décalage. Ce guide couvre pourquoi vous insérez l'EntireColumn et jamais une plage partielle, comment les références suivent les données alors que les adresses VBA en dur ne le font pas, l'insertion de plusieurs colonnes en un seul appel plutôt que dans une boucle vers l'avant, et la règle CopyOrigin qui décide de quel voisin la nouvelle colonne hérite sa mise en forme.

Columns.Delete, c'est Insert à l'envers : il tire chaque colonne de droite d'un cran vers la gauche, et toute formule qui pointait dans la colonne supprimée s'effondre en une erreur #REF! permanente. Ce guide couvre pourquoi les références se cassent, le piège de la boucle vers l'avant qui fait sauter des colonnes à une suppression, la suppression par condition avec un seul Union pour que rien ne se renumérote en cours de boucle, et quand ClearContents est l'opération que vous vouliez vraiment au lieu de Delete.

Dès l'instant où vous insérez ou supprimez une plage partielle au lieu d'une colonne ou d'une ligne entière, vous héritez d'une décision qu'Excel prend en silence : dans quel sens décaler les cellules environnantes. Ce guide couvre pourquoi les opérations sur ligne entière sont le cas sûr, pourquoi omettre l'argument Shift laisse Excel deviner d'après la forme de la plage et brouiller vos voisines, les constantes xlShift exactes pour Insert et Delete, et pourquoi une ligne entière est de toute façon en général ce que vous vouliez.

Worksheets.Add est une fabrique qui vous rend la nouvelle feuille sous forme de valeur de retour : capturez-la donc avec Set ws = Worksheets.Add plutôt que de la traquer ensuite avec ActiveSheet. Ce guide couvre cette valeur de retour que la plupart des débutants ignorent, pourquoi un Add sans argument place la feuille à gauche de la feuille active plutôt qu'à la fin, les arguments Before et After qui contrôlent la position, et les règles de nommage partagées avec le renommage qui déclenchent l'erreur 1004 sur un nom en double ou illégal.

Worksheet.Copy utilise le même positionnement Before et After qu'Add mais ne renvoie rien, et un Copy sans destination ne duplique pas la feuille dans le classeur : il crée un tout nouveau classeur contenant la copie. Ce guide couvre cette surprise, comment saisir la copie via ActiveSheet quand il n'y a pas de valeur de retour, ce qui voyage avec une feuille copiée, y compris son code et ses noms définis, et comment Move reflète Copy avec l'intention inverse.

Worksheet.Delete est la seule opération sur les feuilles qui s'arrête pour demander, en lançant une boîte de dialogue de confirmation modale qui bloque en silence une macro sans surveillance ; vous la faites taire avec Application.DisplayAlerts False et la réactivez dans un gestionnaire d'erreurs. Ce guide couvre cette discipline CleanExit, pourquoi Excel refuse de supprimer la dernière feuille visible avec l'erreur 1004, pourquoi supprimer par index dans une boucle saute des feuilles à moins de boucler à l'envers, et comment supprimer une feuille seulement si elle existe.

Worksheet.Protect est l'interrupteur maître qui active l'étiquette Locked déjà posée sur chaque cellule, et comme chaque cellule est Locked par défaut, protéger une feuille sans préparation fige tout, y compris les cellules de saisie dont vos utilisateurs ont besoin. Ce guide couvre le déverrouiller-puis-protéger en deux temps, pourquoi les indicateurs AllowFiltering et AllowSorting comptent, pourquoi une feuille protégée bloque vos propres macros à moins de passer UserInterfaceOnly, pourquoi cet indicateur est perdu à l'enregistrement, et pourquoi le mot de passe est un garde-fou contre les accidents plutôt qu'une vraie sécurité.

Worksheet.Unprotect remet l'interrupteur maître de protection sur arrêt, mais il laisse l'étiquette Locked de chaque cellule exactement telle qu'elle était : ôter la protection ne déverrouille donc pas les cellules. Ce guide couvre le sandwich ôter la protection-travailler-reprotéger que toute macro d'édition emploie, pourquoi un mot de passe erroné ou absent sur une feuille protégée déclenche l'erreur 1004 ou se bloque sur une boîte de dialogue modale, pourquoi vous devez reprotéger dans un gestionnaire d'erreurs pour qu'un plantage ne laisse jamais la feuille ouverte, comment ôter la protection de chaque feuille dans une boucle, et la limite honnête : VBA ne peut pas récupérer un mot de passe que vous avez oublié.

La propriété Locked en VBA Excel n'est qu'une étiquette posée sur une cellule, pas un verrou actif, et elle ne fait absolument rien tant que la feuille de calcul n'est pas protégée : voilà pourquoi mettre Locked à True et constater que les utilisateurs peuvent toujours modifier la cellule est la confusion numéro un. Ce guide explique pourquoi chaque cellule démarre Locked, le flux de travail inversé qui déverrouille les cellules de saisie, pourquoi Locked renvoie Null sur une sélection mixte, le compagnon FormulaHidden qui masque une formule de la barre de formule, et pourquoi vous devez définir Locked pendant que la feuille n'est pas protégée.

AutoFit en VBA Excel mesure le contenu d'une colonne ou d'une ligne à l'instant où il s'exécute et y verrouille une taille fixe : c'est un instantané ponctuel, pas une règle vivante qui ré-ajuste en continu. Ce guide couvre Columns.AutoFit face à Rows.AutoFit, le piège d'EntireColumn quand vous partez d'une plage partielle, pourquoi AutoFit doit être la dernière ligne après l'écriture des données, pourquoi les cellules fusionnées le cassent en silence, et quand une largeur fixe que vous maîtrisez vaut mieux que de relancer AutoFit.

WrapText en VBA Excel remodèle une cellule pour que le texte long se répartisse sur plusieurs lignes dans la largeur de la colonne au lieu de déborder sur les voisines, et c'est la seule propriété d'affichage qui rejaillit sur la hauteur de ligne. Ce guide explique pourquoi le renvoi n'agrandit la ligne que si la hauteur est en automatique, la séquence largeur fixe puis WrapText puis Rows.AutoFit, en quoi WrapText diffère d'un saut de ligne forcé Chr(10), pourquoi une plage mixte se relit en Null, et quand renvoyer une colonne ou la laisser telle quelle.

FreezePanes en VBA Excel verrouille les lignes du haut ou les colonnes de gauche de l'affichage pour qu'elles restent visibles pendant le défilement, mais c'est une propriété de la fenêtre et non de la feuille, et elle fige tout ce qui se trouve au-dessus et à gauche de la cellule active. Ce guide couvre pourquoi vous devez placer la cellule active avant de l'activer, pourquoi le figeage vit sur ActiveWindow et pourquoi chaque Nouvelle fenêtre a le sien, comment le désactiver et re-figer, FreezePanes face à Split, et la voie sans sélection via SplitRow.

PasteSpecial en VBA Excel est un collage filtré qui lit un presse-papiers vivant, ce qui explique pourquoi il doit suivre immédiatement un Copy et pourquoi tout ce qui vide le presse-papiers entre les deux déclenche PasteSpecial method of Range class failed. Ce guide couvre les deux axes — ce qui traverse (xlPasteValues, xlPasteFormats, xlPasteFormulas, xlPasteColumnWidths) et comment ça atterrit (Operation, Transpose, SkipBlanks) — le piège du format, et quand se passer complètement de PasteSpecial.

Coller les valeurs en VBA Excel fige une formule vivante dans le nombre qu'elle a produit, si bien que le résultat survit à la suppression de sa source, que le recalcul des formules volatiles s'arrête, et que les liens externes se rompent avant l'envoi d'un fichier. Ce guide présente la recette xlPasteValues, le piège de format qui transforme des dates en numéros de série, le moment où se tourner vers xlPasteValuesAndNumberFormats, et le raccourci en une ligne dst.Value = src.Value qui ne touche jamais au presse-papiers.

Range.Copy Destination en VBA Excel copie une plage directement vers une cible en une seule instruction, si bien que le presse-papiers n'est jamais touché, que rien ne peut le corrompre en cours d'exécution, et qu'il n'y a aucun Select pour ralentir la macro. Ce guide met en regard Copy Destination et l'aller-retour Select-Copy-Paste de l'enregistreur, explique la règle de dimensionnement par le coin supérieur gauche, montre ce que transporte une copie complète face au raccourci valeurs seules dst.Value = src.Value, et précise quand le presse-papiers reste nécessaire.

En VBA Excel, ColorIndex n'est pas une couleur mais un numéro de siège dans une palette de 56 emplacements que le classeur peut réattribuer ; c'est pourquoi le même index paraît or sur votre poste et moutarde chez un collègue. Ce guide distingue ColorIndex (un emplacement de palette, de 1 à 56) de Color (une valeur RGB absolue), explique les valeurs spéciales xlNone et xlColorIndexAutomatic, et montre quand recourir encore à ColorIndex et quand Color reste le choix le plus sûr.

La fonction RGB en VBA Excel empile trois canaux de 0 à 255 dans un seul nombre Long, et ce nombre n'est pas stocké comme un code hexadécimal web le laisserait croire. Ce guide explique comment RGB construit une couleur, pourquoi la valeur relue depuis Color est un BGR aux octets inversés (si bien que coller un hexa web comme 4472C4 donne la mauvaise couleur), comment utiliser les constantes de couleur vb, et comment décomposer une couleur stockée en rouge, vert et bleu.

La mise en forme conditionnelle en VBA Excel est une règle permanente que vous confiez à Excel une seule fois via la collection FormatConditions, et qu'Excel réexécute à chaque modification, contrairement à une boucle VBA qui colore les cellules une fois et se périme dès qu'une valeur change. Ce guide couvre l'ajout d'une règle avec FormatConditions.Add, l'habitude du delete-avant-add qui évite l'empilement des règles, le piège des références absolues contre relatives dans une règle par expression, et le moment où une boucle statique reste le bon choix.

ThisWorkbook désigne toujours l'unique classeur qui contient votre code et ne change jamais, même quand l'utilisateur clique sur une autre fenêtre, tandis qu'ActiveWorkbook désigne ce qui se trouve au premier plan à l'instant T. Ce guide explique la distinction entre le fixe et le versatile qui décide si une macro modifie le bon fichier, pourquoi un Range non qualifié est la première cause de macro qui corrompt le mauvais classeur, comment référencer un autre classeur ouvert par son nom, et pourquoi ThisWorkbook doit rester votre ancrage par défaut.

ActiveWorkbook et ActiveSheet pointent vers ce que l'utilisateur a cliqué en dernier, ce qui les rend pratiques et en fait la première source d'une macro qui touche le mauvais fichier. Ce guide explique pourquoi l'objet actif est une cible mouvante, l'anti-modèle Select et Activate que les macros enregistrées laissent derrière elles, quand agir sur l'objet actif est réellement correct, comment lire l'objet actif une seule fois dans une variable au lieu d'y recourir sans cesse, et pourquoi les références directes battent la sélection à tous les coups.

La collection Worksheets est la façon de nommer une feuille en code, et vous pouvez l'adresser de trois manières : par chaîne de nom, par numéro d'index ou par CodeName. Ce guide explique pourquoi le nom casse dès qu'un utilisateur renomme un onglet, pourquoi l'index casse quand quelqu'un réordonne les onglets, pourquoi le CodeName ne casse sur aucun des deux, la vraie différence entre Worksheets et Sheets, et comment définir une fois une variable feuille qualifiée pour que le reste de votre macro ne touche plus jamais une référence fragile.

Un commentaire VBA est la seule ligne que le compilateur a la garantie d'ignorer, ce qui en fait votre geste de débogage le plus sûr et votre habitude de documentation la plus dangereuse. Ce guide couvre l'apostrophe face à Rem, comment mettre tout un bloc en commentaire avec l'Edit toolbar cachée, pourquoi un commentaire ne peut pas cohabiter avec une continuation de ligne, la différence entre un commentaire de source et l'objet Comment d'une cellule, et les seuls commentaires qui valent vraiment la peine d'être écrits.

Option Explicit est la ligne au meilleur rapport bénéfice/effort de tout VBA, car sans elle un nom de variable mal orthographié n'est pas une erreur mais une toute nouvelle variable vide qui renvoie tranquillement zéro. Ce guide montre le bug de la faute de frappe silencieuse qu'elle élimine, pourquoi elle vaut par module et comment le réglage Require Variable Declaration l'ajoute pour vous, quoi faire quand Variable not defined apparaît dans du vieux code, et pourquoi elle force la déclaration mais pas les types de données.

La continuation de ligne VBA est un espace suivi d'un trait de soulignement qui permet à une longue instruction de s'étendre sur plusieurs lignes physiques, et l'analyseur l'efface avant la compilation, si bien qu'elle ne change que la façon dont la source se lit. Ce guide couvre l'espace obligatoire avant le trait de soulignement, pourquoi vous ne pouvez pas couper à l'intérieur d'une chaîne littérale, pourquoi un commentaire tue une continuation, comment le deux-points fait l'inverse en joignant des instructions, et quand y recourir.

Debug.Print écrit une ligne dans l'Immediate Window sans arrêter la macro : c'est la façon non bloquante de regarder une boucle faire défiler ses valeurs au lieu de se noyer sous les popups MsgBox. Ce guide explique pourquoi Debug.Print semble ne rien faire tant que vous n'avez pas ouvert l'Immediate Window avec Ctrl+G, pourquoi le tampon d'environ 200 lignes jette silencieusement vos premières sorties, pourquoi imprimer une expression peut déclencher de vrais effets de bord, en quoi il diffère de MsgBox, et quand cesser de journaliser dans la fenêtre pour écrire dans un fichier à la place.

L'Immediate Window est deux outils en un : l'endroit où atterrit la sortie de Debug.Print, et une console vivante où vous tapez une ligne de VBA et l'exécutez sur-le-champ. Ce guide montre comment le raccourci ? évalue n'importe quelle expression, pourquoi taper ? devant une fonction exécute réellement cette fonction et ses effets de bord, pourquoi vos variables locales se lisent comme vides tant que la macro n'est pas en pause en break mode, comment appeler un Sub ou une boucle d'une ligne à la main, et quand la console a fait son travail et que la logique a sa place dans un module.

Un breakpoint gèle une macro sur une ligne avant qu'elle ne s'exécute et vous dépose en break mode, où vous lisez chaque valeur vivante puis parcourez le code une ligne à la fois avec F8. Ce guide couvre la pose de breakpoints avec F9, la différence entre Step Into et Step Over, pourquoi les breakpoints disparaissent à la fermeture du classeur, pourquoi une instruction Stop ne doit jamais être livrée aux utilisateurs, comment Debug.Assert vous donne un breakpoint conditionnel ignoré à l'exécution, et quand l'exécution pas à pas vaut mieux que parsemer le code de Debug.Print.

IsNumeric ne demande pas si une chaîne est un nombre ; il demande si VBA pourrait la convertir en nombre s'il essayait, et VBA essaie fort. Ce guide montre pourquoi IsNumeric renvoie True pour la notation scientifique, un littéral hexadécimal, un séparateur de milliers, une chaîne entourée d'espaces et même une valeur à signe final, pourquoi cela laisse passer de mauvaises données dans votre validation, pourquoi il dépend des paramètres régionaux au point de corrompre les données d'une machine à l'autre, et quand cesser de lui faire confiance pour verrouiller la forme avec l'opérateur Like à la place.

L'opérateur VBA Like répond à une seule question booléenne : la chaîne entière épouse-t-elle cette forme à caractères génériques ? Ce guide couvre les cinq jokers (astérisque, point d'interrogation, dièse, et les formes [liste] et [!liste]), pourquoi Like teste la chaîne entière — d'où les astérisques autour d'une sous-chaîne —, pourquoi sa sensibilité à la casse est un interrupteur Option Compare à l'échelle du module sans dérogation par appel, comment reconnaître un astérisque littéral avec les crochets, et quand Like l'emporte à la fois sur InStr et sur une expression régulière complète.

Regex en VBA n'est pas un mot-clé : c'est l'objet VBScript RegExp que vous créez, et il ne fait rien d'utile tant que vous n'avez pas réglé trois interrupteurs et choisi la bonne sortie. Ce guide couvre la liaison tardive contre l'ajout de la référence, pourquoi Global vaut False par défaut si bien que vous n'obtenez que la première correspondance, la différence entre Test, Replace et Execute, pourquoi extraire suppose d'aller au-delà de Match.Value jusqu'à SubMatches, et la saveur de motif VBScript avec ses références arrière en signe dollar.

La fonction VBA Filter prend un tableau de chaînes unidimensionnel et renvoie un nouveau tableau, plus petit, ne contenant que les éléments qui incluent une sous-chaîne que vous nommez — c'est la cousine de InStr côté tableau, et elle ne touche jamais une cellule. Ce guide démêle la confusion permanente avec AutoFilter (une méthode de feuille qui masque des lignes), puis couvre les trois pièges qui font croire que Filter est cassé : il correspond à des sous-chaînes et non à des valeurs entières, il est sensible à la casse par défaut tant que vous ne passez pas vbTextCompare, et il renvoie un tableau indexé à partir de zéro dont UBound vaut moins un quand rien ne correspond.

La fonction VBA Join recolle un tableau unidimensionnel en une seule chaîne, en plaçant un délimiteur entre chaque élément — c'est l'exact inverse de Split, et le remède en une ligne à la boucle de concaténation qui laisse toujours un séparateur en trop. Ce guide montre pourquoi Join n'accepte qu'un tableau 1D (donc Range.Value échoue tant que vous ne l'aplatissez pas), pourquoi le délimiteur vaut un espace par défaut plutôt que rien, comment chaque élément est converti en texte, et le pipeline Split-Filter-Join qui remplace une boucle de quinze lignes par une seule expression.

Application.Transpose échange les lignes et les colonnes d'un tableau, mais son vrai travail quotidien en VBA est plus discret : transposer une plage d'une seule colonne la réduit au tableau unidimensionnel dont Join et Filter ont tous deux besoin. Ce guide couvre l'astuce d'aplatissement, pourquoi c'est Application.Transpose et jamais un Transpose nu, le plafond silencieux de 65 536 éléments qui vous trahit sur de gros volumes, et les erreurs qu'il déclenche sur les chaînes de plus de 255 caractères ou les tableaux contenant une valeur d'erreur — pour que vous sachiez exactement où le remodelage s'arrête et où une vraie boucle commence.

Un PivotTable en VBA Excel ne lit pas vos cellules ; il lit un PivotCache, un instantané figé de la source pris au moment de la construction, et ce seul fait explique la plainte numéro un : vous modifiez les données et le pivot affiche encore les totaux de la veille tant que vous n'appelez pas RefreshTable. Ce guide couvre la construction moderne en deux temps avec PivotCaches.Create et CreatePivotTable, la disposition des champs via les quatre valeurs d'Orientation, l'ajout de champs de données avec la bonne fonction de synthèse, le piège du rafraîchissement, et le piège de la plage source que vous réglez en pointant le cache sur une Table pour que le pivot grandisse de lui-même.

Une Table Excel en VBA est un ListObject, une plage qui connaît son propre en-tête, son corps de données et ses bords, et qui s'auto-étend quand vous y écrivez — ce qui explique précisément pourquoi elle supprime la corvée de macro la plus courante : chasser la dernière ligne avec End(xlUp). Ce guide couvre la conversion d'une plage avec ListObjects.Add, l'adressage des parties par leur nom (HeaderRowRange, DataBodyRange, ListColumns), l'ajout de lignes de façon fiable avec ListRows.Add, le piège du DataBodyRange qui vaut Nothing sur une table vide, et l'écriture de formules à références structurées qui survivent aux insertions.

Un graphique en VBA Excel ne contient pas de données ; il contient une référence à un Range, car chaque série stocke ses valeurs sous forme de formule comme =Sheet1!$B$2:$B$13, et ce seul fait explique pourquoi un graphique trace silencieusement les mauvaises cellules dès que sa source bouge. Ce guide couvre la scission en deux conteneurs sur laquelle trébuche chaque macro de graphique (ChartObjects incorporés contre feuilles de graphique), la création d'un graphique et la liaison des données en un seul geste avec SetSourceData, l'ajout de séries à la main avec SeriesCollection.NewSeries, le piège du graphique en double à la réexécution, et la liaison de la source à une Table pour que le graphique suive les données au lieu d'une adresse figée.

Un named range en VBA Excel n'est pas un surnom pour une cellule, c'est une formule stockée qu'Excel réévalue chaque fois que vous utilisez le nom, et ce seul fait explique toutes les surprises que vous rencontrerez avec les noms. C'est pourquoi RefersTo exige un signe égal en tête, pourquoi les signes dollar décident si le nom est absolu ou dérive avec la cellule active, pourquoi un nom possède une portée limitée soit au classeur entier soit à une feuille, et pourquoi supprimer les cellules sous un nom le laisse pointer vers une erreur #REF! permanente. Ce guide couvre Names.Add et le raccourci Range.Name en une ligne, la portée classeur contre feuille, la lecture de la valeur référencée par un nom, et le nettoyage des noms cassés qui alourdissent un classeur.

AutoFill en VBA Excel est un moteur de motifs, pas une commande de copie, et garder cette distinction en tête est ce qui l'empêche de vous surprendre. Range.AutoFill prend une petite amorce et l'étend sur une destination plus grande, prolongeant une série comme 1, 2, 3 ou les mois de l'année plutôt que de simplement répéter l'amorce, ce qui est à la fois tout l'intérêt et tout le piège. Ce guide couvre la règle de destination qui provoque l'erreur d'exécution 1004 que tout le monde rencontre, le FillType qui décide si vous obtenez une série ou une copie, le remplissage d'une formule vers le bas d'une colonne pour que ses références s'ajustent ligne par ligne, et pourquoi les plus simples FillDown et FillRight sont généralement le meilleur outil quand vous ne voulez qu'une copie ordinaire.

Effacer une cellule en VBA Excel est un menu, pas une commande unique, et choisir le mauvais élément, c'est ainsi que des macros ruinent discrètement un modèle ou décalent les cellules dont d'autres formules dépendent. Une cellule est un empilement de couches, la valeur et la formule, le format de nombre, la police et le remplissage, les bordures, la validation et les commentaires, et chaque méthode d'effacement efface un sous-ensemble choisi tandis que le reste survit. Ce guide couvre ClearContents contre Clear contre ClearFormats, pourquoi affecter une chaîne vide à une cellule n'est pas la même chose que la rendre vide, la différence cruciale entre Clear et Delete qui change chaque adresse en dessous, et comment effacer toute une used range en un seul appel rapide.

Lire et écrire une cellule en VBA Excel passe par la propriété .Value du Range, et l'essentiel à retenir tient à ce qui se produit avec plus d'une cellule : une plage multi-cellules vous rend un tableau Variant à deux dimensions en base 1, et lui réaffecter un tableau écrit tout le bloc en un seul appel. C'est la différence entre une macro instantanée et une qui rame, car chaque accès à Cells(i, j).Value franchit la frontière entre VBA et Excel. Ce guide couvre .Value sur une cellule contre une plage, l'aller-retour par tableau qui accélère les lectures et écritures en masse, pourquoi le tableau est en 2D même pour une seule colonne, et le raccourci de propriété par défaut sur lequel il ne faut pas trop compter.

Écrire une formule depuis VBA Excel revient à affecter une chaîne à la propriété .Formula du Range, et la règle qui piège tout le monde, c'est que .Formula ne parle qu'un seul dialecte figé : noms de fonctions en anglais américain et séparateurs virgule, quels que soient la langue ou les paramètres régionaux de l'utilisateur. Affecter =SUM(A1:A10) marche sur chaque machine et Excel localise l'affichage ; affecter la version allemande =SUMME(A1;A10) déclenche l'erreur d'exécution 1004. Ce guide couvre .Formula face à la .FormulaLocal localisée, .FormulaR1C1 pour estamper une formule relative sur toute une plage, pourquoi le signe égal en tête est obligatoire, comment doubler les guillemets à l'intérieur d'une chaîne de formule, et relire une formule avec .HasFormula.

Une cellule en VBA Excel a plus d'un visage, et lire le mauvais est un bug silencieux : .Value2 donne le nombre brut stocké, .Value donne ce nombre converti vers un type VBA correspondant (une cellule au format Date renvoie un Date, une cellule monétaire renvoie un Currency), et .Text donne la chaîne mise en forme affichée à l'écran, en lecture seule. Lire .Text pour faire des calculs vous rend une chaîne comme $1,235 ou même ### quand la colonne est étroite ; lire .Value sur une cellule monétaire peut arrondir un grand nombre ; .Value2 est le choix par défaut, rapide et sans perte. Ce guide explique les trois visages de lecture, quand la conversion Currency et Date perd de la précision, pourquoi .Text est réservé à l'affichage et ne peut pas être affecté, et vers quel visage se tourner.

La fonction VBA Shell lance un programme externe puis s'en va aussitôt — c'est du fire-and-forget. Shell renvoie un identifiant de tâche, pas le code de sortie du programme, ni sa sortie, ni un indicateur de réussite, et la ligne suivante de votre macro s'exécute pendant que le programme démarre encore. Voilà le bug qui piège la plupart du code Shell : vous lancez un convertisseur avec Shell puis tentez d'ouvrir un fichier qu'il n'a pas encore écrit. Ce guide explique pourquoi Shell n'attend pas, comment mettre entre guillemets un chemin contenant des espaces, pourquoi Shell lance des exécutables mais ne sait pas ouvrir seul un PDF ou une URL, et quand abandonner Shell au profit de WScript.Shell Run ou Exec pour vraiment attendre le programme et lire ce qu'il a produit.

La fonction VBA Environ lit les variables d'environnement que Windows remet à chaque programme — USERPROFILE, TEMP, USERNAME, APPDATA — pour que vous construisiez des chemins propres à l'utilisateur sans coder en dur C:\Users\John, un chemin qui casse sur toutes les autres machines. Son piège caractéristique est silencieux : une variable absente ou mal orthographiée renvoie une chaîne vide, pas une erreur, si bien qu'un nom mal saisi comme TMEP au lieu de TEMP donne discrètement du vide et fait atterrir votre chemin à la racine du disque. Ce guide explique pourquoi Environ est l'outil des chemins portables, pourquoi vous devez traiter chaque résultat comme possiblement vide, les deux formes d'appel (par nom ou par indice numérique), l'instantané qu'Environ capture au lancement d'Excel, et ce qu'Environ ne sait pas faire — définir des variables ou lire celles modifiées après le démarrage.

CreateObject est le passe-partout de VBA vers tout ce qui est hors d'Excel — il démarre n'importe quelle application COM par sa chaîne ProgID : Scripting.FileSystemObject, Scripting.Dictionary, Outlook.Application, WScript.Shell, Word.Application. Cette recherche par chaîne, c'est la liaison tardive : le compilateur ne sait rien de l'objet, donc un mauvais ProgID ou une application non installée n'échoue qu'à l'exécution, avec l'error 429. Ce guide explique la vraie décision entre liaison tardive et liaison précoce (portabilité contre IntelliSense), pourquoi CreateObject démarre toujours une nouvelle instance tandis que GetObject se raccroche à une instance déjà en cours, et pourquoi un processus Outlook ou Excel sans interface reste suspendu dans le Gestionnaire des tâches quand vous oubliez de faire Quit sur l'application et de passer l'objet à Nothing.

Une date VBA est un Double — la partie entière compte les jours depuis le 30/12/1899 et la partie décimale porte l'heure, donc Now, Date et Time sont trois lectures de la même horloge. Now renvoie la date et l'heure, Date renvoie aujourd'hui à minuit, Time renvoie l'heure seule. Le bug qui casse le plus de code, c'est de comparer une valeur Now stockée avec Date sans jamais tomber juste, car Now porte une fraction d'heure que Date n'a pas. Pire, Date et Time sont aussi des instructions qui règlent l'horloge système. Ce guide montre ce qu'est vraiment ce Double, pourquoi l'égalité échoue, comment retirer l'heure avec Int ou DateValue, et pourquoi Now donne l'heure locale et non UTC.

Comme une date VBA est un Double, ajouter 1 avance d'un jour et l'arithmétique simple est correcte — pour les jours. Elle casse dès qu'on traite un mois comme 30 jours ou une année comme 365, car les mois et les années bissextiles n'ont pas une longueur fixe. DateAdd connaît le calendrier, donc ajouter un mois au 31 janvier renvoie le 28 février plutôt qu'un 31 impossible. DateDiff compte les frontières franchies, pas le temps écoulé, si bien que l'écart du 31 décembre au 1er janvier vaut un an même si un seul jour a passé. DateSerial construit une date à partir de l'année, du mois et du jour sans ambiguïté régionale et normalise les débordements, ce qui donne l'idiome propre du dernier jour du mois. Ce guide montre quand le plus simple suffit, les codes d'intervalle qui piègent, et pourquoi DateDiff est un comptage de frontières.

Year, Month, Day, Hour, Minute et Second extraient chacun un entier d'une date — ce Double dans lequel vous voyez déjà — et ils sont aussi simples qu'ils en ont l'air. Weekday est celui qui piège — il renvoie 1 à 7, mais la numérotation dépend d'un second argument dont la valeur par défaut fait dimanche égale 1, donc dans un appel nu lundi vaut 2, pas 1, et tout test de week-end bâti sur un nombre codé en dur est discrètement faux. DatePart est l'extracteur général avec les mêmes codes d'intervalle que DateAdd, et il atteint des parties sans fonction dédiée comme le numéro de semaine et le trimestre, même si sa règle de semaine n'est pas ISO 8601 par défaut. WeekdayName et MonthName renvoient des noms dans la langue de la machine, bons pour l'affichage mais pas pour la relecture. Ce guide montre comment extraire chaque partie et pourquoi lundi n'est pas 1.

En VBA intégré, on atteint un fichier texte par un canal numéroté — vous écrivez Open path For Output As #n, et le numéro n est une poignée qu'il faut prendre de FreeFile plutôt que choisir à la main. Codez #1 en dur et, dès que deux fichiers sont ouverts, vous tombez sur l'erreur 55 File already open ; ouvrez For Output un fichier qui contient déjà des données et il est vidé ; oubliez Close et le fichier reste verrouillé jusqu'à la fermeture d'Excel. Ce guide montre pourquoi FreeFile vous remet un numéro de canal à saisir dans une variable, la différence entre For Output, For Append et For Input, pourquoi l'instruction Open n'est pas Workbooks.Open, et le motif de nettoyage qui ferme toujours le canal.

Print # et Write # donnent des réponses opposées à la question de savoir à quoi devraient ressembler les octets sur le disque. Print # écrit le texte exactement tel qu'il apparaît — pas de guillemets, pas de virgules, c'est vous qui construisez la mise en forme — il convient donc à un rapport ou à un CSV fait main. Write # écrit un format machine — chaque chaîne entourée de guillemets, des virgules entre les valeurs, les dates entre dièses — conçu pour être relu par Input #, pas par un humain ni par Excel. Ce guide montre pourquoi Write # est la raison pour laquelle votre CSV est plein de guillemets, pourquoi une virgule dans une liste Print # insère des zones d'impression au lieu de virgules CSV, comment For Output vide tandis que For Append ajoute, le piège de la virgule décimale liée à la locale, et pourquoi l'écriture intégrée est en ANSI plutôt qu'en UTF-8.

Lire un fichier texte en VBA offre trois outils, et choisir le mauvais brouille vos données. Line Input # lit une ligne brute dans une chaîne et c'est vous qui la découpez, ce qui est prévisible. Input # analyse les champs délimités directement dans des variables — rapide pour un fichier que Write # a produit, mais il s'étrangle sur les virgules non protégées et les guillemets égarés. Input(LOF(f), #f) avale tout le fichier dans une seule chaîne. Ce guide montre la boucle EOF qui lit chaque ligne exactement une fois, pourquoi Input # est le jumeau de Write # et Line Input # celui de Print #, comment éviter le décalage d'un cran qui lève l'erreur 62, et quand un CSV vaut mieux ouvert comme un classeur qu'analysé à la main.

L'instruction VBA MkDir crée exactement un niveau de dossier, pas un chemin entier — MkDir sur un chemin dont le parent n'existe pas lève l'erreur 76, et MkDir sur un dossier qui existe déjà lève l'erreur 75 au lieu de ne rien faire. Ainsi la tâche quotidienne créer ce dossier revient en réalité à créer chaque niveau manquant, et seulement là où il est absent. Ce guide montre pourquoi MkDir ne crée qu'un seul niveau, pourquoi FileSystemObject.CreateFolder ne récurse pas davantage, la boucle protégée par un test d'existence qui construit un chemin complet en toute sécurité, et pourquoi un simple nom de dossier atterrit sous CurDir plutôt que dans le dossier de votre classeur.

L'instruction VBA RmDir supprime un dossier uniquement lorsqu'il est complètement vide — pointez-la sur un dossier qui contient encore des fichiers ou des sous-dossiers et elle lève l'erreur 75, l'exact reflet inverse de Kill, qui supprime n'importe quel fichier sans pitié. Ainsi supprimer ce dossier revient en réalité à le vider d'abord, puis à le retirer. Ce guide montre pourquoi RmDir refuse un dossier non vide, pourquoi il supprime les dossiers mais jamais les fichiers, comment vider un dossier avec Kill avant RmDir, et quand FileSystemObject.DeleteFolder efface une arborescence entière en un seul appel — sans corbeille et sans annulation.

En VBA, un chemin relatif n'a aucun sens tant qu'il n'est pas résolu par rapport à CurDir, le répertoire de travail courant — et dans Excel ce répertoire est un réglage vagabond que vous ne contrôlez pas, pas le dossier où votre classeur est enregistré. Ainsi MkDir Reports ou Open data.csv peut atterrir à un endroit différent à chaque exécution, parce qu'une boîte de dialogue Ouvrir un fichier déplace CurDir en silence. Ce guide montre pourquoi CurDir n'est pas ThisWorkbook.Path, pourquoi ChDir ne peut pas changer de lecteur sans ChDrive, et l'unique habitude qui élimine toute la catégorie des bugs de mauvais dossier — ancrez chaque chemin à ThisWorkbook.Path.

Copier un fichier en VBA tient en une ligne, mais laquelle dépend de savoir si le fichier est ouvert. FileCopy est l'instruction intégrée qui n'exige aucune référence, et elle écrase la destination en silence, pourtant elle ne peut pas copier un fichier ouvert et lève l'erreur 70 Permission denied sur le seul classeur que vous voulez le plus sauvegarder. Ce guide trace la frontière entre trois outils de copie pour trois situations — FileCopy pour les fichiers fermés sur le disque, FileSystemObject.CopyFile pour les caractères génériques et un indicateur d'écrasement explicite, et SaveCopyAs pour le classeur ouvert à l'instant même — et montre pourquoi la destination doit être un chemin complet incluant le nom du fichier, pourquoi le dossier cible doit déjà exister, et comment copier-puis-supprimer devient un déplacement.

L'instruction VBA Kill supprime un fichier définitivement — pas de Corbeille, pas de confirmation, pas d'annulation. Ce seul fait est à la fois tout l'intérêt et tout le danger, et chaque autre règle sur la suppression de fichiers est une façon de garder cette ligne irréversible. Ce guide montre pourquoi Kill lève une erreur au lieu de ne rien faire quand un fichier est absent ou ouvert, comment un caractère générique efface toutes les correspondances d'un coup sans invite, pourquoi Kill ne peut pas retirer un dossier et comment RmDir et DeleteFolder se partagent cette tâche, et quand FileSystemObject.DeleteFile avec son indicateur Force est le choix le plus sûr pour les fichiers en lecture seule.

L'instruction VBA Name renomme un fichier, mais c'est en réalité une instruction de renommage-et-déplacement — pointez le nouveau chemin sur un dossier différent et VBA déplace le fichier là-bas au lieu de le renommer sur place. Et contrairement à presque tout le reste sur le disque, Name refuse d'écraser, levant l'erreur 58 quand la cible existe déjà, l'exact opposé de FileCopy qui écrase en silence. Ce guide montre pourquoi Name déplace autant qu'il renomme, pourquoi il ne traverse pas les lecteurs et comment FileCopy plus Kill ou FileSystemObject.MoveFile gère ce cas, et pourquoi vous devez protéger la destination pour qu'une erreur sur un fichier existant n'arrête pas une macro sans surveillance.

Dir ressemble à une fonction mais se comporte comme un itérateur à mémoire cachée — Dir(path) renvoie le premier nom de fichier correspondant, puis Dir() sans argument renvoie le suivant, et une chaîne vide quand le dossier est épuisé. La règle qui vous sauve est de ne jamais rappeler Dir au milieu d'une boucle Dir, car un second Dir lance une nouvelle recherche et réinitialise la première — la cause numéro un des fichiers sautés et des boucles infinies. Découvrez comment parcourir chaque .xlsx d'un dossier, pourquoi Dir ne renvoie que le nom et non le chemin, pourquoi il ne sait pas récurser dans les sous-dossiers, et quand rassembler les noms dans un tableau avant d'agir.

Le FileSystemObject transforme le disque en un modèle objet — des dossiers et fichiers que vous parcourez avec For Each et dont vous lisez les propriétés, au lieu de l'unique curseur caché de Dir. La décision qui vous sauve est CreateObject(Scripting.FileSystemObject) plutôt que Dim fso As New FileSystemObject, car la liaison tardive n'exige aucune référence et tourne partout, tandis que la version à liaison précoce échoue à compiler sur tout PC où Microsoft Scripting Runtime n'est pas coché. Découvrez quand FSO surpasse Dir, comment récurser dans les sous-dossiers via sa collection SubFolders, comment lire Size et DateLastModified, et pourquoi FSO ouvre les fichiers texte mais jamais un classeur Excel.

Il existe deux bonnes façons de tester l'existence d'un fichier en VBA, et un mauvais réflexe. Ce réflexe est de l'ouvrir et de piéger l'erreur, ce qui est lent et masque les vraies défaillances. Les bonnes réponses sont Dir(path) (une ligne intégrée) et fso.FileExists(path) (sans état et plus clair) — et la règle qui vous sauve est de ne jamais utiliser le test Dir à l'intérieur d'une boucle Dir, car Dir partage un unique curseur caché et le test réinitialise en silence votre énumération. Découvrez pourquoi FileExists est le choix par défaut le plus sûr, comment Dir gère mal un dossier ou une barre oblique inverse finale, et pourquoi vérifier puis ouvrir exige encore un garde-fou d'erreur.

Workbooks.Open est une fonction qui renvoie le classeur qu'elle vient d'ouvrir, donc la seule règle qui vous sauve est Set wb = Workbooks.Open(path) — capturez cette valeur de retour et parlez à wb, jamais à ActiveWorkbook, qui change à l'instant où quoi que ce soit vole le focus. Découvrez la différence entre Workbooks.Open (une méthode que vous appelez) et Workbook_Open (un événement qui s'exécute automatiquement), comment protéger un chemin manquant pour obtenir un message plutôt que l'erreur d'exécution 1004, comment gérer un fichier déjà ouvert, et quels paramètres ouvrent en silence une boîte de dialogue et bloquent une macro sans surveillance.

Save écrase le fichier que vous avez déjà, sur place et sans boîte de dialogue. SaveAs écrit un nouveau fichier ou un nouveau type, et le numéro FileFormat est le piège — enregistrez un classeur à macros en xlOpenXMLWorkbook (51, le format xlsx) et Excel supprime en silence chaque ligne de votre VBA ; il vous faut xlOpenXMLWorkbookMacroEnabled (52) pour le xlsm. Découvrez quand utiliser Save, SaveAs et SaveCopyAs, pourquoi Save sur un classeur tout neuf fait apparaître la boîte de dialogue Enregistrer sous et bloque une macro sans surveillance, comment DisplayAlerts transforme l'invite d'écrasement en approbation anticipée, et pourquoi wb.Saved = True marque un classeur comme propre sans rien écrire.

wb.Close sur un classeur comportant des modifications non enregistrées fait surgir la boîte de dialogue modale « Voulez-vous enregistrer les modifications ? », et dans une macro sans surveillance cette boîte attend indéfiniment. Vous y répondez en code avec l'argument SaveChanges — wb.Close SaveChanges:=False abandonne, SaveChanges:=True enregistre d'abord, et l'omettre déclenche l'invite. Découvrez pourquoi fermer sans l'argument est la première raison pour laquelle une macro planifiée ne finit jamais, pourquoi la variable objet est morte à l'instant où vous fermez, en quoi Close diffère d'Application.Quit, et pourquoi fermer le dernier classeur peut laisser un EXCEL.EXE invisible en cours d'exécution.

Application.Wait est un réveil, pas un chronomètre. Vous lui donnez un moment de l'horloge où se réveiller, pas un nombre de secondes à décompter, et c'est pourquoi Application.Wait 5 ne fait presque rien alors que la bonne ligne est Application.Wait Now + TimeValue("0:00:05"). Il ne descend pas sous la seconde entière et il fige Excel pendant toute l'attente, incapable de repeindre l'écran, de mettre à jour une barre d'état ou de laisser l'utilisateur annuler. Découvrez le modèle du réveil, l'argument en temps absolu qui piège tout le monde, pourquoi les pauses inférieures à la seconde exigent Sleep, et pourquoi une pause où Excel doit rester vivant est plutôt une boucle DoEvents.

Sleep n'est pas un mot-clé VBA. C'est une fonction kernel32 de Windows que vous empruntez avec une instruction Declare pour mettre votre macro en pause pendant un nombre de millisecondes, d'où la précision inférieure à la seconde que Application.Wait ne peut pas offrir. Le piège, c'est la déclaration elle-même. Les vieilles lignes Declare Sub Sleep copiées-collées provoquent une erreur de compilation sur Excel 64 bits tant que vous n'ajoutez pas l'attribut PtrSafe dans une garde de compilation conditionnelle VBA7. Découvrez le modèle de l'API empruntée, le correctif 64 bits exact, pourquoi les millisecondes ne sont pas précises, et pourquoi Sleep fige quand même Excel, si bien qu'une pause réactive passe plutôt par une boucle DoEvents.

La fonction VBA Timer est un chronomètre, pas un minuteur de compte à rebours. Malgré son nom, elle ne déclenche jamais rien après N secondes et ne met jamais votre code en pause. Elle renvoie simplement le nombre de secondes écoulées depuis minuit, et vous la lisez deux fois pour mesurer combien de temps a pris un bloc de code. C'est donc l'outil qui prouve que ScreenUpdating = False a réellement accéléré votre macro, au lieu de le supposer. Découvrez le modèle du chronomètre, pourquoi ceux qui cherchent un minuteur veulent en général plutôt Application.OnTime, le bug de passage à minuit qui produit des temps écoulés négatifs, et sa résolution au centième de seconde.

DoEvents met votre macro en pause un instant et laisse Excel traiter les clics, les frappes et les redessins accumulés pendant l'exécution de votre code, ce qui empêche la fenêtre de virer au gris en Ne répond pas et rend possible un bouton d'annulation qui marche. Mais le même moment de cession qui garde Excel en vie rend aussi le contrôle à l'utilisateur en plein milieu de la macro, si bien qu'il peut cliquer de nouveau sur le même bouton et lancer une deuxième copie de votre macro à l'intérieur de la première. C'est cette réentrance, et non la performance, qui est le vrai danger. Découvrez où placer DoEvents, comment vous prémunir contre la réentrance avec un drapeau d'exécution, pourquoi vous devez le limiter en fréquence, et pourquoi ce n'est pas du multithreading.

Application.StatusBar vous permet d'écrire votre propre texte dans la barre en bas de la fenêtre Excel, ce qui est la façon la plus légère d'afficher la progression d'une macro en cours, sans UserForm et sans scintillement. La ligne que tout le monde oublie, c'est la réinitialisation. Le dernier texte que vous avez écrit y reste épinglé après la fin de la macro, car Excel ne reprend pas la barre tant que vous n'avez pas mis Application.StatusBar à False. Et elle ne se met pas à jour de façon visible à l'intérieur d'une boucle serrée à moins qu'Excel n'ait un instant pour repeindre, et c'est là qu'intervient DoEvents. Découvrez le motif écrire-puis-réinitialiser, pourquoi False vaut mieux qu'une chaîne vide, l'idiome du pourcentage de progression, et quand une vraie barre de progression mérite le surcroît de travail.

Application.DisplayAlerts à False dit à Excel de cesser d'afficher ses boîtes de dialogue de confirmation et d'avertissement pendant l'exécution de votre macro, si bien qu'une macro sans surveillance ne se bloque pas en attendant qu'on clique sur OK. Mais il ne fait pas taire l'avertissement, il y répond à votre place avec la réponse par défaut d'Excel, et pour des invites comme supprimer cette feuille ou écraser ce fichier, la réponse par défaut est d'y aller. Il se remet à True tout seul à la fin de la macro, si bien que le vrai piège n'est pas de le laisser désactivé pour toujours mais de supprimer un avertissement qui vous protégeait. Découvrez où il aide, la règle de la fenêtre étroite, pourquoi ce n'est pas la même chose que la gestion des erreurs, et comment il s'associe à ScreenUpdating et Calculation.

Application.ScreenUpdating à False dit à Excel de cesser de repeindre l'écran pendant l'exécution de votre macro et de tout redessiner une seule fois à la fin, ce qui supprime le scintillement et apporte un gain de vitesse modéré. Mais cela n'aide que lorsque votre code écrit, sélectionne ou fait défiler — greffez-le sur une macro limitée par le calcul et vous ne gagnez rien. La règle qui vous sauve, c'est qu'un plantage peut laisser l'écran figé et grisé, alors vous le rétablissez dans un gestionnaire d'erreurs, jamais en comptant sur une réinitialisation automatique. Découvrez où il aide, où il n'aide pas, le piège du scintillement dû au rétablissement imbriqué, et le motif CleanExit qui l'associe à Calculation et EnableEvents.

Application.Calculation à xlCalculationManual dit à Excel de cesser de recalculer après chaque écriture et de tout différer en une seule passe, ce qui constitue le vrai gain de vitesse sur les classeurs chargés de formules. Mais c'est l'interrupteur le plus dangereux de VBA car sa défaillance est silencieuse — laissez-le en manuel et les formules cessent de se mettre à jour sans aucun indice visuel, si bien que les totaux se figent et personne ne le voit. La règle qui vous sauve consiste à sauvegarder l'état de calcul, à forcer un recalcul avec Application.Calculate quand une étape ultérieure a besoin d'un résultat, et à rétablir l'état sauvegardé dans un gestionnaire d'erreurs plutôt que de coder Automatic en dur. Découvrez les pièges du mode manuel, l'error 1004 quand aucun classeur n'est ouvert, et le motif CleanExit.

Application.EnableEvents à False empêche les écritures de votre macro de déclencher des gestionnaires d'événements comme Worksheet_Change, ce qui brise la boucle infinie où un gestionnaire modifie une cellule et se redéclenche lui-même. C'est un interrupteur de justesse, pas de vitesse. La règle qui vous sauve, c'est qu'EnableEvents est une propriété au niveau de l'application qui ne se réinitialise pas d'elle-même, si bien qu'un plantage en le laissant à False laisse morts tous les événements de tous les classeurs ouverts jusqu'au redémarrage d'Excel — ce qui explique pourquoi les utilisateurs signalent que leurs boutons ont cessé de fonctionner. Découvrez le correctif du Worksheet_Change récursif, le rétablissement CleanExit, et pourquoi cet interrupteur compte encore plus que les autres.

SpecialCells laisse Excel choisir les cellules pour vous par type plutôt que par adresse — toutes les vides, toutes les lignes visibles, toutes les formules, toutes les constantes. C'est le jumeau en code de la commande Atteindre les cellules. La règle qui vous sauve, c'est que SpecialCells lève error 1004 quand il ne trouve rien du tout, si bien qu'un appel nu est une bombe à retardement ; la forme mûre associe toujours On Error Resume Next et If Not result Is Nothing. Découvrez les types de cellules qui comptent, les motifs remplir-les-vides et copier-les-lignes-visibles, et pourquoi le résultat est une référence multi-zones.

Union colle des rectangles éparpillés en une seule référence pour que vous puissiez colorer, effacer ou copier plusieurs blocs non adjacents en une opération — la version en code du Ctrl-clic sur plusieurs zones. La règle qui piège tout le monde, c'est qu'Union concatène, il ne déduplique pas ; les cellules qui se chevauchent sont comptées deux fois, donc .Count ment et Union est une liste de lot, pas une union d'ensembles. Découvrez le motif d'accumulation qui évite l'erreur Union of Nothing, pourquoi c'est une opération par référence au lieu d'une boucle cellule par cellule, et en quoi Union diffère d'Intersect.

Intersect ne renvoie que les cellules que deux plages partagent, et renvoie Nothing quand elles ne se touchent pas — et ce Nothing est tout l'intérêt. Son usage numéro un est la protection de Worksheet_Change, If Not Intersect(Target, Range) Is Nothing, qui empêche un événement de se déclencher à chaque modification de la feuille. La règle qui vous sauve, c'est qu'aucun chevauchement renvoie Nothing, si bien que tout accès à une propriété sans vérification Is Nothing plante avec error 91. Découvrez la protection d'événement complète avec EnableEvents, comment restreindre une macro à une zone cible, et en quoi Intersect diffère d'Union.

Cells, c'est Range adressé par des nombres. Range(A1) désigne une cellule avec une chaîne dans l'ordre de lecture, la lettre de colonne puis la ligne ; Cells(ligne, colonne) désigne une cellule avec deux entiers dans l'ordre de stockage d'Excel, la ligne d'abord puis la colonne. Voilà pourquoi Cells(1, 2) est B1, pas A2 — et pourquoi Cells, dont on peut calculer les coordonnées, est la référence conçue pour les boucles. Découvrez quand employer Cells plutôt que Range, comment bâtir un bloc à partir d'angles calculés avec Range(Cells, Cells), pourquoi un Cells nu désigne toute la feuille, et pourquoi qualifier Cells d'une feuille de calcul.

Resize fixe l'ancre en haut à gauche d'une plage et redessine le rectangle à une nouvelle taille. Il ne déplace pas la référence comme le fait Offset, et il ne sélectionne rien — il renvoie une nouvelle plage partant du même coin. La règle qui piège tout le monde, c'est que Resize(lignes, colonnes) est un nombre absolu à base 1 de la taille finale, pas un delta à ajouter, si bien que Range(A1).Resize(5, 3) donne A1:C5 et Resize(0) déclenche l'erreur 1004. Découvrez comment omettre un argument pour laisser une dimension intacte, pourquoi l'ancre est toujours en haut à gauche, et les deux motifs qui paient — retirer un en-tête avec Offset plus Resize, et réécrire un tableau dans un bloc qui lui va.

CurrentRegion est le bloc contigu de cellules autour d'une cellule. Excel part de votre cellule et s'étend vers l'extérieur jusqu'à rencontrer une ligne entièrement vide et une colonne entièrement vide, renvoyant le plus petit rectangle qui enferme cet îlot ininterrompu — exactement ce que sélectionne Ctrl+Maj+astérisque. Vous ne calculez pas les bords ; Excel les trouve. Le piège, c'est qu'une seule ligne ou colonne entièrement vide forme un mur qui scinde le bloc en silence, si bien que vous obtenez la moitié de vos données sans aucune erreur. Découvrez pourquoi CurrentRegion inclut l'en-tête et comment le retirer avec Offset et Resize, en quoi il diffère d'UsedRange et de End(xlUp), et quand utiliser plutôt un vrai tableau.

Une bordure en VBA Excel est une propriété d'un bord, pas un interrupteur sur la cellule. Une plage possède huit bordures adressables — quatre bords extérieurs, deux jeux de quadrillage intérieur et deux diagonales — et la collection Range.Borders nue les désigne toutes à la fois. C'est pourquoi Range.Borders.LineStyle = xlContinuous encadre chaque cellule au lieu de tracer un seul contour. Découvrez quand utiliser BorderAround pour le seul cadre, comment LineStyle, Weight et Color se combinent, comment définir un seul bord avec xlEdgeBottom, et comment effacer les bordures avec xlLineStyleNone.

Fusionner des cellules en VBA Excel n'est pas du formatage — c'est un changement structurel de la grille. Range(A1:C1).Merge fond trois cellules en une seule qui s'étend sur trois colonnes, et seule la valeur en haut à gauche survit tandis que les autres sont effacées. C'est pourquoi les cellules fusionnées cassent silencieusement le tri, les calculs de Range, les insertions de colonnes et les boucles. Découvrez Merge, UnMerge, MergeCells et MergeArea, pourquoi les pros préfèrent Center Across Selection, et comment repérer et nettoyer les cellules fusionnées sans risque en code.

Dimensionner des cellules en VBA Excel agit sur la colonne ou la ligne entière, et les deux dimensions utilisent des unités différentes — ColumnWidth se mesure en caractères de la police Normal, RowHeight se mesure en points. Ce décalage explique pourquoi une largeur de 10 et une hauteur de 10 n'ont rien de comparable. AutoFit est l'autre piège. Il ne s'exécute que sur une colonne ou une ligne entière, et il mesure le texte affiché, donc il ignore silencieusement les cellules fusionnées. Découvrez ColumnWidth face à la propriété Width en lecture seule, RowHeight et le retour à la ligne, EntireColumn.AutoFit, et pourquoi mettre la largeur à zéro est la mauvaise façon de masquer une colonne.

L'objet Font est la couche texte d'une cellule en VBA Excel — couleur, gras, italique, taille et nom, sans jamais toucher à la valeur en dessous. Le piège, c'est la couleur. Il existe trois façons de la définir et elles utilisent des espaces de nombres différents. Range.Font.Color prend un nombre RGB 24 bits, Range.Font.ColorIndex prend un index de palette de 1 à 56, et les deux ne sont pas interchangeables. Découvrez laquelle utiliser, comment mettre en gras ou redimensionner une partie de cellule avec Characters, pourquoi la coloration selon la valeur relève de la Mise en forme conditionnelle, et comment relire une couleur de police sans obtenir le mauvais nombre.

Range.Interior est la couche de remplissage d'une cellule en VBA Excel — la peinture derrière le texte. Définissez-la avec Interior.Color et RGB, effacez-la avec Interior.ColorIndex réglé sur xlNone, et sachez qu'un remplissage blanc n'est pas la même chose qu'une absence de remplissage. Le point plus profond, c'est qu'une cellule colorée ne porte aucune donnée. SUM et SUMIF l'ignorent, si bien que colorer pour catégoriser revient à cacher de l'information là où les formules ne peuvent pas la lire. Découvrez les propriétés de couleur, comment surligner selon une condition sans boucle qui se périme, et comment remplir de nombreuses plages rapidement.

Range.NumberFormat est la couche d'affichage d'une cellule en VBA Excel. Elle change la façon dont un nombre stocké se lit à l'écran et ne change jamais le nombre lui-même, si bien que formater une cellule pour afficher 5 alors qu'elle contient 5.4999 n'est pas un arrondi et que la somme utilise toujours 5.4999. C'est là que l'opposition apparence contre valeur mord pour de bon, car une date est en réalité un numéro de série déguisé. Découvrez le langage des codes de format, en quoi NumberFormat diffère de la fonction Format, le piège des paramètres régionaux avec NumberFormatLocal, et quand il vous faut plutôt Round.

Application.WorksheetFunction permet à VBA d'emprunter les plus de 450 fonctions intégrées d'Excel au lieu de réécrire SUM, VLOOKUP ou COUNTIF sous forme de boucle. Le piège, c'est qu'il existe deux façons de les appeler et qu'elles échouent différemment. WorksheetFunction.X déclenche une erreur d'exécution en l'absence de correspondance, tandis qu'Application.X renvoie une valeur d'erreur que vous testez avec IsError. Découvrez quel style d'appel choisir, pourquoi le résultat doit être un Variant, quelles fonctions ne pas appeler ainsi, et quand passer une plage entière plutôt que de boucler cellule par cellule.

Range.RemoveDuplicates, c'est le bouton Supprimer les doublons d'Excel en une seule ligne de code, mais il est destructeur là où une boucle ne l'est pas. Il supprime les lignes sur place, conserve la première occurrence, et ne peut pas être annulé une fois la macro exécutée. L'argument qui piège tout le monde est Columns, dont les numéros sont des décalages à l'intérieur de la plage, pas des lettres de colonne de la feuille. Découvrez le piège du décalage dans la plage, pourquoi Header xlYes compte, comment garder la dernière ligne plutôt que la première, et quand recourir plutôt au filtre avancé ou à un Dictionary.

Range.AdvancedFilter est le seul filtre qui produit des données plutôt qu'une vue. Il peut extraire une liste unique ou un ensemble de lignes correspondant à des critères vers un autre emplacement en un seul appel, sans boucle et sans rien supprimer. Ce qui déroute, c'est que sa clause WHERE vit dans des cellules, une plage de critères dont l'en-tête doit correspondre exactement aux données. Découvrez xlFilterInPlace face à xlFilterCopy, comment fonctionne la plage de critères, comment Unique True déduplique sans détruire, le piège de correspondance d'en-tête qui renvoie une sortie vide, et en quoi cela diffère d'AutoFilter et de Remove Duplicates.

La méthode VBA Range.Find est le Ctrl+F d'Excel pour le code, et elle déroute parce qu'elle renvoie un objet Range (ou Nothing en l'absence de correspondance) au lieu d'un nombre. Découvrez la vérification unique qui empêche le plantage error-91, le piège des arguments persistants qui fait se comporter Find différemment à chaque exécution, comment LookAt xlWhole face à xlPart tranche entre cellule entière et contenu partiel, et comment boucler FindNext pour obtenir chaque correspondance sans boucle infinie.

La méthode VBA AutoFilter filtre un tableau dans le code, mais les lignes qu'elle masque sont toujours là — elles comptent encore dans SUM, se copient encore, et occupent encore votre plage. Découvrez le modèle mental qui évite les bugs classiques, pourquoi vous devez passer par SpecialCells xlCellTypeVisible pour ne toucher que les lignes visibles, comment fonctionnent les critères et les opérateurs, le piège de la bascule qui désactive votre filtre à la deuxième exécution, et le schéma rapide filtrer-puis-supprimer pour retirer des lignes en masse.

Trier en VBA est une réorganisation permanente sans Ctrl+Z, aussi la première règle est-elle de protéger l'ordre d'origine avant d'y toucher. Découvrez le modèle mental qui sépare une vue d'une mutation, pourquoi Header xlYes compte sous peine de voir vos titres finir dans les données, la différence entre le rapide Range.Sort et l'objet Sort illimité, le piège SortFields.Clear qui hérite d'anciennes clés de tri, et pourquoi des nombres stockés en texte se trient dans le mauvais ordre.

Supprimer une ligne en VBA est une modification structurelle, pas un simple effacement — chaque ligne du dessous remonte pour combler le vide, et c'est pourquoi une boucle vers le bas saute des lignes. Découvrez la règle unique qui corrige tout, boucler de bas en haut ou tout supprimer d'un seul Union, en quoi EntireRow.Delete diffère de l'effacement d'une cellule, la manière rapide de retirer les lignes vides, et comment supprimer des lignes par condition sans corrompre vos données ni vos formules de référence.

Insérer est le miroir de supprimer — cela pousse les lignes existantes vers le bas (ou les colonnes vers la droite) pour faire de la place, si bien que le même décalage qui casse une boucle de suppression casse aussi une boucle d'insertion. Découvrez EntireRow.Insert face à une plage partielle avec l'argument Shift, pourquoi CopyOrigin décide quel voisin donne son format à la nouvelle ligne insérée, le sens sûr pour insérer dans une boucle, et la méthode en un seul appel pour ajouter de nombreuses lignes d'un coup.

Masquer une colonne en VBA, ce n'est ni la supprimer ni la filtrer — les données sont toujours là, toujours dans chaque SUM, toujours copiées lors d'une copie de plage, on leur donne simplement une largeur d'affichage nulle. Découvrez pourquoi .Hidden appartient à EntireColumn et EntireRow, pourquoi les cellules masquées comptent encore dans les formules, la ligne tout-afficher qui sauve une feuille bloquée, et en quoi les lignes masquées à la main diffèrent des lignes masquées par AutoFilter quand vous bouclez.

Worksheet_BeforeDoubleClick est l'événement qu'Excel déclenche à l'instant où vous double-cliquez une cellule, avant qu'elle ne passe en mode édition, et il vous remet la cellule Target ainsi qu'un indicateur Cancel. Mettez Cancel à True pour supprimer le mode édition et exécuter votre propre action — cocher une case, marquer une ligne comme faite, ou descendre au détail. Découvrez comment le cibler sur une seule colonne avec Intersect, pourquoi oublier Cancel fait basculer la cellule en mode édition, et où le code doit résider.

Worksheet_BeforeRightClick est l'événement qu'Excel déclenche à l'instant où vous faites un clic droit sur une cellule, avant l'apparition du menu contextuel, et il vous remet la cellule Target ainsi qu'un indicateur Cancel. Mettez Cancel à True pour supprimer le menu intégré et exécuter votre propre action ou afficher un menu personnalisé à la place. Découvrez comment le cibler avec Intersect pour ne pas paralyser Copier et Coller, pourquoi désactiver le clic droit relève de l'ergonomie plutôt que de la protection, et où le code doit résider.

Workbook_BeforePrint est l'événement qu'Excel déclenche avant que quoi que ce soit dans le classeur ne soit imprimé, et il vous remet un indicateur Cancel. Mettez Cancel à True et l'impression est bloquée — validez avant d'imprimer, ou empêchez un brouillon de sortir. Découvrez pourquoi l'événement se déclenche aussi pour l'aperçu avant impression (si bien qu'un traitement lourd fait ramer l'aperçu), pourquoi il s'exécute une seule fois pour tout le classeur plutôt que par feuille, pourquoi un Cancel silencieux est un bug, et où le code doit résider.

Workbook_BeforeClose est l'événement qu'Excel déclenche à l'instant où quelqu'un tente de fermer le fichier — avant que quoi que ce soit ne soit démantelé — et il vous remet un indicateur Cancel. Mettez Cancel à True et la fermeture est annulée. Découvrez comment lancer un nettoyage à la fermeture, comment empêcher Excel de demander deux fois d'enregistrer grâce à la propriété Saved, pourquoi il ne se déclenche jamais lors d'un plantage, et où le code doit résider.

Workbook_BeforeSave est l'événement qu'Excel déclenche à l'instant où un enregistrement est demandé — avant que quoi que ce soit ne soit écrit sur le disque — et il vous remet deux indicateurs, SaveAsUI et Cancel. Découvrez comment bloquer un enregistrement quand une cellule obligatoire est vide, comment estampiller automatiquement qui a enregistré et quand, pourquoi appeler Save dans le gestionnaire boucle à l'infini, et comment SaveAsUI vous permet d'imposer un nom de fichier.

Worksheet_Activate se déclenche quand une feuille devient active et Worksheet_Deactivate se déclenche à l'instant où vous la quittez — les événements d'arrivée et de départ d'une feuille. Le hic qui les définit — contrairement à BeforeClose et BeforeSave, aucun ne vous donne de Cancel, vous pouvez donc observer un changement de feuille mais pas le bloquer. Découvrez le motif d'actualisation à l'affichage, le contournement par renvoi, et les gestionnaires au niveau feuille contre niveau classeur.

Un class module VBA vous laisse définir votre propre type d'objet — un plan qui regroupe données et comportement — puis fabriquer autant d'instances indépendantes que voulu avec New. Le piège qui surprend tout le monde, c'est que les objets sont des types référence, donc Set b = a fait pointer les deux noms vers la même instance, et Dim x As New cache un piège d'instanciation paresseuse. Découvrez comment le nom du module devient le nom du type, quand une classe l'emporte sur un Type, et comment éviter les pièges classiques de New.

Un Type VBA — un type défini par l'utilisateur déclaré avec Type ... End Type — regroupe plusieurs champs liés dans une seule variable, si bien que Name, Age et Salary voyagent ensemble au lieu de former trois tableaux parallèles. C'est un type valeur, donc affecter une variable Type à une autre copie chaque champ, à la différence des objets, qui se partagent. Découvrez où placer la déclaration, pourquoi copier plutôt que partager change tout, et le moment précis où passer à un class module.

Property Get, Let et Set transforment un champ de classe en une porte — une petite procédure qui exécute votre code chaque fois que l'extérieur le lit ou l'écrit, pour valider une entrée, calculer une valeur à la volée ou rendre un champ en lecture seule. La distinction qui piège tout le monde, c'est Let contre Set — Let affecte une valeur, Set affecte un objet — et se tromper de mot-clé provoque une erreur de compilation ou d'exécution. Découvrez le motif du champ de stockage, quand une simple variable Public est le choix honnête, et comment construire une propriété en lecture seule.

ActiveCell est un pointeur vivant vers l'unique cellule qui a le curseur à cet instant — toujours exactement une cellule, sur la feuille active, à l'intérieur de la Selection courante. Découvrez en quoi il diffère de Selection, comment le lire et l'écrire avec .Value et .Offset, et la raison numéro un de ses plantages — il suit la feuille et le curseur laissés par l'utilisateur, ce qui en fait le mauvais outil pour du code qui ne concerne pas l'endroit où se trouve l'utilisateur.

Selection est un pointeur vivant vers ce qui est en surbrillance à cet instant — le plus souvent une plage de cellules, mais cela peut aussi être un graphique, une forme, ou rien du tout. Voilà pourquoi du code qui suppose que Selection est une plage plante dès qu'un graphique est sélectionné. Découvrez comment parcourir les cellules sélectionnées, gérer les sélections multi-zones avec .Areas, vous protéger avec TypeName, et quand ignorer complètement Selection pour nommer votre plage.

L'enregistreur de macros écrit ce que fait votre souris — Select une feuille, Select une cellule, agir sur la Selection — parce que c'est ainsi qu'une personne travaille, pas ainsi que le code devrait. Découvrez la vraie différence entre Select (mettre en surbrillance une ou plusieurs cellules) et Activate (définir l'unique cellule active), pourquoi presque chaque .Select est un détour lent et fragile que vous pouvez supprimer, les rares fois où sélectionner est vraiment nécessaire, et comment refactoriser le code de l'enregistreur pour agir directement sur des références de plage qualifiées.

Workbook_Open est l'événement qu'Excel déclenche à l'instant où votre fichier finit de s'ouvrir — du code qui s'exécute tout seul, sans bouton. Mais il ne se déclenche que s'il réside dans l'objet ThisWorkbook (pas un Module standard) et que l'utilisateur a activé les macros. Découvrez où placer le code, pourquoi il ne s'exécute jamais en silence, Workbook_Open contre Auto_Open, et comment le garder rapide et à l'épreuve des plantages.

Worksheet_Change est l'événement qu'Excel déclenche chaque fois qu'un utilisateur modifie une cellule de la feuille, en vous remettant la cellule modifiée sous forme de Target. Le piège qui attrape tout le monde — votre gestionnaire écrit dans une cellule, cette écriture redéclenche l'événement, et Excel boucle à l'infini. Découvrez le correctif Application.EnableEvents, comment le cibler avec Intersect, pourquoi il ignore les recalculs de formules, et où le code doit résider.

Worksheet_SelectionChange est l'événement qu'Excel déclenche chaque fois que le curseur se déplace — un clic, une touche fléchée, un appui sur Entrée. Il vous remet la nouvelle sélection sous forme de Target, ce qui rend possibles les astuces qui suivent le curseur, comme surligner la ligne active. Mais il se déclenche en permanence, si bien qu'un code lourd fait ramer toute la feuille. Découvrez le motif « surligner la ligne active » fait correctement, pourquoi il peut boucler, et comment le garder ultraléger.

For Each dit « fais ceci à chaque élément » et laisse VBA gérer l'ordre et les bornes — sans compteur, sans décalage d'une unité. Mais cette commodité cache trois règles strictes — la variable de boucle doit être un objet ou un Variant, parcourir un tableau est en lecture seule, et vous ne devez jamais supprimer d'une collection que vous parcourez. Découvrez quand For Each l'emporte sur For…Next et quand il vous trahit en silence.

Une Collection VBA est une liste ordonnée qui s'agrandit à chaque Add — sans ReDim, sans deviner la taille. Mais elle a quatre arêtes vives que les débutants heurtent à chaque fois — elle est en base 1 et non en base 0, on ne peut pas écraser un élément (seulement Add/Remove), une clé en double déclenche l'erreur 457, et il n'existe aucun test Exists intégré. Découvrez quand une Collection l'emporte sur un tableau ou un Dictionary, et quand elle vous coûte cher en silence.

L'instruction With nomme un objet une seule fois et vous laisse atteindre ses membres avec un simple point initial — moins de frappe, du code plus rapide, des blocs plus nets. Mais ce point initial est tout l'enjeu — oubliez-le et .Font devient Font, qui se lie en silence à la feuille active au lieu de votre objet. Découvrez ce que With optimise vraiment, le piège du point manquant, et comment With s'associe à For Each.

Dim réserve une boîte nommée avant usage, mais la vraie raison de déclarer vos variables, c'est que VBA invente en silence un nouveau Variant vide dès que vous écrivez un nom de travers. Découvrez pourquoi Option Explicit est la ligne la plus précieuse du langage, le piège Dim a, b As Long, et quand Set est indispensable.

Un type de données VBA, c'est la forme et la taille de la boîte d'une variable — et le choisir revient à choisir ce qui peut mal tourner. Découvrez pourquoi Integer déborde à 32 767 (préférez Long), pourquoi Variant est un défaut paresseux qui cache des bugs, pourquoi l'argent réclame Currency et non Double, et comment lire les erreurs Incompatibilité de type et Dépassement de capacité.

Une constante VBA est un nom verrouillé sur une valeur à la compilation — le remède aux nombres magiques éparpillés dans votre code. Découvrez pourquoi Const empêche les valeurs de dériver, pourquoi lui affecter une valeur est une erreur de compilation (c'est la fonctionnalité, pas un défaut), pourquoi Const doit être un littéral connu à la compilation, et quand préférer Enum.

La question VBA la plus recherchée — comment trouver la dernière ligne de données — a quatre réponses, et chacune se casse sur une feuille différente. Découvrez pourquoi Cells(Rows.Count, 1).End(xlUp).Row est le bon choix par défaut, quand passer à .Find, et pourquoi .UsedRange et .End(xlDown) mentent en silence.

Range.Offset renvoie une nouvelle plage décalée de (lignes, colonnes) — elle déplace, elle ne redimensionne pas, et Offset(1,0) signifie une ligne vers le bas, pas la ligne 1. Découvrez le modèle mental, l'idiome de saut d'en-tête Offset(1).Resize(n-1), et en quoi la méthode VBA diffère de la fonction OFFSET de la feuille de calcul.

UsedRange et CurrentRegion saisissent tous deux « tout le bloc », mais répondent à des questions différentes. UsedRange est la boîte englobante mise en cache par Excel — elle surestime et ne rétrécit pas. CurrentRegion est calculée en direct autour d'une cellule et s'arrête aux lignes vides. Apprenez à laquelle vous fier, et quand.

AVERAGE paraît trivial jusqu'à ce qu'une cellule vide et un zéro produisent discrètement deux moyennes différentes des « mêmes » données. AVERAGE saute les vides et le texte mais compte un vrai 0 — enregistrer « aucune vente » en 0 plutôt que de laisser la cellule vide change le résultat en silence, et rien dans la formule ne vous prévient. Apprenez le modèle mental (somme ÷ nombre de valeurs numériques uniquement), le piège vide-vs-zéro qui décide de votre réponse, pourquoi AVERAGEA n'est presque jamais ce que vous voulez, et quand une moyenne de moyennes est carrément la mauvaise question.

Excel n'a pas de fonction WEIGHTEDAVG — la bonne moyenne pondérée est =SUMPRODUCT(valeurs, poids)/SUM(poids). Ce qui compte n'est pas la formule, c'est l'erreur qu'elle corrige : prendre une AVERAGE simple de nombres qui résument des groupes de tailles différentes donne le même poids à chaque groupe, si bien qu'une région à 3 commandes pèse autant qu'une région à 300. Découvrez le modèle mental (les poids redistribuent l'influence selon la taille), pourquoi on divise par SUM(poids), le raccourci quand les poids somment à 1, les exemples moyenne générale, portefeuille et prix mélangé, et comment ajouter une condition.

Trois moyennes spécialisées pour les cas où une AVERAGE simple donne une réponse fausse ou trompeuse. GEOMEAN est la bonne moyenne pour les taux de croissance et les rendements — une année à +50 % et une année à −50 % ne font pas une moyenne de 0 %. TRIMMEAN écarte les valeurs extrêmes hautes et basses avant de moyenner, comme la notation olympique. HARMEAN est la bonne moyenne pour les taux comme la vitesse et les ratios cours/bénéfice. Découvrez quel mensonge chacune corrige, le motif GEOMEAN(1+r)−1 pour un vrai CAGR, pourquoi les trois moyennes se rangent toujours harmonique ≤ géométrique ≤ arithmétique, et les pièges #NOMBRE!.

La fonction PRODUIT d'Excel multiplie une plage en un seul appel — mais la vraie raison de la préférer à l'opérateur * tient à ce qu'elle fait du texte et des cellules vides : elle les ignore, tandis que * renvoie une erreur sur du texte ou réduit silencieusement votre résultat à zéro dès qu'une cellule est vide. Découvrez le modèle mental (PRODUIT est le jumeau multiplicatif de SOMME), l'astuce de croissance composée =PRODUIT(1+plage), en quoi PRODUIT diffère de SOMMEPROD, et quand une chaîne de * reste malgré tout le meilleur choix.

La fonction FACT d'Excel calcule une factorielle — =FACT(5) vaut 5×4×3×2×1 = 120 — mais la première chose à comprendre est ce que signifie une factorielle : le nombre de façons d'ordonner n objets distincts. Découvrez pourquoi FACT(0) vaut 1, pourquoi FACT(171) renvoie #NOMBRE! (la plus grande factorielle possible dans Excel est 170!), en quoi FACTDOUBLE et MULTINOMIALE diffèrent, et pourquoi FACT est l'atome dont sont bâties toutes les fonctions de combinaisons et de permutations.

COMBIN et PERMUTATION comptent toutes deux le nombre de façons de choisir k éléments parmi n — la différence tient à l'importance de l'ordre. PERMUTATION compte les arrangements ordonnés (un podium, un code PIN) ; COMBIN compte les sélections non ordonnées (un loto, un comité), et c'est toujours le plus petit nombre. Découvrez la grille 2×2 qui choisit la bonne fonction à tous les coups (ordre × répétition → PERMUTATION / PERMUTATIONA / COMBIN / COMBINA), l'exemple des chances au loto =COMBIN(49;6), et pourquoi se tromper ne déclenche aucune erreur — juste un décompte faux d'un facteur k!.

Une heure d'horloge dans Excel est une fraction d'une journée de 24 heures — 6:00 vaut littéralement 0,25. HOUR, MINUTE et SECOND lisent les morceaux contenus dans cette fraction ; TIME construit une fraction à partir de morceaux et repasse discrètement après minuit ; TIMEVALUE analyse une heure-texte en cette fraction. Découvrez le modèle mental, pourquoi HOUR renvoie 6 pour une durée de 30 heures, comment TIME(25,0,0) devient 1 h du matin, comment ajouter 90 minutes, et quand recourir plutôt à l'arithmétique.

Une heure dans Excel est une fraction de journée, donc 8:15 est stockée comme 0,34375, et non 8,25. Pour la convertir en heures décimales, multipliez par 24 — la formule d'heure la plus recherchée. Découvrez pourquoi heures × taux horaire donne un résultat 24 fois trop petit, comment (end − start) × 24 donne les heures travaillées, l'astuce MOD pour les postes de nuit qui passent minuit, la soustraction des pauses non payées, et l'arrondi du temps facturable au quart d'heure le plus proche.

Additionnez une colonne d'heures et le total affiche 1:30 au lieu de 25:30 — SUM a raison, c'est le format qui ment. Le format h:mm par défaut d'Excel n'affiche que le reste après les jours entiers, donc il reboucle à 24 heures. Le correctif est le format personnalisé [h]:mm, où les crochets disent à Excel d'accumuler au lieu de reboucler. Découvrez pourquoi les heures négatives affichent #######, comment obtenir un total décimal, et l'aide-mémoire des formats d'heure.

Les fonctions SIN, COS et TAN d'Excel mesurent les angles en radians, pas en degrés — donc =SIN(30) renvoie -0,988, pas 0,5, et Excel ne le signale jamais comme une erreur. Découvrez le seul modèle mental qui corrige toute réponse trigonométrique erronée (envelopper les degrés dans RADIANS), pourquoi TAN explose près de 90° au lieu de renvoyer une erreur, et comment conserver une seule unité d'angle sur toute une feuille.

RADIANS et DEGRES sont le pont entre l'unité d'angle dans laquelle vous pensez (les degrés) et celle qu'exigent les fonctions trigonométriques d'Excel (les radians). Découvrez où placer chaque convertisseur — RADIANS avant SIN/COS/TAN, DEGRES après les fonctions inverses — pourquoi PI() a besoin de ses parenthèses sous peine de renvoyer #NOM?, et pourquoi il ne faut jamais coder en dur 3,14159.

Les fonctions trigonométriques inverses ASIN, ACOS, ATAN et ATAN2 retransforment un rapport en angle — et elles renvoient cet angle en radians, donc vous les enveloppez dans DEGRES. Découvrez pourquoi ATAN ne sait pas dans quel quadrant vous êtes, comment ATAN2 y remédie, le fameux piège où ATAN2(x, y) d'Excel inverse l'ordre des arguments utilisé par tous les langages de programmation, et pourquoi ASIN/ACOS de toute valeur hors de -1..1 renvoie #NOMBRE!.

VPM (PMT) trouve l'unique mensualité constante qui rembourse un prêt à l'euro près — et elle renvoie volontairement un nombre négatif. Découvrez la convention de signe (l'argent qui sort est négatif), l'erreur numéro un (un taux annuel avec des périodes mensuelles), les cinq arguments, comment INTPER et PRINCPER (IPMT/PPMT) séparent chaque versement en intérêts et capital, et comment bâtir un tableau d'amortissement.

VC (FV) et VA (PV) sont la même équation de valeur temporelle de l'argent que VPM (PMT), résolue pour une inconnue différente. Cinq variables — rate, nper, pmt, pv, fv — et une fonction par inconnue : connaissez-en quatre, obtenez la cinquième. Découvrez la valeur future d'un plan d'épargne, la valeur actuelle d'un flux de versements, la même convention de signe (l'argent qui entre est négatif), l'argument type pour l'annuité de début de période, et quand recourir à RATE et NPER.

NPV et IRR gèrent les flux de trésorerie que PMT et FV ne savent pas traiter — ceux, inégaux et irréguliers, d'un vrai projet. La plus grosse erreur, et toute la raison de lire ceci : le NPV d'Excel suppose que la première valeur arrive une période dans le FUTUR, donc un investissement à l'instant zéro doit rester EN DEHORS de l'appel à NPV. Découvrez le NPV bien posé, IRR et pourquoi il renvoie #NUM!, le piège des TRI multiples, et pourquoi XNPV et XIRR (dates réelles) sont ce que les analystes utilisent vraiment.

DSUM et DCOUNT répondent à « totalise (ou compte) les lignes qui correspondent », mais vous écrivez les conditions sous forme de petite table sur la feuille, pas à l'intérieur de la formule. Découvrez les trois arguments, pourquoi la base de données doit inclure sa ligne d'en-têtes, comment une plage de critères encode le ET et le OU, pourquoi DCOUNT ignore le texte (utilisez DCOUNTA) et quand un bloc de critères visible l'emporte sur SUMIFS.

DGET extrait une valeur unique d'un tableau à l'aide d'une plage de critères — et son trait distinctif, c'est qu'il génère une erreur volontairement : #NUM! quand plus d'une ligne correspond, #VALUE! quand aucune ne correspond. Ce n'est pas un bug, c'est un contrôle d'unicité intégré que VLOOKUP saute en silence. Découvrez les trois arguments, les recherches multicritères sans colonne auxiliaire, et quand DGET l'emporte sur XLOOKUP (et quand ce n'est pas le cas).

Les douze fonctions D — DSUM, DCOUNT, DGET, DAVERAGE, DMAX, DMIN et les autres — partagent toutes une signature et une compétence : la plage de critères. Découvrez comment un bloc de critères encode le ET et le OU, pourquoi une plage sur un seul champ réclame son en-tête en double, comment fonctionnent les critères sous forme de formule (et la règle d'en-tête qui les fait réussir ou échouer), le piège du « commence par » qui sur-compte, et l'arbre de décision entre fonctions D, SUMIFS et FILTER.

GROUPBY(champs_lignes; valeurs; fonction) groupe les lignes et les agrège dans une seule formule qui se déverse — le remplaçant moderne du duo UNIQUE + SUMIFS et, pour bien des rapports, du tableau croisé dynamique lui-même. Le piège qui surprend tout le monde : vous passez la fonction par son nom (SUM, pas SUM()), car c'est une lambda qu'Excel applique à chaque groupe. Découvrez les trois arguments obligatoires, pourquoi elle se recalcule en direct là où un tableau croisé se périme, comment ajouter des totaux et trier par la valeur agrégée, et la version qu'elle exige.

PIVOTBY(champs_lignes; champs_colonnes; valeurs; fonction) est GROUPBY doté d'une seconde dimension — il croise les données dans une grille lignes par colonnes, un tableau croisé dynamique exprimé sous forme d'une seule formule qui se déverse et se recalcule en direct, sans Actualiser. Découvrez les quatre arguments obligatoires, pourquoi champs_lignes et champs_colonnes ne sont pas interchangeables, comment ajouter des totaux sur les deux axes, et le vrai compromis face à un tableau croisé dynamique classique (vivant et référençable, mais sans interactivité glisser-déposer). Exige Excel 365.

Les arguments facultatifs que GROUPBY et PIVOTBY partagent sont l'endroit où ils cessent de remplacer les tableaux croisés dynamiques pour commencer à les surpasser : PERCENTOF pour le pourcentage du total en un seul mot, plusieurs colonnes de valeurs pour plusieurs métriques d'un coup, une LAMBDA dans l'emplacement fonction pour une moyenne pondérée que les tableaux croisés ne savent pas faire, et matrice_filtre pour n'agréger que les lignes voulues. Découvrez la grammaire des fonctions êta-réduites, le piège du pourcentage du total, et les erreurs (#CALC!, #FIELD!, #SPILL!) qui vous disent quel argument est faux.

ROW([référence]) renvoie un numéro de ligne et COLUMN([référence]) un numéro de colonne — la position d'une cellule, jamais son contenu. Sans argument, chacune renvoie la coordonnée de la cellule qui contient la formule. Découvrez le modèle mental qui sépare « où se trouve une cellule » de « ce qu'elle contient », comment ROW() moins une ancre construit des numéros d'ordre qui se réparent tout seuls, pourquoi MOD(ROW(),n) pilote le zébrage et le regroupement, et le piège n°1 : ROW(C10) vaut 10, pas la valeur de C10.

ROWS(matrice) renvoie combien de lignes possède une plage et COLUMNS(matrice) combien de colonnes — une taille, pas une position. ROWS(A1:A10) vaut 10 ; COLUMNS(A1:C1) vaut 3. Découvrez pourquoi les formes plurielles diffèrent de ROW et COLUMN, l'usage phare d'un index de colonne VLOOKUP qui s'ajuste tout seul grâce à COLUMNS(), le décompte des lignes qu'un FILTER renvoie, et le piège n°1 : le mélange singulier/pluriel qui échoue en silence dans les formules matricielles.

HYPERLINK(link_location, [friendly_name]) est une formule qui construit un saut cliquable — vers une cellule, une feuille, un fichier, une page web ou un e-mail — dont d'autres formules peuvent calculer la cible. Ce n'est pas la même chose que le menu Insertion > Lien, qui crée un lien statique. Découvrez le préfixe # pour sauter à l'intérieur d'un classeur, les cibles dynamiques avec ADDRESS et MATCH, le piège n°1 selon lequel le lien navigue au clic au lieu de récupérer une valeur, et pourquoi vous devriez toujours passer friendly_name.

ALEA() renvoie un décimal aléatoire de 0 jusqu'à 1 exclu ; ALEA.ENTRE.BORNES(min; max) renvoie un entier aléatoire dans une plage, les deux bornes incluses. Découvrez le modèle mental selon lequel les deux sont volatiles — elles se recalculent à chaque modification — pourquoi c'est le piège n° 1, comment les figer avec le Collage spécial, pourquoi ALEA.ENTRE.BORNES répète des valeurs, et la formule =a+(b-a)*ALEA() pour des décimaux aléatoires.

TABLEAU.ALEA([lignes];[colonnes];[min];[max];[nombre_entier]) déverse un bloc de nombres aléatoires depuis une seule formule — ALEA et ALEA.ENTRE.BORNES fusionnées et améliorées. Découvrez pourquoi l'indicateur nombre_entier vaut FAUX par défaut (vous obtenez des décimaux sauf demande d'entiers), pourquoi elle reste volatile, quand elle renvoie #PROPAGATION!, et l'astuce de mélange SORTBY(liste; TABLEAU.ALEA(...)).

L'astuce unique derrière chaque tirage aléatoire dans Excel : attacher un nombre aléatoire à chaque ligne, puis trier dessus. Découvrez le one-liner moderne TAKE(SORTBY(données; TABLEAU.ALEA(...)); n), la méthode classique à colonne d'aide ALEA, la distinction cruciale avec remise contre sans remise qui gâche les échantillons, et pourquoi il faut figer la colonne aléatoire avant de trier.

PUISSANCE(x;n) et l'opérateur ^ élèvent un nombre à une puissance ; RACINE(x) est le raccourci de la racine carrée pour ^(1/2). Comprenez le modèle mental selon lequel les racines ne sont que des exposants fractionnaires, pourquoi =-3^2 renvoie 9 et =27^1/3 renvoie 9 (deux pièges de priorité des opérateurs), pourquoi RACINE d'un négatif donne #NOMBRE!, et comment une seule formule PUISSANCE vous donne le TCAM.

ABS(x) renvoie la grandeur d'un nombre (sa distance à zéro) ; SIGNE(x) n'en renvoie que la direction, sous la forme -1, 0 ou +1. Comprenez le modèle mental selon lequel tout nombre est une grandeur multipliée par une direction, pourquoi un test de tolérance a besoin de ABS(A-B) et non de A-B, l'identité x = SIGNE(x)*ABS(x), et pourquoi ABS est l'outil des cas où la direction n'a vraiment aucune importance — pas un pansement sur un signe que vous n'attendiez pas.

EXP(x) élève e à une puissance ; LN, LOG10 et LOG en sont les réciproques. Comprenez le modèle mental selon lequel un logarithme est une élévation à une puissance parcourue à l'envers (on cherche l'exposant), pourquoi LOG(x) sans base est en base 10 et NON le logarithme népérien, pourquoi LN(0) et LOG d'un négatif donnent #NOMBRE!, et les deux formules dont les professionnels ont réellement besoin : moyenne géométrique = EXP(MOYENNE(LN)) et durée jusqu'à un objectif = LN(objectif)/LN(taux).

FORMULETEXTE(référence) renvoie la formule d'une cellule sous forme de texte ; ESTFORMULE(référence) renvoie VRAI lorsqu'une cellule contient une formule. Découvrez le modèle mental — ces fonctions auditent une feuille, elles ne calculent pas —, le #N/A obtenu sur une cellule sans formule, l'astuce de mise en forme conditionnelle qui surligne chaque formule, et quand les préférer à Afficher les formules.

CELLULE(type_info; [référence]) renvoie des métadonnées sur une cellule — son adresse, sa ligne, sa colonne, son format de nombre, son type de contenu ou le nom de fichier du classeur — au lieu de sa valeur. Découvrez le modèle mental, pourquoi type_info est une chaîne mot-clé, la tâche pour laquelle elle reste unique (récupérer le chemin du fichier et le nom de la feuille), et le piège de recalcul qui la fait paraître fautive.

TYPE(valeur) renvoie un code décrivant le genre de valeur que contient une cellule — 1 nombre, 2 texte, 4 logique, 16 erreur, 64 matrice — et N(valeur) convertit une valeur en nombre. Découvrez le modèle mental, comment TYPE démasque les nombres stockés en texte, pourquoi N(«quoi que ce soit») renvoie 0 au lieu d'une erreur, et l'astuce classique de N() pour glisser un commentaire à l'intérieur d'une formule.

SI.MULTIPLE compare une expression à une liste de valeurs exactes et renvoie la première correspondance — =SWITCH(expr, val1, res1, val2, res2, default). Découvrez le modèle mental, pourquoi elle ne fait que de l'égalité exacte (la frontière entre SI.MULTIPLE et SI.CONDITIONS), le piège de l'argument par défaut qui renvoie #N/A, l'astuce SWITCH(TRUE()) pour gérer les plages, et quand la préférer à un SI imbriqué.

CHOISIR renvoie le Nième élément d'une liste par sa position — =CHOOSE(index_num, value1, value2, …). Découvrez le modèle mental, pourquoi elle sélectionne par position et non par correspondance (la frontière entre CHOISIR et SI.MULTIPLE), le #VALEUR! obtenu quand l'index sort des limites, et son superpouvoir sous-exploité — renvoyer des plages entières pour basculer entre scénarios ou réordonner des colonnes en vue d'une recherche vers la gauche.

MAX.SI.ENS et MIN.SI.ENS renvoient la plus grande ou la plus petite valeur qui satisfait une ou plusieurs conditions — =MAXIFS(max_range, criteria_range1, criteria1, …). Découvrez le modèle mental, l'ordre des arguments qui piège les habitués de SOMME.SI, pourquoi elles remplacent l'ancienne formule matricielle {=MAX(IF())}, et le piège du 0 silencieux qu'elles renvoient quand aucune ligne ne correspond.

COUNT ne compte que les nombres, COUNTA compte toute cellule non vide et COUNTBLANK compte les cellules vides — trois fonctions pour trois questions différentes du type combien y en a-t-il. Découvrez pourquoi =COUNT sur une colonne d'identifiants texte renvoie 0, pourquoi COUNTA compte quand même une formule qui renvoie une chaîne vide, et pourquoi COUNTA plus COUNTBLANK ne fait pas toujours le total.

COUNTIF compte les cellules qui remplissent une seule condition — =COUNTIF(plage, critère) — où le critère est un petit test écrit sous forme de texte. Découvrez pourquoi les opérateurs doivent aller entre guillemets, comment utiliser la valeur d'une cellule comme seuil avec &, les caractères génériques pour les correspondances de texte, le piège des 15 chiffres sur les longs nombres, et quand passer à COUNTIFS.

Excel n'a pas de fonction COUNTUNIQUE, donc compter les valeurs distinctes a deux réponses — la moderne =COUNTA(UNIQUE(plage)) dans 365/2021, et la classique =SUMPRODUCT(1/COUNTIF(plage,plage)) pour les versions plus anciennes. Découvrez pourquoi les cellules vides ajoutent 1 à votre comptage, comment les exclure avec FILTER, pourquoi la formule classique renvoie #DIV/0!, et la différence entre les valeurs distinctes et les valeurs qui n'apparaissent qu'une fois.

SUPPRESPACE (TRIM) et EPURAGE (CLEAN) suppriment tous deux des caractères invisibles issus de texte importé, mais ne visent pas la même chose — SUPPRESPACE retire les espaces superflus (ASCII 32), EPURAGE retire les caractères de contrôle non imprimables (0 à 31). Aucun des deux n'enlève l'espace insécable CHAR(160) laissé par les copies du web et des PDF, la première cause du fameux « SUPPRESPACE ne marche pas ». Découvrez le bon modèle mental et la formule unique qui attrape tout.

MAJUSCULE, MINUSCULE et NOMPROPRE modifient la casse du texte, mais dans Excel la casse relève de l'affichage et de l'export, pas de la correspondance — la comparaison avec = et RECHERCHEV ignorent déjà la casse. Le vrai piège, c'est NOMPROPRE, qui met une majuscule à chaque mot et transforme McDonald en Mcdonald et iPhone en Iphone. Découvrez quand la casse compte vraiment et pourquoi NOMPROPRE est un point de départ, pas une finition.

NBCAR compte les caractères d'une cellule, mais sa vraie force est diagnostique — parce qu'il compte chaque caractère, y compris les espaces finaux et les caractères non imprimables, NBCAR permet de prouver qu'une cellule qui ressemble à « Apple » est en réalité « Apple » avec 6 caractères. Découvrez NBCAR pour la validation, l'astuce de comptage NBCAR moins NBCAR, l'extraction dynamique, et pourquoi NBCAR ignore la mise en forme des nombres.

VLOOKUP parcourt la colonne la plus à gauche d'un tableau et compte N colonnes vers la droite — cette conception unidirectionnelle est à l'origine de tous ses bugs. Découvrez pourquoi le 4ᵉ argument (range_lookup) doit presque toujours valoir FALSE, pourquoi VLOOKUP ne sait pas regarder à gauche, pourquoi un numéro de colonne codé en dur casse en silence dès que vous insérez une colonne, et comment corriger le #N/A qui signifie « introuvable ».

INDEX et MATCH scindent une recherche en deux tâches : MATCH trouve la position (« quelle ligne ? »), INDEX renvoie la valeur à cette position (« qu'y a-t-il là ? »). Découpler la recherche de la récupération, c'est ce qui donne à INDEX/MATCH tout ce qui manque à VLOOKUP — il regarde à gauche aussi facilement qu'à droite, survit aux colonnes insérées et réalise de vraies recherches bidimensionnelles. Apprenez le motif, le piège de match_type, et quand il bat encore XLOOKUP.

HLOOKUP, c'est VLOOKUP pivoté de 90 degrés — il recherche dans la première LIGNE et lit vers le bas. LOOKUP est l'ancêtre de VLOOKUP, et son défaut fatal est de n'avoir aucune option de correspondance exacte : il approxime toujours et exige des données triées. Découvrez quand une disposition horizontale fait de HLOOKUP le bon choix, pourquoi la vieille astuce LOOKUP(2,1/…) traîne encore dans les feuilles anciennes, et pourquoi les deux cèdent surtout la place à XLOOKUP.

AND et OR ne décident rien — ils réduisent plusieurs tests VRAI/FAUX en un seul verdict qui alimente un IF, une règle ou un filtre. Découvrez pourquoi AND se loge dans le premier argument de IF, pourquoi un =AND(...) isolé n'affiche que le mot TRUE, pourquoi Excel évalue chaque argument (aucun court-circuit, d'où le #DIV/0!) et quand leur préférer des masques matriciels en +/*.

NOT inverse un seul verdict VRAI/FAUX ; XOR est le ou exclusif que AND et OR n'expriment pas. Découvrez pourquoi NOT prend exactement un argument (d'où NOT(AND(...))), quand NOT n'est qu'un <> déguisé, pourquoi la loi de De Morgan est son vrai superpouvoir, et la surprise de XOR : avec 3 entrées ou plus, il renvoie TRUE pour un nombre IMPAIR de TRUE, pas « exactement un ».

La famille IS inspecte une cellule et renvoie un verdict VRAI/FAUX — elle classe, elle ne transforme jamais. Découvrez pourquoi ISBLANK est plus strict que « paraît vide », pourquoi ISERROR cache de vrais bugs quand ISNA et IFNA sont plus sûrs, pourquoi IF(ISERROR(x),…,x) calcule x deux fois, et l'atout d'ISNUMBER : transformer SEARCH en un test de correspondance partielle bien net.

La fonction TEXTE transforme un nombre ou une date en une chaîne de texte mise en forme à l'aide d'un code de format — =TEXT(1234.5,"$#,##0.00") donne "$1 234,50". Découvrez le modèle mental (incruster une mise en forme dans une vraie chaîne vs le format d'affichage d'une cellule), le piège n°1 (le résultat est du texte, donc SOMME l'ignore), le cours accéléré des codes de format pour les nombres et les dates, les zéros de tête et les paramètres régionaux, et quand un format de cellule, CONCAT ou ARRONDI est le meilleur outil.

CNUM analyse une chaîne de texte qui ressemble à un nombre — "1 234,50" ou "9,00 $" — pour en faire un vrai nombre que vous pouvez additionner, trier et mettre en graphique. C'est l'inverse de TEXTE. Découvrez le modèle mental, la cause n°1 dans la vraie vie (des nombres stockés comme texte après un import ou un collage), pourquoi CNUM suit les paramètres régionaux de votre système et comment VALEURNOMBRE règle un "1.234,56" à l'européenne, les correctifs plus rapides sans formule (*1, double moins unaire, Convertir), et pourquoi Excel moderne convertit certains textes mais SOMME jamais.

Une date dans Excel est en réalité un numéro de série habillé d'un format de date ; une date qui arrive en texte est un imposteur qui refuse de se trier, se soustraire ou nourrir DATEDIF. DATEVALUE analyse une date-texte en son numéro de série et TIMEVALUE analyse une heure-texte en une fraction de jour. Découvrez le modèle mental, les symptômes des dates-texte, le piège de l'ambiguïté régionale avec 03/04/2026, comment combiner date + heure, quand DATEVALUE ne parvient pas à analyser une chaîne, et les alternatives DATE(GAUCHE,STXT,DROITE) et Convertir.

INDIRECT transforme une chaîne de texte comme "A1" ou "Sheet2!B3" en une référence de cellule vivante. Découvrez le modèle mental, le piège n°1 (le texte ne se met pas à jour tout seul : renommer une feuille casse chaque INDIRECT avec #REF!), pourquoi elle est volatile et invisible pour le traceur de dépendances d'Excel, le piège du #REF! sur classeur fermé, son seul usage imbattable — lire depuis une feuille nommée dans une cellule — et quand un Tableau, une référence 3D ou CHOISIR est le meilleur outil.

OFFSET renvoie une référence décalée d'un certain nombre de lignes et de colonnes depuis une ancre, éventuellement redimensionnée en un bloc entier. Découvrez le modèle mental, pourquoi elle renvoie une référence (pas une valeur) et peut donc alimenter SUM, le coût de la volatilité, l'astuce classique de la plage nommée dynamique et pourquoi un Tableau ou une plage de déversement la surpasse aujourd'hui, le piège du #REF! hors bord, et le choix clé : utiliser INDEX non volatile pour indexer dans une plage, et réserver OFFSET aux fenêtres réellement mobiles.

ADDRESS construit le texte d'une adresse de cellule — =ADDRESS(1,1) renvoie la chaîne "$A$1", pas ce que contient A1. Découvrez le modèle mental (c'est l'inverse du côté entrée d'INDIRECT), le malentendu n°1 selon lequel elle renvoie du texte et non une valeur, l'argument abs_num pour le verrouillage par $, pourquoi elle n'est PAS volatile contrairement à INDIRECT et OFFSET, ses vrais rôles — signaler où se trouve une valeur via MATCH et construire des références pour INDIRECT — et un avis honnête sur sa nature de niche dans Excel moderne.

SUMPRODUCT multiplie des plages élément par élément et additionne les résultats — une seule cellule, un produit scalaire. Découvrez le piège #VALUE! lié aux dimensions incompatibles, pourquoi on multiplie les tableaux booléens pour le ET et on les additionne pour le OU (jamais AND()/OR()), quand la double négation -- est nécessaire, et les calculs de total pondéré et de OU entre colonnes que SUMIFS ne sait toujours pas faire.

SUBTOTAL est un total qui tient compte du filtre : il ignore les lignes masquées par un filtre, si bien que le nombre au bas de votre liste se met à jour à mesure que vous filtrez. Découvrez le tableau des function_num, le piège 1–11 vs 101–111 (pourquoi masquer des lignes manuellement ne change pas votre total), pourquoi SUBTOTAL ignore les autres SUBTOTAL pour que les totaux généraux ne comptent jamais en double, et pourquoi il ne sait pas ignorer les erreurs — la tâche pour laquelle AGGREGATE a été conçu.

AGGREGATE, c'est SUBTOTAL avec deux améliorations : 19 fonctions au lieu de 11, et un argument options qui lui permet d'ignorer les valeurs d'erreur, les lignes masquées et les totaux imbriqués. Découvrez la grille function_num + options, son astuce la plus sous-exploitée — sommer une colonne qui contient des #N/A sans aucun nettoyage IFERROR — et les fonctions matricielles (LARGE, SMALL, PERCENTILE) qui réclament un argument k supplémentaire.

LEFT, RIGHT et MID découpent une chaîne par position — en comptant depuis la gauche, depuis la droite ou à partir d'un point fixe. Découvrez pourquoi MID commence à 1, pourquoi le résultat est toujours du texte (et casse SUM), et la vraie raison pour laquelle les positions codées en dur sont la ligne la plus fragile de votre feuille.

FIND et SEARCH renvoient la position d'une chaîne à l'intérieur d'une autre — le point d'ancrage que vous fournissez à MID et LEFT. Découvrez les deux vraies différences (FIND est sensible à la casse et sans caractères génériques ; SEARCH ignore la casse et accepte les génériques), pourquoi les deux renvoient #VALUE! en l'absence de correspondance, et l'astuce du test de présence ISNUMBER(SEARCH()).

SUBSTITUTE et REPLACE remplacent tous deux du texte, mais ils raisonnent différemment : SUBSTITUTE fait correspondre par contenu (remplacer chaque 'x', ou seulement le Nème), tandis que REPLACE travaille par position (écraser les caractères 5 à 9). Découvrez lequel utiliser, pourquoi SUBSTITUTE est sensible à la casse, et l'astuce de comptage LEN-moins-LEN.

ROUND modifie la valeur stockée selon un nombre de décimales ; la mise en forme d'une cellule ne change que son apparence. Découvrez pourquoi cet écart fait que les totaux de factures se décalent d'un centime, l'astuce de num_digits (positif, zéro, négatif), en quoi ROUNDUP et ROUNDDOWN diffèrent de ROUND, et pourquoi ils arrondissent selon la distance à zéro — et non vers le haut ou vers le bas.

MROUND, CEILING et FLOOR arrondissent au multiple le plus proche d'un nombre — 5 centimes, 15 minutes, un carton complet — et non à un nombre de décimales. Découvrez pourquoi le second argument est un multiple et non des chiffres, pourquoi l'ancien CEILING renvoie #NUM! sur les négatifs, pourquoi CEILING.MATH et FLOOR.MATH sont les choix modernes sûrs, et quand choisir chacun.

INT et TRUNC suppriment tous deux les décimales, mais INT arrondit vers moins l'infini tandis que TRUNC tronque simplement vers zéro — d'où leur divergence sur les nombres négatifs. MOD renvoie le reste, et dans Excel le reste prend le signe du diviseur, pas celui du nombre. Découvrez le piège du décalage d'une unité, la séparation des dates et des heures, et le motif zébré.

IF pose une seule question oui/non et renvoie l'une de deux réponses. Découvrez pourquoi un troisième argument manquant affiche FALSE, pourquoi les pyramides de IF imbriqués s'effondrent au-delà de deux niveaux (préférez IFS ou une recherche), comment combiner des conditions avec AND/OU au lieu d'imbriquer, et pourquoi la comparaison de texte de IF ignore la casse.

IFS vérifie une liste de conditions de haut en bas et renvoie la première qui correspond ; SWITCH compare une valeur à une liste de cas. Découvrez les deux pièges à l'origine de la plupart des bugs — IFS n'a pas de else intégré (un défaut oublié renvoie #N/A) et la première correspondance l'emporte, donc l'ordre compte — et quand préférer IFS, SWITCH ou une table de recherche.

IFERROR remplace l'erreur d'une formule par une valeur de repli, mais il intercepte tous les types d'erreur — il masque donc en silence de vrais bugs comme #REF! et #NAME?. Découvrez pourquoi IFNA est généralement le bon outil pour les recherches, pourquoi tout envelopper dans IFERROR est un anti-motif, et comment le if_not_found de XLOOKUP bat les deux.

SUMIFS additionne uniquement les lignes qui passent tous les tests. Découvrez pourquoi SUMIF et SUMIFS inversent leurs arguments (le bug numéro un du mauvais total), comment comparer à une cellule avec ">"&A1, pourquoi le ET est intégré mais pas le OU, et comment déverser tout un tableau récapitulatif avec UNIQUE.

COUNTIFS compte les lignes qui passent tous les tests, et un mauvais critère vous donne un nombre plausible mais faux, sans aucune erreur. Découvrez pourquoi il faut écrire ">"&A1 et non ">A1", pourquoi le ET est intégré mais pas le OU, comment compter entre deux dates, et pourquoi les comptages distincts réclament UNIQUE, pas COUNTIFS.

AVERAGEIFS ne fait la moyenne que des lignes qui passent tous les tests — mais quand rien ne correspond, il renvoie #DIV/0! (pas 0 comme SUMIFS), et il compte les zéros tout en ignorant les vides. Découvrez la protection contre l'ensemble vide, le piège zéro-vs-vide, l'ordre des arguments inversé, et pourquoi il ne sait pas faire de moyenne pondérée.

LET permet de déclarer des variables nommées au sein d'une seule formule. Découvrez la règle des noms par paires et du résultat en dernier, pourquoi LET ne calcule chaque valeur qu'une seule fois (donc plus rapide, pas seulement plus propre), les pièges de nommage, et à quel moment une formule imbriquée de 200 caractères doit devenir un LET.

LAMBDA transforme une formule en une fonction nommée et réutilisable, sans VBA. Découvrez pourquoi un LAMBDA seul renvoie #CALC!, l'astuce de la parenthèse finale pour l'appeler, comment le nommer dans le Gestionnaire de noms pour que tout le classeur puisse l'utiliser, et comment un LAMBDA peut s'appeler lui-même pour la récursivité.

MAP, REDUCE, SCAN, BYROW et BYCOL exécutent un LAMBDA sur tout un tableau — un For Each sans macro. Découvrez la règle de la valeur unique de BYROW qui corrige #CALC!, le motif de l'accumulateur de REDUCE, la forme que renvoie chaque fonction d'assistance, et quand un simple SUMIFS reste gagnant.

VSTACK empile les plages l'une sur l'autre et HSTACK les place côte à côte, fusionnant plusieurs tableaux en un seul qui se met à jour tout seul. Apprenez à combiner des feuilles sans copier-coller, pourquoi les plages inégales se complètent par #N/A, et comment DROP et SORT finissent le travail.

SEQUENCE crée un tableau de nombres à partir de rien — c'est le moteur derrière les numéros de ligne dynamiques, les séries de dates et les grilles, pas un remplaçant de la poignée de recopie. Découvrez l'ordre des arguments (lignes, colonnes, début, pas), comment bâtir un calendrier vivant, pourquoi elle renvoie #SPILL! et quand elle remplace le glissement ou LIGNE().

TAKE garde les N premières ou dernières lignes ou colonnes d'un tableau ; DROP les retire. Ensemble, elles découpent un tableau dynamique par l'un ou l'autre bord. Découvrez l'astuce positif/négatif pour haut vs bas, l'association de TAKE avec SORT pour un Top 10 vivant, et comment DROP retire l'en-tête d'un VSTACK.

TEXTJOIN est un pistolet à colle avec séparateur qui ignore les cellules vides pour vous. Découvrez l'argument ignore_vide que tout le monde oublie, la limite de 32 767 caractères derrière #VALUE!, quand préférer TEXTJOIN à CONCAT et à l'opérateur &, et comment joindre un tableau déversé en une seule cellule.

TEXTSPLIT est la version formule de Convertir en colonnes, sauf que le résultat est un tableau vivant qui se met à jour avec la source. Apprenez à découper en colonnes et en lignes à la fois, à passer plusieurs séparateurs en tableau de constantes, à corriger #SPILL! et quand elle remplace GAUCHE/STXT/TROUVE.

CONCAT remplace CONCATENER et prend une plage entière d'un coup — mais sans séparateur et sans rien ignorer. Découvrez quand CONCAT gagne, pourquoi CONCATENER est un vestige, comment il lit une plage 2D ligne par ligne, le piège du format des nombres et quand passer directement à TEXTJOIN.

FILTER est une requête, pas une recherche — elle renvoie chaque ligne qui correspond et la déverse dans une plage qui se met à jour seule. Découvrez l'astuce ET/OU, pourquoi un résultat vide donne

UNIQUE renvoie les valeurs distinctes d'une plage et les tient à jour — contrairement au bouton destructeur Supprimer les doublons. Découvrez le piège d'exactly_once, comment compter les valeurs distinctes et pourquoi UNIQUE vit presque toujours dans SORT ou une liste déroulante.

La fonction SORT renvoie une copie triée qui se retrie quand la source change — contrairement au bouton Trier destructeur du ruban. Découvrez la règle de l'indice de colonne, le tri sur plusieurs colonnes, quand utiliser SORTBY et le motif vivant SORT(UNIQUE(FILTER())).

VBA propose deux façons de joindre du texte — & et + — et une seule est sûre. Découvrez pourquoi & est la seule colle à texte fiable, le piège Null qui se cache derrière +, et quand passer à Join.

UCase et LCase ne servent pas à stocker des données — ils servent à les comparer et à les afficher. Découvrez pourquoi le = de VBA est sensible à la casse, comment comparer sans modifier vos données, et pourquoi StrConv ruine des noms comme McDonald.

La fonction Str de VBA cache deux pièges — un espace de tête devant les nombres positifs et un point décimal aveugle à la locale. Découvrez quand Str rend service, pourquoi CStr est le choix par défaut le plus sûr, et comment convertir des nombres en texte correctement.

ThisWorkbook est le fichier où vit votre code ; ActiveWorkbook est celui qui est au premier plan à l'instant T — les confondre est la raison principale pour laquelle les macros VBA lisent, écrivent et enregistrent dans le mauvais classeur.

Une feuille a trois poignées — nom d'onglet, CodeName et index — et deux d'entre elles cassent quand les utilisateurs renomment ou réordonnent les feuilles. Quelle référence choisir et pourquoi Sheets n'est pas Worksheets.

ActiveSheet, ActiveCell et Selection sont un état global mutable qui change sous votre macro. Pourquoi un Range non qualifié écrit en silence dans la mauvaise feuille — et la seule habitude qui corrige cela.

VBA offre deux façons d'appeler VLOOKUP — l'une plante sur une valeur absente, l'autre renvoie une erreur testable. Le modèle mental, la boucle qui transforme VLOOKUP en piège O(n²), et la solution Dictionary. Testé sur Excel 365, 2021, 2019.

L'enregistreur de macro écrit Select, Copy, Paste — trois étapes via le presse-papiers, lentes et fragiles. Le modèle mental, pourquoi .Value = .Value gagne, et quand PasteSpecial reste justifié. Testé sur Excel 365, 2021, 2019.

Envoyer un e-mail Outlook depuis Excel VBA, c'est du late binding plus un mur de sécurité — et un pont que Microsoft démonte. Le modèle mental, CreateObject vs référence, .Display vs .Send, et ce que tue New Outlook. Testé sur Excel 365, 2021, 2019.

VBA Trim ne nettoie que les deux extrémités, pas les espaces à l'intérieur — et il ignore l'espace insécable Chr(160) que le copier-coller depuis le web et les PDF laisse derrière lui. Le modèle mental, la fonction de nettoyage à utiliser et quand chaque outil gagne. Testé sur Excel 365, 2021, 2019.

VBA Format transforme une valeur en chaîne d'affichage — il ne change jamais ce que la valeur EST. Le modèle mental, les codes de format qui comptent, le piège m-veut-dire-mois, et pourquoi écrire Format() dans une cellule casse silencieusement SOMME et le tri. Testé sur Excel 365, 2021, 2019.

CStr, CDate et Val changent ce que la valeur EST, pas seulement son apparence. Le modèle mental, le piège des paramètres régionaux qui fait lire 01/02 comme 2 janv. sur un PC et 1er févr. sur un autre, pourquoi Val tronque silencieusement les décimales françaises, et le correctif DateSerial. Testé sur Excel 365, 2021, 2019.

VBA Split expliqué comme l'inverse de la concaténation : une chaîne à délimiteurs devient un tableau indexé à partir de 0. Le décalage d'indice qui perd votre premier champ, pourquoi ce n'est pas un parseur CSV et quand l'employer. Testé sur Excel 365, 2021, 2019.

VBA Mid, Left et Right expliqués comme couper une chaîne par coordonnées. Le décalage d'indice lié au départ à 1, pourquoi Mid est aussi une instruction et quand l'extraction par position est le mauvais outil. Testé sur Excel 365, 2021, 2019.

VBA Replace expliqué comme un Rechercher-Remplacer en code : chaque occurrence, en une passe. Pourquoi il est sensible à la casse par défaut, l'argument start qui tronque votre chaîne en silence et quand Range.Replace l'emporte. Testé sur Excel 365, 2021, 2019.

Gestion des erreurs VBA sans try/catch : armer un gestionnaire, nettoyer en un point unique, puis Resume. Le motif fiable. Testé sur Excel 365, 2021, 2019.

On Error en VBA : l'aiguillage qui décide où va la macro après une erreur d'exécution. Resume Next vs GoTo vs GoTo 0. Testé sur Excel 365, 2021, 2019.

L'objet Err en VBA, boîte noire d'une erreur d'exécution : Err.Number, Err.Description, et Err.Raise pour lever la vôtre. Testé sur Excel 365, 2021, 2019.

VBA Sub expliqué tel qu'il fonctionne : un Sub est une action nommée, votre macro EST un Sub, et la règle des parenthèses à l'appel cause la moitié des erreurs de compilation. Exemples à copier, testés sur Excel 365, 2021, 2019.

VBA Function expliqué : renvoyer une valeur en l'affectant au nom de la fonction (pas de Return), la transformer en fonction personnalisée tapée dans une cellule, et savoir quand préférer Function à Sub. Testé sur Excel 365, 2021, 2019.

VBA ByRef vs ByVal expliqué : ByRef passe la variable d'origine (les changements persistent), ByVal passe une copie. Pourquoi VBA utilise ByRef par défaut et modifie vos variables en silence — et l'habitude qui l'évite. Testé sur Excel 365, 2021, 2019.

VBA MsgBox expliqué tel qu'il fonctionne vraiment : quand mettre des parenthèses, comment lire une réponse Oui/Non/Annuler, et pourquoi MsgBox est une porte de décision — pas un débogueur. Exemples à copier, testé sur Excel 365, 2021, 2019.

Excel a deux InputBox en VBA, pas une. Quand la simple InputBox suffit, quand Application.InputBox avec un Type l'emporte, et le piège de l'annulation qui casse les deux en silence. Exemples à copier, testé sur Excel 365, 2021, 2019.

Un UserForm VBA bien fait : la pensée pilotée par événements, pourquoi votre code 'disparaît' après .Show, et la règle Unload-contre-Hide qui décide si vous pouvez lire ce que l'utilisateur a tapé. Code d'événement à copier, testé sur Excel 365, 2021, 2019.

Maîtrisez l'objet VBA Range dans Excel : Range contre Cells, .Value contre .Value2, plages dynamiques avec End et CurrentRegion, et pourquoi ne jamais utiliser .Select. 8 exemples à copier-coller. Testé sur Excel 365, 2021, 2019.

Maîtrisez les tableaux VBA dans Excel : déclarer des tableaux statiques et dynamiques, ReDim Preserve, UBound/LBound, et l'astuce qui rend les macros 100× plus rapides — lire une plage dans un tableau. 7 exemples à copier-coller. Testé sur Excel 365, 2021, 2019.

Maîtrisez le VBA Dictionary dans Excel : liaison précoce contre tardive, Add et Exists, plus les deux usages que font vraiment les analystes — listes uniques et comptage/regroupement. 6 exemples à copier-coller. Testé sur Excel 365, 2021, 2019.

VBA If Then Else est une liste de contrôle de questions indépendantes. Apprenez le piège qui le casse en silence (VBA n'évalue jamais en court-circuit), la règle une ligne vs bloc et quand passer à Select Case — avec exemples à copier. Testé sur Excel 365, 2021, 2019.

Une boucle While VBA est une promesse qu'elle se terminera — et c'est vous qui la tenez. Apprenez les trois parties que toute boucle While exige, pourquoi Do While vaut mieux que While...Wend, et comment ne plus jamais figer Excel. Avec exemples à copier. Testé sur Excel 365, 2021, 2019.

VBA Select Case est un aiguillage, pas une liste de contrôle. Comprenez la règle unique qui explique tous les bugs de Select Case, quand l'utiliser à la place de ElseIf, et l'astuce Select Case True — avec des exemples à copier. Testé sur Excel 365, 2021, 2019.

ExcelMaster V2 évolue du meilleur générateur de code VBA au monde vers un agent IA entièrement autonome qui planifie, exécute et s'auto-corrige directement dans Excel — avec des résultats basés sur des formules, auditables et vérifiables.

Découvrez comment l'intelligence artificielle transforme l'automatisation Excel avec VBA. Ce guide complet explore les meilleures pratiques, outils et techniques pour optimiser votre productivité avec des macros intelligentes et des solutions d'automatisation avancées en 2025.

Les zones nommées sont des outils clés dans Excel pour améliorer l'efficacité du travail et la lisibilité du code. Grâce à ce guide, vous avez acquis des compétences allant des bases aux applications avancées des zones nommées, incluant la création, la gestion, l'ajustement dynamique, la gestion des erreurs et des études de cas pratiques. En suivant les meilleures pratiques et les conseils d'optimisation des performances, vous pouvez construire des classeurs Excel plus efficaces et faciles à maintenir. Continuez à pratiquer et à explorer, et vous deviendrez un expert des zones nommées dans Excel VBA !