JavaScript
Wyrażenia regularne

Składnia

• niech regex = / pattern / [ flags ]
• let regex = new RegExp (' pattern ', [ flags ])
• let ismatch = regex.test (' text ')
• let results = regex.exec (' text ')

Parametry

Uwagi

Tworzenie obiektu RegExp

Standardowe dzieło

Zaleca się stosowanie tego formularza tylko podczas tworzenia wyrażenia regularnego ze zmiennych dynamicznych.

Użyj, gdy wyrażenie może się zmienić lub wyrażenie zostanie wygenerowane przez użytkownika.

var re = new RegExp(".*");

Z flagami:

var re = new RegExp(".*", "gmi");

Z odwrotnym ukośnikiem: (należy to zmienić, ponieważ wyrażenie regularne jest określone ciągiem znaków)

var re = new RegExp("\\w*");

Inicjalizacja statyczna

Użyj, jeśli wiesz, że wyrażenie regularne się nie zmieni, a wiesz, jakie jest wyrażenie przed uruchomieniem.

var re = /.*/;

Z flagami:

var re = /.*/gmi;

Z odwrotnym ukośnikiem: (nie należy tego zmieniać, ponieważ wyrażenie regularne jest określone dosłownie)

var re = /\w*/;

Flagi RegExp

Istnieje kilka flag, które można określić, aby zmienić zachowanie RegEx. Flagi mogą być dołączane na końcu literału wyrażenia regularnego, na przykład określając gi w /test/gi , lub mogą być określone jako drugi argument do konstruktora RegExp , jak w new RegExp('test', 'gi') .

g - Globalny. Znajduje wszystkie mecze zamiast zatrzymywać się po pierwszym.

i - Ignoruj wielkość liter. /[az]/i jest równoważne /[a-zA-Z]/ .

m - Multiline. ^ i $ pasują odpowiednio do początku i końca każdej linii, traktując \n i \r jako ograniczniki zamiast po prostu początku i końca całego łańcucha.

Dopasowanie do .exec ()

Dopasuj za pomocą .exec()

RegExp.prototype.exec(string) zwraca tablicę przechwyceń lub null jeśli nie było dopasowania.

var re = /([0-9]+)[a-z]+/;
var match = re.exec("foo123bar");

match.index ma wartość 3 (zero) lokalizację dopasowania.

match[0] to ciąg pełnego dopasowania.

match[1] to tekst odpowiadający pierwszej przechwyconej grupie. match[n] byłoby wartością n- tej przechwyconej grupy.

Pętla poprzez .exec() pomocą .exec()

var re = /a/g;
var result;
while ((result = re.exec('barbatbaz')) !== null) {
    console.log("found '" + result[0] + "', next exec starts at index '" + re.lastIndex + "'");
}

Oczekiwany wynik

znaleziono „a”, następny exec zaczyna się od indeksu „2”
znaleziono „a”, następny exec zaczyna się od indeksu „5”
znaleziono „a”, następny exec zaczyna się od indeksu „8”

Sprawdź, czy łańcuch zawiera wzorzec za pomocą .test ()

var re = /[a-z]+/;
if (re.test("foo")) {
    console.log("Match exists.");
}

Metoda test wykonuje wyszukiwanie, aby sprawdzić, czy wyrażenie regularne pasuje do łańcucha. Wyrażenie regularne [az]+ wyszuka jedną lub więcej małych liter. Ponieważ wzorzec pasuje do ciągu, „dopasowanie istnieje” zostanie zarejestrowane w konsoli.

Używanie RegExp z ciągami

Obiekt String ma następujące metody, które akceptują wyrażenia regularne jako argumenty.

• "string".match(...
• "string".replace(...
• "string".split(...
• "string".search(...

Dopasuj z RegExp

console.log("string".match(/[i-n]+/));
console.log("string".match(/(r)[i-n]+/));

Oczekiwany wynik

Array [„in”]
Array [„rin”, „r”]

Zamień na RegExp

console.log("string".replace(/[i-n]+/, "foo"));

Oczekiwany wynik

strfoog

Podziel za pomocą RegExp

console.log("stringstring".split(/[i-n]+/));

Oczekiwany wynik

Array [„str”, „gstr”, „g”]

Wyszukaj za pomocą RegExp

.search() zwraca indeks, przy którym znaleziono dopasowanie lub -1.

console.log("string".search(/[i-n]+/));
console.log("string".search(/[o-q]+/));

Oczekiwany wynik

3)
-1

Zastąpienie ciągu znaków funkcją wywołania zwrotnego

String#replace może mieć funkcję jako drugi argument, dzięki czemu można zapewnić zamianę w oparciu o pewną logikę.

"Some string Some".replace(/Some/g, (match, startIndex, wholeString) => {
  if(startIndex == 0){
    return 'Start';
  } else {
    return 'End';
  }
});
// will return Start string End

Biblioteka szablonów z jedną linią

let data = {name: 'John', surname: 'Doe'}
"My name is {surname}, {name} {surname}".replace(/(?:{(.+?)})/g, x => data[x.slice(1,-1)]);

// "My name is Doe, John Doe"

Grupy RegExp

JavaScript obsługuje kilka rodzajów grup w wyrażeniach regularnych, grupach przechwytujących, grupach nie przechwytujących i prognozach . Obecnie nie ma wsparcia wstecznego .

Zdobyć

Czasami pożądane dopasowanie zależy od kontekstu. Oznacza to, że prosty RegExp nadmiernie znajdzie interesujący cię ciąg , więc rozwiązaniem jest napisanie grupy przechwytywania (pattern) . Przechwycone dane można następnie określić jako ...

• Zastępowanie łańcucha "$n" gdzie n jest n-tą grupą przechwytywania (od 1 )
• N-ty argument w funkcji zwrotnej
• Jeśli RegExp nie jest oznaczony g , n + 1-ty element w zwróconej tablicy str.match
• Jeśli RegExp jest oznaczony g , str.match odrzuca przechwytywanie, zamiast tego użyj re.exec

Powiedzmy, że istnieje ciąg znaków, w którym wszystkie znaki + muszą zostać zastąpione spacją, ale tylko jeśli występują po znaku litery. Oznacza to, że proste dopasowanie będzie zawierało ten znak literowy i zostanie również usunięte. Przechwycenie go jest rozwiązaniem, ponieważ oznacza, że dopasowaną literę można zachować.

let str = "aa+b+cc+1+2",
    re = /([a-z])\+/g;

// String replacement
str.replace(re, '$1 '); // "aa b cc 1+2"
// Function replacement
str.replace(re, (m, $1) => $1 + ' '); // "aa b cc 1+2"

Brak przechwytywania

Korzystając z formularza (?:pattern) , działają one w podobny sposób do przechwytywania grup, z tym wyjątkiem, że nie przechowują zawartości grupy po dopasowaniu.

Mogą być szczególnie przydatne, jeśli przechwytywane są inne dane, których nie chcesz przenosić indeksów, ale musisz wykonać zaawansowane dopasowanie wzorców, takie jak OR

let str = "aa+b+cc+1+2",
    re = /(?:\b|c)([a-z])\+/g;

str.replace(re, '$1 '); // "aa+b c 1+2"

Patrz przed siebie

Jeśli pożądane dopasowanie opiera się na czymś, co następuje po nim, zamiast dopasowywać to i przechwytywać, możliwe jest skorzystanie z wybiegania w przyszłość w celu przetestowania tego, ale nie uwzględnienie go w meczu. Pozytywne spojrzenie w przyszłość ma postać (?=pattern) , negatywne spojrzenie w przyszłość (gdzie dopasowanie do wyrażenia zachodzi tylko wtedy, gdy wzór w przód nie pasuje) ma postać (?!pattern)

let str = "aa+b+cc+1+2",
    re = /\+(?=[a-z])/g;

str.replace(re, ' '); // "aa b cc+1+2"

Użycie Regex.exec () z wyrażeniem regularnym w nawiasach, aby wyodrębnić dopasowania ciągu

Czasami nie chcesz po prostu zastąpić lub usunąć łańcucha. Czasami chcesz wyodrębnić i przetworzyć dopasowania. Oto przykład manipulowania dopasowaniami.

Co to jest dopasowanie? Po znalezieniu zgodnego podłańcucha dla całego wyrażenia regularnego w ciągu komenda exec tworzy dopasowanie. Dopasowanie to tablica składająca się najpierw z całego pasującego podciągu i wszystkich nawiasów w dopasowaniu.

Wyobraź sobie ciąg HTML:

<html>
<head></head>
<body>
  <h1>Example</h1>
  <p>Look a this great link : <a href="https://stackoverflow.com">Stackoverflow</a> http://anotherlinkoutsideatag</p>
  Copyright <a href="https://stackoverflow.com">Stackoverflow</a>
</body>

Chcesz wyodrębnić i uzyskać wszystkie linki wewnątrz a tagu. Na początku tutaj regex, który piszesz:

var re = /<a[^>]*href="https?:\/\/.*"[^>]*>[^<]*<\/a>/g;

Ale teraz wyobraź sobie, że chcesz href i anchor każdego łącza. I chcesz to razem. Możesz po prostu dodać nowe wyrażenie regularne dla każdego dopasowania LUB możesz użyć nawiasów:

var re = /<a[^>]*href="(https?:\/\/.*)"[^>]*>([^<]*)<\/a>/g; 
var str = '<html>\n    <head></head>\n    <body>\n        <h1>Example</h1>\n        <p>Look a this great link : <a href="https://stackoverflow.com">Stackoverflow</a> http://anotherlinkoutsideatag</p>\n\n        Copyright <a href="https://stackoverflow.com">Stackoverflow</a>\n    </body>\';\n';
var m;
var links = [];

while ((m = re.exec(str)) !== null) {
    if (m.index === re.lastIndex) {
        re.lastIndex++;
    }
    console.log(m[0]); // The all substring
    console.log(m[1]); // The href subpart
    console.log(m[2]); // The anchor subpart

    links.push({
      match : m[0],   // the entire match
      href : m[1],    // the first parenthesis => (https?:\/\/.*)
      anchor : m[2],  // the second one => ([^<]*)
    });
}

Na końcu pętli masz tablicę linków z anchor i href i możesz jej użyć do zapisania przeceny, na przykład:

links.forEach(function(link) {
  console.log('[%s](%s)', link.anchor, link.href);
});

Iść dalej :

• Zagnieżdżony nawias