Notion et ses formules (débutant à expert)
Formule Notion et Javascript
Les formules Notion permettent d’effectuer toutes sortes de calculs et de fonctions basés sur d’autres propriétés.
En fait, le langage des formules de Notion s’inspire de JavaScript. Par exemple, il est possible de créer des variables locales avec let, exactement comme en JavaScript. On peut aussi utiliser la dot notation pour accéder aux sous-champs d’une propriété (ex. prop("Created By").name() renvoie le nom complet d’une personne). Bref, écrire une formule Notion, c’est un peu comme écrire du code JavaScript simplifié.
Type de données
Les formules supportent presque tous les types de propriétés d’une base de données. Concrètement, on peut manipuler du texte, des nombres, des dates, des booléens (cases à cocher), ou des listes (multi-sélection, relations).
Par exemple, un champ multisélection apparaît comme une liste dans la formule, sur laquelle on peut faire length() pour obtenir le nombre de valeurs dans la liste ou includes() permet de savoir si une valeur est présente dans la liste. Une case à cocher devient un booléen (vrai/faux).
Voici les types de données disponibles :
- Texte : propriétés Titre ou Texte (chaînes de caractères). On peut les concaténer, extraire des sous-chaînes, etc.
- Nombre : propriétés numériques (opérations +, -, ×, ÷, etc.).
- Date : propriétés date/heure (fonctions dédiées pour ajouter/j, comparer, formater, etc.).
- Booléen : case à cocher (donné vrai ou faux directement utilisable).
- Listes (ou array) : multi-sélection ou relation (traitées comme des listes dans les formules), manipulables avec des fonctions de listes.
Résumé des formules
| Fonction | Type | Définition | Exemple |
|---|---|---|---|
prop("X") |
Référence propriété | Récupère la valeur d’une propriété/colonne nommée X. Il est possible de récupérer le nom ou l’adresse mail d’un propriété ‘Person’ | prop("Montant") prop(”Person”).name |
let(name, expr, return) |
Contrôle / variable locale | Définit une variable locale name = expr, puis évalue return. Utile pour rendre les formules lisibles. |
let(x, prop("A") + prop("B"), x * 0.2) |
if(condition, trueValue, falseValue) |
Conditionnelle | Retourne trueValue si condition est vraie, sinon falseValue. |
if(prop("Score") > 50, "OK", "Revoir") |
format(value) |
Conversion / texte | Convertit value en chaîne de caractères (texte). |
"Le CA est de " + format(prop("Montant")) |
toNumber(text) |
Conversion | Convertit une chaîne en nombre (si possible). | toNumber("42") → 42 |
now() |
Date/heure | Renvoie la date et heure actuelle. | now() → October 16, 2025 7:20 PM |
today() |
Date | Renvoie la date du jour. | today() → October 16, 2025 |
dateAdd(date, amount, "unit") |
Date | Ajoute amount (entier) d’unités ("days", "months", "years", "hours", "minutes", "weeks") à date. |
dateAdd(prop("Date"), 7, "days") |
dateSubtract(date, amount, "unit") |
Date | Soustrait du temps à date. |
dateSubtract(now(), 1, "months") |
dateBetween(d1, d2, "unit") |
Date | Calcule la différence entre d1 et d2 en unit (ex. "days"). |
dateBetween(prop("Fin"), prop("Début"), "days") |
formatDate(date, "format") |
Date → texte | Formate une date selon un motif (ex. "MMMM D, Y"). |
formatDate(prop("Date"), "YYYY-MM-DD") |
parseDate(text) |
Texte → date | Convertit une chaîne ISO en date. | parseDate("2025-10-16") |
+, -, *, /, % |
Nombres / opérateurs | Opérateurs arithmétiques de base. | prop("A") + prop("B") |
^ / pow(x,y) |
Mathématiques | Puissance : x élevé à la y. |
5 ^ 3 ou pow(5, 3) |
sum(...) |
Agrégat | Somme des arguments ou d’une liste. | sum(prop("A"), prop("B")) ou sum(1,2,3) |
min(...), max(...) |
Agrégat | Renvoie la plus petite / plus grande valeur. | min(prop("A"), prop("B")) |
mean(...), median(...) |
Statistiques | Moyenne / médiane d’arguments. | mean(2,4,6) |
round(x) |
Mathématiques | Arrondit x à l’entier le plus proche. |
round(prop("Prix")) |
abs(x) |
Mathématiques | Valeur absolue de x. |
abs(prop("Diff")) |
substring(text, start, end) |
Texte | Extrait une sous-chaîne de start (incl.) à end (excl.). |
substring(prop("Nom"), 0, 4) |
contains(text, "mot") |
Texte / recherche | Vérifie si text contient la sous-chaîne. |
contains(prop("Notes"), "urgent") |
lower(text), upper(text) |
Texte | Met le texte en minuscules / majuscules. | lower(prop("Tag")) |
join(list, sep) |
Liste ↔ Texte | Concatène les éléments d’une liste en une chaîne séparée par sep. |
join(prop("Tags"), ", ") |
split(text, sep) |
Texte ↔ Liste | Coupe text en liste selon sep. |
split(prop("ListeTexte"), ",") |
length(listOrText) |
Liste / Texte | Nombre d’éléments dans une liste ou caractères dans un texte. | length(prop("Tags")) |
first(list), last(list) |
Liste | Premier / dernier élément d’une liste. | first(prop("Participants")) |
slice(list, start, end) |
Liste | Extrait une sous-liste (comme substring). | slice(prop("Liste"), 0, 3) |
concat(l1, l2) |
Liste | Concatène deux listes. | concat(prop("ListeA"), prop("ListeB")) |
unique(list) |
Liste | Renvoie une liste sans doublons. | unique(prop("Choix")) |
includes(list, val) |
Liste | Vrai si val est présent dans list. |
includes(prop("Tags"), "Important") |
find(list, cond) |
Liste / recherche | Renvoie le premier élément qui satisfait cond. |
find(prop("Tâches"), t -> t.status == "done") (ici dans le tableau Tâches, il y a une colonne Status) |
filter(list, cond) |
Liste | Filtre la liste selon la condition cond. |
filter(prop("Tâches"), t -> t.priority == "High") |
map(list, expr) |
Liste / transformation | Applique expr à chaque élément et renvoie une nouvelle liste. Idéal pour modifier la structure d’une liste. Par exemple, vous pouvez filtrer sur les tâches en cours, puis obtenir le budget de ses tâches et enfin en faire la somme. |
map(prop("Produits"), p -> p.price) |
some(list, cond), every(list, cond) |
Liste / logique | some = au moins un élément satisfait cond; every = tous la satisfont. |
some(prop("Tâches"), t -> t.done) |
sort(list, key?), reverse(list) |
Liste | Trie la liste (optionnellement par clé) / inverse l’ordre. | sort(prop("Dates")) / reverse(prop("Historique")) |
at(list, index) |
Liste | Accède à l’élément à l’index (0-based ou support négatif selon version). | at(prop("Liste"), 0) |
flat(list) |
Liste | Aplati une liste de listes en une seule liste. | flat(prop("ListesDeTags")) |
Formules liées aux textes
Notion propose de nombreuses fonctions pour traiter du texte. On peut concaténer des chaînes avec l’opérateur +, extraire une partie de texte avec substring(), vérifier la présence d’une séquence avec contains(), etc. D’autres fonctions changent la casse (lower(), upper()), répètent du texte ou convertissent des valeurs en texte (format()). Parmi les fonctions utiles :
- Concaténation (
+) : relie deux chaînes ("Hello" + "World"donne"HelloWorld"). - Sous-chaîne (
substring) : ex.substring("Contact", 3, 5)→ “ta”. - Recherche de texte (
contains) : ex.contains(texte, "mot")→ renvoie vrai ou faux. - Casse (
lower/upper) :lower("NOTION")→"notion",upper("notion")→"NOTION". - Formatage (
format) : convertit n’importe quelle valeur en texte (ex.format(1234)→"1234",format(now())donne la date/heure sous forme de texte).
Formules liées aux dates
Notion inclut des fonctions spécialisées pour les dates. Par exemple, now() renvoie la date et l’heure actuelles (et today() la date du jour). On peut ajouter ou soustraire du temps à une date avec dateAdd(date, quantité, "unités") ou dateSubtract(...). On peut aussi calculer l’écart entre deux dates avec dateBetween(date1, date2, "unités") (ex. en jours ou mois). La fonction formatDate(date, "format") sert à formater une date (p. ex. "MMMM D, Y" pour "août 30, 2023"). Enfin, parseDate("YYYY-MM-DD") crée une date à partir d’une chaîne (standard ISO 8601).
- Date/Heure courante :
now(),today(). - Ajouter/soustraire du temps :
dateAdd(d, n, "unité"),dateSubtract(d, n, "unité"). - Différence :
dateBetween(d1, d2, "unités"). - Formatage de date :
formatDate(d, "format"). - Conversion depuis texte :
parseDate("2023-04-19").
Formules liées aux nombres
Les formules numériques couvrent les opérations de base et les fonctions mathématiques. On peut effectuer l’addition, la soustraction, la multiplication, la division, l’exponentiation (^). Notion fournit aussi sum(), min(), max(), median(), mean() pour regrouper des valeurs. D’autres fonctions utiles : round(x) (arrondi), abs(x) (valeur absolue), pow(x, y) ou l’opérateur ^ (puissance). Pour convertir un texte en nombre, on utilise toNumber(texte) (ex. toNumber("42") = 42).
- Opérations de base :
+,-,*,/,%,^(ex.5 + 10 = 15,5 ^ 3 = 125). - Sommes/agrégats :
sum(…),min(…),max(…)(ex.sum(1,2,3) = 6). - Statistiques :
median(…),mean(…). - Arrondi/absolu :
round(x),abs(x). - Convertir en nombre :
toNumber("23")(rend 23).
Formules liées aux tableaux
La version 2.0 des formules introduit des fonctions sur les listes. Une liste peut provenir d’une multi-sélection, d’un champ Personne ou Relation. On dispose par exemple de length(liste) pour la longueur, first(liste)/last(liste) pour le premier/dernier élément, et slice(liste, début, fin) pour extraire une sous-liste. On peut concaténer deux listes avec concat(l1, l2), trier avec sort(), inverser avec reverse(). Les fonctions join(liste, sep) et split(texte, sep) font la jonction entre texte et liste. D’autres outils : unique(liste) (valeurs uniques), includes(liste, val) (vérifie la présence), find(liste, cond), findIndex(liste, cond), filter(liste, cond), et les tests some(liste, cond), every(liste, cond). Enfin, map(liste, expr) et flat(liste) font appel à la programmation fonctionnelle sur les éléments.
- Longueur :
length(list). - Accès :
first(list),last(list),at(list, index). - Sous-listes :
slice(list, debut, fin),concat(l1, l2). - Tri et inversion :
sort(list),reverse(list). - Texte ⇄ Liste :
join(list, sep),split(text, sep). - Unique et inclusion :
unique(list),includes(list, val). - Recherche :
find(list, cond),findIndex,filter(list, cond). - Condition sur liste :
some(list, cond),every(list, cond). - Fonctions avancées :
map(list, expr),flat(list).