Introduktion till reguljära uttryck i JavaScript
Reguljära uttryck är kommandon för avancerad sökning och ersättning (eller bara sökning). De låter dig göra väldigt intressanta saker, men tyvärr är de ganska svåra att lära sig.
Det finns flera JavaScript-metoder för
att arbeta med reguljära uttryck. Vi börjar
lära känna dem med exemplet replace
- du är redan bekant med denna metod: den tar
det första parametern som vad som ska ersättas, och den andra
- med vad som ska ersättas. Och själva metoden tillämpas
på strängen där ersättningen görs:
'bab'.replace('a', '!'); // returnerar 'b!b'
Som första parameter till denna metod kan du skicka
inte bara en sträng, utan ett reguljärt uttryck.
Ett reguljärt uttryck är en uppsättning
kommandon placerade inom snedstreck /. Dessa
snedstreck kallas avgränsare för reguljära
uttryck.
De reguljära uttrycken i sig består av två typer av tecken: de som representerar sig själva och de som är kommandotecken, som kallas specialtecken.
Bokstäver och siffror representerar sig själva. I nästa
exempel kommer vi att använda ett reguljärt uttryck
för att ersätta bokstaven 'a' med !:
'bab'.replace(/a/, '!'); // returnerar 'b!b'
Men en punkt är ett specialtecken
och representerar vilket tecken som helst. I nästa
exempel kommer vi att hitta en sträng med följande mönster:
bokstaven 'x', sedan vilket tecken som helst, sedan
åter bokstaven 'x':
'xax eee'.replace(/x.x/, '!'); // returnerar '! eee'
Efter avgränsarna kan du skriva modifierare
- kommandon som ändrar de allmänna egenskaperna
för det reguljära uttrycket. Till exempel, modifieraren
g aktiverar läget för global sökning
och ersättning - utan den hittar det reguljära uttrycket bara
den första matchningen, och med den - alla matchningar.
I följande exempel är modifieraren
g inte angiven och det reguljära uttrycket kommer bara att hitta den första
matchningen:
'aab'.replace(/a/, '!'); // returnerar '!ab'
Och nu kommer det reguljära uttrycket att hitta alla matchningar:
'aab'.replace(/a/g, '!'); // returnerar '!!b'
Given en sträng:
let str = 'ahb acb aeb aeeb adcb axeb';
Skriv ett reguljärt uttryck som hittar strängarna
'ahb', 'acb', 'aeb'
enligt mönstret: bokstaven 'a', vilket tecken som helst,
bokstaven 'b'.
Given en sträng:
let str = 'aba aca aea abba adca abea';
Skriv ett reguljärt uttryck som hittar strängarna
'abba', 'adca', 'abea'
enligt mönstret: bokstaven 'a', 2
valfria tecken, bokstaven 'a'.
Given en sträng:
let str = 'aba aca aea abba adca abea';
Skriv ett reguljärt uttryck som hittar strängarna
'abba' och 'abea', utan att fånga
'adca'.