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

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 !