Fonctions de chaînes

Les fonctions de chaînes effectuent des opérations sur du texte et des valeurs de type chaîne. La plupart des fonctions de chaînes renvoient un type de données chaîne, bien que certaines (comme Length et Find) renvoient des nombres, et d'autres (comme IsNullOrEmpty) renvoient des valeurs booléennes. Lorsque des valeurs non-chaîne sont passées à ces fonctions, elles sont automatiquement interprétées comme des chaînes.

Fonction LCase

La fonction LCase convertit toutes les lettres majuscules d'une chaîne en minuscules. Les caractères non alphabétiques restent inchangés.

Cette fonction renvoie un type de données String (chaîne).

Syntaxe

LCase(exprAsString)

Paramètre	Description
exprAsString	Obligatoire. La chaîne à convertir en minuscules.

Exemples

1. Convertir une chaîne en minuscules :

   LCase("Hello WORLD")

   Résultat : "hello world"

2. Normaliser les données du destinataire pour la comparaison :

   If(LCase(|->[Country]) = "france") {"EU"} else {"Other"}

3. Créer une adresse e-mail normalisée :

   LCase(|->[FirstName] & "." & |->[LastName] & "@example.com")

   Si FirstName = "John" et LastName = "SMITH" :

   Résultat : "john.smith@example.com"

Fonction UCase

La fonction UCase convertit toutes les lettres minuscules d'une chaîne en majuscules. Les caractères non alphabétiques restent inchangés.

Cette fonction renvoie un type de données String (chaîne).

Syntaxe

UCase(exprAsString)

Paramètre	Description
exprAsString	Obligatoire. La chaîne à convertir en majuscules.

Exemples

1. Convertir une chaîne en majuscules :

   UCase("Hello WORLD")

   Résultat : "HELLO WORLD"

2. Mettre en majuscules les données d'adresse pour la mise en forme postale :

   UCase(|->[City] & ", " & |->[State] & " " & |->[Zip])

   Si City = "boston", State = "ma", Zip = "02101" :

   Résultat : "BOSTON, MA 02101"

3. Créer un code référence en majuscules :

   UCase(SubString(|->[LastName], 0, 3) & "-" & |->[ID])

   Si LastName = "Smith" et ID = "1234" :

   Résultat : "SMI-1234"

Fonction TCase

La fonction TCase (Title Case) convertit la première lettre de chaque mot en majuscule et les lettres restantes en minuscules. Les mots sont délimités par des espaces.

Cette fonction renvoie un type de données String (chaîne).

Syntaxe

TCase(exprAsString)

Paramètre	Description
exprAsString	Obligatoire. La chaîne à convertir en casse de titre.

Exemples

1. Convertir une chaîne en casse de titre :

   TCase("hello WORLD")

   Résultat : "Hello World"

2. Mettre en forme les noms des destinataires de manière cohérente :

   TCase(|->[FirstName]) & " " & TCase(|->[LastName])

   Si FirstName = "JOHN" et LastName = "smith" :

   Résultat : "John Smith"

3. Créer une formule de salutation :

   "Cher(e) " & TCase(|->[FirstName]) & ","

Fonction Length

La fonction Length renvoie le nombre de caractères dans une chaîne, espaces compris.

Cette fonction renvoie un type de données Number (nombre).

Syntaxe

Length(exprAsString)

Paramètre	Description
exprAsString	Obligatoire. La chaîne dont on souhaite obtenir la longueur.

Exemples

1. Obtenir la longueur d'une chaîne :

   Length("Hello WORLD")

   Résultat : 11

2. Vérifier si un champ dépasse une longueur maximale :

   If(Length(|->[Description]) > 50) {SubString(|->[Description], 0, 47) & "..."} else {|->[Description]}

3. Valider un code postal :

   If(Length(|->[ZipCode]) = 5) {"Valid"} else {"Invalid"}

Fonction IsNullOrEmpty

La fonction IsNullOrEmpty vérifie si une chaîne est nulle (null) ou vide (longueur zéro). Elle renvoie True si la chaîne est nulle ou vide, False dans le cas contraire.

Cette fonction renvoie un type de données Boolean (booléen).

Syntaxe

IsNullOrEmpty(exprAsString)

Paramètre	Description
exprAsString	Obligatoire. La chaîne à vérifier.

Exemples

1. Vérifier si un champ est vide :

   IsNullOrEmpty("")

   Résultat : True

2. Vérifier si un champ contient des données :

   IsNullOrEmpty("Hello")

   Résultat : False

3. Fournir une valeur par défaut lorsqu'un champ est vide :

   If(IsNullOrEmpty(|->[MiddleName])) {|->[FirstName] & " " & |->[LastName]} else {|->[FirstName] & " " & |->[MiddleName] & " " & |->[LastName]}

4. Valider un champ obligatoire :

   If(IsNullOrEmpty(|->[Email])) {"Non renseigné"} else {|->[Email]}

Fonction SubString

La fonction SubString extrait une portion d'une chaîne en commençant à une position donnée et sur une longueur spécifiée. Si la longueur est définie sur -1, la fonction renvoie tous les caractères depuis la position de départ jusqu'à la fin de la chaîne.

Cette fonction renvoie un type de données String (chaîne).

Syntaxe

SubString(exprAsString, startPosition, length)

Paramètre	Description
exprAsString	Obligatoire. La chaîne source à partir de laquelle extraire.
startPosition	Obligatoire. La position de départ (indexée à zéro).
length	Obligatoire. Le nombre de caractères à extraire. Utilisez -1 pour extraire jusqu'à la fin de la chaîne.

Exemples

1. Extraire les 5 premiers caractères :

   SubString("Hello WORLD", 0, 5)

   Résultat : "Hello"

2. Extraire à partir de la position 6 jusqu'à la fin :

   SubString("Hello WORLD", 6, -1)

   Résultat : "WORLD"

3. Obtenir les initiales d'un nom :

   SubString(|->[FirstName], 0, 1) & SubString(|->[LastName], 0, 1)

   Si FirstName = "John" et LastName = "Smith" :

   Résultat : "JS"

4. Masquer les derniers chiffres d'un numéro de compte :

   "****" & SubString(|->[AccountNum], Length(|->[AccountNum]) - 4, 4)

   Si AccountNum = "1234567890" :

   Résultat : "****7890"

Fonction Trim

La fonction Trim supprime les espaces blancs au début et à la fin d'une chaîne. Les espaces à l'intérieur de la chaîne ne sont pas affectés.

Cette fonction renvoie un type de données String (chaîne).

Syntaxe

Trim(exprAsString)

Paramètre	Description
exprAsString	Obligatoire. La chaîne dont on souhaite supprimer les espaces de début et de fin.

Exemples

1. Supprimer les espaces aux deux extrémités :

   Trim(" Hello WORLD ")

   Résultat : "Hello WORLD"

2. Nettoyer les données du destinataire pouvant contenir des espaces supplémentaires :

   Trim(|->[FirstName] & " " & |->[LastName])

   Si FirstName = " John " et LastName = " Smith " :

   Résultat : "John Smith"

3. Garantir des données propres avant comparaison :

   If(Trim(|->[Status]) = "Active") {"Yes"} else {"No"}

Fonction LTrim

La fonction LTrim supprime les espaces blancs uniquement au début (côté gauche) d'une chaîne. Les espaces de fin sont conservés.

Cette fonction renvoie un type de données String (chaîne).

Syntaxe

LTrim(exprAsString)

Paramètre	Description
exprAsString	Obligatoire. La chaîne dont on souhaite supprimer les espaces de début.

Exemples

1. Supprimer uniquement les espaces de début :

   LTrim(" Hello WORLD ")

   Résultat : "Hello WORLD "

2. Nettoyer des données complétées à gauche :

   LTrim(|->[AccountNumber])

   Si AccountNumber = " 12345" :

   Résultat : "12345"

Fonction RTrim

La fonction RTrim supprime les espaces blancs uniquement à la fin (côté droit) d'une chaîne. Les espaces de début sont conservés.

Cette fonction renvoie un type de données String (chaîne).

Syntaxe

RTrim(exprAsString)

Paramètre	Description
exprAsString	Obligatoire. La chaîne dont on souhaite supprimer les espaces de fin.

Exemples

1. Supprimer uniquement les espaces de fin :

   RTrim(" Hello WORLD ")

   Résultat : " Hello WORLD"

2. Nettoyer des données à largeur fixe complétées à droite :

   RTrim(|->[Description])

   Si Description = "Widget " :

   Résultat : "Widget"

Fonction Find

La fonction Find recherche une sous-chaîne dans une chaîne et renvoie sa position (indexée à zéro). Si la sous-chaîne n'est pas trouvée, la fonction renvoie -1. La recherche est sensible à la casse.

Cette fonction renvoie un type de données Number (nombre).

Syntaxe

Find(exprAsString, searchString, startPosition)

Paramètre	Description
exprAsString	Obligatoire. La chaîne dans laquelle effectuer la recherche.
searchString	Obligatoire. La sous-chaîne à rechercher.
startPosition	Obligatoire. La position (indexée à zéro) à partir de laquelle commencer la recherche.

Exemples

1. Trouver la position d'une sous-chaîne :

   Find("Hello WORLD", "WORLD", 0)

   Résultat : 6

2. La recherche est sensible à la casse :

   Find("Hello WORLD", "world", 0)

   Résultat : -1 (non trouvé)

3. Vérifier si une chaîne contient une valeur spécifique :

   If(Find(|->[Email], "@", 0) > -1) {"Symbole @ trouvé"} else {"Symbole @ manquant"}

4. Trouver la deuxième occurrence en démarrant après la première :

   Find("apple,banana,apple", "apple", 1)

   Résultat : 13

5. Extraire le domaine d'une adresse e-mail :

   SubString(|->[Email], Find(|->[Email], "@", 0) + 1, -1)

   Si Email = "john@example.com" :

   Résultat : "example.com"

Fonction Replace

La fonction Replace remplace un nombre spécifié de caractères à une position donnée par une nouvelle chaîne. Ceci est utile pour insérer ou écraser des caractères à des emplacements spécifiques dans une chaîne.

Cette fonction renvoie un type de données String (chaîne).

Syntaxe

Replace(exprAsString, insertString, startPosition, charactersToReplace)

Paramètre	Description
exprAsString	Obligatoire. La chaîne originale à modifier.
insertString	Obligatoire. La chaîne à insérer à la position spécifiée.
startPosition	Obligatoire. La position (indexée à zéro) à partir de laquelle commencer le remplacement.
charactersToReplace	Obligatoire. Le nombre de caractères à supprimer avant l'insertion. Utilisez 0 pour insérer sans supprimer.

Exemples

1. Remplacer des caractères à une position spécifique :

   Replace("Hello WORLD", "UNIVERSE", 6, 5)

   Résultat : "Hello UNIVERSE"

2. Insérer des caractères sans en supprimer (charactersToReplace à 0) :

   Replace("HelloWorld", " ", 5, 0)

   Résultat : "Hello World"

3. Masquer une partie d'un numéro de carte de crédit :

   Replace(|->[CardNumber], "****-****-****-", 0, 15)

   Si CardNumber = "1234-5678-9012-3456" :

   Résultat : "****-****-****-3456"

Fonction FindAndReplace

La fonction FindAndReplace recherche toutes les occurrences d'une sous-chaîne et les remplace par une nouvelle valeur. La recherche est sensible à la casse.

Cette fonction renvoie un type de données String (chaîne).

Syntaxe

FindAndReplace(exprAsString, searchString, replacementString)

Paramètre	Description
exprAsString	Obligatoire. La chaîne dans laquelle effectuer la recherche.
searchString	Obligatoire. La sous-chaîne à rechercher.
replacementString	Obligatoire. La chaîne de remplacement pour chaque occurrence.

Exemples

1. Remplacer un mot dans une chaîne :

   FindAndReplace("Hello WORLD", "WORLD", "UNIVERSE")

   Résultat : "Hello UNIVERSE"

2. Supprimer une sous-chaîne en la remplaçant par une chaîne vide :

   FindAndReplace("Hello WORLD", " WORLD", "")

   Résultat : "Hello"

3. Remplacer les espaces par des tirets pour une URL :

   FindAndReplace(|->[ProductName], " ", "-")

   Si ProductName = "Premium Widget Set" :

   Résultat : "Premium-Widget-Set"

4. Standardiser les données en remplaçant les abréviations :

   FindAndReplace(FindAndReplace(|->[Address], "St.", "Street"), "Ave.", "Avenue")

5. Supprimer le symbole de devise avant la conversion numérique :

   AsNumber(FindAndReplace(|->[Price], "$", ""))

   Si Price = "$99.99" :

   Résultat : 99.99

Fonction FindAndReplaceChars

La fonction FindAndReplaceChars remplace toutes les instances de n'importe quel caractère d'un ensemble spécifié par une chaîne de remplacement. Contrairement à FindAndReplace, cette fonction traite le paramètre de recherche comme des caractères individuels, et non comme une sous-chaîne.

Cette fonction renvoie un type de données String (chaîne).

Syntaxe

FindAndReplaceChars(exprAsString, charactersToReplace, replacementString)

Paramètre	Description
exprAsString	Obligatoire. La chaîne dans laquelle effectuer la recherche.
charactersToReplace	Obligatoire. Une chaîne contenant tous les caractères à remplacer (chaque caractère est traité individuellement).
replacementString	Obligatoire. La chaîne de remplacement pour chaque caractère correspondant.

Exemples

1. Supprimer les caractères de mise en forme d'un numéro de téléphone :

   FindAndReplaceChars(|->[Phone], "()- ", "")

   Si Phone = "(555) 123-4567" :

   Résultat : "5551234567"

2. Supprimer les signes de ponctuation :

   FindAndReplaceChars("Hello, World! How are you?", ",.!?", "")

   Résultat : "Hello World How are you"

3. Assainir un nom de fichier en remplaçant les caractères non valides :

   FindAndReplaceChars(|->[FileName], "/\\:*?\"<>|", "_")

   Si FileName = "Report: Q1/Q2" :

   Résultat : "Report_ Q1_Q2"

4. Supprimer les voyelles d'une chaîne :

   FindAndReplaceChars("Hello World", "aeiouAEIOU", "")

   Résultat : "Hll Wrld"

Fonction FindByRegExp

La fonction FindByRegExp recherche dans une chaîne à l'aide d'un motif d'expression régulière et renvoie le texte correspondant. Elle offre des capacités puissantes de correspondance de motifs pour l'extraction de texte complexe.

Cette fonction renvoie un type de données String (chaîne).

Syntaxe

FindByRegExp(exprAsString, regExpPattern, firstMatchOnly)

Paramètre	Description
exprAsString	Obligatoire. La chaîne dans laquelle effectuer la recherche.
regExpPattern	Obligatoire. Le motif de l'expression régulière à rechercher.
firstMatchOnly	Obligatoire. Définissez sur True pour renvoyer uniquement la première correspondance, ou False pour renvoyer toutes les correspondances concaténées.

Remarque : La grammaire des expressions régulières utilisée est ECMA-262 sous Windows avec des modifications et Extended sous Macintosh.

Exemples

1. Extraire le premier mot d'une chaîne :

   FindByRegExp("Hello WORLD", "[A-Za-z]+", True)

   Résultat : "Hello"

2. Extraire une adresse e-mail d'un texte :

   FindByRegExp(|->[Notes], "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}", True)

   Si Notes = "Contact me at john@example.com for details" :

   Résultat : "john@example.com"

3. Extraire tous les nombres d'une chaîne :

   FindByRegExp("Order 123 has 5 items", "[0-9]+", False)

   Résultat : "1235"

4. Extraire un code postal d'une adresse :

   FindByRegExp(|->[Address], "[0-9]{5}(-[0-9]{4})?", True)

   Si Address = "123 Main St, Boston, MA 02101-1234" :

   Résultat : "02101-1234"

Fonction FindAndReplaceByRegExp

La fonction FindAndReplaceByRegExp recherche du texte correspondant à un motif d'expression régulière et le remplace par une chaîne spécifiée. Elle offre des capacités puissantes de recherche et remplacement basées sur des motifs.

Cette fonction renvoie un type de données String (chaîne).

Syntaxe

FindAndReplaceByRegExp(exprAsString, regExpPattern, replacementString, firstMatchOnly)

Paramètre	Description
exprAsString	Obligatoire. La chaîne dans laquelle effectuer la recherche.
regExpPattern	Obligatoire. Le motif de l'expression régulière à rechercher.
replacementString	Obligatoire. La chaîne de remplacement pour chaque correspondance.
firstMatchOnly	Obligatoire. Définissez sur True pour remplacer uniquement la première correspondance, ou False pour remplacer toutes les correspondances.

Exemples

1. Remplacer le premier mot d'une chaîne :

   FindAndReplaceByRegExp("Hello WORLD", "[A-Za-z]+", "Hi", True)

   Résultat : "Hi WORLD"

2. Supprimer tous les chiffres d'une chaîne :

   FindAndReplaceByRegExp("abc123def456", "[0-9]+", "", False)

   Résultat : "abcdef"

3. Masquer toutes les adresses e-mail dans un texte :

   FindAndReplaceByRegExp(|->[Comments], "[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}", "[email hidden]", False)

4. Supprimer les caractères non numériques d'un numéro de téléphone formaté :

   FindAndReplaceByRegExp(|->[Phone], "[^0-9]", "", False)

   Si Phone = "+1 (555) 123-4567" :

   Résultat : "15551234567"

5. Remplacer les espaces multiples par un seul espace :

   FindAndReplaceByRegExp("Hello World", " +", " ", False)

   Résultat : "Hello World"

Fonction CleanNumber

La fonction CleanNumber supprime tous les caractères non numériques d'une chaîne, ne conservant que les chiffres 0 à 9. Ceci est utile pour nettoyer les numéros de téléphone, les numéros de compte ou toute donnée numérique pouvant contenir des caractères de mise en forme.

Cette fonction renvoie un type de données String (chaîne, et non un nombre), ce qui préserve les zéros en début de chaîne et permet des séquences de plus de 14 chiffres.

Syntaxe

CleanNumber(exprAsString)

Paramètre	Description
exprAsString	Obligatoire. La chaîne de laquelle extraire les chiffres.

Exemples

1. Supprimer la mise en forme d'un numéro de téléphone :

   CleanNumber("+1 888-452-1111")

   Résultat : "18884521111"

2. Nettoyer un numéro de sécurité sociale formaté :

   CleanNumber("123-45-6789")

   Résultat : "123456789"

3. Extraire les chiffres d'une valeur monétaire :

   CleanNumber("$1,234.56")

   Résultat : "123456"

4. Préparer un numéro de téléphone pour le reformater :

   FormatNumber(CleanNumber(|->[Phone]), "(###) ###-####")

   Si Phone = "555.123.4567" :

   Résultat : "(555) 123-4567"

Remarque 1 : Comme CleanNumber renvoie une chaîne, elle peut gérer des nombres de plus de 14 chiffres (la limite pour les calculs numériques dans QLingo). Cela la rend adaptée aux numéros de téléphone, numéros de carte de crédit et autres identifiants numériques longs.

Remarque 2 : CleanNumber supprime les séparateurs de milliers et les décimales !

Fonction CleanRecipientKey

La fonction CleanRecipientKey supprime ou remplace les caractères non sécurisés pour une utilisation dans les URL et les clés de destinataire. Cela inclut les espaces, les guillemets, les deux-points et d'autres caractères spéciaux pouvant causer des problèmes dans les URL personnalisées (PURL).

Cette fonction renvoie un type de données String (chaîne).

Syntaxe

CleanRecipientKey(exprAsString [, replaceInvalidWith])

Paramètre	Description
exprAsString	Obligatoire. La chaîne à nettoyer pour une utilisation comme clé de destinataire.
replaceInvalidWith	Facultatif. La chaîne de remplacement pour les caractères non valides. Si omis, les caractères non valides sont supprimés.

Exemples

1. Remplacer les espaces par des traits de soulignement :

   CleanRecipientKey("John Michael.Smith", "_")

   Résultat : "John_Michael.Smith"

2. Supprimer entièrement les caractères non valides :

   CleanRecipientKey("John's Key: 123")

   Résultat : "JohnsKey123"

3. Créer une clé PURL propre à partir du nom du destinataire :

   CleanRecipientKey(|->[FirstName] & |->[LastName] & |->[ID], "-")

   Si FirstName = "John", LastName = "O'Brien", ID = "123" :

   Résultat : "JohnO-Brien123"

4. Générer un identifiant sécurisé pour les URL :

   LCase(CleanRecipientKey(|->[CompanyName], "-"))

   Si CompanyName = "Acme & Sons, Inc." :

   Résultat : "acme---sons--inc."

Fonction SecureID

La fonction SecureID génère un identifiant unique et cryptographiquement sécurisé qui ne peut pas être deviné. Ceci est utile pour créer des clés de destinataire sécurisées pour les URL personnalisées où la prévisibilité constituerait un risque de sécurité.

Cette fonction renvoie un type de données String (chaîne).

Syntaxe

SecureID()

Cette fonction ne prend aucun paramètre.

Exemples

1. Générer un identifiant sécurisé :

   SecureID()

   Résultat : "5ADCF67B419A4AD796DA4458D25A038E" (exemple - la valeur réelle varie)

2. Créer une PURL sécurisée pour les applications sensibles :

   "https://example.com/offer/" & SecureID()

   Résultat : "https://example.com/offer/5ADCF67B419A4AD796DA4458D25A038E"

3. Combiner avec les données du destinataire pour une clé traçable mais sécurisée :

   |->[CustomerID] & "-" & SecureID()

   Si CustomerID = "C1001" :

   Résultat : "C1001-5ADCF67B419A4AD796DA4458D25A038E"

Remarque : Contrairement aux identifiants séquentiels ou aux identifiants basés sur les données du destinataire, les valeurs SecureID ne peuvent pas être prédites ni énumérées. Cela empêche l'accès non autorisé au contenu personnalisé par la déduction des URL.

Fonction HexToUnicode

La fonction HexToUnicode convertit des valeurs hexadécimales en leurs caractères Unicode correspondants. Ceci est utile pour insérer des caractères spéciaux, des symboles ou des caractères de scripts non latins.

Cette fonction renvoie un type de données String (chaîne).

Syntaxe

HexToUnicode(exprAsHexString)

Paramètre	Description
exprAsHexString	Obligatoire. Une chaîne de caractères hexadécimaux. Les groupes de quatre caractères représentent un caractère Unicode. Les groupes plus courts sont complétés avec des zéros en début.

Exemples

1. Insérer le symbole Euro :

   HexToUnicode("20AC")

   Résultat : "€"

2. Insérer le symbole de copyright :

   HexToUnicode("00A9")

   Résultat : "©"

3. Insérer un symbole de marque déposée :

   HexToUnicode("2122")

   Résultat : "™"

4. Créer un prix formaté avec un symbole de devise :

   HexToUnicode("00A3") & FormatNumber(|->[Price], "#,##0.00")

   Si Price = 1234.56 :

   Résultat : "£1,234.56"

5. Insérer plusieurs caractères :

   HexToUnicode("00A9002000AE")

   Résultat : "© ®" (copyright, espace, marque déposée)

Fonction HtmlEncode

La fonction HtmlEncode encode les caractères spéciaux en utilisant l'encodage par pourcentage (encodage URL). Cela convertit les caractères non sécurisés dans les URL en leurs équivalents hexadécimaux %XX.

Cette fonction renvoie un type de données String (chaîne).

Syntaxe

HtmlEncode(exprAsString)

Paramètre	Description
exprAsString	Obligatoire. La chaîne à encoder pour une utilisation sécurisée dans les URL.

Exemples

1. Encoder une chaîne avec des caractères spéciaux :

   HtmlEncode("John&Mary.pdf")

   Résultat : "John%26Mary.pdf"

2. Encoder les espaces dans un paramètre d'URL :

   HtmlEncode("Hello World")

   Résultat : "Hello%20World"

3. Construire une URL sécurisée avec les données du destinataire :

   "https://example.com/search?name=" & HtmlEncode(|->[FullName])

   Si FullName = "John O'Brien" :

   Résultat : "https://example.com/search?name=John%20O%27Brien"

4. Encoder un chemin de fichier pour une URL de téléchargement :

   "https://example.com/download/" & HtmlEncode(|->[FileName])

   Si FileName = "Report Q1 2024.pdf" :

   Résultat : "https://example.com/download/Report%20Q1%202024.pdf"

Rubriques associées

• Fonctions de conversion - Fonctions de conversion entre types de données

• Fonctions numériques - Fonctions pour les opérations mathématiques

• Fonctions de date - Fonctions pour les opérations de date et d'heure