JavaScript Šablonu Atbilstība ar Regulārajām Izteiksmēm: Visaptverošs Ceļvedis

Regulārās izteiksmes (regex) ir spēcīgs rīks šablonu atbilstībai un teksta manipulācijām JavaScript. Tās ļauj izstrādātājiem meklēt, validēt un pārveidot virknes, pamatojoties uz definētiem šabloniem. Šis ceļvedis sniedz visaptverošu pārskatu par regulārajām izteiksmēm JavaScript, aptverot sintaksi, lietošanu un padziļinātas tehnikas.

Kas ir Regulārās Izteiksmes?

Regulārā izteiksme ir rakstzīmju secība, kas definē meklēšanas šablonu. Šie šabloni tiek izmantoti, lai saskaņotu un manipulētu ar virknēm. Regulārās izteiksmes plaši izmanto programmēšanā tādiem uzdevumiem kā:

• Datu Validācija: Pārliecināšanās, ka lietotāja ievade atbilst noteiktiem formātiem (piemēram, e-pasta adreses, tālruņa numuri).
• Datu Ekstrakcija: Konkrētas informācijas iegūšana no teksta (piemēram, datumu, URL vai cenu izgūšana).
• Meklēšana un Aizvietošana: Teksta atrašana un aizvietošana, pamatojoties uz sarežģītiem šabloniem.
• Teksta Apstrāde: Virkņu sadalīšana, savienošana vai pārveidošana, pamatojoties uz definētiem noteikumiem.

Regulāro Izteiksmju Izveide JavaScript

JavaScript regulārās izteiksmes var izveidot divos veidos:

1. Izmantojot Regulārās Izteiksmes Literāli: Ietveriet šablonu slīpsvītrās (/).
2. Izmantojot RegExp Konstruktoru: Izveidojiet RegExp objektu, kurā šablons ir virkne.

Piemērs:

// Izmantojot regulārās izteiksmes literāli
const regexLiteral = /hello/;

// Izmantojot RegExp konstruktoru
const regexConstructor = new RegExp("hello");

Izvēle starp abām metodēm ir atkarīga no tā, vai šablons ir zināms kompilēšanas laikā vai tiek dinamiski ģenerēts. Izmantojiet literāļa apzīmējumu, ja šablons ir fiksēts un zināms iepriekš. Izmantojiet konstruktoru, ja šablonu nepieciešams veidot programmatiski, īpaši, ja tajā iekļauti mainīgie.

Regex Pamatsintakse

Regulārās izteiksmes sastāv no rakstzīmēm, kas attēlo saskaņojamo šablonu. Šeit ir dažas fundamentālas regex sastāvdaļas:

• Burtiskās Rakstzīmes: Atbilst pašām rakstzīmēm (piem., /a/ atbilst rakstzīmei 'a').
• Metarakstzīmes: Ir īpašas nozīmes (piem., ., ^, $, *, +, ?, [], {}, (), \, |).
• Rakstzīmju Klases: Attēlo rakstzīmju kopas (piem., [abc] atbilst 'a', 'b' vai 'c').
• Kvantifikatori: Norāda, cik reizes rakstzīmei vai grupai jāparādās (piem., *, +, ?, {n}, {n,}, {n,m}).
• Enkuri: Atbilst pozīcijām virknē (piem., ^ atbilst sākumam, $ atbilst beigām).

Biežākās Metarakstzīmes:

• . (punkts): Atbilst jebkurai atsevišķai rakstzīmei, izņemot jaunas rindas rakstzīmi.
• ^ (jumtiņš): Atbilst virknes sākumam.
• $ (dolārs): Atbilst virknes beigām.
• * (zvaigznīte): Atbilst nullei vai vairāk iepriekšējās rakstzīmes vai grupas atkārtojumiem.
• + (plus): Atbilst vienam vai vairākiem iepriekšējās rakstzīmes vai grupas atkārtojumiem.
• ? (jautājumzīme): Atbilst nullei vai vienam iepriekšējās rakstzīmes vai grupas atkārtojumam. Izmanto neobligātām rakstzīmēm.
• [] (kvadrātiekavas): Definē rakstzīmju klasi, kas atbilst jebkurai atsevišķai rakstzīmei iekavās.
• {} (figūriekavas): Norāda atbilstību skaitu. {n} atbilst tieši n reizes, {n,} atbilst n vai vairāk reizes, {n,m} atbilst no n līdz m reizēm.
• () (apaļās iekavas): Grupē rakstzīmes kopā un saglabā saskaņoto apakšvirkni.
• \ (atpakaļsvītra): Atceļ metarakstzīmju speciālo nozīmi, ļaujot tās saskaņot burtiski.
• | (caurule): Darbojas kā "vai" operators, saskaņojot izteiksmi pirms vai pēc tā.

Rakstzīmju Klases:

• [abc]: Atbilst jebkurai no rakstzīmēm a, b vai c.
• [^abc]: Atbilst jebkurai rakstzīmei, kas *nav* a, b vai c.
• [a-z]: Atbilst jebkuram mazajam burtam no a līdz z.
• [A-Z]: Atbilst jebkuram lielajam burtam no A līdz Z.
• [0-9]: Atbilst jebkuram ciparam no 0 līdz 9.
• [a-zA-Z0-9]: Atbilst jebkurai burtu vai ciparu rakstzīmei.
• \d: Atbilst jebkuram ciparam (ekvivalents [0-9]).
• \D: Atbilst jebkurai rakstzīmei, kas nav cipars (ekvivalents [^0-9]).
• \w: Atbilst jebkurai vārda rakstzīmei (burti, cipari un pasvītra; ekvivalents [a-zA-Z0-9_]).
• \W: Atbilst jebkurai rakstzīmei, kas nav vārda rakstzīme (ekvivalents [^a-zA-Z0-9_]).
• \s: Atbilst jebkurai atstarpes rakstzīmei (atstarpe, tabulācija, jauna rinda utt.).
• \S: Atbilst jebkurai rakstzīmei, kas nav atstarpe.

Kvantifikatori:

• *: Atbilst iepriekšējam elementam nulli vai vairāk reizes. Piemēram, a* atbilst "", "a", "aa", "aaa" un tā tālāk.
• +: Atbilst iepriekšējam elementam vienu vai vairāk reizes. Piemēram, a+ atbilst "a", "aa", "aaa", bet ne "".
• ?: Atbilst iepriekšējam elementam nulli vai vienu reizi. Piemēram, a? atbilst "" vai "a".
• {n}: Atbilst iepriekšējam elementam tieši *n* reizes. Piemēram, a{3} atbilst "aaa".
• {n,}: Atbilst iepriekšējam elementam *n* vai vairāk reizes. Piemēram, a{2,} atbilst "aa", "aaa", "aaaa" un tā tālāk.
• {n,m}: Atbilst iepriekšējam elementam no *n* līdz *m* reizēm (ieskaitot). Piemēram, a{2,4} atbilst "aa", "aaa" vai "aaaa".

Enkuri:

• ^: Atbilst virknes sākumam. Piemēram, ^Hello atbilst virknēm, kas *sākas* ar "Hello".
• $: Atbilst virknes beigām. Piemēram, World$ atbilst virknēm, kas *beidzas* ar "World".
• \b: Atbilst vārda robežai. Tā ir pozīcija starp vārda rakstzīmi (\w) un rakstzīmi, kas nav vārda rakstzīme (\W), vai virknes sākumu vai beigām. Piemēram, \bword\b atbilst visam vārdam "word".

Karodziņi:

Regex karodziņi maina regulāro izteiksmju darbību. Tie tiek pievienoti regex literāļa beigās vai nodoti kā otrs arguments RegExp konstruktoram.

• g (global): Atbilst visiem šablona gadījumiem, nevis tikai pirmajam.
• i (ignore case): Veic reģistrjutību neievērojošu saskaņošanu.
• m (multiline): Iespējo vairākrindu režīmu, kurā ^ un $ atbilst katras rindas sākumam un beigām (atdalītas ar \n).
• s (dotAll): Ļauj punktam (.) atbilst arī jaunas rindas rakstzīmēm.
• u (unicode): Iespējo pilnu Unicode atbalstu.
• y (sticky): Atbilst tikai no indeksa, ko norāda regex lastIndex īpašība.

JavaScript Regex Metodes

JavaScript nodrošina vairākas metodes darbam ar regulārajām izteiksmēm:

• test(): Pārbauda, vai virkne atbilst šablonam. Atgriež true vai false.
• exec(): Izpilda meklēšanu pēc atbilstības virknē. Atgriež masīvu, kas satur saskaņoto tekstu un saglabātās grupas, vai null, ja atbilstība nav atrasta.
• match(): Atgriež masīvu, kas satur virknes saskaņošanas rezultātus ar regulāro izteiksmi. Darbojas atšķirīgi ar un bez g karodziņa.
• search(): Pārbauda atbilstību virknē. Atgriež pirmās atbilstības indeksu vai -1, ja atbilstība nav atrasta.
• replace(): Aizvieto šablona gadījumus ar aizvietošanas virkni vai funkciju, kas atgriež aizvietošanas virkni.
• split(): Sadala virkni apakšvirkņu masīvā, pamatojoties uz regulāro izteiksmi.

Piemēri, izmantojot Regex Metodes:

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

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

// match() ar 'g' karodziņu
const regex3 = /\d+/g; // Atbilst vienam vai vairākiem cipariem globāli
const str3 = "There are 123 apples and 456 oranges.";
const matches = str3.match(regex3);
console.log(matches); // Izvade: ["123", "456"]

// match() bez 'g' karodziņa
const regex4 = /\d+/;
const str4 = "There are 123 apples and 456 oranges.";
const match = str4.match(regex4);
console.log(match); // Izvade: ["123", index: 11, input: "There are 123 apples and 456 oranges.", groups: undefined]

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

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

// replace() ar funkciju
const regex7 = /(\d+)-(\d+)-(\d+)/;
const str7 = "Today's date is 2023-10-27";
const newStr2 = str7.replace(regex7, (match, year, month, day) => {
  return `${day}/${month}/${year}`;
});
console.log(newStr2); // Izvade: Today's date is 27/10/2023

// split()
const regex8 = /, /;
const str8 = "apple, banana, cherry";
const arr = str8.split(regex8);
console.log(arr); // Izvade: ["apple", "banana", "cherry"]

Padziļinātas Regex Tehnikas

Saglabāšanas Grupas:

Apaļās iekavas () tiek izmantotas, lai izveidotu saglabāšanas grupas regulārajās izteiksmēs. Saglabātās grupas ļauj izgūt konkrētas saskaņotā teksta daļas. exec() un match() metodes atgriež masīvu, kurā pirmais elements ir visa atbilstība, bet turpmākie elementi ir saglabātās grupas.

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

console.log(match[0]); // Izvade: 2023-10-27 (Visa atbilstība)
console.log(match[1]); // Izvade: 2023 (Pirmā saglabātā grupa - gads)
console.log(match[2]); // Izvade: 10 (Otrā saglabātā grupa - mēnesis)
console.log(match[3]); // Izvade: 27 (Trešā saglabātā grupa - diena)

Nosauktās Saglabāšanas Grupas:

ES2018 ieviesa nosauktās saglabāšanas grupas, kas ļauj piešķirt nosaukumus saglabāšanas grupām, izmantojot sintaksi (?...). Tas padara kodu lasāmāku un vieglāk uzturamu.

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

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

Nesaglabājošās Grupas:

Ja nepieciešams grupēt regex daļas, tās nesaglabājot (piemēram, lai piemērotu kvantifikatoru grupai), varat izmantot nesaglabājošo grupu ar sintaksi (?:...). Tas novērš nevajadzīgu atmiņas piešķiršanu saglabātajām grupām.

const regex = /(?:https?:\/\/)?([\w\.]+)/; // Atbilst URL, bet saglabā tikai domēna vārdu
const url = "https://www.example.com/path";
const match = regex.exec(url);

console.log(match[1]); // Izvade: www.example.com

Priekšskatīšanās (Lookarounds):

Priekšskatīšanās ir nulles platuma apgalvojumi, kas atbilst pozīcijai virknē, pamatojoties uz šablonu, kas ir pirms (lookbehind) vai pēc (lookahead) šīs pozīcijas, neiekļaujot pašu priekšskatīšanās šablonu atbilstībā.

• Pozitīvā Priekšskatīšanās (Positive Lookahead): (?=...) Atbilst, ja šablons priekšskatīšanās iekšienē *seko* pašreizējai pozīcijai.
• Negatīvā Priekšskatīšanās (Negative Lookahead): (?!...) Atbilst, ja šablons priekšskatīšanās iekšienē *neseko* pašreizējai pozīcijai.
• Pozitīvā Atskatīšanās (Positive Lookbehind): (?<=...) Atbilst, ja šablons atskatīšanās iekšienē *ir pirms* pašreizējās pozīcijas.
• Negatīvā Atskatīšanās (Negative Lookbehind): (? Atbilst, ja šablons atskatīšanās iekšienē *nav pirms* pašreizējās pozīcijas.

// Pozitīvā priekšskatīšanās: Iegūt cenu tikai tad, ja tai seko USD
const regex = /\d+(?= USD)/;
const text = "The price is 100 USD";
const match = text.match(regex);
console.log(match); // Izvade: ["100"]

// Negatīvā priekšskatīšanās: Iegūt vārdu tikai tad, ja tam neseko skaitlis
const regex2 = /\b\w+\b(?! \d)/;
const text2 = "apple 123 banana orange 456";
const matches = text2.match(regex2);
console.log(matches); // Izvade: null because match() only returns the first match without 'g' flag, which isn't what we need.
// lai to labotu:
const regex3 = /\b\w+\b(?! \d)/g;
const text3 = "apple 123 banana orange 456";
const matches3 = text3.match(regex3);
console.log(matches3); // Izvade: [ 'banana' ]

// Pozitīvā atskatīšanās: Iegūt vērtību tikai tad, ja pirms tās ir $
const regex4 = /(?<=\$)\d+/;
const text4 = "The price is $200";
const match4 = text4.match(regex4);
console.log(match4); // Izvade: ["200"]

// Negatīvā atskatīšanās: Iegūt vārdu tikai tad, ja pirms tā nav vārda 'not'
const regex5 = /(?

const regex = /([a-z]+) \1/;
const text = "hello hello world";
const match = regex.exec(text);
console.log(match); // Izvade: ["hello hello", "hello", index: 0, input: "hello hello world", groups: undefined]

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

console.log(emailRegex.test("test@example.com"));    // Izvade: true
console.log(emailRegex.test("invalid-email"));       // Izvade: false
console.log(emailRegex.test("test@sub.example.co.uk")); // Izvade: 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 = "Visit our website at https://www.example.com or check out http://blog.example.org.";
const urls = text.match(urlRegex);
console.log(urls); // Izvade: ["https://www.example.com", "http://blog.example.org"]

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

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


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

const phoneRegex = /^\+(?:[0-9] ?){6,14}[0-9]$/;
console.log(phoneRegex.test("+1 555 123 4567")); // Izvade: true (ASV piemērs)
console.log(phoneRegex.test("+44 20 7946 0500")); // Izvade: true (AK piemērs)
console.log(phoneRegex.test("+81 3 3224 5000"));  // Izvade: true (Japānas piemērs)
console.log(phoneRegex.test("123-456-7890"));   // Izvade: false

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

console.log(passwordRegex.test("P@ssword123")); // Izvade: true
console.log(passwordRegex.test("password"));       // Izvade: false (nav lielā burta vai cipara)
console.log(passwordRegex.test("Password"));       // Izvade: false (nav cipara)
console.log(passwordRegex.test("Pass123"));        // Izvade: false (nav mazā burta)
console.log(passwordRegex.test("P@ss1"));          // Izvade: false (mazāk par 8 rakstzīmēm)