Metody tříd RegExp a String

V tomto článku probereme do hloubky různé metody, které pracují s regulárními výrazy.

řetězec.match(rv)

Metoda řetězec.match(rv) najde shody regulárního výrazu rv v Å™etÄ›zci řetězec.

Pracuje ve třech režimech:

1. Jestliže rv neobsahuje příznak g, pak metoda vrátí první shodu jako pole se zachytávacími skupinami a vlastnostmi index (pozice shody), input (vstupní Å™etÄ›zec, je roven řetězec):

   let řetězec = "Mám rád JavaScript";
   
   let výsledek = řetězec.match(/Java(Script)/);
   
   alert( výsledek[0] );     // JavaScript (celá shoda)
   alert( výsledek[1] );     // Script (první zachytávací skupina)
   alert( výsledek.length ); // 2
   
   // Další informace:
   alert( výsledek.index );  // 8 (pozice shody)
   alert( výsledek.input );  // Mám rád JavaScript (zdrojový řetězec)

2. Jestliže rv obsahuje příznak g, pak metoda vrátí pole vÅ¡ech shod jako Å™etÄ›zce, bez zachytávacích skupin a dalších detailů.

   let řetězec = "Mám rád JavaScript";
   
   let výsledek = řetězec.match(/Java(Script)/g);
   
   alert( výsledek[0] ); // JavaScript
   alert( výsledek.length ); // 1

3. Jestliže žádné shody nejsou, metoda bez ohledu na přítomnost příznaku g vrátí null.

   To je důležitý detail. Pokud nenastanou žádné shody, neobdržíme prázdné pole, ale null. Je snadné na to zapomenout a udÄ›lat chybu, například:

   let řetězec = "Mám rád JavaScript";
   
   let výsledek = řetězec.match(/HTML/);
   
   alert(výsledek); // null
   alert(výsledek.length); // Error: Cannot read property 'length' of null

   Pokud chceme, aby výsledek byl pole, můžeme to zapsat následovně:

   let výsledek = řetězec.match(rv) || [];

řetězec.matchAll(rv)

Metoda řetězec.matchAll(rv) je „novÄ›jší a vylepÅ¡ená“ varianta metody řetězec.match.

Používá se převážně k hledání všech shod se všemi skupinami.

Od metody match se liší ve tÅ™ech vÄ›cech:

1. Namísto pole vrací iterovatelný objekt se shodami. Můžeme z nÄ›j vytvoÅ™it skutečné pole pomocí Array.from.
2. Každá shoda se vrátí jako pole se zachytávacími skupinami (ve stejném formátu jako u řetězec.match bez příznaku g).
3. Pokud žádné výsledky nejsou, místo null vrátí prázdný iterovatelný objekt.

Příklad použití:

let řetězec = '<h1>Ahoj, světe!</h1>';
let rv = /<(.*?)>/g;

let matchAll = řetězec.matchAll(rv);

alert(matchAll); // [object RegExp String Iterator], ne pole, ale iterovatelný objekt

matchAll = Array.from(matchAll); // teď je to pole

let prvníShoda = matchAll[0];
alert( prvníShoda[0] );  // <h1>
alert( prvníShoda[1] );  // h1
alert( prvníShoda.index );  // 0
alert( prvníShoda.input );  // <h1>Ahoj, světe!</h1>

Pokud budeme procházet shody z metody matchAll pomocí cyklu for..of, nebudeme už Array.from potÅ™ebovat.

řetězec.split(rv|podřetězec, limit)

Rozdělí řetězec podle regulárního výrazu (nebo podřetězce) jako oddělovače.

Můžeme použít split s Å™etÄ›zci, například:

alert('12-34-56'.split('-')) // pole ['12', '34', '56']

Stejným způsobem však můžeme rozdělovat i podle regulárního výrazu:

alert('12, 34, 56'.split(/,\s*/)) // pole ['12', '34', '56']

řetězec.search(rv)

Metoda řetězec.search(rv) vrátí pozici první shody nebo -1, pokud shoda nebyla nalezena:

let řetězec = "A drop of ink may make a million think";

alert( řetězec.search( /ink/i ) ); // 10 (pozice první shody)

Důležité omezení: search najde pouze první shodu.

Jestliže potÅ™ebujeme i pozice dalších shod, mÄ›li bychom je najít jiným způsobem, například pomocí řetězec.matchAll(rv).

řetězec.replace(řetězec|rv, řetězec|funkce)

Toto je obecná metoda pro hledání a nahrazování, jedna z nejužitečnějších. Švýcarský armádní nůž pro hledání a nahrazování.

Můžeme ji použít bez regulárních výrazů k nalezení a nahrazení podřetězce:

// nahradí pomlčku dvojtečkou
alert('12-34-56'.replace("-", ":")) // 12:34-56

Je tady však jedna záludnost.

Pokud je prvním argumentem replace Å™etÄ›zec, metoda nahradí jen první shodu.

Můžete to vidÄ›t v uvedeném příkladu: za ":" byla nahrazena jedinÄ› první "-".

Abychom naÅ¡li vÅ¡echny pomlčky, nesmíme použít Å™etÄ›zec "-", ale regulární výraz /-/g s povinným příznakem g:

// nahradí všechny pomlčky dvojtečkou
alert( '12-34-56'.replace( /-/g, ":" ) )  // 12:34:56

Druhým argumentem je nahrazovací řetězec. Můžeme v něm používat speciální znaky:

Příklad:

let řetězec = "Jan Novák";

// přehodí jméno a příjmení
alert(řetězec.replace(/(jan) (novák)/i, '$2, $1')) // Novák, Jan

V situacích, které vyžadují „chytré“ nahrazení, může být druhým argumentem funkce.

Tato funkce bude volána pro každou shodu a jako nahrazovací řetězec pak bude vložena její návratová hodnota.

Funkce bude volána s argumenty funkce(shoda, p1, p2, ..., pn, pozice, vstup, skupiny):

1. shoda – shoda,
2. p1, p2, ..., pn – obsahy zachytávacích skupin (pokud nÄ›jaké jsou),
3. pozice – pozice shody,
4. vstup – zdrojový Å™etÄ›zec,
5. skupiny – objekt s pojmenovanými skupinami.

Pokud regulární výraz neobsahuje závorky, pak jsou argumenty pouze tÅ™i: funkce(řetězec, pozice, vstup).

Například převeďme všechny shody na velká písmena:

let řetězec = "html a css";

let výsledek = řetězec.replace(/html|css/gi, řetězec => řetězec.toUpperCase());

alert(výsledek); // HTML a CSS

Každou shodu nahraďme její pozicí v řetězci:

alert("Ha-Ha-ha".replace(/ha/gi, (shoda, pozice) => pozice)); // 0-3-6

V následujícím příkladu jsou dvoje závorky, takže nahrazovací funkce je volána s 5 argumenty: první je celá shoda, pak jsou 2 závorky a po nich (v příkladu nepoužité) pozice shody a zdrojový řetězec:

let řetězec = "Jan Novak";

let výsledek = řetězec.replace(/(\w+) (\w+)/, (shoda, jméno, příjmení) => `${příjmení}, ${jméno}`);

alert(výsledek); // Novak, Jan

Pokud je skupin mnoho, je vhodné přistupovat k nim pomocí zbytkových parametrů:

let řetězec = "Jan Novak";

let výsledek = řetězec.replace(/(\w+) (\w+)/, (...shoda) => `${shoda[2]}, ${shoda[1]}`);

alert(výsledek); // Novak, Jan

Nebo jestliže používáme pojmenované skupiny, objekt skupiny s nimi je vždy poslední, takže jej můžeme získat následovnÄ›:

let řetězec = "Jan Novak";

let výsledek = řetězec.replace(/(?<jméno>\w+) (?<příjmení>\w+)/, (...shoda) => {
  let skupiny = shoda.pop();

  return `${skupiny.příjmení}, ${skupiny.jméno}`;
});

alert(výsledek); // Novak, Jan

Použití funkce nám dává mocnou nahrazovací sílu, jelikož funkce obdrží všechny informace o shodě, má přístup k vnějším proměnným a může udělat cokoli.

řetězec.replaceAll(řetězec|rv, řetězec|funkce)

Tato metoda je v zásadÄ› stejná jako řetězec.replace, ale má dva hlavní rozdíly:

1. Pokud je první argument Å™etÄ›zec, nahradí vÅ¡echny výskyty tohoto Å™etÄ›zce, zatímco replace nahrazuje jedinÄ› první výskyt.
2. Pokud je první argument regulární výraz bez příznaku g, nastane chyba. S příznakem g funguje stejnÄ› jako replace.

Hlavní využití metody replaceAll je nahrazení vÅ¡ech výskytů Å™etÄ›zce.

Například:

// nahradí všechny pomlčky dvojtečkou
alert('12-34-56'.replaceAll("-", ":")) // 12:34:56

rv.exec(řetězec)

Metoda rv.exec(řetězec) vrátí shodu s regulárním výrazem rv v Å™etÄ›zci řetězec. Na rozdíl od pÅ™edchozích metod se nevolá na Å™etÄ›zci, ale na regulárním výrazu.

Chová se odliÅ¡nÄ› podle toho, zda regulární výraz obsahuje příznak g.

Pokud neobsahuje g, pak rv.exec(řetězec) vrátí první shodu stejnÄ›, jako řetězec.match(rv). Toto chování nepÅ™ináší nic nového.

AvÅ¡ak pokud je příznak g uveden, pak:

• Volání rv.exec(řetězec) vrátí první shodu a uloží pozici bezprostÅ™ednÄ› za ní do vlastnosti rv.lastIndex.
• Další takové volání začne hledat od pozice rv.lastIndex, vrátí další shodu a uloží pozici bezprostÅ™ednÄ› za ní do rv.lastIndex.
• …A tak dále.
• Pokud nejsou žádné shody, rv.exec vrátí null a vyresetuje rv.lastIndex na 0.

Opakovaná volání tedy vracejí vÅ¡echny shody jednu po druhé a ve vlastnosti rv.lastIndex si pamatují aktuální pozici hledání.

V minulosti, než byla do JavaScriptu pÅ™idána metoda řetězec.matchAll, se volání rv.exec používala v cyklu k získání vÅ¡ech shod ve skupinách:

let řetězec = 'Více se o JavaScriptu dozvíte na https://javascript.info';
let rv = /javascript/ig;

let výsledek;

while (výsledek = rv.exec(řetězec)) {
  alert( `Nalezeno ${výsledek[0]} na pozici ${výsledek.index}` );
  // Nalezeno JavaScript na pozici 10, pak
  // Nalezeno javascript na pozici 40
}

To funguje dosud, ačkoli u nových prohlížečů je řetězec.matchAll zpravidla vhodnÄ›jší.

Můžeme použít rv.exec pro hledání od zadané pozice, když nastavíme lastIndex ručnÄ›.

Například:

let řetězec = 'Ahoj, svete!';

let rv = /\w+/g; // bez příznaku "g" je vlastnost lastIndex ignorována
rv.lastIndex = 5; // hledá od 5. pozice (od čárky)

alert( rv.exec(řetězec) ); // svete

Pokud RV obsahuje příznak y, pak bude hledání provedeno výhradnÄ› na pozici rv.lastIndex a nikde dál.

Nahraďme v uvedeném příkladu příznak g příznakem y. Nenajde se žádná shoda, protože na pozici 5 není žádné slovo:

let řetězec = 'Ahoj, svete!';

let rv = /\w+/y;
rv.lastIndex = 5; // hledá výhradně na pozici 5

alert( rv.exec(řetězec) ); // null

To se hodí v situacích, kdy potřebujeme z řetězce něco „načíst“ regulárním výrazem z přesně dané pozice, ale ne odnikud dál.

rv.test(řetězec)

Metoda rv.test(řetězec) se pokusí najít shodu a vrátí true/false podle toho, zda existuje.

Například:

let řetězec = "Mám rád JavaScript";

// tyto dva testy udělají totéž
alert( /rád/i.test(řetězec) ); // true
alert( řetězec.search(/rád/i) != -1 ); // true

Příklad se zápornou odpovědí:

let řetězec = "Bla-bla-bla";

alert( /rád/i.test(řetězec) ); // false
alert( řetězec.search(/rád/i) != -1 ); // false

Jestliže RV obsahuje příznak g, pak rv.test hledá od vlastnosti rv.lastIndex a aktualizuje ji, stejnÄ› jako rv.exec.

Můžeme ji tedy použít pro hledání od určité pozice:

let rv = /rád/gi;

let řetězec = "Mám rád JavaScript";

// začneme hledat na pozici 10:
rv.lastIndex = 10;
alert( rv.test(řetězec) ); // false (žádná shoda)

let rv = /javascript/g;  // (rv právě vytvořen: rv.lastIndex=0)

alert( rv.test("javascript") ); // true (teď je rv.lastIndex=10)
alert( rv.test("javascript") ); // false