# Fonctions de transformation prises en charge - Nettoyage des données Dans la formule de saisie, vous pouvez écrire une expression basique ou complexe pour transformer les données.\ \ Les expressions sont composées soit d'une valeur, d'une fonction, d'une opération, soit d'une autre expression entre parenthèses. Voir ci-dessous la description de chacune d'elles. {% hint style="info" %} Les fonctions peuvent être imbriquées, ex : `SHA256(LOWER(user.email))` {% endhint %} ## Fonctions disponibles | NOM DE LA FONCTION | CE QU'ELLE FAIT | Exemple | | ---------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | EXTRACT(text, delimiter, position) | Extrait du texte donné la sous-chaîne à la position indiquée, après séparation par le délimiteur donné. |

EXTRACT("a-b-c", "-", 1)
renvoie "b"

EXTRACT("a-b-c", "-", 0)
renvoie "a"

| | SUBSTITUTE(text, search\_text,substitute\_text) | Substitue new\_text à la place de old\_text dans une chaîne de texte. Utilisez SUBSTITUTE lorsque vous souhaitez remplacer un texte spécifique dans une chaîne de texte. | `SUBSTITUTE("The-Clone-Wars", "-", ".")`renvoie `"The.Clone.Wars"` | | REPLACE(sourceStr, pattern, replaceStr) | Remplace chaque correspondance de pattern (une expression regex) dans sourceStr. |

REPLACE("The Clone Wars", "\s", ".")
renvoie "The.Clone.Wars"

REPLACE('0123456789', '(\[0-9]{2})', '$1-')
renvoie

01-23-45-67-89

| | SHA256(stringToHash) | Renvoie un hash SHA256 de la chaîne donnée |

SHA256("test")
renvoie "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"

| | MD5(stringToHash) | Renvoie un hash MD5 de la chaîne donnée |

MD5("test")
renvoie
"098f6bcd4621d373cade4e832627b4f6"

| | COALESCE(value1, value2, ...) | Renvoie la première valeur de la liste qui n’est pas vide |

COALESCE("123", "hello")
renvoie
"123"

| | CONCAT(string1, string2, ...) |

Concatène plusieurs valeurs en une seule propriété. Des séparateurs peuvent être spécifiés :
CONCAT(prop1, "

| ", prop2, " | | TRIM(text) | Supprime tous les espaces, retours à la ligne et tabulations au début et à la fin d'un texte. |

TRIM(" \Hello World \n")
renvoie
"Hello World"

| | SELECT(sourceStr, pattern, \) |

Renvoie la première correspondance du pattern (une expression regex) dans sourceStr.
Si le troisième paramètre est défini, il renverra le groupe correspondant à l'intérieur de la correspondance.

|

SELECT("From A to Z alphabet", 'A(.\*?)Z")
renvoie
"A to Z"

| | LOWER(text) | Convertit toutes les lettres majuscules d'une chaîne de texte en minuscules |

LOWER("ABC")
renvoie
"abc"

| | UPPER(text) | Convertit toutes les lettres minuscules d'une chaîne de texte en majuscules |

UPPER("abc")
renvoie
"ABC"

| | NUMBER(value1) | Convertit une chaîne en nombre |

NUMBER("123.456") renvoie
123.456

NUMBER("not a number")
renvoie
null

| | STRING(value) | Convertit un nombre ou n'importe quelle valeur en chaîne |

STRING(123.456) renvoie
"123.456"

STRING(true)
renvoie
"true"

STRING(null)
renvoie
""

| | ENCODE\_BASE64(value1) | Encode une chaîne en base64 |

ENCODE\_BASE64("hello")
renvoie
"aGVsbG8="

| | DECODE\_BASE64(value1) | Décode une chaîne depuis base64 |

DECODE\_BASE64("aGVsbG8=")
renvoie
"hello"

| | TIMESTAMP() | Renvoie le timestamp de la date actuelle | `TIMESTAMP ()` renvoie une valeur comme `1674832519845` (change avec l'heure actuelle) | | LEFT(text, length) | Renvoie le nombre demandé de caractères depuis le début d'une chaîne ou d'un nombre. |

LEFT("Hello world", 3)
renvoie
"Hel"

| | RIGHT(text, length) | Renvoie le nombre demandé de caractères depuis la fin d'une chaîne ou d'un nombre. |

RIGHT("Hello world", 2)
renvoie
"ld"

| | CHAR(text, position)\* | Renvoie le caractère à la position spécifiée (début à 0). |

CHAR("Hello world", 5)
renvoie
"o"

| | IF(condition,resultIfTrue,resultIfFalse) | Renvoie le deuxième argument si le premier argument est vrai, sinon le troisième argument | `IF(city="Paris", ListA, ListB)` | | SWITCH(expression, value1, result1, \[value2, result2], ..., \[default]) | Évalue l'expression par rapport à une liste de valeurs et renvoie le résultat correspondant à la première correspondance. Si aucune correspondance n'est trouvée, renvoie la valeur par défaut facultative, ou null si aucune valeur par défaut n'est fournie. |

SWITCH(country, "FR", "France", "US", "United States", "Unknown")
renvoie "France" si country est "FR", "Unknown" si aucune correspondance

SWITCH(LOWER(status), "active", 1, "inactive", 0)
renvoie 1 si status est "Active"

| | ISEMPTY(value) | Indique si la valeur est vide ou non |

ISEMPTY("abc")
renvoie
false

| | SIZE(array or object) | Renvoie le nombre d'éléments dans la liste |

SIZE(items)
renvoie le nombre d'éléments

| | LENGTH(string) | Renvoie le nombre de caractères dans la chaîne |

LENGTH("abc")
renvoie
3

| | SUBSTRING(text, pos1, pos2) | Renvoie une nouvelle chaîne composée des caractères entre les deux positions définies par pos1 et pos2. Les positions commencent à 0. Si un nombre négatif est donné, les positions commencent à partir de la fin de la chaîne. Si pos2 est omis, la fin de la chaîne est utilisée. |

SUBSTRING("hello beautiful world", 6, 14)
renvoie
"beautiful"

| | JSON\_PARSE(string) |

Analyse une chaîne JSON (fonctionne pour les objets et les tableaux).
Utile pour créer une propriété d'objet ou de tableau qui contiendra toutes les propriétés ou éléments présents dans un JSON sérialisé que vous pourriez avoir dans une autre propriété d'événement

|

JSON\_PARSE('{"optin":1,"message":"ok"}')
renvoie un objet avec une optin clé égale à 1 et message clé égale à "ok"

JSON\_PARSE('\["morgan","justine"]')
renvoie un tableau contenant "morgan" et "justine"

| | JSON\_STRINGIFY(value, defaultValue) |

Convertit une valeur en JSON.
(Optionnel) Vous pouvez spécifier une defaultValue en cas de value est undefined

|

JSON\_STRINGIFY({"message":"ok"})
renvoie une chaîne égale à '{"message":"ok"}'

| | VALUE\_FROM\_JSON(string, path) | Extrait une valeur d'une chaîne de données au format JSON |

VALUE\_FROM\_JSON('{"info":{"code":42},"message":"ok"}', 'info.code')

renvoie

42

| | GET(property name) |

GET(name) renvoie la valeur de la propriété d'événement donnée.
Utile pour les noms de propriété qui contiennent un caractère spécial comme "-"

|

GET("droid-type")

renvoie

"r2d2"

GET("invalidProperty")
renvoie
null

| | GETHEADER(name) | GETHEADER(name) renvoie la valeur de l'en-tête http donné |

GETHEADER("Accept-Language")

renvoie

"fr,fr-FR;q=0.8,en-US;q=0.5,en;q=0.3"

| | GETCOOKIE(name) | GETCOOKIE(name) renvoie la valeur du cookie http donné |

GETCOOKIE("cart")

renvoie

"empty"

| | DATEPARSE(str, format) | Prend une date dans un format spécifique et la convertit en une date correcte |

DATEPARSE('2023-05-23', 'yyyy-MM-dd') renvoie
2023-05-23T00:00:00.000+01:00
voir plus d'informations sur le format

| | DATEFORMAT(date, format) | Prend une date au format ISO-8601 ou timestamp et la convertit au format spécifié |

DATEFORMAT('2023-01-31T23:59:00.000+01:00', 'yyyy-MM-dd HH:mm') renvoie
2023-01-31 23:59
voir plus d'informations sur le format

| | DATEADD(date, interval, unit) | Ajoute l'intervalle en tant qu'unité (années, mois, semaines, jours, heures, minutes, secondes) |

DATEADD('2023-01-23T00:05:00.000+01:00', 3, 'days')
renvoie
2023-01-26T00:05:00.000+01:00

| | DATESUB(date, interval, unit) | Soustrait l'intervalle en tant qu'unité (années, mois, semaines, jours, heures, minutes, secondes) |

DATESUB('2023-01-23T00:05:00.000+01:00', 3, 'days')
renvoie
2023-01-20T00:05:00.000+01:00

| | DATEDIFF(date1, date2, unit) | Renvoie l'intervalle entre deux dates dans l'unité spécifiée |

DATEDIFF('2023-01-20T00:05:00.000+01:00', '2023-01-23T00:05:00.000+01:00', 'days')
renvoie
0

| | AGE(date, unit) | Renvoie le temps écoulé depuis la date donnée dans l'unité spécifiée (si l'unité n'est pas précisée, les années sont utilisées par défaut) |

AGE('2022-01-20T00:05:00.000+01:00')
renvoie
1 en 2023

| | YEAR(date), MONTH(date), DAY(date), HOUR(date), MINUTES(date), SECONDS(date) | Renvoie l'unité de date spécifiée |

YEAR('2023-01-20T00:05:00.000+01:00')
renvoie
2023, MONTH pour la même date renvoie 1, etc

| | TIMEZONE(date) | Renvoie le fuseau horaire en UTC |

TIMEZONE('2023-01-20T00:05:00.000+01:00')
renvoie
UTC+1

| | TODAY() | Renvoie la date actuelle au format ISO-8601 | `TODAY()` peut renvoyer `2023-01-20T00:05:00.000+01:00`, en supposant que la date actuelle est le 20 janvier 2023 | ## Opérateurs | **Opérateur** | **Description** | **Exemple** | | --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------- | | =, == |

Renvoie true si la partie gauche est égale à la partie droite.
Si l'une des parties est un tableau, vérifie si certaines valeurs sont égales entre les deux parties.

| `gender = "F"` | | !=, <> | Inverse de ce qui précède | `gender != "F"` | | AND ou && | Effectue un AND booléen entre les deux parties | `age >18 AND gender = "M"` | | OR ou \|\| | Effectue un OR booléen entre les deux parties | `age >18 OR gender = "M"` | | NOT(expression) | Effectue un NOT booléen sur l'expression | `NOT(age>18)` | | IN() | Renvoie true si la partie gauche est égale à au moins une valeur de la partie droite. | `currency IN("€", "$", "£")` | | !IN | Renvoie true si aucune des valeurs de la partie droite n'est égale à la valeur de la partie gauche. | `currency !IN("€", "$", "£")` | | <, >, <=, ou >= |

Compare deux valeurs
Si l'une des valeurs est un tableau, vérifie qu'au moins une des valeurs correspond.

| `age > 18` | | BETWEEN() | Vérifie si la valeur de gauche est comprise entre les deux valeurs passées en arguments. Si la valeur de gauche est un tableau, vérifie qu'au moins une des valeurs correspond. | `age BETWEEN(7, 80)` | | EXISTS() | Vérifie si la propriété existe | `EXISTS(my_property)` | | \~ ou !\~ |

Vérifie si la valeur de gauche correspond à la regex dans la valeur de droite (ou ne correspond pas si !\~). Le langage regex est celui de JavaScript.
Si la valeur de gauche est un tableau, vérifie qu'au moins une des valeurs correspond.

| `email ~ "@example.com"` | | STARTSWITH(), ENDSWITH(), or CONTAINS() |

Vérifie si la valeur de gauche commence par, se termine par, ou contient la valeur de droite.
Si la valeur de gauche est un tableau, vérifie qu'au moins une des valeurs correspond.

| `lastname STARTSWITH("DE")` | | \* ou / | Multiplication ou division | `3*5` | | + ou - | Addition / concaténation ou soustraction | `1+2` | ## Agrégations | NOM DE LA FONCTION | CE QU'ELLE FAIT | Exemple | | -------------------------- | --------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | AVERAGE(array, expression) | Calcule la moyenne des valeurs dans un tableau ou à partir d'une expression. Le paramètre expression est facultatif. |

AVERAGE(\[0, null, 10])
Renvoie 5 (les valeurs null sont ignorées)

AVERAGE(items, price)
Renvoie la moyenne du prix de chaque élément (les valeurs null sont ignorées)

AVERAGE(items, EXTRACT(price, "€", 0))
Extrait la valeur numérique avant € et calcule la moyenne

AVERAGE(items, IF(returned\_quantity = 0, NUMBER(EXTRACT(product.price, "€",0)), 0))
Prix moyen uniquement pour les éléments non retournés

| | MIN(array, expression) | Renvoie la valeur minimale d'un tableau ou d'une expression. Le paramètre expression est facultatif. |

MIN(\[null, 15, 8])
Renvoie 8 (ignore null)

MIN(orders, DATEPARSE(order\_date, "yyyy-MM-dd"))
Trouver la date de commande la plus ancienne

MIN(items, IF(status = "active", price, 999999))
Prix minimum parmi les éléments actifs uniquement

| | MAX(array, expression) | Renvoie la valeur maximale d'un tableau ou d'une expression. Le paramètre expression est facultatif. |

MAX(\[null, 15, 8])
Renvoie 15 (ignore null)

MAX(users, AGE(birth\_date))
Trouver l'âge de l'utilisateur le plus âgé

MAX(transactions, IF(type = "purchase", amount, 0))
Montant d'achat maximum

| | SUM(array, expression) | Calcule la somme des valeurs dans un tableau ou à partir d'une expression. Le paramètre expression est facultatif. |

SUM(items, quantity \* NUMBER(EXTRACT(unit\_price, "$", 0)))
Calculer la valeur totale de tous les éléments

SUM(\[5, null, 15])
Renvoie 20 (ignore null)

SUM(items, IF(returned\_quantity = 0, NUMBER(EXTRACT(product.price, "€",0)), 0))
Additionne les prix uniquement pour les éléments avec quantité non retournée

| | COUNT(array, expression) | Compte le nombre de valeurs non vides dans un tableau ou à partir d'une expression. Le paramètre expression est facultatif. |

COUNT(users, IF(ISEMPTY(email), null, email))
Compte les clients avec un email non vide

COUNT(items, IF(status = "completed" AND amount > 100, 1, null))
Compter les éléments complétés au-dessus de 100

| ## Exemples 1. Scénario : créer un Flag qui montre si l'adresse principale des consommateurs se trouve en Californie\ `IF(EXTRACT(city_state, '-', 1) == " CA", "TRUE", "FALSE")` 2. Scénario : définir une valeur avec plusieurs conditions. La valeur est égale à "12345" pour le pays FR et l'environnement prod, sinon elle est égale à 98888 pour le pays DE et l'environnement dev : \\ {% code overflow="wrap" %} ```` ```xquery IF(country = "FR" AND environment_work = "prod", "12345", IF(country = "DE" AND environment_work = "dev", "98888") ``` ```` {% endcode %} --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://doc.commandersact.com/fr/fonctionnalites/data-quality/data-cleansing/supported-transformation-functions.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.