Espressione regolare (TMS)

Contenuti tradotti automaticamente dall'inglese con Phrase Language AI.

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

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

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

Consiglio

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

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

Importante

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

Esempi generali

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

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	un'interruzione di riga preceduta da qualsiasi carattere di spazio
\S\n	un'interruzione di riga preceduta da qualsiasi carattere non di spazio
<[^>]+>\|\$[^=]+=	converte variabili php e codice html ($svariable['name'] =)
^\s*\'[^:]+:	converte la chiave di campo di 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 simboli ^
\@[^\@]+\@	rappresenta il testo tra i simboli @
\^[^\^\?]+\?	rappresenta il testo tra i simboli ^ 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 delle virgolette dopo i due punti e uno spazio, ad es. `valore` nella stringa `"chiave": "valore"`
(?<=\\: ').*(?=')	rappresenta il testo all'interno degli apostrofi dopo i 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>

Importare TXT

Nota

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

Esempi di espressioni regolari durante l'importazione di un testo specifico:

## ErrorMessage ##1## Il numero deve essere maggiore di 0. ##Z##

Per importare il testo tra ##1## e ##Z## ,usare regex: (?<=##1## ).*(?= ##Z##)
Messaggio di errore ("Il numero deve essere superiore a 0.")

Per importare il testo tra (\" e \") , usare regex: (?<=\$\").*(?=\"\$)
'errorMessage' = 'Il numero deve essere maggiore di 0.'

Per importare testo dopo il segno = e tra ' e ' , usare regex: (?<=\\= ').*(?=')
messaggioDiErrore = \"questo deve essere tradotto\"

Per importare il testo dopo il segno = e tra 'e' usare regex: (?<=\\= \").*(?=\")
msgstr ("Il numero deve essere superiore a 0.")

Per importare Strings msgstr in file PO monolingua usando un filtro TXT, usare la regex: (?<=msgstr \").*(?=\")
# Nota: Questa è una nota

Per escludere le righe che iniziano con # , usare regex: (^[^#].*)
valori '126', 'DCeT', 'Testo (en)'

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

Importazione 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 non interruzione (abbreviazioni ecc.) e le regole di interruzione (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 a 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
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, usando il separatore decimale appropriato specifico per la lingua.	`(?<;n1>;\d+)\.(?<;n2>;\d+)`	`(?<;n1>;\d+),(?<;n2>;\d+)`

Controllo QA	Regex di origine	Regex di destinazione
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, usando il separatore decimale appropriato specifico per la lingua.	`(?<;n1>;\d+)\.(?<;n2>;\d+)`	`(?<;n1>;\d+),(?<;n2>;\d+)`