In Chain Builder, puoi utilizzare gli operatori di espressione regolare (regex) per abbinare i caratteri delle stringhe di testo, ad esempio per definire i modelli per:
- Mappatura delle regole di trasformazione per una pipeline Data Prep connettore
- I comandi Utilità file connettore's Trova, Trova e sostituisci, e Dividi file
- La trasformazione tabellare Il connettore 's Filtro colonne, Filtrare le righe, Trovare e sostituire, Unire le colonne, e Comandi di filtro intelligente delle righe
Operatori comuni
Per definire i modelli da abbinare, puoi utilizzare questi operatori comuni:
| Operatore | Descrizione | Esempio | Restituzioni |
|---|---|---|---|
^ |
Corrisponde all'inizio di una stringa | ^abc |
abc, abcdef..., abc123 |
$ |
Corrisponde alla fine di una stringa | abc$ |
my:abc, 123abc, theabc |
. |
Corrisponde a qualsiasi carattere come carattere jolly | a.c |
abc, asc, a123c |
| |
Un carattere OR | abc|xyz |
abc o xyz |
(...) |
Cattura i valori tra le parentesi | (a)b(c) |
a e c |
[...] |
Corrisponde a qualsiasi cosa all'interno delle parentesi | [abc] |
a, b, o c |
[a-z] |
Corrisponde ai caratteri minuscoli tra a e z | [b-z] |
bc, mente, xyz |
[0-9] |
Corrisponde a qualsiasi valore numerico compreso tra 0 e 9 | [0-3] |
3201 |
{x} |
Il numero esatto di volte da abbinare | (abc){2} |
abcabc |
{x,} |
Il numero minimo di volte da abbinare | (abc){2,} |
abcabcabc |
* |
Corrisponde a qualsiasi cosa al posto di *, o a una corrispondenza "avida". | ab*c |
abc, abbcc, abcdc |
+ |
Corrisponde al carattere prima del + una o più volte | a+c |
ac, aac, aaac |
? |
Corrisponde al carattere prima del ? zero o una volta, oppure è una corrispondenza "non avida". | ab?c |
ac, abc |
/ |
Esegue l'escape del carattere dopo la /, oppure crea una sequenza di escape | a/bc |
a c, con lo spazio corrispondente a /b |
Per utilizzare il carattere letterale di un operatore all'interno di uno schema, non come regex:
- Per un carattere circonflesso (
^), un punto (.), una parentesi aperta ([), un segno del dollaro ($), una parentesi aperta o chiusa (() o ()), una pipe (|), un asterisco (*), un segno più (+), un punto interrogativo (?), parentesi graffa aperta ({) o backslash (\), seguiti dall'operatore di escape (\). - Per una parentesi graffa finale (
]) o una parentesi graffa finale (}), fai in modo che sia il primo carattere, con o senza apertura^. - Per un trattino (
-), usa il primo o l'ultimo carattere o il secondo estremo di un intervallo.
Suggerimento: Tutti i caratteri all'interno delle parentesi sono considerati letteralmente e non come operatori regex. Ad esempio, [*\+?{}.] corrisponde a qualsiasi carattere letterale all'interno delle parentesi.
Corrisponde all'inizio o alla fine della stringa (^ e $)
Per abbinare i modelli all'inizio o alla fine della stringa, usa gli operatori ^ e $ , rispettivamente. Ad esempio:
| Esempio | Corrisponde |
|---|---|
^Il |
Qualsiasi stringa che inizi con Il |
di disperazione$ |
Qualsiasi stringa che finisca con di disperazione |
^abc$ |
Una stringa che inizia e finisce con abc- una corrispondenza esatta |
Suggerimento: Se non viene utilizzato ^ o $, il modello corrisponde a qualsiasi stringa che contenga i caratteri specificati. Ad esempio, notice- senza ^ o $- restituisce qualsiasi stringa che contenga notice.
Corrispondenza di caratteri (*, +, e ?)
Per ottenere una corrispondenza basata su un carattere specifico, segui il carattere con l'operatore *, +, o ?. Questi operatori indicano il numero di volte in cui il carattere deve essere presente per una corrispondenza, rispettivamente zero o più, uno o più o uno o zero. Ad esempio:
| Esempio | Corrispondenze |
|---|---|
ab* |
Una stringa che contiene a, seguito da zero o più bs-ac, abc, o abbc |
ab+ |
Una stringa che contiene a, seguito da uno o più bs-abc o abbc, ma non ac |
ab? |
Una stringa che contiene a, seguito da zero o uno bs-ac o abc, ma non abc |
a?b+$ |
Una stringa che termina con uno o più bs, con o senza un precedente a; per esempio, ab, abb, b, o bb, ma non aab o aabb |
Corrisponde alla frequenza dei caratteri ({...} o (...))
Per trovare una corrispondenza in base alla frequenza di un singolo carattere, seguilo con il numero o l'intervallo di istanze, racchiuso tra parentesi graffe ({...}). Ad esempio:
| Esempio | Corrispondenze |
|---|---|
ab{2} |
Una stringa che contiene a, seguito da esattamente 2 bs-abb |
ab{2,} |
Una stringa che contiene a, seguito da almeno 2 bs-abb, abbbb, ecc. |
ab{3,5} |
Una stringa che contiene a, seguito da tre a cinque bs-abbb, abbbb, o abbbbb |
Suggerimento: Specifica sempre il primo numero di un intervallo:{0,2}, non {,2}. Invece degli intervalli {0,}, {1,}, o {0,1}, puoi usare gli operatori *, +, o ?, rispettivamente.
Per abbinare un modello basato sulla frequenza di una sequenza di caratteri, avvolgila tra parentesi ((...)). Ad esempio, a(bc){1,5} corrisponde a una stringa che contiene a, seguita da una a cinque istanze di bc.
Corrisponde a uno dei modelli multipli (|)
Per abbinare uno dei modelli multipli - ad esempio questo O che- usa l'operatore OR |. Ad esempio:
| Esempio | Abbinamenti |
|---|---|
ciao|hello |
Una stringa che contiene hi o hello |
(b|cd)ef |
Una stringa che contiene bef o cdef |
(a|b)*c |
Una stringa con una sequenza alternata di as e bs, che termina con c |
Corrisponde a qualsiasi carattere (.)
Per rappresentare qualsiasi carattere in un modello da abbinare, usa l'operatore jolly .. Ad esempio:
| Esempio | Abbinamenti |
|---|---|
a.[0-9] |
Una stringa che contiene a, seguita da qualsiasi carattere e da una cifra |
^.{3}$ |
Qualsiasi stringa di tre caratteri esatti |
Corrisponde alla posizione del carattere ([...])
Per abbinare un modello basato sulla posizione di un carattere, usa le parentesi ([...]). Ad esempio:
| Esempio | Corrisponde |
|---|---|
[ab] |
Una stringa che contiene a o b; equivalente a a|b |
[a-d] |
Una stringa che contiene una minuscola |
^[a-zA-Z] |
Una stringa che inizia con qualsiasi lettera, indipendentemente dalle maiuscole e dalle minuscole |
[0-9]% |
Una stringa che contiene qualsiasi cifra singola seguita da un segno di percentuale |
,[a-zA-Z0-9]$ |
Una stringa che termina con una virgola seguita da qualsiasi carattere |
Nota: Tutti i caratteri all'interno delle parentesi sono considerati letteralmente e non come operatori regex. Ad esempio, [*\+?{}.] corrisponde a qualsiasi carattere letterale all'interno delle parentesi.
Corrisponde a caratteri indesiderati ([^...])
Per corrispondere a un modello che non contiene caratteri, inizia la sequenza con un operatore ^ e avvolgila tra parentesi. Ad esempio, %[^a-zA-z]% corrisponde a una stringa con qualsiasi carattere non lettera tra due segni di percentuale.