Expression régulière (TMS)

Le contenu est traduit de l’anglais par Phrase Language AI.

L'expression régulière (abrégée en regex ou regex) est une séquence de caractères qui forme un modèle de recherche principalement pour une utilisation dans la correspondance de modèles avec des Strings ou la correspondance de chaîne. La fonctionnalité est similaire aux opérations rechercher et Remplacer avec plus de complexité et de spécificité ou comme méthode pour exclure du contenu défini. Consultez l'entrée wikipedia pour une description détaillée des expressions régulières et un tableau des caractères utilisés.

Pour utiliser plusieurs expressions régulières à la fois, insérez un caractère de pipeline | entre elles.

Les expressions régulières peuvent être utilisées dans les champs de filtre, de recherche et de Remplacer dans le CAT Editor, dans les champs source et cible de la fonctionnalité de recherche de contenu, pour la fonctionnalité Convertir en balises dans les paramètres d'importation de fichiers et pour personnaliser les règles de segmentation. Le convertisseur et le CAT Desktop Editor utilisent Java regex, tandis que le CAT Web Editor et la recherche dans TMS utilisent le moteur Lucene regex.

Astuce

Les chatbots utilisant l'IA peuvent être très efficaces pour générer et vérifier les expressions régulières.

Utilisez des outils comme Regex101 pour tester votre expression régulière avec différentes entrées.

Important

Phrase prend en charge Java regex, mais rejettera les expressions régulières complexes pour protéger le système contre une surcharge. Les expressions régulières complexes sont celles comportant des quantificateurs (à l'exception des possessifs) sur des groupes qui contiennent d'autres quantificateurs (à l'exception des possessifs).

Exemples généraux

Exemples pour convertir du texte en balises lors de l'importation de fichiers et utiliser des expressions régulières dans l'éditeur de bureau pour les fonctions de filtre et de Remplacer :

Exemple	Description
<[^>]+>	représente <html_tag>
\{[^\}]+\}	représente {variable},
\[[^\]]+\]	représente [variable],
\[\[.+?\]\]	représente [[aa[11]bb]].
\$[^\$]+\$	represents $operator_Name1$.
\d+	représente des nombres. Également, [0-9]+
[A-Za-z0-9]	représente n'importe quel caractère alphanumérique.
.+\@.+\..+	email address name@domain.com
\d{4}[-]\d{2}[-]\d{2}	la date 2018-08-01
\s$	un espace à la fin du segment
^\s	un espace au début du segment
\s\s	un double espace
^\d	un chiffre au début du segment
\w+\s\s\w+	un double espace entre les mots
\s\n	un saut de ligne précédé par n'importe quel caractère d'espace
\S\n	un saut de ligne précédé par n'importe quel caractère sans espace
<[^>]+>\|\$[^=]+=	convertit les variables php et le code html ($svariable['name'] =)
^\s*\'[^:]+:	convertit la clé de champ javascript avec des espaces ajoutés au début de la ligne ( 'clé' :)
\{\{[^\}]+\}\}\|\'[^']+\'	ne traduit pas {{text here}} le contenu '{{text here}} et le convertit en balises
\{\{[^\}]+\}\}	représente le texte entre les crochets {{}}
$[^$]+\)	représente le texte entre les crochets ()
\^[^\^]+\^	représente le texte entre les marques ^
\@[^\@]+\@	représente le texte entre les marques @
\^[^\^\?]+\?	représente le texte entre les marques ^ et ?
\'[^']+\'	représente le texte entre les apostrophes ' '
\"[^"]+\"	représente le texte entre les guillemets \"\"
\%[^\%]+\%	représente le texte entre les symboles %
\$\{[^}]*\}	représente le texte entre ${ et }, par ex. ${variable}
\$[a-zA-Z0-9\-_]+	représente une chaîne qui commence par $, par ex. $appName
(?<=\: ").*(?=")	représente le texte entre guillemets après un deux-points et une Espace, par ex. `value` dans la chaîne `\"key\": \"value\"`
(?<=\: ').*(?=')	représente le texte entre guillemets simples après deux-points et une espace, par ex. `JohnDoe` dans la chaîne `utilisateur: 'JohnDoe'`
(?<=\=).*(?=)	représente le texte après un signe égal et sans espace, par ex. clé=valeur
(.*)=	représente le texte avant un signe égal
=(.*)	représente le texte après un signe égal
\/\/\S*	représente les hyperliens. Également, https:\\/\\/\\S*
</?mrk[^>]*>	représente les balises `mrk` HTML/XML ouvrantes et fermantes, par ex. <mrk id=\"abc\"> et </mrk>

importer TXT

Remarque

Comme les fichiers TXT dans TMS sont traités ligne par ligne, certaines expressions régulières qui fonctionnent dans d'autres environnements peuvent ne pas fonctionner comme prévu.

Exemples d'expressions régulières lors de l'importer d'un texte spécifique :

## ErrorMessage ##1## Le nombre doit être supérieur à 0. ##Z##

Pour importer du texte entre ##1## et ##Z## ,utiliser l'expression régulière : (?<=##1## ).*(?= ##Z##)
ErrorMessage (\"Le nombre doit être supérieur à 0.\")

Pour importer du texte entre (\" et \") , utiliser l'expression régulière : (?<=\$\").*(?=\"\$)
'errorMessage' = 'Le nombre doit être supérieur à 0.'

Pour importer du texte après le signe = et entre ' et ' , utiliser l'expression régulière : (?<=\\= ').*(?=')
errorMessage = \"ceci doit être traduit\"

Pour importer du texte après le signe = et entre 'et', utiliser l'expression régulière : (?<=\\= \").*(?=\")
msgstr (\"Le nombre doit être supérieur à 0.\")

Pour importer des Strings msgstr dans des fichiers BDC monolingues en utilisant un filtre TXT, utiliser l'expression régulière : (?<=msgstr \").*(?=\")
# Remarque : Ceci est une remarque

Pour Exclure les lignes commençant par # , utiliser l'expression régulière : (^[^#].*)
valeurs '126', 'DCeT', 'Texte (en)'

Pour importer uniquement le texte entre guillemets et avec (en), tel que Texte (en)' utiliser l'expression régulière : (?<=')[^']*\$en\$(?=')

JSON Import

Exemple de structure JSON :

{
"liste": {
        "id": "1",
        "value": "text 1 for translation."
        },
"text": {
        "id": "2",
        "value": "text 2 for translation."
        },
"menu": {
        "id": "3",
        "value": "text 3 for translation."
         },"array": ["blue","green"],"arrays": [{        "color": "blue",        "title": "BLUE"
         },         {        "color": "green",        "title": "GREEN"         }    ]}

pour importer chaque valeur quel que soit le niveau, utiliser : (^|.*/)value
pour importer une seule valeur d'une liste, utiliser : list/value
pour importer une valeur d'une liste et/ou d'un menu, utiliser l'opérateur | (OU) : list/value|menu/value
pour importer uniquement la première instance d'une valeur d'un menu, utiliser : menu\\[1\\]/value
pour importer le contenu d'un tableau JSON suivant une certaine clé, utiliser : (^|.*/)array\\[.*\\]
pour importer le contenu d'un tableau d'objets spécifique, utiliser : (^|.*/)arrays\\[.*\\].*

Importer YAML

Exemple de fichier YAML :

title: A
text: translate A
categories:
  title: B
  text: translate B
categories:
  title: C
  text: translate C
categories:
  content:
      title: D
      text: translate D

expression régulière pour l'importation :

seulement 'traduire A' : texte
seulement 'traduire C': catégories\[2\]/texte
seulement 'traduire D': catégories\[\\d+\]/contenu\[\\1\]/texte
tout le texte : texte|catégories\[\\d+\]/texte|catégories\[\\d+\]/contenu\[\\d+\]/texte

Règles de segmentation

Okapi, Java et Unicode sont utilisés pour les règles de segmentation dans les fichiers .SRX.

Utiliser des expressions régulières dans les fichiers .SRX est complexe et une connaissance de base de l'utilisation des expressions régulières est recommandée avant de tenter de travailler avec.

Les règles de non-coupure (abréviations, etc.) et les règles de coupure (fin de phrase avec un point, etc.) se trouvent dans les fichiers .SRX.

Exemple	Description
[\p{C}]	Caractère de contrôle invisible.
[\p{Z}]	Whitespace
[\p{Lu}]	Une lettre majuscule qui possède une variante minuscule.
[\p{N}]	Tout type de caractère numérique.
\Q ... \E	Début et fin d'une citation - (\QApprox.\E). Ceci est utilisé pour les abréviations.
\t	Tabulation
\n	Saut de ligne
\u2029	Séparateur de paragraphe
\u200B	Espace sans chasse
\u3002	Point idéographique
\ufe52	Petit point
\uff0e	Point pleine chasse
\uff61	Point idéographique demi-chasse
\ufe56	Petit point d'interrogation
\uff1f	Point d'interrogation pleine chasse
\u203c	Double point d'exclamation
\u2048	Point d'interrogation et point d'exclamation
\u2762	Ornement point d'exclamation gras
\u2763	Ornement point d'exclamation en forme de cœur gras
\ufe57	Petit point d'exclamation
\uff01	Point d'exclamation pleine chasse
`[\u0080-\uFFFF]+`	Caractères de la plage Unicode \u0080 à \uFFFF
`[\u00a8\u00b9\u00c4]+`	Une ou plusieurs occurrences des caractères Unicode spécifiés entre crochets, par ex. \u00a8 + \u00b9 + \u00c4

Vérifications QA personnalisé courantes

Contrôle QA	Regex source	Regex cible
Nombres supplémentaires dans la cible	`\d`	`\d`
Commande des balises (non appariées, pour les segments avec 3 balises). Ajuster la regex en fonction du nombre de balises requis.	`^.\{1\}.\{2\}.\{3\}.$`	`^.\{1\}.\{2\}.\{3\}.$`
Commande des balises (appariées, pour les segments avec 3 balises). Ajuster la regex en fonction du nombre de balises requis.	`^.\\{1\\>.\\<1\\}.\\{2\\>.\\<2\\}.\\{3\\>.\\<3\\}.*$`	`^.\\{1\\>.\\<1\\}.\\{2\\>.\\<2\\}.\\{3\\>.\\<3\\}.*$`
Espaces avant les balises	`\s(\{[1-9][0-9]\}\|\{[1-9][0-9]>\|<[1-9][0-9]*\}\|\{[biu_\^]{1,4}>\|<[biu_\^]{1,4}\})`	`\s(\{[1-9][0-9]\}\|\{[1-9][0-9]>\|<[1-9][0-9]*\}\|\{[biu_\^]{1,4}>\|<[biu_\^]{1,4}\})`
Espaces après les balises	`(\{[1-9][0-9]\}\|\{[1-9][0-9]>\|<[1-9][0-9]*\}\|\{[biu_\^]{1,4}>\|<[biu_\^]{1,4}\})\s`	`(\{[1-9][0-9]\}\|\{[1-9][0-9]>\|<[1-9][0-9]*\}\|\{[biu_\^]{1,4}>\|<[biu_\^]{1,4}\})\s`
Aucun Espace avant les balises	`\S(\{[1-9][0-9]\}\|\{[1-9][0-9]>\|<[1-9][0-9]*\}\|\{[biu_\^]{1,4}>\|<[biu_\^]{1,4}\})`	`\S(\{[1-9][0-9]\}\|\{[1-9][0-9]>\|<[1-9][0-9]*\}\|\{[biu_\^]{1,4}>\|<[biu_\^]{1,4}\})`
Caractères sans Espace après les balises appariées	`((\{[1-9][0-9]>)\|(<[1-9][0-9]\}))\S`	`((\{[1-9][0-9]>)\|(<[1-9][0-9]\}))\S`
Crochets manquants	`[^\[\]]\[[^\[\]]\][^\[\]]*`	`[^\[\]]\[[^\[\]]\][^\[\]]*`
Parenthèses manquantes	`[^]$[^\($]\)[^]*`	`[^]$[^\($]\)[^]*`
Utiliser les expressions régulières suivantes pour vérifier le même nombre de nombres décimaux identiques, en utilisant le séparateur décimal approprié à la langue.	`(?<;n1>;\d+)\.(?<;n2>;\d+)`	`(?<;n1>;\d+),(?<;n2>;\d+)`