Fonctions de texte

Les fonctions de texte vous permettent de formater, assembler et extraire des portions de chaînes de caractères pour créer des affichages personnalisés.

Changement de casse

texte.toUpperCase()

Convertit tout le texte en lettres majuscules.

JavaScript

"bonjour".toUpperCase() // "BONJOUR"
"Hello World".toUpperCase()                                // "HELLO WORLD"
client.nom.toUpperCase()                               // Nom en majuscules

// Afficher un statut en majuscules
commande.statut.toUpperCase()                          // "VALIDÉE", "EN COURS", etc.

texte.toLowerCase()

Convertit tout le texte en lettres minuscules.

JavaScript

"BONJOUR".toLowerCase() // "bonjour"
"Hello World".toLowerCase()                                // "hello world"
client.email.toLowerCase()                             // Email normalisé

// Créer un identifiant en minuscules
produit.reference.toLowerCase()

Assemblage

arg1.concat(arg2, ...)

Assemble plusieurs éléments (textes, nombres, dates) en une seule chaîne. C'est la fonction de texte la plus utilisée.

JavaScript

 // Assembler du texte
"Bonjour ".concat("Constance")      // "Bonjour Constance"

// Mélanger texte et nombres
"Total : ".concat(150.50, " €")     // "Total : 150.50 €"

// Créer une adresse complète
client.adresse.concat("\n",
  client.codePostal, " ", client.ville
)

// Créer un libellé personnalisé
"Commande n°".concat(commande.numero,
  " - ", client.nom,
  " (", commande.date.formatDDMMYYYY(), ")"
)

Astuce : Vous pouvez passer autant d'arguments que vous voulez à concat. Tous seront assemblés dans l'ordre.

tableau.join(séparateur)

Joint les éléments d'un tableau avec un séparateur entre chaque élément.

JavaScript

["a", "b", "c"].join(", ") // "a, b, c"
["Paris", "Lyon", "Marseille"].join(" - ")                    // "Paris - Lyon - Marseille"

// Lister les produits d'une commande
commande.produits.nom.join(", ")                          // "Produit A, Produit B, Produit C"

// Créer une liste avec points
tache.etapes.join(" • ")                                  // "Étape 1 • Étape 2 • Étape 3"

// Un élément par ligne
commande.produits.nom.join("\n")                         // "Produit A", "Produit B" sur deux lignes

Extraction

texte.slice(début, fin?)

Extrait une portion d'une chaîne de caractères, entre deux bornes : la position de début, puis la position de fin, qui est exclue. Une fin absente va jusqu'au bout, et un indice négatif compte depuis la fin.

JavaScript

 // Les 3 premiers caractères : de 0 à 3 (exclu)
"Bonjour".slice(0, 3)               // "Bon"

// De la position 3 à la position 7 (exclue)
"Bonjour".slice(3, 7)               // "jour"

// Sans fin : jusqu'au bout
"Bonjour".slice(3)                  // "jour"

// Négatif : les 4 derniers caractères
"Bonjour".slice(-4)                 // "jour"

// Le premier caractère
client.prenom.slice(0, 1)       // "C" pour "Constance"

// Limiter la longueur d'un nom
client.nom.count() > 20
? client.nom.slice(0, 17).concat("...")
: client.nom

Attention : les positions commencent à 0, pas à 1. Dans "Bonjour", le "B" est à la position 0. Et la seconde borne est une position de fin, pas une longueur : slice remplace l'ancienne fonction cut(texte, longueur, depuis?), qui prenait une longueur puis un décalage. La traduction est cut(s, n, d) → s.slice(d, d + n).

Accès par index [n]

Vous pouvez aussi accéder à un caractère spécifique avec la notation par index.

JavaScript

"Bonjour"[0] // "B"
"Bonjour"[3]                                    // "j"
"Café"[3]                                       // "é" (compte des caractères, pas des octets)
"Bonjour"[99]                                   // vide (hors bornes)
client.prenom[0]                            // Première lettre du prénom

texte.indexOf(recherche, ignorerCasse?)

Donne la position du premier caractère de recherche dans le texte, en comptant à partir de 0. Renvoie -1 si la recherche est absente. Sensible à la casse par défaut.

JavaScript

"CMD-2025".indexOf("-")                        // 3
"CMD2025".indexOf("-")                                                            // -1 (absent)
"Réf CMD".indexOf("cmd", true)                                                    // 4 (en ignorant la casse)

// Extraire ce qui suit un séparateur
"Café-2024".slice("Café-2024".indexOf("-") + 1, "Café-2024".indexOf("-") + 1 + 4) // "2024"

// Tester la présence avant d'extraire
commande.ref.indexOf("-") >= 0
? commande.ref.split("-")[0]
: commande.ref

Bon à savoir : la position compte des caractères, pas des octets : dans "Café-2024", le tiret est en position 4. L'index peut donc être réinjecté tel quel dans slice. Une recherche vide renvoie 0 ; un texte ou une recherche vide de valeur renvoie une valeur vide. Attention : une recherche absente renvoie -1, et slice compte les négatifs depuis la fin — texte.slice(texte.indexOf("x")) rendrait donc le dernier caractère. Écrivez indexOf(…) + 1, qui ramène l'absence à 0.

texte.trailingNumber()

Extrait le nombre situé à la fin d'une chaîne de caractères et le retourne en tant que nombre. Idéal pour récupérer un numéro de séquence dans une référence.

JavaScript

"LOT042".trailingNumber() // 42
"CMD-2025-0042".trailingNumber()                             // 42
"Facture n°157".trailingNumber()                             // 157
lot.reference.trailingNumber()                           // Numéro du lot

// Incrémenter un numéro de référence
commande.ref.trailingNumber() + 1

// Seuls les chiffres EN FIN de chaîne sont extraits
"ABC123DEF456".trailingNumber()                              // 456 (pas 123)

Attention : La chaîne doit se terminer par un nombre et ne peut pas être vide ou manquante. Seuls les chiffres consécutifs en toute fin de texte sont extraits. Si aucun chiffre n'est trouvé en fin de texte, si l'argument est manquant, ou si la valeur passée n'est pas du texte, une erreur sera levée.

Recherche dans le texte

Ces fonctions répondent par true ou false. Elles servent typiquement dans une condition de règle, par exemple pour déclencher une action selon le préfixe d'un numéro de dossier.

Attention : ces fonctions sont sensibles à la casse par défaut. Passez true en dernier argument pour l'ignorer. C'est une différence assumée avec l'opérateur $startsWithde findObjects, qui ignore la casse, lui, toujours.

texte.startsWith(préfixe, ignorerCasse?)

Vérifie qu'un texte commence par un préfixe donné.

JavaScript

   // Condition de règle : le dossier est-il un DIGFGX ?
commande.projet.numeroDossier.startsWith("DIGFGX")

"digfgx-1".startsWith("DIGFGX")       // false (la casse diffère)
"digfgx-1".startsWith("DIGFGX", true) // true (casse ignorée)
"abc".startsWith("")                  // true (tout texte commence par le vide)

// Protéger contre les espaces parasites d'un import
commande.code.trim().startsWith("DIGFGX")

texte.endsWith(suffixe, ignorerCasse?)

Vérifie qu'un texte se termine par un suffixe donné.

JavaScript

"facture.pdf".endsWith(".pdf") // true
"facture.PDF".endsWith(".pdf", true)                              // true
document.nom.endsWith(".pdf", true)                           // Le document est-il un PDF ?

valeur.includes(cherchée, ignorerCasse?)

Une seule méthode pour les deux sens. Sur un texte, elle vérifie qu'il en contient un autre, n'importe où ; sur un tableau, que la valeur s'y trouve. C'est le type de la valeur qui tranche, et il n'y a donc plus deux fonctions à ne pas confondre.

JavaScript

"ticket urgent".includes("urgent") // true
"Ticket URGENT".includes("urgent", true)                              // true
ticket.libelle.includes("urgent", true)

// Sur un tableau : l'appartenance
commande.tags.includes("urgent")                                  // true si l'étiquette est présente
["WEB", "Tél"].includes("web", true)                                  // true

Bon à savoir : un receveur vide rend false — « la valeur est-elle dans rien ? » se répond non. C'est la seule règle que l'unification a dû choisir : sur un texte vide, l'ancienne fonction includesText rendait une valeur vide. La valeur cherchée vide, elle, rend toujours une valeur vide sur un texte.

Valeurs vides : ces trois fonctions renvoient une valeur vide, et non false, si le texte ou la recherche est vide de valeur. C'est volontaire : « pas de numéro de dossier » ne doit pas se confondre avec « le numéro ne commence pas par DIGFGX ».

JavaScript

// Pour retomber explicitement sur false
commande.numero.startsWith("DIG").ifEmpty(false)

// Pour une comparaison strictement sensible à la casse, == reste exact
commande.numero.slice(0, 6) === "DIGFGX"

Types acceptés : les fonctions de texte acceptent du texte, des nombres, des booléens et des dates. Un champ qui contient une liste(multi-select, liste de références) lève une erreur explicite plutôt que de donner un résultat trompeur — utilisez join pour en faire d'abord un texte.

Transformation

texte.trim()

Retire les espaces en début et en fin de texte. Indispensable sur des données d'import, où un espace invisible fait échouer silencieusement une comparaison.

JavaScript

"  hello  ".trim()                        // "hello"
client.nom.trim()

// Comparer sans se faire piéger par un espace parasite
commande.code.trim() === "DIGFGX"

Bon à savoir : trim ne touche qu'aux extrémités. Les espaces à l'intérieur du texte sont conservés :" a b ".trim() donne "a b".

texte.replace(ancien, nouveau)

Remplace toutes les occurrences d'un texte par un autre. La comparaison est exacte, sensible à la casse.

JavaScript

"01 23 45 67 89".replace(" ", "") // "0123456789"
client.telephone.replace(" ", "")                                // Numéro sans espaces
produit.ref.replace("-", "/")                                    // Changer de séparateur
"abc".replace("z", "y")                                              // "abc" (inchangé si absent)

Attention : le texte à remplacer ne peut pas être vide, cela lève une erreur. Si l'un des trois arguments est vide de valeur, le résultat est vide.

texte.split(séparateur)

Découpe un texte en tableau, selon un séparateur. C'est l'inverse exact de join.

JavaScript

"a-b-c".split("-") // ["a", "b", "c"]
"CMD-2025-0042".split("-")[2]                         // "0042"
"abc".split("-")                                      // ["abc"] (séparateur absent)
"a-b-c".split("-").join(", ")                         // "a, b, c"

// Récupérer le prénom d'un nom complet
client.nomComplet.split(" ")[0]

Attention : le séparateur ne peut pas être vide, cela lève une erreur. Pour découper à une position plutôt qu'à un séparateur, utilisez slice.

Utilitaires

codePays.nationality()

Retourne la nationalité correspondant à un code pays ISO.

JavaScript

"FR".nationality() // "Français"
"DE".nationality()                                    // "Allemand"
"US".nationality()                                    // "Américain"
employe.paysNaissance.nationality()               // Nationalité de l'employé

texte.count()

Retourne le nombre de caractères dans une chaîne.

JavaScript

"Bonjour".count() // 7
"".count()                                           // 0
client.telephone.count()                         // Nombre de chiffres

// Valider la longueur d'un champ
client.siret.count() !== 14
? "SIRET invalide"
: "SIRET valide"

Exemples pratiques

Créer des initiales

JavaScript

let prenom = client.prenom;
let nom = client.nom;
prenom.slice(0, 1).concat(nom.slice(0, 1))

// Résultat: "MD" pour "Constance Dupont"

Formater un numéro de téléphone

JavaScript

let tel = client.telephone;
tel.slice(0, 2).concat(" ",
  tel.slice(2, 4), " ",
  tel.slice(4, 6), " ",
  tel.slice(6, 8), " ",
  tel.slice(8, 10)
)

// "0612345678" → "06 12 34 56 78"

Générer un nom de fichier normalisé

JavaScript

let client = client.nom.toLowerCase();
let jour = today().formatDDMMYYYY();
let numero = facture.numero.padZeros(5);

"facture_".concat(client, "_", numero, "_", jour, ".pdf")

// Résultat: "facture_dupont_00042_19012026.pdf"

Créer une salutation personnalisée

JavaScript

let civilite = client.civilite;
let nom = client.nom.toUpperCase();

civilite === "M"
? "Cher Monsieur ".concat(nom)
: civilite === "Mme"
? "Chère Madame ".concat(nom)
: "Cher(e) ".concat(nom)

// Résultat: "Chère Madame DUPONT"

Afficher une adresse complète

JavaScript

let lignes = [
  client.prenom.concat(" ", client.nom).toUpperCase(),
  client.adresse,
  client.adresse2.exists() ? client.adresse2 : "",
  client.codePostal.concat(" ", client.ville.toUpperCase()),
  client.pays.toUpperCase()
];

let lignesNonVides = lignes.filter(ligne => ligne !== "");
lignesNonVides.join("\n")

// Résultat:
// MARIE DUPONT
// 123 rue de la Paix
// 75001 PARIS
// FRANCE

Extraire un numéro de séquence

JavaScript

let ref = lot.reference;
let numero = ref.trailingNumber();
let prochain = numero + 1;

"Prochain lot : LOT".concat(prochain.padZeros(3))

// "LOT042" → "Prochain lot : LOT043"

Tronquer un texte avec ellipse

JavaScript

let description = produit.description;
let longueurMax = 100;

description.count() > longueurMax
? description.slice(0, longueurMax - 3).concat("...")
: description

// "Ce produit est vraiment..." (tronqué à 100 caractères)

Prochaine étape

Découvrez maintenant les fonctions booléennes pour tester des conditions et vérifier l'état de vos données.

Fonctions booléennes →← Fonctions numériques