Espressione regolare (TMS)

Contenuti tradotti automaticamente dall'inglese con Phrase Language AI.

L'espressione regolare (abbreviata come regex o regex) è una sequenza di carattere che forma un modello di ricerca principalmente da usare nella corrispondenza di modelli con Strings o corrispondenza di stringa. La funzionalità è simile alle operazioni trova e Sostituisci con maggiore complessità e specificità o come metodo per escludere contenuto definito. Vedere la voce wikipedia per una descrizione dettagliata delle espressioni regolari e una tabella dei carattere usati.

Per usare più espressioni regolari alla volta, inserire un carattere pipeline | tra di esse.

Le espressioni regolari possono essere usate nei campi filtrare, cercare e Sostituisci nel CAT Editor, nei campi di origine e destinazione della funzionalità cercare contenuto, per la funzionalità convertire in tag nelle impostazioni importare file e per personalizzare le regole di segmentazione. Il convertitore e il CAT Desktop Editor usare Java regex, mentre il CAT Web Editor e la ricerca in TMS usare il motore Lucene regex.

Consiglio

I chatbot IA possono essere molto efficaci nel generare e verificare espressioni regolari.

Usare Strumenti come Regex101 per testare espressioni regolari con input diversi.

Importante

Phrase supporta Java regex, ma rifiuterà espressioni regolari complesse per proteggere il sistema dal sovraccarico. Le espressioni regolari complesse sono quelle con quantificatori (eccetto i possessivi) su gruppi che contengono altri quantificatori (eccetto i possessivi).

Esempi generali

Esempi per convertire testo in tag durante l'importare di file e usare espressioni regolari nell'editor desktop per filtrare e per le funzioni Sostituisci e trova:

Esempio	Descrizione
<[^>]+>	rappresenta <html_tag>
\{[^\}]+\}	rappresenta {variable},
\[[^\]]+\]	rappresenta [variable],
\[\[.+?\]\]	rappresenta [[aa[11]bb]].
\$[^\$]+\$	represents $operator_Name1$.
\d+	rappresenta numeri. Also, [0-9]+
[A-Za-z0-9]	rappresenta qualsiasi carattere alfanumerico.
.+\\@.+\\..+	indirizzo e-mail name@dominio.com
\d{4}[-]\d{2}[-]\d{2}	la data 2018-08-01
\s$	uno spazio alla fine del segmento
^\\s	uno spazio all'inizio del segmento
\s\s	un doppio spazio
^\\d	una cifra all'inizio del segmento
\w+\s\s\w+	un doppio spazio tra le parole
\s\n	una nuova riga preceduta da qualsiasi carattere di spazio
\S\n	una nuova riga preceduta da qualsiasi carattere non di spazio
<[^>]+>\|\$[^=]+=	converte variabili php e codice html ($svariable['name'] =)
^\\s*\\'[^:]+:	converte la chiave di campo javascript con spazi aggiunti all'inizio della riga ( 'chiave' :)
\{\{[^\}]+\}\}\|\'[^']+\'	non traduce {{text here}} '{{text here}} contenuto e lo converte in tag
\{\{[^\}]+\}\}	rappresenta il contenuto tra le parentesi {{}}
$[^$]+\)	rappresenta il testo tra parentesi ()
\^[^\^]+\^	rappresenta il testo tra i segni ^
\@[^\@]+\@	rappresenta il testo tra i segni @
\^[^\^\?]+\?	rappresenta il testo tra i segni ^ e ?
\'[^']+\'	rappresenta il testo tra gli apostrofi ' '
\"[^"]+\"	rappresenta il testo tra le virgolette ""
\%[^\%]+\%	rappresenta il testo tra i simboli %
\$\{[^}]*\}	rappresenta il testo tra ${ e }, ad es. ${variabile}
\$[a-zA-Z0-9\-_]+	rappresenta una stringa che inizia con $, ad es. $appName
(?<=\: ").*(?=")	rappresenta il testo all'interno di virgolette doppie dopo due punti e uno spazio, ad es. `value` nella stringa `"chiave": "value"`
(?<=\\: ').*(?=')	rappresenta il testo all'interno di virgolette singole dopo due punti e uno spazio, ad es. `JohnDoe` nella stringa `utente: 'JohnDoe'`
(?<=\=).*(?=)	rappresenta il testo dopo un segno di uguale e senza spazio, ad es. chiave=valore
(.*)=	rappresenta il testo prima di un segno di uguale
=(.*)	rappresenta il testo dopo un segno di uguale
\/\/\S*	rappresenta i collegamenti ipertestuali. Inoltre, https:\\/\\/\\S*
</?mrk[^>]*>	rappresenta i tag HTML/XML di apertura e chiusura `mrk`, ad es. <mrk id="abc"> e </mrk>

Importazione TXT

Nota

Poiché i file TXT nel TMS vengono elaborati riga per riga, alcune espressioni regolari che lavoro in altri ambienti potrebbero non funzionare come previsto.

Esempi di espressioni regolari quando importare un testo specifico:

## ErrorMessage ##1## The number must be higher than 0. ##Z##

Per importare testo tra ##1## e ##Z## ,usare regex: (?<=##1## ).*(?= ##Z##)
ErrorMessage (\"The number must be higher than 0.\")

Per importare testo tra (\" and \") , usare regex: (?<=\$\").*(?=\"\$)
'errorMessage' = 'The number must be higher than 0.'

Per importare testo dopo il segno = e tra ' and ' , usare regex: (?<=\\= ').*(?=')
errorMessage = \"this is to be translated\"

Per importare testo dopo il segno = e tra 'and' usare regex: (?<=\\= \").*(?=\")
msgstr (\"The number must be higher than 0.\")

Per importare Strings msgstr in file PO monolingua usando un filtro TXT, usare regex: (?<=msgstr \").*(?=\")
# Note: This is a note

Per Escludi righe che iniziano con # , usare regex: (^[^#].*)
values '126', 'DCeT', 'Text (en)'

Per importare solo testo tra virgolette e con (en), come Text (en)' usare regex: (?<=')[^']*\$en\$(?=')

importare JSON

Esempio di struttura JSON:

{
"list": {
        "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"         }    ]}

per importare ogni valore indipendentemente dal livello, usare: (^|.*/)value
per importare solo un valore da un elenco, usare: list/value
per importare un valore da un elenco e/o menu, usare l'operatore | (OR): list/value|menu/value
per importare solo la prima istanza di un valore da un menu, usare: menu\\[1\\]/value
per importare il contenuto di un array JSON che segue una certa chiave, usare: (^|.*/)array\\[.*\\]
per importare il contenuto di uno specifico array di oggetti, usare: (^|.*/)arrays\\[.*\\].*

Importazione YAML

Esempio di file 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

espressione regolare per importare:

solo 'translate A' : text
solo 'translate C': categories\\[2\\]/text
solo 'translate D': categories\\[\\d+\\]/content[\\1\\]/text
all text: text|categories\[\d+\]/text|categories\[\d+\]/content[\d+\]/text

Regole di segmentazione

Okapi, Java e Unicode sono usati per le regole di segmentazione nei file .SRX.

Usare le espressioni regolari nei file .SRX è complesso e si raccomanda una conoscenza di base dell'uso delle espressioni regolari prima di tentare di lavorare con esse.

Le regole di nobreak (abbreviazioni ecc.) e le regole di break (fine della frase con un punto, ecc.) sono nei file .SRX.

Esempio	Descrizione
[\p{C}]	Carattere di controllo invisibile.
[\p{Z}]	Spazio bianco
[\p{Lu}]	Una lettera maiuscola che ha una variante minuscola.
[\p{N}]	Qualsiasi tipo di carattere numerico.
\Q ... \E	Inizio e fine di una citazione - (\QApprox.\E). Questo viene utilizzato per le abbreviazioni.
\t	Tabulatore
\n	Nuova riga
\u2029	Separatore di paragrafo
\u200B	Spazio di larghezza zero
\u3002	Punto fermo ideografico
\ufe52	Punto fermo piccolo
\uff0e	Punto fermo a larghezza intera
\uff61	Punto fermo ideografico a mezza larghezza
\ufe56	Punto interrogativo piccolo
\uff1f	Punto interrogativo a larghezza intera
\u203c	Punto esclamativo doppio
\u2048	Punto interrogativo esclamativo
\u2762	Ornamento punto esclamativo pesante
\u2763	Ornamento punto esclamativo a cuore pesante
\ufe57	Punto esclamativo piccolo
\uff01	Punto esclamativo a larghezza intera
`[\u0080-\uFFFF]+`	Caratteri dall'intervallo Unicode \u0080 a \uFFFF
`[\u00a8\u00b9\u00c4]+`	Una o più occorrenze dei caratteri Unicode specificati all'interno delle parentesi quadre, ad es. \u00a8 + \u00b9 + \u00c4

Controlli QA personalizzati comuni

Controllo QA	Regex di origine	Regex di destinazione
Numeri aggiuntivi nella destinazione	`\d`	`\d`
Ordine dei tag (non accoppiati, per segmenti con 3 tag). Regolare la regex in base al numero richiesto di tag.	`^.\{1\}.\{2\}.\{3\}.$`	`^.\{1\}.\{2\}.\{3\}.$`
Ordine dei tag (accoppiati, per segmenti con 3 tag). Regolare la regex in base al numero richiesto di tag.	`^.\\{1\\>.\\<1\\}.\\{2\\>.\\<2\\}.\\{3\\>.\\<3\\}.*$`	`^.\\{1\\>.\\<1\\}.\\{2\\>.\\<2\\}.\\{3\\>.\\<3\\}.*$`
Spazio prima dei tag	`\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}\})`
Spazio dopo i tag	`(\{[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`
Nessuno spazio prima dei tag	`\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}\})`
Caratteri non di spazio dopo i tag accoppiati	`((\{[1-9][0-9]>)\|(<[1-9][0-9]\}))\S`	`((\{[1-9][0-9]>)\|(<[1-9][0-9]\}))\S`
Parentesi quadre mancanti	`[^\[\]]\[[^\[\]]\][^\[\]]*`	`[^\[\]]\[[^\[\]]\][^\[\]]*`
Parentesi tonde mancanti	`[^]$[^\($]\)[^]*`	`[^]$[^\($]\)[^]*`
Usare le seguenti espressioni regolari per verificare lo stesso conteggio di numeri decimali identici, utilizzando il separatore decimale appropriato per la lingua.	`(?<;n1>;\d+)\.(?<;n2>;\d+)`	`(?<;n1>;\d+),(?<;n2>;\d+)`