Formules Power Query : Guide complet

Les formules Power Query offrent de nombreuses possibilités de manipulation de données sur Excel et Power Query. Découvrez tout ce que vous devez savoir sur les différents types et leur utilisation…

Avec Power Query, les utilisateurs d’Excel et Power BI peuvent transformer, nettoyer, combiner et interroger les données en provenance de multiples sources.

Son interface intuitive rend l’analyse de données accessible au plus grand nombre au sein d’une entreprise. L’éditeur de requêtes ne nécessite pas de code, et c’est ce qui permet une démocratisation de la Business Intelligence.

L’outil propose même des outils de nettoyage de données automatiques pour la détection et la suppression des doublons, la correction des erreurs de données, la suppression des espaces ou la normalisation des dates.

De plus, Power Query propose également des outils de nettoyage de données automatiques tels que la détection et la suppression des doublons, la correction des erreurs de données, la suppression des espaces, la normalisation des dates, etc. Ces outils permettent aux utilisateurs de nettoyer les données sans avoir besoin d’écrire de formules.

Cependant, afin de manipuler les données de façon plus efficace et précise, les utilisateurs avancés peuvent se servir des formules Power Query. Elles sont écrites en langage M.

Ces formules peuvent servir à effectuer des calculs, des manipulations de texte, des agrégations de données importées ou d’autres opérations comme la fusion, le filtrage, le tri ou encore le formatage.

Puissantes et flexibles, les formules Power Query permettent de personnaliser les transformations de données en fonction des besoins spécifiques. À travers cet article, vous allez découvrir les différentes catégories et leur fonctionnement !

Qu’est-ce que le langage M ?

Le langage de programmation M, aussi appelé Power Query Formula Language, est utilisé dans Power Query pour décrire les étapes de transformation de données. C’est un langage fonctionnel, sensible à la casse, typé dynamiquement et à évaluation partiellement paresseuse : il s’appuie sur des fonctions qui prennent des arguments et renvoient des valeurs, et n’évalue certaines parties qu’au moment où elles sont nécessaires. Pour une approche structurée, voir la Formation Power BI.

On l’emploie dans Power Query pour écrire des formules, c’est‑à‑dire des expressions qui définissent les transformations à effectuer. M est un outil puissant pour l’ETL et l’analyse de données. Ses fonctions sont regroupées par bibliothèques thématiques, ce qui facilite la découverte et la réutilisation.

Quels sont les types et structures de données (listes, enregistrements, tables) ?

M manipule des valeurs primitives (number, text, logical, null, date, time, datetime, datetimezone, duration, binary) et des structures qui organisent les données : List, Record et Table. Comprendre ces trois blocs est essentiel, ainsi que quelques fonctions clés qui les transforment.

Structure	Littéral ou forme	Accès / sélection	Fonctions clés	Quand l’utiliser
List (liste ordonnée de valeurs)	{1, 2, 3} ou {« A », « B »}	Par index : {0} renvoie le premier élément	List.Transform(list, each ...), List.Sum, List.Distinct	Itérer, agréger, dédupliquer, préparer des colonnes
Record (paires nom:valeur)	[Nom = « Liora », Ville = « Paris »]	Par champ : [Ville] ou Record.Field(rec, "Ville")	Record.Field, Record.AddField, Record.RemoveFields	Regrouper des attributs nommés, passer des paramètres
Table (colonnes nommées, lignes)	Créée depuis listes/records ou source de données	Colonne : [Col] dans un each, ligne par contexte	Table.TransformColumns, Table.AddColumn, Table.SelectRows, Table.Group	Transformer des jeux de données tabulaires
Valeurs primitives	42, « Texte », true, null, #date(2026,6,22)	Direct	Number.Round, Text.Upper, Date.Year…	Nettoyer et typer finement les colonnes

Exemples rapides

Comment fonctionne la syntaxe let/in et l’évaluation paresseuse ?

La structure let … in permet de décomposer une transformation en étapes nommées. Chaque nom défini dans let a une portée limitée à l’expression courante. L’évaluation paresseuse signifie que M ne calcule une étape que si une étape suivante en a besoin, ce qui rend les requêtes efficaces et facilite le chaînage.

1. Déclarez vos étapes intermédiaires dans let : connexions, nettoyages, enrichissements.
2. Référencez ces étapes par leur nom pour construire la suite.
3. Retournez l’étape finale après in.

Ici, seules les étapes nécessaires à filtrage sont réellement évaluées. La lisibilité progresse grâce à des noms explicites, et l’ordre réel d’exécution suit les dépendances, pas la position dans le texte.

Quels opérateurs et contrôles de flux utiliser ?

M propose des opérateurs usuels et des contrôles de flux simples pour écrire des expressions lisibles.

• Arithmétiques : +, -, *, /, ^
• Comparaison : =, <>, <, <=, >, >=
• Logiques : and, or, not
• Concaténation de texte : & (par exemple "Hello" & " " & "World")
• Contrôle conditionnel : if ... then ... else
• Raccourci de fonction : each avec le paramètre implicite _

Exemples appliqués

Bibliothèque de fonctions M essentielles

Les différentes fonctions du langage M sont organisées en bibliothèques, regroupées par thème et par catégorie. Voici une carte d’orientation des familles les plus utilisées, avec des exemples rapides pour démarrer.

Famille	Usage courant	Exemples M
Text.*	Nettoyage, normalisation, recherche/remplacement	Text.Trim(" ABC ") → "ABC", Text.Replace([Tel]," ","")
Date.*, DateTime.*, Duration.*	Conversions, calculs calendaires, âges et périodes	Date.StartOfMonth([Date]), Duration.Days(DateTime.LocalNow() - DateTime.From([DateCommande]))
Number.*	Conversions typées, arrondis, modulo, puissances	Number.From([Texte]), Number.Round([Montant],2), Number.Mod(7,3)
List.* / Record.*	Recherche dans des listes, accumulation, accès/ajout de champs	List.Select({1,-2,3}, each _ > 0), Record.Field([Détails],"Code")
Table.*	Filtrer, sélectionner, trier, regrouper, joindre, étendre	Table.SelectRows(Source, each [Pays]="FR"), Table.Group(...)

Exemple express: standardiser un nom de client en créant une colonne formatée prénom/nom en majuscules initiales puis en majuscules complètes: Table.TransformColumns(#"Type modifié",{{"Prénom", Text.Proper, type text},{"Nom", Text.Upper, type text}}).

Quelles fonctions Text.* utiliser au quotidien ?

• Text.Trim: supprime les espaces de début et fin. Exemple: Text.Trim([Libellé]).
• Text.Clean: retire les caractères non imprimables, utile après des imports hétérogènes: Text.Clean([Commentaire]).
• Text.Upper et Text.Lower: normalisation de casse pour les clés de jointure: Text.Upper([CodePays]).
• Text.Replace: corrige des séparateurs ou masques: Text.Replace([Téléphone],"-","").
• Text.Split: fractionne un champ composite: Text.Split([Adresse], ",") puis List.First/List.Last pour récupérer les éléments.
• Text.Contains: filtre rapide sur mot clé, avec option de casse: Text.Contains([Objet],"URGENT", Comparer.OrdinalIgnoreCase).

Cas concret: nettoyer des codes produits “fr- 001 ” en “FR001” pour fiabiliser une jointure: Text.Upper(Text.Replace(Text.Trim([CodeProduit])," ","")).

Date.*, DateTime.* et Duration.* : quels cas d’usage ?

• Conversions: Date.From([DateHeure]), DateTime.From([Date]), Duration.From(#duration(0,1,30,0)).
• Ajouts/soustractions: Date.AddDays([Date],7), Date.AddMonths([Date],-1), Date.AddYears([Anniversaire],1).
• Âge (en années approximatives): Number.IntegerDivide(Duration.Days(Date.Age([DateNaissance], Date.From(DateTime.LocalNow()))), 365).
• Débuts/fins de périodes: Date.StartOfMonth([Date]), Date.EndOfMonth([Date]), Date.StartOfWeek([Date]), Date.StartOfYear([Date]).
• Horodatage actuel: DateTime.LocalNow() pour un calcul relatif au moment du rafraîchissement.

Exemple: dater chaque vente au premier jour du mois et calculer l’intervalle écoulé depuis la commande: Date.StartOfMonth([DateVente]), puis Duration.Days(DateTime.LocalNow() - DateTime.From([DateCommande])).

Quelles fonctions Number.* sont vraiment utiles ?

• Number.From et Number.FromText: conversion robuste depuis du texte ou un type variant: Number.From([Montant]).
• Arrondis: Number.Round([Taux],4), Number.RoundUp([Pages]/25,0), Number.RoundDown([Prix],2).
• Number.Mod et Number.Power: contrôles et calculs: Number.Mod([Index], 2), Number.Power(2,10).
• Conversions typées lors des transformations de colonnes: Table.TransformColumns(#"Étape",{{"Quantité", Number.From, Int64.Type}}).

Exemple: regrouper des dossiers par “lots” de 50: Table.AddColumn(#"Étape", "Lot", each Number.IntegerDivide([Index], 50), Int64.Type).

List.* et Record.* : comment rechercher et transformer efficacement ?

Les listes servent aux recherches et agrégations fines, les enregistrements à accéder dynamiquement à des champs.

• List.Select: filtrer une liste: List.Select({-1,0,2,5}, each _ >= 0) → {0,2,5}.
• List.PositionOf: trouver un élément: List.PositionOf({"FR","DE","ES"},"DE") → 1.
• List.Accumulate: cumuler/réduire: List.Accumulate({1,2,3}, 0, (s, c) => s + c) → 6.
• Record.Field: accès dynamique à un champ: Record.Field([Détails], "Code").
• Record.AddField: enrichir un enregistrement: Record.AddField([Détails], "Source", "CRM").

Cas concret: créer une colonne “EstVIP” en testant l’appartenance catégorie dans une liste de référence: Table.AddColumn(Source, "EstVIP", each List.Contains({"A","B"}, [Catégorie]), type logical).

Table.* : comment sélectionner, trier et regrouper rapidement ?

• Table.SelectRows pour filtrer: Table.SelectRows(Source, each [Pays]="FR" and [Montant]>0).
• Table.RemoveColumns et Table.SelectColumns pour épurer le schéma.
• Table.Sort pour ordonner: Table.Sort(Source, {{"Date", Order.Ascending},{"Client", Order.Ascending}}).
• Table.AddColumn pour créer des calculs: Table.AddColumn(Source,"CA_HT", each [Qté]*[PU], type number).
• Table.Group pour agréger: Table.Group(Source, {"Client"}, {{"CA", each List.Sum([CA_HT]), type number}}).
• Table.Join/Table.NestedJoin puis Table.ExpandTableColumn pour enrichir depuis des dimensions.

Paragraphe pratique: un pipeline 80/20 typique en M enchaîne l’épuration (Table.RemoveColumns), le filtrage (Table.SelectRows), l’ordonnancement (Table.Sort), la création de colonnes métiers (Table.AddColumn avec Text.*, Date.*, Number.*), l’agrégation (Table.Group), puis la jointure d’une table de référence (Table.NestedJoin + Table.ExpandTableColumn). Cette combinaison couvre l’essentiel des besoins opérationnels.

Quelles sont les formules de transformation de texte ?

Dans Power Query, les chaînes de caractères se transforment avec les fonctions du module Text. du langage M. Elles servent à nettoyer, normaliser, extraire, rechercher ou formater des colonnes texte, par exemple des noms, adresses ou descriptions produit. Ces opérations s’appliquent via l’interface ou en écrivant des formules M pour un contrôle fin, sensible à la casse et à la culture si nécessaire. ([learn.microsoft.com](https://learn.microsoft.com/en-gb/powerquery-m/text-functions?utm_source=openai))

Comment nettoyer et normaliser un texte ?

• Supprimer les espaces superflus: Text.Trim pour début et fin, Text.TrimStart et Text.TrimEnd au besoin.
• Nettoyer les caractères non imprimables: Text.Clean.
• Uniformiser la casse: Text.Upper, Text.Lower, Text.Proper (majuscule à chaque mot).
• Réduire les espaces multiples au sein d’un texte: découper puis recomposer, par exemple Text.Combine(List.Select(Text.Split(Text.Trim([Col]), " "), each _ <> ""), " ").

Astuce pratique: appliquez ces fonctions avec Table.TransformColumns pour traiter une ou plusieurs colonnes en une seule étape. ([learn.microsoft.com](https://learn.microsoft.com/en-gb/powerquery-m/text-functions?utm_source=openai))

Comment extraire et fractionner des sous-chaînes ?

Pour prélever des segments fixes, utilisez Text.Start(text, n), Text.End(text, n) ou Text.Range(text, offset, [count]). Pour découper selon un séparateur, Text.Split(text, ",") renvoie une liste à développer en colonnes. Quand les séparateurs varient, Text.SplitAny(text, "-_/") scinde sur n’importe quel caractère fourni. ([learn.microsoft.com](https://learn.microsoft.com/en-gb/powerquery-m/text-splitany?utm_source=openai))

Expressions régulières: M ne propose pas de regex natives. On peut toutefois créer une fonction personnalisée s’appuyant sur un moteur JavaScript pour des remplacements ou captures par motif complexes, approche réservée aux cas avancés. ([reddit.com](https://www.reddit.com/r/excel/comments/npq9vv?utm_source=openai))

Comment rechercher et remplacer des motifs ?

• Détecter un motif: Text.Contains(text, substring, optional comparer) selon une comparaison ordinale sensible ou non à la casse, ou bien dépendante d’une culture avec Comparer.FromCulture("fr-FR", true).
• Localiser la position: Text.PositionOf(text, substring, optional occurrence, optional comparer).
• Remplacer un motif unique: Text.Replace(text, "ancien", "nouveau") est sensible à la casse.
• Remplacer dans une table: Table.ReplaceValue(..., Replacer.ReplaceText, {ListeDeColonnes}) pour cibler une ou plusieurs colonnes.
• Séries de remplacements: Text.ReplaceEach(text, {{"é","e"},{"à","a"}}) pour chaîner plusieurs substitutions, pratique pour désaccentuer avant une comparaison.

Pour la gestion fine de la casse et des accents, utilisez les comparers intégrés: Comparer.Ordinal, Comparer.OrdinalIgnoreCase ou Comparer.FromCulture. Exemple: Text.Contains([Desc], "ref", Comparer.OrdinalIgnoreCase) ignore la casse. ([learn.microsoft.com](https://learn.microsoft.com/mt-mt/powerquery-m/text-contains?utm_source=openai))

Comment concaténer et formater des colonnes texte ?

Pour assembler des morceaux, Text.Combine({[Prénom], [Nom]}, " ") joint une liste de valeurs avec un séparateur. Pour produire des libellés plus élaborés, Text.Format remplace des espaces réservés dans un gabarit: Text.Format("#{0}, #{1}", {Text.Proper([Ville]), Text.Upper([Pays])}) ou avec noms de champs Text.Format("Né à #[Ville] en #[Année]", [Ville=[Ville], Année=[Année]]), avec culture optionnelle pour les formats locaux. Enrichissez au besoin avec des concaténations conditionnelles: if [Code] <> null then Text.Combine({[Code], [Libellé]}, " - ") else [Libellé]. ([learn.microsoft.com](https://learn.microsoft.com/en-gb/powerquery-m/text-functions?utm_source=openai))

Les formules de transformation de dates

Pour manipuler facilement les données temporelles dans Power Query, utilisez les fonctions du langage M dédiées aux dates, heures et fuseaux. Elles permettent de convertir, typer, calculer des périodes et enrichir vos modèles avec des composants utiles.

• Conversions et typage fiable des colonnes date, datetime et datetimezone.
• Calculs de délais et d’âges robustes avec les fonctions Date.* et Duration.*.
• Extraction de composants clés pour le reporting, comme l’année, le mois, le jour ou l’heure.
• Gestion d’un calendrier fiscal personnalisé en joignant une table calendrier.

Comment convertir et typer correctement les dates ?

Le bon réflexe consiste à forcer le type et à sécuriser la conversion. Préférez les fonctions Date.From, DateTime.From et DateTimeZone.From plutôt que des transformations implicites. En présence de textes hétérogènes, utilisez les variantes *.FromText avec la culture adéquate (par exemple "fr-FR"). En cas de valeurs invalides, gérez les erreurs et les null pour éviter les ruptures de rafraîchissement.

Exemple pratique, conversion sécurisée d’une colonne texte en date, avec mise en type :

Besoin d’appliquer un fuseau horaire local à un horodatage UTC :

Comment effectuer des calculs de temps et de périodes ?

• Ajouter un décalage calendaire : Date.AddDays([Date], 7), Date.AddMonths([Date], 1), Date.AddYears([Date], 1).
• Calculer l’ancienneté ou un délai en jours via une durée : Duration.Days(Date.From(DateTime.LocalNow()) - [DateCommande]).
• Âge à partir d’une date de naissance : Date.Age([DateNaissance]) retourne une durée que vous convertissez selon le besoin.
• Convertir une durée en unités utiles : Duration.TotalDays(d), Duration.TotalHours(d), Duration.TotalMinutes(d), où d est une valeur de type duration.

Exemple complet, délai moyen de traitement entre réception et expédition, en jours :

Comment extraire des composants utiles de date/heure ?

• Année, mois, jour : Date.Year([Date]), Date.Month([Date]), Date.Day([Date]).
• Jour de la semaine et nom du jour : Date.DayOfWeek([Date], Day.Monday), Date.DayOfWeekName([Date], "fr-FR").
• Nom du mois : Date.MonthName([Date], "fr-FR").
• Heure, minute, seconde à partir d’un datetime : Time.Hour(Time.From([Horodatage])), Time.Minute(...), Time.Second(...).
• Périodes utiles au reporting : Date.StartOfMonth([Date]), Date.EndOfMonth([Date]), Date.WeekOfYear([Date], Day.Monday).

Astuce pratique, ajouter d’un coup plusieurs composants à partir d’une même colonne date :

Comment gérer un calendrier fiscal ou personnalisé ?

La méthode la plus robuste consiste à créer une table calendrier contenant toutes les dates et attributs métiers (exercice, période fiscale, semaine, trimestre), puis à l’associer à vos faits. Vous pouvez générer ce calendrier dans Power Query et le joindre par date.

Exemple, génération d’un calendrier, ajout d’un exercice fiscal commençant en juillet, puis mappage sur la table des ventes avec une jointure :

Alternative si vous disposez déjà d’un calendrier de référence dans une autre source, importez la table et utilisez simplement Table.NestedJoin puis développez les colonnes nécessaires. Cette approche garantit une définition unique et partageable de vos périodes fiscales.

Quelles formules pour transformer les nombres ?

Avec Power Query, la transformation numérique va au‑delà des calculs de base. Vous pouvez convertir et typer correctement vos colonnes, arrondir et formater selon les besoins métiers, agréger des valeurs pour produire des indicateurs, puis sécuriser l’ensemble avec une gestion robuste des null et des erreurs.

• Conversions et typage précis: Number.From, Int64.From, Decimal.From, colonnes « nullable ».
• Arrondis et formatage: Number.Round, Number.RoundUp, Number.RoundDown, Number.RoundAwayFromZero, distinction affichage vs stockage.
• Agrégations en M: fonctions List.* comme List.Sum, List.Average, List.Median, et usage via Table.Group.
• Gestion des valeurs nulles et exceptions: try … otherwise et valeurs par défaut pour éviter les ruptures de rafraîchissement.

Comment convertir et contrôler le typage numérique ?

Le langage M propose des fonctions de conversion sûres pour garantir la cohérence des colonnes numériques: Number.From pour un nombre générique, Int64.From pour un entier 64 bits, Decimal.From pour une précision décimale. Combinez-les avec des types explicites comme Int64.Type ou Decimal.Type, et utilisez des types nullable quand des valeurs vides sont possibles. En cas de texte à convertir, vous pouvez aussi recourir à la variante sensible à la culture, par exemple Number.FromText, si vous devez forcer une interprétation « 1,23 » en français.

Exemple simple, conversion robuste avec gestion d’erreurs et colonnes nullable:

Comment arrondir et formater proprement ?

Pensez à distinguer l’arrondi stocké dans la donnée et le format d’affichage. L’arrondi se fait dans Power Query avec les fonctions Number.Round, Number.RoundUp et Number.RoundDown, ou le mode « éloigner de zéro » via Number.RoundAwayFromZero. Le format d’affichage (séparateurs, symboles monétaires) est généralement appliqué plus tard côté rapport ou feuille Excel. Évitez de convertir en texte trop tôt, afin de conserver le caractère numérique pour les calculs.

Exemple de comparaison d’arrondis:

Comment agréger des valeurs en M ?

En M, les agrégations se font sur des listes: List.Sum, List.Average, List.Median, List.Min, List.Max, List.Count… Pour des tableaux, utilisez Table.Group afin de regrouper par une ou plusieurs clés et calculer plusieurs mesures en une seule étape.

• Somme d’une colonne: List.Sum(Table.Column(#"Étape", "Montant"))
• Moyenne robuste: List.Average(List.RemoveNulls([Montant]))
• Par groupe, plusieurs agrégats en parallèle avec Table.Group.

Comment traiter les valeurs nulles et exceptions ?

Des erreurs de conversion ou des zéros divisions peuvent interrompre le rafraîchissement. Enveloppez les expressions risquées dans try … otherwise, remplacez par une valeur par défaut ou par null, et privilégiez les types nullable là où c’est pertinent. Pour les agrégations, retirez les null avant calcul avec List.RemoveNulls.

Exemple pratique, calcul d’un PrixNet robuste et typé:

Quelles formules de recherche et de filtre ?

Recherche et filtrage n’ont pas le même but dans Power Query. La recherche sert à tester une présence ou à localiser une valeur (dans un texte, une liste ou une table). Le filtrage sert à retenir ou exclure des lignes en fonction d’un ou plusieurs critères.

• Recherche : contrôle rapide, par exemple « ce libellé contient-il tel mot clé ? » ou « ce code figure-t‑il dans ma liste de référence ? ».
• Filtre : sélection de lignes, par exemple « ne garder que les commandes supérieures à 1 000, non annulées, du mois courant ».

Comment filtrer des lignes de table de façon performante ?

En M, le filtre se fait avec Table.SelectRows et un prédicat qui renvoie vrai ou faux pour chaque ligne. La performance dépend de la simplicité des tests et de l’ordre des étapes, ce qui favorise le query folding quand la source le permet.

1. Définir les types d’abord avec Table.TransformColumnTypes pour comparer des nombres avec des nombres et des dates avec des dates.
2. Écrire des prédicats simples et relationnels : =, <>, >=, and, or.
3. Chaîner les filtres les plus restrictifs en premier pour réduire le volume très tôt.
4. Éviter les étapes non repliables avant le filtre (certaines transformations complexes cassent le folding). Contrôlez « Afficher la requête native » dans l’éditeur.
5. Utiliser des listes mises en mémoire pour les inclusions/exclusions fréquentes : List.Buffer sur de petites listes. Évitez Table.Buffer trop tôt, qui peut empêcher le folding.

Comment rechercher dans du texte ou des listes ?

• Text.Contains : vérifie si un texte contient un motif. Peut accepter un comparer pour ignorer la casse ou tenir compte de la culture.
• Text.StartsWith / Text.EndsWith : contrôles rapides de début/fin de chaîne.
• List.Contains : teste la présence d’une valeur dans une liste.
• List.PositionOf : renvoie l’index d’une valeur dans une liste, utile pour des règles par priorité.

Comment écrire des filtres avancés avec each et fonctions anonymes ?

Le prédicat passé à Table.SelectRows est souvent une fonction anonyme each .... Pour des règles plus riches, il est pratique de définir des fonctions nommées réutilisables, de capturer des variables (closures) et de composer les tests.

Comment gérer la casse, les accents et les correspondances partielles ?

Pour fiabiliser les recherches, normalisez vos données avant les contrôles, puis utilisez un comparer adapté.

• Uniformiser la casse : Text.Lower ou Text.Upper sur les colonnes de texte que vous interrogez.
• Gérer les accents : créez une fonction de « désaccentuation » simple par remplacements ciblés, ou bien travaillez avec des colonnes déjà normalisées côté source.
• Comparer selon une culture : les fonctions Text.* acceptent un comparer, par exemple Comparer.FromCulture("fr-FR", true) pour ignorer la casse en contexte francophone.
• Préparer une colonne normalisée pour toutes les recherches répétées, afin d’éviter de recalculer à chaque filtre.

Quelles formules de fusion et de jointure ?

Pour combiner des données issues de plusieurs tables ou sources, Power Query propose la fusion par jointure, accessible dans l’interface « Fusionner des requêtes » et en langage M via les fonctions Table.Join et Table.NestedJoin. La fusion permet d’enrichir une table avec des colonnes d’une autre selon des clés d’appariement. À ne pas confondre avec l’ajout de lignes (append) réalisé par Table.Combine.

Quels sont les types de jointure et quand les utiliser ?

Selon le besoin, choisissez le type de jointure et la fonction adaptée. Table.Join renvoie une table déjà « aplatie », Table.NestedJoin renvoie une colonne de tables imbriquées que l’on peut ensuite étendre.

Type	Résultat	Quand l’utiliser	Implémentation M
Inner	Conserve uniquement les lignes avec correspondance des deux côtés	Contrôler l’intersection stricte de deux tables	Table.Join/NestedJoin avec JoinKind.Inner
Left Outer	Toutes les lignes de gauche, infos de droite si trouvées	Enrichir une table principale sans perdre de lignes	JoinKind.LeftOuter
Right Outer	Toutes les lignes de droite, infos de gauche si trouvées	Symétrique de Left si la table de référence est à droite	JoinKind.RightOuter
Full Outer	Toutes les lignes des deux tables	Comparer des référentiels ou auditer les écarts	JoinKind.FullOuter
Left Anti	Lignes de gauche sans aucune correspondance à droite	Détecter les « manquants » de la table de droite	JoinKind.LeftAnti
Right Anti	Lignes de droite sans correspondance à gauche	Détecter les « manquants » côté gauche	JoinKind.RightAnti
Left Semi	Lignes de gauche qui ont au moins une correspondance, sans colonnes de droite	Filtrer la table de gauche par existence dans la droite	Table.NestedJoin, puis filtrer sur lignes où la table imbriquée n’est pas vide
Right Semi	Lignes de droite qui ont au moins une correspondance, sans colonnes de gauche	Filtrer la table de droite par existence dans la gauche	Table.NestedJoin dans l’autre sens, puis même filtrage

Exemple simple en M avec Left Outer et extension ciblée:

Comment gérer des clés composées et les normaliser ?

• Typage identique des colonnes clés des deux côtés: appliquez le même type (texte, nombre, date) avant la fusion.
• Nettoyage minimal: supprimer les espaces en début et fin (Text.Trim), uniformiser la casse (Text.Upper ou Text.Lower), harmoniser les formats de date et de nombre.
• Clés composées sans colonne dédiée:
  • Dans l’interface, sélectionnez plusieurs colonnes clés dans le même ordre des deux tables.
  • Ou créez une clé composite robuste:

  Cas concret: pour apparier des ventes sur Pays, Ville et Date, normalisez Pays et Ville en majuscules sans espaces superflus, transformez la Date en « yyyy-MM-dd », puis fusionnez sur ces trois colonnes ou sur la clé composite « Cle » créée.

  Comment optimiser les fusions (folding, ordre des étapes) ?

  • Filtrer tôt: appliquez les filtres et ne gardez que les colonnes utiles avant la jointure pour réduire le volume traité.
  • Typer d’abord les clés: définissez le type des colonnes d’appariement avant la fusion pour éviter les conversions implicites coûteuses.
  • Préserver le query folding: privilégiez les étapes prises en charge par la source, évitez les opérations qui le cassent inutilement (fonctions de ligne complexes, Table.Buffer non nécessaire, étapes de tri coûteuses avant la fusion).
  • Ordre recommandé: import → typage → nettoyage → création de clé composite → sélection de colonnes → filtres → jointure → extension/agrégation → suppression des colonnes temporaires → renommage final.
  • Un-à-plusieurs: si une clé côté droit peut renvoyer plusieurs lignes, remplacez l’extension brute par une agrégation contrôlée avec Table.AggregateTableColumn pour éviter la duplication des lignes.
  • Requêtes de préparation: utilisez des requêtes « staging » pour centraliser le nettoyage d’une source et réutiliser le résultat dans plusieurs fusions.

  Astuce pratique: avec Table.NestedJoin, un « semi-join » efficace consiste à filtrer sur Table.RowCount([ColonneJoin]) > 0, puis à supprimer la colonne imbriquée si vous ne souhaitez garder que la table de gauche filtrée.

  Comment étendre et sélectionner efficacement les colonnes jointes ?

  • Sélectionnez uniquement les colonnes nécessaires au moment de l’extension pour limiter la largeur de la table.
  • Renommez proprement lors de l’extension pour éviter les collisions de noms: utilisez le paramètre des nouveaux noms dans Table.ExpandTableColumn pour ajouter un préfixe.
  • Supprimez les colonnes temporaires: clés composites, colonnes de travail, tables imbriquées non nécessaires après extension.
  • Gérez les relations 1‑N: si l’extension duplique les lignes de gauche, remplacez-la par Table.AggregateTableColumn (Somme, Max, Min, First, Count) avant l’extension.
  Se former à la Data et à l'IA

  Exemple d’extension avec préfixe et nettoyage:

  Se former à Power BI

  Les formules de tableaux croisés dynamiques

  Les tableaux croisés dynamiques sont couramment utilisés pour analyser des données dans Excel et Power BI. En Power Query, vous obtenez le même résultat en réorganisant vos tables avec le langage M : pivoter, dépivoter, puis regrouper et agréger. Les fonctions clés sont Table.Pivot, Table.Unpivot et Table.Group avec des agrégateurs comme List.Sum, List.Average ou un décompte distinct via List.Count(List.Distinct(...)). Ceci permet par exemple de créer un tableau des ventes par région, de repasser en format long pour des modèles analytiques, puis d’obtenir des KPIs agrégés par groupe.

  Comment pivoter et dépivoter (Table.Pivot / Table.Unpivot) ?

  On parle de format « long » quand une colonne contient les catégories, et de format « large » quand chaque catégorie devient une colonne. Table.Pivot transforme un format long en large, avec un agrégateur pour gérer d’éventuels doublons. À l’inverse, Table.Unpivot et Table.UnpivotOtherColumns convertissent un format large en long, idéal pour normaliser les données avant un modèle ou des visuels.

  Exemple court : vous avez une table Ventes avec Produit, Mois, Ventes en format long. Pour créer une table « large » avec un total par mois en colonnes :

  Pour revenir en format long en conservant la colonne Produit comme clé :

  Comment regrouper et agréger (Table.Group, List.Sum) ?

  • Somme par groupe : {"Ventes totales", each List.Sum([Ventes]), type number}
  • Moyenne par groupe : {"Vente moyenne", each List.Average([Ventes]), type number}
  • Décompte distinct d’un attribut : {"Produits distincts", each List.Count(List.Distinct([Produit])), Int64.Type}
  • Autres exemples utiles : List.Min, List.Max, List.NonNullCount, ou des mesures personnalisées avec each ....

  Exemple d’agrégations multiples par Région :

  Quand utiliser Table.Transpose pour réorienter les données ?

  Table.Transpose échange lignes et colonnes, sans agrégation et sans logique de catégories. C’est utile pour corriger une orientation « tableur » mal fichue, par exemple transformer une seule ligne d’attributs en entêtes de colonnes, puis appliquer Table.PromoteHeaders. En revanche, pour créer un tableau croisé avec totaux par catégorie, privilégiez Table.Pivot. Limites : Table.Transpose suppose un tableau rectangulaire cohérent, ne gère pas les doublons et peut faire perdre des noms de colonnes si l’on ne promeut pas les en-têtes au bon moment.

  Cas concret : vous recevez un petit tableau où les mois sont en lignes et les mesures en colonnes, mais vous avez besoin des mois en colonnes. Une simple transposition suivie d’une promotion des en-têtes suffit, sans passer par pivot ou agrégations.

  Un mini-exemple de bout en bout pour pivoter/dépivoter ?

  1. Source longue : colonnes Région, Canal, Mois, Produit, Ventes.
  2. Pivoter par Mois pour obtenir un tableau « large » des ventes mensuelles.
  3. Dépivoter pour revenir en format long standardisé.
  4. Regrouper par Région et calculer plusieurs agrégations : somme, moyenne, distinct count.
  Maîtriser pivot, unpivot et regroupements en Power Query

  Comment utiliser les formules Power Query ?

  

  Ouvrez l’éditeur Power Query depuis Excel ou Power BI, connectez votre source puis appliquez des transformations. L’interface enregistre chaque action dans la liste « Étapes appliquées », et génère le code M correspondant. Vous pouvez travailler en mode 100 % interface, ou affiner vos expressions en M pour aller plus loin et standardiser vos transformations.

  Où saisir une formule : barre de formule ou Éditeur avancé ?

  Trois points d’entrée pour écrire ou modifier du M, avec une traçabilité complète via « Étapes appliquées » :

  • Barre de formule (Affichage, activer « Barre de formule») : modifie l’expression de l’étape sélectionnée, idéal pour de petits ajustements rapides.
  • Colonne personnalisée ou autres boîtes de dialogue de l’interface : vous écrivez l’expression dans un champ prévu, Power Query crée automatiquement l’étape et son code M.
  • Éditeur avancé : affiche tout le script let … in de la requête pour insérer, réordonner, renommer ou factoriser des étapes.

  Bonnes pratiques :

  • Renommez les étapes clés pour la lisibilité.
  • Commentez dans l’Éditeur avancé avec // si nécessaire.
  • Préférez l’interface pour les opérations standard, puis finalisez les détails dans la barre de formule.

  Comment créer une colonne personnalisée ?

  1. Onglet Ajouter une colonne, choisir Colonne personnalisée.
  2. Saisir l’expression M en référencant les champs avec [NomDeColonne] (exemple : [CA HT] * 1.2).
  3. Valider, puis définir le type de la nouvelle colonne si besoin.

  Alternative sans code : Colonne à partir d’exemples apprend à partir de valeurs que vous tapez. Idéal pour des découpes de texte simples. Pour des règles stables et réutilisables, privilégiez une expression M explicite.

  Exemple M généré par l’interface :

  Table.AddColumn(#"Type modifié", "CA TTC", each [CA HT] * 1.2, type number)

  Conseils :

  • Nommez clairement les nouvelles colonnes.
  • Fixez les types tôt dans le flux pour éviter des erreurs de conversion plus loin.
  • Évitez les dépendances implicites, préférez des calculs simples et testables.

  Comment référencer étapes, colonnes et types sans erreur ?

  Étapes : une étape est une valeur nommée dans le bloc let. Si son nom contient des espaces ou des accents, entourez-le avec #"" : #"Étape précédente".

  Colonnes :

  • Dans un contexte « ligne » (par exemple each …) utilisez [NomCol] pour la valeur de la ligne courante.
  • Hors contexte ligne, #"Étape précédente"[NomCol] renvoie la liste de la colonne.

  Types : utilisez les annotations de type M pour fiabiliser vos transformations, par exemple type text, type number, Int64.Type, type date.

  Exemples :

  Table.TransformColumns(#"Type modifié", {{"Nom", Text.Upper, type text}})
Table.TransformColumns(#"Type modifié", {{"Date", Date.Year, Int64.Type}})

  Comment créer et utiliser une fonction personnalisée réutilisable ?

  1. Définir la fonction dans une requête vierge, avec paramètres et types.
  2. Désactiver le chargement de cette requête de fonction pour ne pas l’ajouter au modèle.
  3. Invoquer la fonction dans d’autres requêtes via l’interface « Invoker une fonction personnalisée » ou en M avec Table.AddColumn.

  Exemple :

  Invocation :

  Table.AddColumn(#"Source nettoyée", "Nom propre", each fxNettoieTexte([Nom]), type text)

  Modularisez vos règles métier dans des fonctions dédiées, testez-les isolément, puis réutilisez-les partout.

  Comment gérer les erreurs avec try … otherwise ?

  Problème : conversions qui échouent, divisions par zéro, recherches manquantes. Sans garde-fou, votre étape renvoie une erreur bloquante.

  Solution : encapsuler l’expression risquée avec try … otherwise pour fournir une valeur de secours.

  Exemples :

  Table.AddColumn(#"Type modifié", "Montant", each try Number.FromText([MontantTxt]) otherwise null, type number)
Table.AddColumn(#"Calcul", "Prix unitaire", each try [CA] / [Qté] otherwise 0, type number)

  Comment diagnostiquer et tester vos étapes ?

  • Aperçus intermédiaires : sélectionnez une étape pour voir l’état exact des données à ce point.
  • Isoler une sous-expression : créez temporairement une colonne calculant uniquement la partie complexe, ou introduisez une variable intermédiaire dans let.
  • Profil de colonnes (qualité, distribution, profil) pour repérer valeurs nulles, extrêmes et types incohérents.
  • Échantillonnage : « Garder les premières lignes » pendant vos tests, puis supprimez cette étape avant production.
  • Diagnostics de performances (Power BI Desktop) pour mesurer le coût des étapes et identifier les goulots d’étranglement.

  Pratique : introduisez tôt les filtres sélectifs et les projections de colonnes utiles, vous réduirez le volume traité aux étapes suivantes.

  Évaluation, ordre des étapes et query folding, que faut-il savoir ?

  Les requêtes M s’évaluent via un bloc let … in où chaque étape dépend de la précédente. L’optimisation majeure vient du query folding : quand c’est possible, Power Query traduit vos transformations en instructions exécutées par la source (SQL, etc.). Cela réduit fortement les temps de traitement.

  Repères et conseils :

  • Afficher la requête native sur une étape (clic droit) disponible signifie que le folding est encore actif à ce point.
  • Appliquez d’abord les opérations qui se plient bien côté source : filtres, sélections de colonnes, agrégations simples.
  • Évitez d’insérer trop tôt des étapes qui cassent le folding, par exemple index, colonnes par exemple, fonctions personnalisées ligne par ligne avant les filtres.
  • Regroupez les changements de type dans une même étape pour limiter le coût.

  Paramètres et requêtes paramétrées : à quoi servent-ils ?

  Les paramètres rendent vos requêtes dynamiques sans dupliquer le code : chemins de fichiers, URL d’API, dates de bornage, seuils métiers. Créez-les dans « Gérer les paramètres », puis utilisez-les dans vos étapes (Source, filtres, calculs).

  Cas concret :

  Table.SelectRows(#"Type modifié", each [Montant] >= ParamSeuil)
Date.From([DateVente]) >= ParamDateDebut

  Vous déployez ainsi la même requête sur plusieurs environnements ou périodes, avec seulement les valeurs de paramètres à changer.

  Exemples pratiques de formules M

  Avec Power Query, les utilisateurs d’Excel et Power BI peuvent transformer, nettoyer, combiner et interroger les données issues de multiples sources. Voici 6 recettes rapides pour ancrer les concepts et passer à l’action.

  • Dédoublonner sur plusieurs colonnes: Table.Distinct(Source, {"ClientID","Produit","Date"})
  • Éclater une liste en lignes: Table.ExpandListColumn(Table.TransformColumns(Source, {"Tags", each Text.Split(_, ";")}), "Tags")
  • Extraire le domaine d’un email: Table.AddColumn(Clean, "Domaine", each Text.AfterDelimiter([Email], "@"))
  • Fusionner tous les fichiers d’un dossier: Table.Combine(List.Transform(Tables[Data], each Table.SelectColumns(_, AllCols, MissingField.UseNull)))
  • Filtrer sur plusieurs mots-clés: Table.SelectRows(Source, each List.AnyTrue(List.Transform(Mots, (m) => Text.Contains([Texte], m, Comparer.OrdinalIgnoreCase))))
  • Calculer l’âge depuis la date de naissance: Number.RoundDown(Duration.Days(Date.Age(Date.From([Naissance]))) / 365.25)

  Comment dédupliquer sur plusieurs colonnes ?

  1. Si les doublons doivent être évalués sur un sous-ensemble de colonnes, utilisez directement Table.Distinct avec la liste de colonnes.
  2. Si vous devez contrôler quelle ligne garder par groupe, regroupez puis conservez le premier enregistrement.

  Exemple simple avec Table.Distinct:

  Variante avec Table.Group pour garder la première ligne de chaque groupe:

  Comment éclater une colonne Liste en lignes ?

  Lorsque des valeurs multiples sont stockées dans une même cellule sous forme de texte séparé par un délimiteur, convertissez d’abord en liste puis dépliez.

  Exemple pratique avec une colonne Tags contenant des valeurs séparées par « ; »:

  Comment extraire le domaine d’un email ?

  Nettoyez le texte, basculez en minuscules pour homogénéiser, puis récupérez ce qui suit le caractère @.

  • Nettoyage préalable: Text.Trim pour les espaces, Text.Lower pour la casse.
  • Extraction: Text.AfterDelimiter avec le délimiteur "@".

  Exemple:

  Comment fusionner automatiquement tous les fichiers d’un dossier ?

  1. Listez les fichiers avec Folder.Files puis filtrez l’extension souhaitée.
  2. Créez une fonction d’import qui retourne une table par fichier.
  3. Unifiez les schémas, puis combinez toutes les tables.

  Cas concret avec des CSV à en-têtes variables:

  Comment filtrer sur plusieurs mots-clés à la fois ?

  Créez une liste de termes, testez la présence de chaque terme dans le texte, et gardez la ligne si au moins un terme matche.

  Exemple:

  Comment calculer l’âge à partir d’une date de naissance ?

  Utilisez Date.Age pour obtenir une durée relative à la date du jour, convertissez en jours puis en années avec 365,25 pour tenir compte des années bissextiles, enfin arrondissez à l’inférieur.

  Exemple:

  Maîtriser Power BI

  Bonnes pratiques, performance et debug

  Objectif : centraliser des recommandations transverses pour des requêtes Power Query robustes, lisibles et rapides. En synthèse :

  • Soignez la lisibilité : étapes renommées, commentaires, factorisation via let…in et requêtes de référence.
  • Optimisez l’ordre des transformations pour conserver le query folding et réduire les données traitées localement.
  • Surveillez en continu le folding et diagnostiquez les goulots avec les indicateurs et les outils intégrés.
  • Mutualisez et versionnez via paramètres, fonctions personnalisées et modules réutilisables.

  Comment nommer les étapes et structurer le code pour la lisibilité ?

  • Renommez chaque étape côté « Étapes appliquées » avec un verbe et un objet, par exemple : 01_Source_SQL, 02_Filtres, 03_Types, 04_Join_Clients, 05_Colonnes_calculées, 99_Sortie. Cela facilite la relecture et le debug.
  • Ajoutez des commentaires dans la barre de formule avec // pour expliquer les choix non évidents ou les compromis de performance.
  • Factorisez les expressions communes dans un bloc let…in, et séparez les sous-pipelines en « requêtes de référence » (Reference) plutôt que de dupliquer du code.
  • Adoptez des conventions de nommage cohérentes pour les colonnes et les paramètres, en rappelant que M est sensible à la casse et de nature fonctionnelle. ([learn.microsoft.com.mcas.ms](https://learn.microsoft.com.mcas.ms/en-us/powerquery-m/?utm_source=openai))
  • Limitez les étapes « fourre-tout » : préférez plusieurs petites transformations nommées à une unique formule complexe difficile à auditer.

  Exemple de structuration lisible avec let…in : définir une source, appliquer des filtres, normaliser les types, puis exposer clairement le résultat final dans in. Cette approche suit le modèle d’évaluation de M et rend les dépendances explicites. ([learn.microsoft.com.mcas.ms](https://learn.microsoft.com.mcas.ms/en-us/powerquery-m/?utm_source=openai))

  Comment ordonner filtres, types et jointures pour gagner en performance ?

  1. Filtres le plus tôt possible : réduisez le volume en amont pour que la source exécute la sélection quand c’est possible, ce qui favorise le query folding. ([learn.microsoft.com](https://learn.microsoft.com/fr-fr/power-query/query-folding-basics?utm_source=openai))
  2. Typage juste après les filtres : définissez les types de colonnes avant les jointures pour éviter des conversions locales coûteuses et permettre des correspondances et comparaisons côté source. ([learn.microsoft.com](https://learn.microsoft.com/en-us/power-bi/guidance/power-query-folding?utm_source=openai))
  3. Jointures ensuite : effectuez les merges quand les clés sont correctement typées et idéalement issues de la même source relationnelle. ([learn.microsoft.com](https://learn.microsoft.com/en-us/power-bi/guidance/power-query-folding?utm_source=openai))
  4. Colonnes calculées et enrichissements : placez-les après les opérations massives. Quand une transformation ne peut pas se plier, mettez-la le plus tard possible. ([learn.microsoft.com](https://learn.microsoft.com/en-us/power-bi/guidance/power-query-folding?utm_source=openai))
  5. Tri, agrégation, top N : gardez ces étapes en fin de pipeline, sauf si vous pouvez les exprimer nativement dans la source. ([learn.microsoft.com](https://learn.microsoft.com/en-us/power-bi/guidance/power-query-folding?utm_source=openai))
  6. Choix du connecteur : privilégiez un connecteur natif (ex. SQL Server plutôt qu’ODBC) pour maximiser le folding. ([learn.microsoft.com](https://learn.microsoft.com/power-query/best-practices?utm_source=openai))

  Quelles opérations cassent le query folding et comment les éviter ?

  Le query folding délègue à la source les transformations traduisibles dans son langage natif. Il est dépendant du connecteur et des étapes, et doit être vérifié au dernier maillon avec les « indicateurs de pliage » et « Afficher la requête native ». ([learn.microsoft.com](https://learn.microsoft.com/fr-fr/power-query/query-folding-basics?utm_source=openai))

  Opération à risque	Fonction/étape M typique	Impact sur le folding	Alternative côté source ou contournement
  Mise en mémoire locale	Table.Buffer	Rompt le folding pour toutes les étapes suivantes	Éviter par défaut ; sinon, placer très tard. Si l’objectif est uniquement de couper le folding, utiliser Table.StopFolding. ([learn.microsoft.com](https://learn.microsoft.com/en-my/powerquery-m/table-buffer?utm_source=openai))
  Rupture volontaire du folding	Table.StopFolding	Empêche explicitement tout folding en aval	N’utiliser qu’en dernier recours et en fin de pipeline, après avoir poussé un maximum de traitements à la source. ([learn.microsoft.com](https://learn.microsoft.com/en-us/powerquery-m/table-stopfolding?utm_source=openai))
  Requête SQL écrite manuellement	Value.NativeQuery	Sans précaution, les étapes suivantes ne se plient pas	Employer Value.NativeQuery avec EnableFolding=true et des paramètres, puis vérifier les indicateurs de pliage sur la dernière étape. Attention : l’incrémental ne supporte pas la requête SQL native. ([learn.microsoft.com](https://learn.microsoft.com/en-us/power-query/native-query-folding?utm_source=openai))
  Combiner des sources hétérogènes	Merge/Append entre SQL et fichiers plats	Pas de folding à travers plusieurs sources, traitement local	Rapprocher les données dans la même source ou un dataflow, puis joindre ; choisir des connecteurs offrant le folding. ([learn.microsoft.com](https://learn.microsoft.com/fr-fr/power-query/query-folding-basics?utm_source=openai))
  Garder N dernières lignes	Keep bottom rows	Souvent évalué côté moteur Power Query, non pliable	Exprimer l’équivalent côté source (fenêtres, ORDER BY/TOP) ou placer cette étape en fin de chaîne. ([learn.microsoft.com](https://learn.microsoft.com/vi-vn/power-query/query-folding-examples?utm_source=openai))
  Fonctions personnalisées ligne à ligne	Custom function + Table.AddColumn	Peuvent empêcher le folding selon la logique et le connecteur	Traduire en vue SQL/ETL ou appliquer en fin de pipeline si non pliable. ([mssqltips.com](https://www.mssqltips.com/sqlservertip/3635/query-folding-in-power-query-to-improve-performance/?utm_source=openai))

  Bon réflexe : activez les indicateurs de pliage et contrôlez systématiquement le dernier step de chaque requête avant publication. ([learn.microsoft.com](https://learn.microsoft.com/en-us/power-query/step-folding-indicators?utm_source=openai))

  Comment versionner et réutiliser vos requêtes et fonctions ?

  • Mutualisez via des « requêtes de référence » : créez une requête Source unique, puis référencez-la pour bâtir plusieurs dérivés spécialisés. Cela évite la duplication et simplifie le versioning.
  • Paramétrez ce qui varie : introduisez des paramètres (dates, environnements, seuils, URL) pour adapter vos requêtes sans les modifier. Les paramètres peuvent aussi alimenter des fonctions réutilisables. ([learn.microsoft.com](https://learn.microsoft.com/en-us/power-query/power-query-query-parameters?utm_source=openai))
  • Encapsulez la logique récurrente dans des fonctions personnalisées et regroupez-les dans un module dédié. Documentez les signatures et les attentes de type. ([learn.microsoft.com](https://learn.microsoft.com/en-us/power-query/custom-function?utm_source=openai))
  • Outillage de debug : utilisez Query Diagnostics pour repérer les étapes coûteuses et confirmer où s’effectue le traitement, puis ajustez l’ordre des étapes pour restaurer le folding. ([learn.microsoft.com](https://learn.microsoft.com/en-us/power-query/query-diagnostics?utm_source=openai))
  • Traçabilité : consignez dans les commentaires le « point de rupture » de folding et la raison (ex. contrainte métier), afin de garder le contexte lors des évolutions futures. ([learn.microsoft.com](https://learn.microsoft.com/en-us/power-bi/guidance/power-query-folding?utm_source=openai))
  Découvrir le métier de Power BI

  Conclusion : les formules M étendent le champ des possibles de Power Query

  L’interface de Power Query suffit pour de nombreux besoins, mais le langage M élargit réellement le périmètre des transformations possibles. Fonctionnel et sensible à la casse, il s’appuie sur des structures claires (tables, colonnes, listes, enregistrements, fonctions) et sur une syntaxe lisible avec let … in. En combinant ces briques et la bibliothèque standard, vous allez bien au‑delà des options de l’éditeur graphique pour répondre à des cas avancés ou paramétrables.

  • Structures et syntaxe utiles : maîtrisez les familles de fonctions M (Table.*, List.*, Record.*, Text.*, Date.*, DateTime.*, Duration.*, Number.*, Function.*), la portée des variables avec let … in, ainsi que les expressions if … then … else pour bâtir des requêtes claires et réutilisables.
  • Qualité et lisibilité : typage des colonnes le plus tôt possible, normalisation des formats de dates et de textes, renommage explicite des étapes, commentaires sur les transformations complexes, et vérification régulière de la qualité des colonnes.
  • Robustesse : gérez les cas limites avec try … otherwise, préférez les colonnes conditionnelles et les fonctions natives plutôt que des traitements manuels après chargement, et paramétrez les sources pour faciliter la maintenance.
  • Performance : filtrez et réduisez les colonnes en amont, évitez les opérations coûteuses répétées, et regroupez les transformations par nature pour simplifier le pipeline.
  • Pour aller plus loin : explorez la bibliothèque de fonctions M pour découvrir des capacités rarement exposées par l’interface (fusion, pivot/dépivot, agrégations, opérations sur listes) et affinez vos scripts dans l’éditeur avancé.

  En bref, la combinaison des bonnes pratiques, d’une syntaxe M maîtrisée et de la bibliothèque de fonctions fait de Power Query un véritable moteur ETL, précis et durable pour vos projets Excel et Power BI.

  S’inscrire à la formation Power BI

  Vous savez tout sur les formules Power Query. Pour approfondir, consultez la bibliothèque de fonctions M dans la documentation et découvrez aussi notre guide complet sur Power Query et notre dossier consacré à Power BI.