JavaScript'i Mustrite Sobitamine Regulaaravaldistega: Põhjalik Juhend

Regulaaravaldised (regex) on võimas tööriist mustrite sobitamiseks ja teksti manipuleerimiseks JavaScriptis. Need võimaldavad arendajatel otsida, valideerida ja teisendada stringe defineeritud mustrite alusel. See juhend pakub põhjalikku ülevaadet regulaaravaldistest JavaScriptis, käsitledes süntaksit, kasutust ja täiustatud tehnikaid.

Mis on Regulaaravaldised?

Regulaaravaldis on märkide jada, mis defineerib otsingumustri. Neid mustreid kasutatakse stringide sobitamiseks ja manipuleerimiseks. Regulaaravaldisi kasutatakse programmeerimises laialdaselt järgmiste ülesannete jaoks:

• Andmete valideerimine: Kasutaja sisendi vastavuse tagamine kindlatele formaatidele (nt e-posti aadressid, telefoninumbrid).
• Andmete eraldamine: Spetsiifilise teabe hankimine tekstist (nt kuupäevade, URL-ide või hindade eraldamine).
• Otsing ja asendamine: Teksti leidmine ja asendamine keerukate mustrite alusel.
• Tekstitöötlus: Stringide tükeldamine, ühendamine või teisendamine defineeritud reeglite alusel.

Regulaaravaldiste Loomine JavaScriptis

JavaScriptis saab regulaaravaldisi luua kahel viisil:

1. Kasutades regulaaravaldise literaali: Pange muster kaldkriipsude (/) vahele.
2. Kasutades RegExp konstruktorit: Looge RegExp objekt, mille mustriks on string.

Näide:

// Regulaaravaldise literaali kasutamine
const regexLiteral = /hello/;

// RegExp konstruktori kasutamine
const regexConstructor = new RegExp("hello");

Valik kahe meetodi vahel sõltub sellest, kas muster on teada kompileerimise ajal või genereeritakse dünaamiliselt. Kasutage literaalset notatsiooni, kui muster on fikseeritud ja ette teada. Kasutage konstruktorit, kui muster tuleb luua programmiliselt, eriti kui see sisaldab muutujaid.

Regex'i Põhisüntaks

Regulaaravaldised koosnevad märkidest, mis esindavad sobitatavat mustrit. Siin on mõned regex'i põhikomponendid:

• Literaalsed märgid: Sobivad märkidega endiga (nt /a/ sobib märgiga 'a').
• Metamärgid: Neil on eritähendus (nt ., ^, $, *, +, ?, [], {}, (), \, |).
• Märgiklassid: Esindavad märkide hulki (nt [abc] sobib 'a', 'b' või 'c').
• Kvantorid: Määravad, mitu korda märk või grupp peaks esinema (nt *, +, ?, {n}, {n,}, {n,m}).
• Ankrud: Sobitavad positsioone stringis (nt ^ sobitab alguse, $ sobitab lõpu).

Levinud Metamärgid:

• . (punkt): Sobib mis tahes üksiku märgiga, välja arvatud reavahetus.
• ^ (katus): Sobitab stringi alguse.
• $ (dollar): Sobitab stringi lõpu.
• * (tärn): Sobitab eelneva märgi või grupi null või rohkem korda.
• + (pluss): Sobitab eelneva märgi või grupi üks või rohkem korda.
• ? (küsimärk): Sobitab eelneva märgi või grupi null või üks kord. Kasutatakse valikuliste märkide jaoks.
• [] (kantsulud): Defineerib märgiklassi, sobitades mis tahes üksiku märgi sulgude seest.
• {} (looksulud): Määrab sobitatavate esinemiste arvu. {n} sobitab täpselt n korda, {n,} sobitab n või rohkem korda, {n,m} sobitab n ja m korra vahel.
• () (ümarsulud): Grupeerib märgid kokku ja püüab sobitatud alamstringi.
• \ (kaldkriips): Muudab metamärgid literaalseteks, võimaldades teil neid sõna-sõnalt sobitada.
• | (toru): Toimib kui "või" operaator, sobitades kas sellele eelneva või järgneva avaldise.

Märgiklassid:

• [abc]: Sobitab ühe märgiga a, b või c.
• [^abc]: Sobitab mis tahes märgiga, mis *ei ole* a, b või c.
• [a-z]: Sobitab mis tahes väiketähega a-st z-ni.
• [A-Z]: Sobitab mis tahes suurtähega A-st Z-ni.
• [0-9]: Sobitab mis tahes numbriga 0-st 9-ni.
• [a-zA-Z0-9]: Sobitab mis tahes tähe- või numbrimärgiga.
• \d: Sobitab mis tahes numbriga (samaväärne [0-9]-ga).
• \D: Sobitab mis tahes mitte-numbrilise märgiga (samaväärne [^0-9]-ga).
• \w: Sobitab mis tahes sõnamärgiga (täht, number pluss allkriips; samaväärne [a-zA-Z0-9_]-ga).
• \W: Sobitab mis tahes mitte-sõnamärgiga (samaväärne [^a-zA-Z0-9_]-ga).
• \s: Sobitab mis tahes tühikumärgiga (tühik, tabulaator, reavahetus jne).
• \S: Sobitab mis tahes mitte-tühikumärgiga.

Kvantorid:

• *: Sobitab eelnevat elementi null või rohkem korda. Näiteks a* sobib "", "a", "aa", "aaa" jne.
• +: Sobitab eelnevat elementi üks või rohkem korda. Näiteks a+ sobib "a", "aa", "aaa", aga mitte "".
• ?: Sobitab eelnevat elementi null või üks kord. Näiteks a? sobib "" või "a".
• {n}: Sobitab eelnevat elementi täpselt *n* korda. Näiteks a{3} sobib "aaa".
• {n,}: Sobitab eelnevat elementi *n* või rohkem korda. Näiteks a{2,} sobib "aa", "aaa", "aaaa" jne.
• {n,m}: Sobitab eelnevat elementi *n* ja *m* korra vahel (kaasa arvatud). Näiteks a{2,4} sobib "aa", "aaa" või "aaaa".

Ankrud:

• ^: Sobitab stringi alguse. Näiteks ^Hello sobitab stringe, mis *algavad* sõnaga "Hello".
• $: Sobitab stringi lõpu. Näiteks World$ sobitab stringe, mis *lõppevad* sõnaga "World".
• \b: Sobitab sõna piiri. See on positsioon sõnamärgi (\w) ja mitte-sõnamärgi (\W) vahel või stringi alguses või lõpus. Näiteks \bword\b sobitab terve sõna "word".

Lipud:

Regex'i lipud muudavad regulaaravaldiste käitumist. Need lisatakse regex'i literaali lõppu või antakse teise argumendina RegExp konstruktorile.

• g (global): Sobitab kõik mustri esinemised, mitte ainult esimese.
• i (ignore case): Teostab tõstutundetu sobitamise.
• m (multiline): Lubab mitmerealise režiimi, kus ^ ja $ sobitavad iga rea alguse ja lõpu (eraldatud \n-ga).
• s (dotAll): Lubab punktil (.) sobitada ka reavahetusmärke.
• u (unicode): Lubab täieliku Unicode'i toe.
• y (sticky): Sobitab ainult indeksi kohast, millele viitab regex'i lastIndex omadus.

JavaScript'i Regex'i Meetodid

JavaScript pakub mitmeid meetodeid regulaaravaldistega töötamiseks:

• test(): Testib, kas string sobib mustriga. Tagastab true või false.
• exec(): Käivitab otsingu vaste leidmiseks stringis. Tagastab massiivi, mis sisaldab sobitatud teksti ja püütud gruppe, või null, kui vastet ei leita.
• match(): Tagastab massiivi, mis sisaldab stringi ja regulaaravaldise sobitamise tulemusi. Käitub erinevalt g lipuga ja ilma.
• search(): Testib vaste olemasolu stringis. Tagastab esimese vaste indeksi või -1, kui vastet ei leita.
• replace(): Asendab mustri esinemised asendusstringi või asendusstringi tagastava funktsiooniga.
• split(): Jaotab stringi alamstringide massiiviks regulaaravaldise alusel.

Näited Regex'i Meetodite Kasutamisest:

// test()
const regex = /hello/;
const str = "hello world";
console.log(regex.test(str)); // Väljund: true

// exec()
const regex2 = /hello (\w+)/;
const str2 = "hello world";
const result = regex2.exec(str2);
console.log(result); // Väljund: ["hello world", "world", index: 0, input: "hello world", groups: undefined]

// match() 'g' lipuga
const regex3 = /\d+/g; // Sobitab ühe või mitu numbrit globaalselt
const str3 = "Seal on 123 õuna ja 456 apelsini.";
const matches = str3.match(regex3);
console.log(matches); // Väljund: ["123", "456"]

// match() ilma 'g' liputa
const regex4 = /\d+/;
const str4 = "Seal on 123 õuna ja 456 apelsini.";
const match = str4.match(regex4);
console.log(match); // Väljund: ["123", index: 9, input: "Seal on 123 õuna ja 456 apelsini.", groups: undefined]

// search()
const regex5 = /world/;
const str5 = "hello world";
console.log(str5.search(regex5)); // Väljund: 6

// replace()
const regex6 = /world/;
const str6 = "hello world";
const newStr = str6.replace(regex6, "JavaScript");
console.log(newStr); // Väljund: hello JavaScript

// replace() funktsiooniga
const regex7 = /(\d+)-(\d+)-(\d+)/;
const str7 = "Tänane kuupäev on 2023-10-27";
const newStr2 = str7.replace(regex7, (match, year, month, day) => {
  return `${day}/${month}/${year}`;
});
console.log(newStr2); // Väljund: Tänane kuupäev on 27/10/2023

// split()
const regex8 = /, /;
const str8 = "õun, banaan, kirss";
const arr = str8.split(regex8);
console.log(arr); // Väljund: ["õun", "banaan", "kirss"]

Täiustatud Regex'i Tehnikad

Püüdegrupid:

Ümarsulge () kasutatakse püüdegruppide loomiseks regulaaravaldistes. Püüdegrupid võimaldavad teil eraldada sobitatud teksti spetsiifilisi osi. exec() ja match() meetodid tagastavad massiivi, kus esimene element on terve vaste ja järgnevad elemendid on püütud grupid.

const regex = /(\d{4})-(\d{2})-(\d{2})/;
const dateString = "2023-10-27";
const match = regex.exec(dateString);

console.log(match[0]); // Väljund: 2023-10-27 (Kogu vaste)
console.log(match[1]); // Väljund: 2023 (Esimene püüdegrupp - aasta)
console.log(match[2]); // Väljund: 10 (Teine püüdegrupp - kuu)
console.log(match[3]); // Väljund: 27 (Kolmas püüdegrupp - päev)

Nimega Püüdegrupid:

ES2018 tõi kaasa nimega püüdegrupid, mis võimaldavad teil määrata püüdegruppidele nimesid süntaksiga (?...). See muudab koodi loetavamaks ja hooldatavamaks.

const regex = /(?\d{4})-(?\d{2})-(?\d{2})/;
const dateString = "2023-10-27";
const match = regex.exec(dateString);

console.log(match.groups.year);  // Väljund: 2023
console.log(match.groups.month); // Väljund: 10
console.log(match.groups.day);   // Väljund: 27

Mittepüüdevad Grupid:

Kui teil on vaja grupeerida regex'i osi neid püüdmata (nt kvantori rakendamiseks grupile), saate kasutada mittepüüdvat gruppi süntaksiga (?:...). See väldib tarbetut mälu eraldamist püüdegruppidele.

const regex = /(?:https?:\/\/)?([\w\.]+)/; // Sobitab URL-i, kuid püüab ainult domeeninime
const url = "https://www.example.com/path";
const match = regex.exec(url);

console.log(match[1]); // Väljund: www.example.com

Lookaround'id:

Lookaround'id on null-laiusega väited, mis sobitavad positsiooni stringis mustri alusel, mis eelneb (lookbehind) või järgneb (lookahead) sellele positsioonile, ilma et lookaround'i muster ise vastesse kaasataks.

• Positiivne Lookahead: (?=...) Sobitab, kui lookahead'i sees olev muster *järgneb* praegusele positsioonile.
• Negatiivne Lookahead: (?!...) Sobitab, kui lookahead'i sees olev muster *ei järgne* praegusele positsioonile.
• Positiivne Lookbehind: (?<=...) Sobitab, kui lookbehind'i sees olev muster *eelneb* praegusele positsioonile.
• Negatiivne Lookbehind: (? Sobitab, kui lookbehind'i sees olev muster *ei eelne* praegusele positsioonile.

// Positiivne Lookahead: Hangi hind ainult siis, kui sellele järgneb USD
const regex = /\d+(?= USD)/;
const text = "Hind on 100 USD";
const match = text.match(regex);
console.log(match); // Väljund: ["100"]

// Negatiivne Lookahead: Hangi sõna ainult siis, kui sellele ei järgne numbrit
const regex2 = /\b\w+\b(?! \d)/;
const text2 = "õun 123 banaan apelsin 456";
const matches = text2.match(regex2);
console.log(matches); // Väljund: null, sest match() tagastab ilma 'g' liputa ainult esimese vaste, mida me siin ei vaja.
// parandamiseks:
const regex3 = /\b\w+\b(?! \d)/g;
const text3 = "õun 123 banaan apelsin 456";
const matches3 = text3.match(regex3);
console.log(matches3); // Väljund: [ 'banaan' ]

// Positiivne Lookbehind: Hangi väärtus ainult siis, kui sellele eelneb $
const regex4 = /(?<=\$)\d+/;
const text4 = "Hind on $200";
const match4 = text4.match(regex4);
console.log(match4); // Väljund: ["200"]

// Negatiivne Lookbehind: Hangi sõna ainult siis, kui sellele ei eelne sõna 'not'
const regex5 = /(?

const regex = /([a-z]+) \1/;
const text = "tere tere maailm";
const match = regex.exec(text);
console.log(match); // Väljund: ["tere tere", "tere", index: 0, input: "tere tere maailm", groups: undefined]

const emailRegex = /^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/;

console.log(emailRegex.test("test@example.com"));    // Väljund: true
console.log(emailRegex.test("invalid-email"));       // Väljund: false
console.log(emailRegex.test("test@sub.example.co.uk")); // Väljund: true

const urlRegex = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)/g;
const text = "Külastage meie veebisaiti aadressil https://www.example.com või vaadake http://blog.example.org.";
const urls = text.match(urlRegex);
console.log(urls); // Väljund: ["https://www.example.com", "http://blog.example.org"]

const csvString = 'John,Doe,"123, Main St",New York';
const csvRegex = /(?:"([^"]*(?:""[^"]*)*)")|([^,]+)/g; //Parandatud CSV regex
let values = [];
let match;  

while (match = csvRegex.exec(csvString)) {
  values.push(match[1] ? match[1].replace(/""/g, '"') : match[2]);
}


console.log(values); // Väljund: ["John", "Doe", "123, Main St", "New York"]

const phoneRegex = /^\+(?:[0-9] ?){6,14}[0-9]$/;
console.log(phoneRegex.test("+1 555 123 4567")); // Väljund: true (USA näide)
console.log(phoneRegex.test("+44 20 7946 0500")); // Väljund: true (UK näide)
console.log(phoneRegex.test("+81 3 3224 5000"));  // Väljund: true (Jaapani näide)
console.log(phoneRegex.test("123-456-7890"));   // Väljund: false

const passwordRegex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$/;

console.log(passwordRegex.test("P@ssword123")); // Väljund: true
console.log(passwordRegex.test("password"));       // Väljund: false (pole suurtähte ega numbrit)
console.log(passwordRegex.test("Password"));       // Väljund: false (pole numbrit)
console.log(passwordRegex.test("Pass123"));        // Väljund: false (pole väiketähte)
console.log(passwordRegex.test("P@ss1"));          // Väljund: false (vähem kui 8 tähemärki)