Le CEL (Common Expression Language) est un langage d’expression simple conçu par Google. Il est utilisé pour écrire des formules rapides, portables et sûres. Ce guide vous montre toutes les fonctions que vous pouvez utiliser lorsque vous écrivez des formules afin de créer des expressions puissantes.

Bon à savoir

Pour en savoir plus, consultez les ressources officielles :

• Spécification CEL
• Implémentation de CEL Go
• Définition du langage CEL

Opérations de base (Opérateurs)

Le tableau suivant montre les symboles de base que vous pouvez utiliser dans vos formules.

➡️ Pour en savoir plus, consultez les opérateurs CEL.

Fonctions disponibles

Conversion entre plusieurs types

Les fonctions suivantes vous permettent de changer les données d’un type à un autre.

➡️ Pour en savoir plus, consultez les conversions de type CEL.

bool() Convertir en true/false

Modifie un texte ou d’autres valeurs en true/false.

Par exemple :

bool(true)        // vous donne : true
bool("true")      // vous donne : true (convertit du texte en true/false)
bool("false")     // vous donne : false

bytes() Convertir en données binaires

Convertit les données en octets (format binaire brut). La plupart des utilisateurs n’en auront pas besoin.

Par exemple :

bytes(b'bonjour')   // vous donne : b'bonjour'
bytes("bonjour")    // vous donne : b'bonjour' (convertit du texte en données binaires)

double() Convertir en nombre décimal

Change des valeurs en nombres décimaux (nombres avec une virgule, comme 3,14).

Par exemple :

double(3,14)      // vous donne : 3,14
double(42)        // vous donne : 42,0 (ajoute la virgule décimale)
double("3,14")    // vous donne : 3,14 (convertit le texte en nombre)
double(100)       // vous donne : 100,0

int() Convertir en nombre entier

Transforme les valeurs en nombres entiers (sans décimales).

Par exemple :

int(42)                                 // vous donne : 42
int(3,14)                               // vous donne : 3 (retire ,14)
int(durée("1h"))                     // vous donne : 3600 (secondes dans 1 heure)
int("123")                              // vous donne : 123 (convertit le texte)
int(horodatage("2024-01-01T00:00:00Z"))  // vous donne : 1704067200

string() Convertir en texte

Transforme toute valeur en texte.

Par exemple :

string("bonjour")                         // vous donne : "bonjour"
string(true)                              // vous donne : "true"
string(3,14)                              // vous donne : "3,14"
   string(123)                            // vous donne : "123"
string(horodatage("2024-01-01T00:00:00Z")) // vous donne : "2024-01-01T00:00:00Z"

type() Découvrir quel est le type d'un élément

Vous indique quel type de données vous avez (texte, nombre, true/false, etc.).

Par exemple :

type(42)          // vous donne : int (type nombre entier)
type("bonjour")   // vous donne : string (type texte)
type(3,14)        // vous donne : double (type nombre décimal)
type(true)        // vous donne : bool (type true/false)

Travail avec les dates et heures

Les fonctions suivantes vous permettent de travailler avec des dates, des heures et des horodatages.

➡️ Pour en savoir plus, consultez les horodatages CEL.

timestamp() Créer ou convertir une date/heure

Crée une valeur de date et d’heure à partir de différentes sources.

Par exemple :

timestamp("2024-01-01T00:00:00Z")             // crée : 1er janvier 2024 à minuit
timestamp(1704067200)                         // crée : 2024-01-01T00:00:00Z

getFullYear() Obtenir l’année

Obtient l’année à partir d’une date (comme 2024).

Par exemple :

timestamp("2024-01-15T10:30:00Z").getFullYear()                      // vous donne : 2024
timestamp("2024-01-01T02:00:00Z").getFullYear("Amérique/New_York")   // vous donne : 2023 (soirée du 31 décembre)
createdAt.getFullYear()                                              // obtient une année à partir de createdAt

getMonth() Obtenir le mois

Obtient le mois à partir d’une date.

Par exemple :

horodatage("2024-03-15T10:30:00Z").getMonth()                        // vous donne : 2 (Mars est le 3ème mois)
horodatage("2024-03-01T02:00:00Z").getMonth("Amérique/New_York")     // vous donne : 1 (Février)
createdAt.getMonth()                                                // obtient un mois à partir de createdAt

// Rappelez-vous : janvier=0, février=1, mars=2, avril=3, mai=4, juin=5,
//           juillet=6, août=7, septembre=8, octobre=9, novembre=10, décembre=11

getDate() Obtenir le jour du mois

Obtient le jour du mois (du 1er au 31).

Par exemple :

horodatage("2024-03-15T10:30:00Z").getDate()                         // vous donne : 15 (le 15e jour)
horodatage("2024-03-01T02:00:00Z").getDate("Amérique/New_York")      // vous donne : 28 (28 février)
createdAt.getDate()                                                 // obtient le jour depuis createdAt

getDayOfWeek() Obtenir le jour de la semaine

Obtient le jour de la semaine.

Par exemple :

horodatage("2024-03-15T10:30:00Z").getDayOfWeek()                    // vous donne : 5 (vendredi)
horodatage("2024-03-17T02:00:00Z").getDayOfWeek("Amérique/New_York") // vous donne : 6 (samedi)

// Rappelez-vous : dimanche=0, lundi=1, mardi=2, mercredi=3,
//           jeudi=4, vendredi=5, samedi=6

getHours() Obtenir l’heure

Obtient l’heure à partir d’une heure (0-23, où 0 est minuit et 23 est 23h).

Par exemple :

horodatage("2024-03-15T14:30:00Z").getHours()                        // vous donne : 14 (14h30)
horodatage("2024-03-15T14:30:00Z").getHours("Amérique/New_York")     // vous donne : 10 (10:30 EST)
durée("2h30m").getHours()                                        // vous donne : 2 heures

getMinutes() Obtenir les minutes

Obtient les minutes d’une durée (0-59).

Par exemple :

horodatage("2024-03-15T14:45:00Z").getMinutes()                      // vous donne : 45 minutes
horodatage("2024-03-15T14:45:00Z").getMinutes("Amérique/New_York")   // vous donne : 45 minutes
durée("2h30m").getMinutes()                                      // vous donne : 150 (total des minutes)

getSeconds() Obtenir les secondes

Obtient les secondes d’une durée (0-59).

Par exemple :

horodatage("2024-03-15T14:45:30Z").getSeconds()                      // vous donne : 30 secondes
horodatage("2024-03-15T14:45:30Z").getSeconds("Amérique/New_York")   // vous donne : 30 secondes
durée("2h30m45s").getSeconds()                                   // vous donne : 9045 (total des secondes)

Travail avec des périodes de temps

Les fonctions suivantes vous permettent de créer et de travailler avec des durées (périodes de temps).

➡️ Pour en savoir plus, consultez les durées de CEL.

duration() Créer une période de temps

Crée une durée représentant une période de temps (pas une date spécifique).

Par exemple :

duration(3600)              // crée : 1 heure (3600 secondes)
duration("1h30m")           // crée : 1 heure et 30 minutes
duration("90s")             // crée : 90 secondes
duration("2h")              // crée : 2 heures

Format de la période de temps : Vous pouvez utiliser h pour les heures, m pour les minutes, s pour les secondes. Combinez-les comme ceci : "1h30m15s".

Fonctions textuelles

Les fonctions suivantes vous permettent de travailler avec du texte (chaînes de caractères).

➡️ Pour en savoir plus, consultez les fonctions de chaîne CEL.

contains() Vérifier si le texte contient quelque chose

Vérifie si un texte se trouve à l’intérieur d’un autre texte.

Par exemple :

"bonjour tout le monde".contains("monde")     // vous donne : true (je l’ai trouvé !)
"bonjour tout le monde".contains("xyz")       // vous donne : false (non trouvé)
statut.contains("actif")                      // vérifie si le statut contient "actif"
contact.email.contains("@")                   // vérifie si l'email contient le symbole @

startsWith() Vérifier si le texte commence par quelque chose

Vérifie si le texte commence par des caractères spécifiques.

Par exemple :

"bonjour tout le monde".startsWith("bonjour")           // vous donne : true
"bonjour tout le monde".startsWith("monde")             // vous donne : false (commence par "bonjour" et non par "monde")
contact.email.startsWith("admin")                       // vérifie si l’email commence par "admin"
statut.startsWith("en attente")                         // vérifie si le statut commence par "en attente"

endsWith() Vérifie si le texte se termine par quelque chose

Vérifie si le texte se termine par des caractères spécifiques.

Par exemple :

"bonjour tout le monde".endsWith("monde")               // vous donne : true
"bonjour tout le monde".endsWith("bonjour")             // vous donne : false (se termine par "monde" et non par "bonjour")
contact.email.endsWith("@exemple.com")                  // vérifie si le domaine email est @exemple.com
statut.endsWith("_approuvé")                            // vérifie si le statut se termine par "_approuvé"

matches() Vérifier si le texte correspond à un modèle

Vérifie si le texte correspond à un modèle (utilise des expressions régulières - fonctionnalité avancée).

Par exemple :

// Vérifiez si le texte ressemble à un email
"test@exemple.com".matches("^[a-zA-Z0-9+_.-]+@[a-zA-Z0-9.-]+$")    // vous donne : true
"pas-un-email".matches("^[a-zA-Z0-9+_.-]+@[a-zA-Z0-9.-]+$")        // vous donne : false

// Validez le format de l’email
contact.email.matches("^[a-z]+@[a-z]+\\.[a-z]+$")                   // vérifie le format de l’email

trim() Retirer des caractères des deux extrémités

Supprime certains caractères du début et de la fin du texte (comme la suppression des espaces).

Par exemple :

trim("  bonjour  ", " ")      // vous donne : "bonjour" (espaces supprimés)
trim("###test###", "#")       // vous donne : "test" (symboles # supprimés)
trim("___nom___", "_")        // vous donne : "nom" (traits de soulignement supprimés)
trim("000123000", "0")        // vous donne : "123" (zéros supprimés)

ltrim() Supprimer les caractères à partir de la gauche (début)

Supprime certains caractères uniquement au début du texte.

Par exemple :

ltrim("  bonjour  ", " ")     // vous donne : "bonjour  " (espaces supprimés à partir de la gauche)
ltrim("###test###", "#")      // vous donne : "test###" (# supprimés à partir de la gauche)
ltrim("000123", "0")          // vous donne : "123" (zéros supprimés à partir de la gauche)

rtrim() Supprimer les caractères à partir de la droite (fin)

Supprime certains caractères uniquement à la fin du texte.

Par exemple :

rtrim("  bonjour  ", " ")     // vous donne : "  bonjour" (espaces supprimés à partir de la droite)
rtrim("###test###", "#")      // vous donne : "###test" (# supprimés à partir de la droite)
rtrim("123000", "0")          // vous donne : "123" (zéros supprimés à partir de la droite)

Fonctions mathématiques

Les fonctions suivantes sont destinées aux calculs mathématiques.

➡️ Pour en savoir plus, consultez les fonctions numériques CEL.

abs() Obtenir une valeur absolue

Supprime le signe négatif d’un nombre (ce qui le rend positif).

Par exemple :

abs(-5)                     // vous donne : 5
abs(10)                     // vous donne : 10 (déjà positif)
abs(-100)                   // vous donne : 100
abs(0)                      // vous donne : 0

round() Arrondir au nombre entier le plus proche

Arrondit un nombre décimal au nombre entier le plus proche.

Par exemple :

round(3,7)                  // vous donne : 4 (arrondit au nombre supérieur)
round(3,2)                  // vous donne : 3 (arrondit au nombre inférieur)
round(3,5)                  // vous donne : 4 (à mi-chemin, donc arrondit au nombre supérieur)
round(-2,5)                 // vous donne : -2
round(quantité)             // arrondit la variable de quantité

roundUp() Toujours arrondir au nombre supérieur

Arrondit toujours au nombre entier suivant (plafond).

Par exemple :

roundUp(3,2)                // vous donne : 4 (arrondit au nombre supérieur même si le nombre est proche de 3)
roundUp(3,9)                // vous donne : 4
roundUp(3,0)                // vous donne : 3 (déjà un nombre entier)
roundUp(-2,5)               // vous donne : -2

roundDown() Toujours arrondir au nombre inférieur

Arrondit toujours au nombre entier précédent (plancher).

Par exemple :

roundDown(3,8)              // vous donne : 3 (arrondit au nombre inférieur même si le nombre est proche de 4)
roundDown(3,2)              // vous donne : 3
roundDown(3,0)              // vous donne : 3 (déjà un nombre entier)
roundDown(-2,5)             // vous donne : -3

min() Trouver le plus petit nombre

Renvoie le plus petit de deux nombres.

Par exemple :

min(5, 10)                  // vous donne : 5 (nombre le plus petit)
min(-3, 2)                  // vous donne : -3 (les nombres négatifs sont plus petits)
min(âge, 100)               // vous donne : selon ce qui est le plus petit, entre l'âge et 100
min(3,5, 5)                 // vous donne : 3

Cas d’utilisation : min(âge, 65) garantit que l’âge ne dépasse pas 65 ans.

max() Trouver le plus grand nombre

Renvoie le plus grand de deux nombres.

Par exemple :

max(5, 10)                  // vous donne : 10 (nombre le plus grand)
max(-3, 2)                  // vous donne : 2
max(âge, 18)                // vous donne : selon ce qui est le plus grand, entre l'âge et 18
max(3,5, 5)                 // vous donne : 5

Cas d’utilisation : max(âge, 18) garantit que l’âge est au moins 18 ans.

Fonctions de liste et de cartographie

Les fonctions suivantes vous permettent de travailler avec des listes (collections ordonnées) et des cartes (paires clé-valeur).

➡️ Pour en savoir plus, consultez les listes CEL et les cartes CEL.

size() Compter des éléments

Compte le nombre d'éléments se trouvant dans une liste, sur une carte, ou le nombre de caractères dans un texte.

Par exemple :

size([1, 2, 3])               // vous donne : 3 (trois éléments dans la liste)
[1, 2, 3].size()              // vous donne : 3
partenaires.size()               // vous donne : votre nombre de partenaires
size({"a": 1, "b": 2})        // vous donne : 2 (deux paires clé-valeur)
adresses.size()              // vous donne : votre nombre d'adresses
size("bonjour")               // vous donne : 5 (cinq lettres)
"bonjour".size()              // vous donne : 5
contact.email.size() > 5      // vérifie si l'email dépasse 5 caractères

in() Vérifier si l’élément existe

Vérifie si une valeur existe dans une liste ou si une clé existe dans une carte.

Par exemple :

5 dans [1, 2, 3, 4, 5]                           // vous donne : true (5 est dans la liste)
10 dans [1, 2, 3]                                // vous donne : false (10 n'est pas dans la liste)
"actif" dans ["actif", "attente", "terminé"]     // vous donne : true
"name" dans {"name": "John", "age": 30}          // vous donne : true (la clé "name" existe)
"email" dans {"name": "John", "age": 30}         // vous donne : false (aucune clé "email")
"domicile" dans des adresses                     // vérifie si l'adresse "domicile" existe

Nos recommandations pour les débutants

Pour en savoir plus, consultez : 

• Définition du langage CEL - Guide complet du langage
• Tutoriel d’introduction au CEL - Prise en main du CEL
• Meilleures pratiques du CEL - Conseils et modèles

Compréhension des types de données

Pour en savoir plus, consultez le système de type CEL.

• Texte (chaîne) : mots et phrases, toujours entre guillemets : "bonjour"
• Nombres (int) : nombres entiers sans guillemets : 42
• Décimales (double) : nombres avec des décimales : 3,14
• True/False (bool) : juste true ou false, sans guillemets
• Listes : plusieurs éléments entre parenthèses : [1, 2, 3] ou ["a", "b", "c"]
• Cartes : paires clé-valeur entre crochets : {"nom": "John", "âge": 30}

Utilisation des fonctions de membres (notation des points)

Certaines fonctions sont appelées à l’aide d’un point (.) après la valeur :

"bonjour".contains("j")                          // Vérifie si "bonjour" contient "j"
[1, 2, 3].size()                                 // Compte les éléments dans la liste
horodatage("2024-01-01T00:00:00Z").getFullYear()  // Obtient l'année à partir d'une date

Utilisation des fonctions régulières

D’autres fonctions entourent la valeur :

int("123")                      // Convertit le texte en nombre
round(3,7)                      // Arrondit la décimale au nombre entier
min(5, 10)                      // Trouve le plus petit nombre

Combinaison de fonctions

Vous pouvez imbriquer des fonctions les unes dans les autres :

string(round(3,7))              // Commence par arrondir 3,7 en 4, puis convertit en "4"
int(duration("1h"))             // Convertit une heure en 3600 secondes

Fuseaux horaires

Certaines fonctions de date acceptent un fuseau horaire (comme "Amérique/New_York" ou "Europe/Paris") :

createdAt.getHours()                    // Obtient une heure en UTC (heure universelle)
createdAt.getHours("Amérique/New_York") // Obtient une heure à l’heure de New York

À retenir

• Les mois commencent à 0 : janvier correspond à 0, décembre à 11
• Les jours de la semaine commencent à 0 : dimanche correspond à 0, samedi à 6
• Les heures utilisent le format 24 heures : 0 correspond à minuit, 13 à 13 heures, 23 à 23 h
• Utilisez des guillemets pour le texte : "bonjour" et non bonjour
• Pas de guillemets pour les nombres : 42 et non "42"

⏭️ Et après ?

• Documentation officielle du CEL
• Référence de langage
• Terrain de jeu CEL

🤔 Vous avez des questions ?

Pour toute question, n’hésitez pas à contacter notre service client en créant un ticket à partir de votre compte. Si vous n’avez pas encore de compte, vous pouvez nous contacter ici.

Si vous avez besoin d'aide pour un projet impliquant Brevo, nous pouvons vous mettre en relation avec une agence partenaire Brevo.