Categorie
Javascript Programmazione

{JS} new RegExp()

L’oggetto RegEx

Una espressione regolare è uno schema di stringa (pattern) composto da una sequenza di caratteri alfanumerici e di eventuali caratteri speciali.

Un potente strumento per il controllo formale della sintassi di una stringa al fine di verificare che questa corrisponda o meno ad un modello (pattern) predefinito.

JavaScript ha un supporto nativo per le espressioni regolari basato sull’oggetto RegExp, avremo quindi proprietà e metodi che ci consentiranno di gestire i testi, individuare ed eventualmente sostituire stringhe all’interno di altre stringhe.

Un classico esempio di controllo di espressione regolare è rappresentato dalla verifica della corretta formattazione sintattica dell’indirizzo email o il controllo formale di un codice fiscale

Dichiarazione di una espressione regolare

La creazione di un’espressione regolare è possibile attraverso l’utilizzo dell’oggetto RegExp o attraverso una speciale notazione letterale

Tramite l’oggetto RegEx

var espressioneRegolare = new RegExp('^[a-z]+$','i');

Tramite notazione letterale

var espressioneRegolare = /^[a-z]+$/i;

Creazione del pattern

Delimitazione

Il pattern di un espressione regolare è delimitato da uno slash “/” in apertura ed un altro “/” in chiusura.

Sintassi

Per capire come scrivere correttamente un pattern per le espressioni regolari prendiamo come esempio la seguente RegExp:

var espressioneRegolare = /^[a-z0-9]+$/i;

di seguito elenchiamo tutte le regole di sintassi, dei metacaratteri e caratteri speciali, che una RegExp può contenere:

^indica che la stringa deve iniziare con
[ ]indicano qualsiasi carattere tra quelli al loro interno
[^ ]esclude i caratteri contenuti nelle parentesi
a-z 0-9indica un range e che la stringa può contenere tutti i caratteri che vanno da “a” a “z” e da 0 a 9
+indica che la stringa deve contenere almeno uno dei caratteri tra le parentesi quadre
$indica il termine della stringa

Ipotizziamo che uno dei caratteri da controllare in un’espressione regolare sia proprio un metacarattere o carattere speciali potremo usare il carattere back-slash (\) per isolarlo

\literal escape, isola da metacaratteri e caratteri speciali
.tutti i caratteri tranne il ritorno a capo
\wverifica che i caratteri siano minuscoli alfanumerici
\Wverifica che i caratteri siano maiuscoli alfanumerici
\dqualsiasi cifra numerica
\Dqualsiasi carattere che non sia una cifra numerica
\sindica uno spazio vuoto
\Squalsiasi carattere che non sia uno spazio vuoto
\tuna tabulazione
\rindica un carriage return
\nindica un linefeed
Ripetizioni di caratteri o caratteri che deve contenere/delimitatori
{n}deve ripetere/contenere n ripetizioni/caratteri
{n, }deve ripetere/contenere almeno n ripetizioni/caratteri a infinito
{n, n}deve ripetere/contenere almeno n ripetizioni/caratteri ed un massimo di n ripetizioni/caratteri
*equivale a {0, }, ovvero, può non contenere nessuna ripetizione/caratteri a infinito
+equivale a {1, }, ovvero, deve contenere almeno una ripetizione/carattere a infinito
? indica il carattere precedente per 0 o 1 occorrenza, se c’è o non c’è
( … ) le parentesi tonde identificano dei gruppi di caratteri 
( … | … )il simobolo | identifica un alternanza (o questo o quello) all’interno del gruppo
Esempi snippet riutilizzabili

Questi esempi di pattern già pronti sono utili a comprende il funzionamento di quanto precedentemente spiegato:

Nome/^[A-Za-z ]{6,30}$/
Password/^[A-Za-z0-9]{8,20}$/
Email/^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/
Url/^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/
IP/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/

Modificatori

Al termine è posto quello che è chiamato modificatore “i”
I modificatori indicano al nostro programma di effettuare la ricerca in una determinata maniera:

iesegue una ricerca ignorando la distinzione tra maiuscole e minuscole
gesegue una ricerca globale, cioè individua tutte le occorrenza di un pattern, non si ferma quindi alla prima occorrenza
mesegue una ricerca su stringhe multilinea, il pattern viene confrontato con ogni linea del testo

E’ possibile includere più modificatori all’interno della nostro pattern

var espressioneRegolare = new RegExp("^[a-z]+$", "ig");
var espressioneRegolare = /^[a-z]+$/ig;

Proprietà

Le proprietà di Regexp indicano se per l’espressione corrente sono stati specificati i rispettivi modificatori e restituiscono valori booleani (true/false)

  1. global (g)
  2. ignorecase (i)
  3. multiline (m)
var espressioneRegolare = /^[a-z]+$/ig;
var verificaG = espressioneRegolare.global;
var verificaI = espressioneRegolare.ignorecase;
var verificaM = espressioneRegolare.multiline;
document.write(verificaG); // Risulterà true
document.write(verificaI); // Risulterà true
document.write(verificaM); // Risulterà false

Metodi

L’oggetto RegExp ha a disposizione diversi metodi, tra i più comuni ci sono test() e exec()

test()

Per impostare il controllo di un’espressione regolare si utilizza il metodo test() dell’oggetto RegExp il quale restituirà true in caso di successo o false in caso contrario

var testoDaVerificare = "luca.bianchi";

var patternVerifica = /^[a-z]+$/ig;
var risultatoVerifica = patternVerifica.test(testoDaVerificare);
doucment.write(risultatoVerifica); /* Il risultato stampato sarà false */

/* oppure */

if (risultatoVerifica == true) {
document.write("Verifica Superata!);
}else{
document.write("Verifica Fallita.");
}

exec()

Se il metodo test() restuisce semplicemente true o false, il metodo exec() restuisce la stringa corrispondente al pattern (se trovata) oppure null (in caso di match non riuscito)

var testoDaVerificare = "Luca.bianchi";

var patternVerifica = /^luca/i;
/* La stringa dovrà iniziare con la parola Luca ignore-case*/

var risultatoVerifica = patternVerifica.exec(testoDaVerificare);
document.write(risultatoVerifica);
/* Sarà stampato a video "Luca" */

Metodi di String compatibili:
search(), replace(), split() e match()

Alcuni metodi dell’oggetto String accettano espressioni regolari come argomento.

Il metodo search() dell’oggetto String restituisce l’indice della prima occorrenza di una stringa individuata tramite l’espressione regolare passata come argomento

var x = "str1nga".search(/\d/);

Anche il metodo split(), che genera un array a partire da una stringa, accetta espressioni regolari come input

var x = "str1nga".split(/\d/);	//["str", "nga"]

Il metodo replace() consente di sostituire una o più occorrenze di una stringa individuata da un’espressione regolare con un’altra stringa

var x = "str1ng4".replace(/\d/g, "numero");	//"strnumerongnumero"
Note: come vedremo successivamete \d identifica tutti i caratteri con valore numerico

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *