Appunti su RegExp: Oggetto JavaScript RegExp

Panoramica

Il costruttore RegExp crea un oggetto di espressione regolare, utilizzando il modello per corrispondere al testo.

Per una presentazione degli espressioni regolari, leggere la sezione Espressioni Regolari del Manuale JavaScript.

Sintassi

Sono possibili testi e simboli costruttivi:
/pattern/flags new RegExp(pattern [, flags])

Parametri

pattern
Testo dell'espressione regolare
flags
Se specificato, il flag può essere una combinazione di qualsiasi valore seguente:

g
Corrispondenza globale
i
Ignora maiuscole e minuscole
m
Multi-line; Lascia che i caratteri di inizio e fine (^ e $) funzionino in modalità multi-linea (ad esempio, ^ e $ possono corrispondere all'inizio e alla fine di ogni riga della stringa, divisa da \n o \r, non solo all'inizio e alla fine dell'intera stringa di input).
u
Unicode. Considera il modello come una sequenza di punti di codice (code points) Unicode.
y
Viscosità; In una stringa di destinazione, la corrispondenza inizia solo dalla posizione specificata dall'attributo lastIndex dell'espressione regolare (e non tenta di corrispondere da qualsiasi indice successivo).
Description
There are two ways to create a regular expression object: literals and constructors. To represent a string, the literal form does not use quotes, and the parameters passed to the constructor use quotes. The following expression creates the same regular expression:

/ab+c/i;
new RegExp('ab+c', 'i');
new RegExp(/ab+c/, 'i');

When the expression is assigned, the literal form provides the compilation state of the regular expression, which is used when the regular expression remains constant. For example, when you use a literal to construct a regular expression in a loop, the regular expression will not be recompiled (recompiled) in each iteration.
The constructor of regular expression objects, such as new RegExp('ab+c'), provides runtime compilation of regular expressions. If you know that the regular expression pattern will change, or if you do not know what pattern to use in advance but obtain it from another source, such as user input, these situations can be handled using the constructor.
Starting from ECMAScript 6, when the first parameter is a regular expression and the second flag parameter exists, new RegExp(/ab+c/, 'i') no longer throws a TypeError ('Flags are not supported when constructing from other regular expressions') exception, instead, a new regular expression will be created using these parameters.

When creating regular expression objects using the constructor, you need to follow the standard character escaping rules (add a backslash \ in front). For example, the following are equivalent:

var re = new RegExp("\\w+");
var re = /\w+/;

Define regular expressions by literals
var expression = /pattern/ flags;
The pattern part can be any simple or complex regular expression
flag indicates the behavior of regular expression 1.g: Global mode, does not stop after finding the first match 2.i: Case insensitive mode 3.m: Multiline mode
Esempio:

var pattern1 = /at/g; //Match all 'at' in the string
var pattern2 = /[bc]at/i; //Match 'bat' or 'cat', case insensitive
var pattern3 = /.at/gi; //Global match for three characters ending with '.at', case insensitive

All the meta characters used in the pattern must be escaped. Meta characters in regular expressions include:([{\^$|?*+.}])
Esempio:

var pattern4 = /\[bc\]at/i; //Match the first '[bc]at', case insensitive

Utilizza il costruttore RegExp, accetta 2 parametri, parametro 1: il modello di stringa da abbinare, parametro 2: flag opzionale di comportamento
Esempio:

var pattern5 = new RegExp("[bc]at", "i");

Nota: poiché i parametri del costruttore RegExp sono tutti stringhe, in alcuni casi è necessario effettuare una doppia escape. Tutti i caratteri di escape devono essere doppiamente escapati

Esempio:
Letterale 　　　　　　 Stringa equivalente
/\[bc\]at/ 　　　　 "\\[bc\\]at"
/\.at/ 　　　　　　 "\\.at"
/name/\age/ 　　 "name\\/age"
/\d.\d{1,2}/ 　　 "\\d.\\d{1,2}"
/\w\\hello\\123/ "\\w\\\\hello\\\\123"

Nota: la creazione di un'espressione regolare tramite letterale e istanziazione non è la stessa, il letterale condivide sempre la stessa istanza RegExp (ECMAScript3). Ogni nuova istanza di RegExp creata tramite il costruttore è una nuova istanza.

Proprietà dell'istanza RegExp

console.log(pattern5.global); //false Se è stato impostato il flag g
console.log(pattern5.ignoreCase); //true Se è stato impostato il flag i
console.log(pattern5.multiline); //false Se è stato impostato il flag m
console.log(pattern5.lastIndex); //0 Posizione di partenza per la ricerca della prossima corrispondenza
console.log(pattern5.source); //[bc]at Rappresentazione stringa dell'espressione regolare

Proprietà ereditate

console.log(pattern5.toString()); // /[bc]at/i Rappresentazione letterale dell'espressione regolare
console.log(pattern5.toLocaleString()); // /[bc]at/i Rappresentazione letterale dell'espressione regolare
console.log(pattern5.valueOf()); // /[bc]at/i Rappresentazione letterale dell'espressione regolare

Metodi dell'istanza RegExp
Metodo uno: exec(), accetta un parametro, una stringa di modello applicativa. Restituisce un array contenente le informazioni della prima corrispondenza, se non c'è restituisce null, l'istanza dell'array restituito contiene due attributi index(la posizione della corrispondenza nel carattere) e input(stringa applicativa del regex).

var text = "huang jin liang shi ge hao ren";
var pattern6 = new RegExp("huang( jin liAng( shi ge hao ren)?)?", "i");
var matches = pattern6.exec(text);
console.log(matches); 
//[ 'huang jin liang shi ge hao ren',
// ' jin liang shi ge hao ren',
// ' shi ge hao ren',
// index: 0,
// input: 'huang jin liang shi ge hao ren' ]
var text1 = "cat, bat, sat";
var pattern7 = new RegExp(".at")
var matches1 = pattern7.exec(text1);
console.log(matches1); //cat
var pattern8 = new RegExp(".at", "gm");
var matches2 = pattern8.exec(text1);
console.log(matches2); //cat
var matches3 = pattern8.exec(text1);
console.log(matches3); //bat
var matches4 = pattern8.exec(text1);
console.log(matches4); //sat
var matches5 = pattern8.exec(text1);
console.log(matches5); //null

Metodo due: test(), accetta un parametro che è una stringa di modello. Restituisce true se il modello corrisponde al parametro, altrimenti false

var text2 = "000-00-0000";
var pattern9 = new RegExp("\\d{3}-\\d{2}-\\d{4}");
console.log(pattern9.test(text2))
console.log(text2);
if (pattern9.test(text2)) {
console.log("Abbinamento riuscito");
} else {
console.log("Abbinamento fallito");
}

Attributi del costruttore (alcuni browser non lo supportano)
Nome attributo lungo 　　 Nome attributo breve 　　 Spiegazione
input 　　　　 $_ 　　 Stringa da abbinare più recentemente
lastMatch 　　 $& 　　 Abbinamento più recente
lastParen 　　 $+ 　　 Gruppo di cattura più recente
leftContext 　　 $` 　　 Testo prima di lastMatch nella stringa di input
multiline 　　 $* 　　 Booleano, se è in modalità multilinea
rightContext $' 　　 Testo dopo lastMatch nella stringa di input
　　　　　　　　$1~$9 vengono utilizzati per memorizzare il gruppo di cattura numero quante

Nelle limitazioni ECMAScript
1. Ancora \A e \Z per abbinare l'inizio e la fine della stringa
2. Ricerca in avanti
3. Classi di unione e intersezione
4. Gruppi atomici
5. Supporto Unicode (escluso il singolo carattere)
6. Gruppi di cattura denominati
7. Abbinamento del modello s e x
8. Abbinamento condizionale
9. Commenti nelle espressioni regolari

Ho appena scoperto un metodo per abbinare più righe in JavaScript

<script>
var s = "Please yes\nmake my day!";
alert(s.match(/yes.*day/));
// Restituisce null
alert(s.match(/yes[^]*day/));
// Restituisce 'yes\nmake my day'
</script>

Purtroppo, editplus non può essere utilizzato, molte volte è più comodo usare dw.