Czy w Javascript jest dostępna funkcja RegExp.escape?

Chcę tylko utworzyć wyrażenie regularne z dowolnego możliwego ciągu.

var usersString = "Hello?!*`~World()[]";
var expression = new RegExp(RegExp.escape(usersString))
var matches = "Hello".match(expression);

Czy istnieje do tego wbudowana metoda? Jeśli nie, z czego korzystają ludzie? Ruby ma RegExp.escape. Nie wydaje mi się, żebym musiał pisać własne, musi być coś standardowego. Dzięki!

Funkcja powiązana powyżej jest niewystarczająca. Nie można uciec ^lub $(początek i koniec łańcucha), lub -, który w grupie znaków jest używany dla zakresów.

Użyj tej funkcji:

function escapeRegex(string) {
    return string.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
}

Choć na pierwszy rzut oka może się to wydawać niepotrzebne, funkcja zmiany znaczenia -(a także ^) sprawia, że ​​funkcja ta jest odpowiednia do wstawiania znaków do klasy znaków, a także treści wyrażenia regularnego.

/Funkcja Escaping sprawia, że ​​funkcja jest odpowiednia do zmiany znaczenia znaków i może być używana w dosłownym wyrażeniu regularnym JS do późniejszej ewaluacji.

Ponieważ nie ma żadnej wady ucieczki od któregoś z nich, sensowne jest ucieczka, aby objąć szersze przypadki użycia.

I tak, rozczarowujące jest to, że nie jest to część standardowego JavaScript.

Dla każdego, kto za pomocą lodash, ponieważ v3.0.0 _.escapeRegExp funkcją jest wbudowany w:

_.escapeRegExp('[lodash](https://lodash.com/)');
// → '\[lodash\]\(https:\/\/lodash\.com\/\)'

W przypadku, gdy nie chcesz wymagać pełnej biblioteki lodash, możesz potrzebować tylko tej funkcji !

Większość wyrażeń tutaj rozwiązuje pojedyncze przypadki użycia.

W porządku, ale wolę podejście „zawsze działa”.

function regExpEscape(literal_string) {
    return literal_string.replace(/[-[\]{}()*+!<=:?.\/\\^$|#\s,]/g, '\\$&');
}

Spowoduje to „całkowite uniknięcie” literału dla dowolnego z poniższych zastosowań w wyrażeniach regularnych:

• Wstawienie w wyrażeniu regularnym. Na przykładnew RegExp(regExpEscape(str))
• Wstawienie do klasy postaci. Na przykładnew RegExp('[' + regExpEscape(str) + ']')
• Wstawienie do specyfikatora liczby całkowitej. Na przykładnew RegExp('x{1,' + regExpEscape(str) + '}')
• Wykonanie w silnikach wyrażeń regularnych innych niż JavaScript.

Objęte znaki specjalne:

• -: Tworzy zakres znaków w klasie znaków.
• [/ ]: Zaczyna / kończy klasę znaków.
• {/ }: Uruchamia / kończy specyfikator numeracji.
• (/ ): Zaczyna / kończy grupę.
• */ +/ ?: Określa typ powtarzania.
• .: Pasuje do dowolnej postaci.
• \: Ucieka znaki i uruchamia byty.
• ^: Określa początek pasującej strefy i neguje dopasowanie w klasie znaków.
• $: Określa koniec pasującej strefy.
• |: Określa naprzemienność.
• #: Określa komentarz w trybie wolnych odstępów.
• \s: Ignorowane w trybie swobodnych odstępów.
• ,: Oddziela wartości w specyfikatorze numeracji.
• /: Rozpoczyna lub kończy wyrażenie.
• :: Uzupełnia specjalne typy grup i część klas postaci w stylu Perla.
• !: Neguje grupę o zerowej szerokości.
• </ =: Część specyfikacji grupy o zerowej szerokości.

Uwagi:

• /nie jest absolutnie konieczne w żadnym smaku wyrażenia regularnego. Jednakże, chroni w przypadku gdy ktoś (Dreszcz) robi eval("/" + pattern + "/");.
• , zapewnia, że ​​jeśli ciąg ma być liczbą całkowitą w specyfikatorze liczbowym, poprawnie spowoduje błąd kompilacji RegExp zamiast kompilacji po cichu niepoprawnej.
• #i \snie trzeba zmieniać znaczenia w JavaScript, ale w wielu innych odmianach. Są one tutaj usuwane na wypadek, gdyby wyrażenie regularne zostało później przekazane do innego programu.

Jeśli potrzebujesz również w przyszłości zabezpieczyć wyrażenie regularne przed potencjalnymi dodatkami do możliwości silnika regex JavaScript, zalecam użycie bardziej paranoicznej:

function regExpEscapeFuture(literal_string) {
    return literal_string.replace(/[^A-Za-z0-9_]/g, '\\$&');
}

Ta funkcja unika każdego znaku z wyjątkiem tych, które wyraźnie gwarantują, że nie zostaną użyte w składni w przyszłych smakach wyrażeń regularnych.

Jeśli naprawdę zależy Ci na higienie, rozważ ten przypadek:

var s = '';
new RegExp('(choice1|choice2|' + regExpEscape(s) + ')');

To powinno dobrze skompilować się w JavaScript, ale nie będzie w innych smakach. Jeśli zamierzasz przejść do innego smaku, zerowy przypadek s === ''powinien być niezależnie sprawdzony, tak jak:

var s = '';
new RegExp('(choice1|choice2' + (s ? '|' + regExpEscape(s) : '') + ')');

Przewodnik po wyrażeniach regularnych Mozilla Developer Network udostępnia tę funkcję zmiany znaczenia:

function escapeRegExp(string) {
  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
}

W widżecie autouzupełniania jQueryUI (wersja 1.9.1) używają nieco innego wyrażenia regularnego (wiersz 6753), oto wyrażenie regularne połączone z podejściem @bobince.

RegExp.escape = function( value ) {
     return value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
}

Nic nie powinno powstrzymywać Cię przed ucieczką od każdego niealfanumerycznego znaku:

usersString.replace(/(?=\W)/g, '\\');

Tracisz przy tym pewien stopień czytelności, re.toString()ale zyskujesz dużą prostotę (i bezpieczeństwo).

Zgodnie z ECMA-262, z jednej strony, regularne wyrażenie „znaków składniowe” są zawsze niealfanumeryczne tak, że wynik jest bezpieczna, a szczególne sekwencje ( \d, \w, \n) są zawsze alfanumeryczny takie, że żadne fałszywe ucieka kontroli będzie produkowany .

Propozycję ES7 dotyczącą RegExp.escape można znaleźć na stronie https://github.com/benjamingr/RexExp.escape/ , a polifill jest dostępny na stronie https://github.com/ljharb/regexp.escape .

To jest krótsza wersja.

RegExp.escape = function(s) {
    return s.replace(/[$-\/?[-^{|}]/g, '\\$&');
}

Obejmuje to non-meta znaków %, &, 'oraz ,, ale specyfikacja JavaScript RegExp pozwala na to.

XRegExp ma funkcję ucieczki:

XRegExp.escape('Escaped? <.>'); // -> 'Escaped\?\ <\.>'

Więcej na: http://xregexp.com/api/#escape

Zamiast tylko uciekających znaków, które spowodują problemy w wyrażeniu regularnym (np. Czarna lista), dlaczego nie rozważyć użycia białej listy. W ten sposób każda postać jest uważana za skażoną, chyba że pasuje.

W tym przykładzie przyjmij następujące wyrażenie:

RegExp.escape('be || ! be');

Ta biała lista zawiera litery, cyfry i spacje:

RegExp.escape = function (string) {
    return string.replace(/([^\w\d\s])/gi, '\\$1');
}

Zwroty:

"be \|\| \! be"

Może to oznaczać ucieczkę postaci, które nie wymagają ucieczki, ale nie przeszkadza to w wyrażeniu (być może niewielkie kary czasowe - ale warto dla bezpieczeństwa).

escapeRegExp = function(str) {
  if (str == null) return '';
  return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
};

Funkcje w pozostałych odpowiedziach są nadmiernie zblokowane, aby uciec przed całymi wyrażeniami regularnymi (mogą być przydatne do ucieczki części wyrażeń regularnych, które później zostaną połączone w większe wyrażenia regularne).

Jeśli ucieczka całego wyrażenia regularnego i są z nim zrobić, cytując metaznaków które są albo samodzielnym ( ., ?, +, *, ^, $, |, \) lub uruchomić coś ( (, [, {) to wszystko, czego potrzebujesz:

String.prototype.regexEscape = function regexEscape() {
  return this.replace(/[.?+*^$|({[\\]/g, '\\$&');
};

I tak, to rozczarowujące, że JavaScript nie ma takiej funkcji jak ta wbudowana.

Innym (znacznie bezpieczniejszym) podejściem jest ucieczka od wszystkich znaków (a nie tylko kilku specjalnych, które obecnie znamy) przy użyciu formatu unikodu \u{code}:

function escapeRegExp(text) {
    return Array.from(text)
           .map(char => `\\u{${char.charCodeAt(0).toString(16)}}`)
           .join('');
}

console.log(escapeRegExp('a.b')); // '\u{61}\u{2e}\u{62}'

Pamiętaj, że musisz przekazać uflagę, aby ta metoda działała:

var expression = new RegExp(escapeRegExp(usersString), 'u');

Dotychczas istniało i będzie 12 znaków meta, które należy uciec,
aby uznać je za dosłowne.

Nie ma znaczenia, co się dzieje z ciągiem znaków ucieczki, wstawionym do zbalansowanego
wyrażenia regularnego, dołączonym, nie ma znaczenia.

Wykonaj zamianę ciągu za pomocą tego

var escaped_string = oldstring.replace( /[\\^$.|?*+()[{]/g, '\\$&' );