Javascript'te bir RegExp.escape işlevi var mı?

Sadece olası bir dize dışında düzenli bir ifade oluşturmak istiyorum.

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

Bunun için yerleşik bir yöntem var mı? Değilse, insanlar ne kullanır? Ruby var RegExp.escape. Kendi yazmam gerekmiyormuş gibi hissetmiyorum, orada standart bir şey olmalı. Teşekkürler!

Yukarıda bağlı olan işlev yetersiz. Bir karakter grubunda aralıklar için kullanılan ( veya dizenin başlangıcı ve bitişi) ^veya kaçamaz .$-

Bu işlevi kullanın:

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

İlk bakışta gereksiz gibi görünse de, kaçmak -(yanı sıra ^) işlevi, bir karakter sınıfına ve normal ifadenin gövdesine eklenecek karakterlerden kaçmak için uygun hale getirir.

Kaçış /işlevi, sonraki değerlendirme için bir JS normal ifadesinde kullanılacak karakterlerden kaçmak için işlevi uygun hale getirir.

Her ikisinden de kaçmanın bir dezavantajı olmadığından, daha geniş kullanım durumlarını kapsamak için kaçmak mantıklıdır.

Ve evet, bunun standart JavaScript'in bir parçası olmaması hayal kırıklığı yaratıyor.

Lodash kullanan herkes için, v3.0.0'dan beri bir _.escapeRegExp işlevi yerleşiktir:

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

Ve tam lodash kütüphanesine ihtiyaç duymamanız durumunda, sadece bu fonksiyona ihtiyacınız olabilir !

Buradaki ifadelerin çoğu tek kullanımlık durumları çözer.

Sorun değil, ama "her zaman işe yarar" yaklaşımını tercih ederim.

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

Bu, normal ifadelerde aşağıdaki kullanımlardan herhangi biri için değişmez bir dizeden "tamamen kaçar":

• Normal ifadeye ekleme. Örneğinnew RegExp(regExpEscape(str))
• Bir karakter sınıfına ekleme. Örneğinnew RegExp('[' + regExpEscape(str) + ']')
• Tamsayı sayısı belirleyicisine ekleme. Örneğinnew RegExp('x{1,' + regExpEscape(str) + '}')
• JavaScript olmayan normal ifade motorlarında yürütme.

Kapsanan Özel Karakterler:

• -: Karakter sınıfında bir karakter aralığı oluşturur.
• [/ ]: Karakter sınıfını başlatır / bitirir.
• {/ }: Bir numara belirleyiciyi başlatır / sonlandırır.
• (/ ): Bir grubu başlatır / bitirir.
• */ +/ ?: Tekrarlama türünü belirtir.
• .: Herhangi bir karakterle eşleşir.
• \: Karakterlerden kaçar ve objeleri başlatır.
• ^: Eşleme bölgesinin başlangıcını belirtir ve bir karakter sınıfındaki eşleşmeyi reddeder.
• $: Eşleşen bölgenin sonunu belirtir.
• |: Değişimi belirtir.
• #: Boş aralık modunda yorumu belirtir.
• \s: Boş aralık modunda yok sayılır.
• ,: Sayı belirleyicisindeki değerleri ayırır.
• /: İfadeyi başlatır veya bitirir.
• :: Özel grup türlerini ve Perl tarzı karakter sınıflarının bir bölümünü tamamlar.
• !: Sıfır genişlikli grubu olumsuzlar.
• </ =: Sıfır genişlikli grup özelliklerinin bir parçası.

Notlar:

• /düzenli ifadenin herhangi bir çeşidinde kesinlikle gerekli değildir. Bununla birlikte, birisinin (ürperti) yapması durumunda korur eval("/" + pattern + "/");.
• , dizenin sayısal belirleyicide bir tamsayı olması gerekiyorsa, sessizce yanlış derlemek yerine bir RegExp derleme hatasına neden olur.
• #ve \sJavaScript'ten kaçmasına gerek yoktur, ancak diğer birçok aromada da kullanılır. Düzenli ifadenin daha sonra başka bir programa geçmesi durumunda buradan kaçarlar.

Ayrıca, düzenli ifadeyi JavaScript normal ifade motoru özelliklerine olası eklemelere karşı gelecekte kanıtlamanız gerekiyorsa, daha paranoyak kullanmanızı öneririz:

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

Bu işlev, gelecekteki düzenli ifade tatlarında sözdizimi için kullanılmayacağı açıkça garanti edilenler dışında her karakterden kaçar.

Gerçekten sanitasyon meraklısı için, bu son durumu düşünün:

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

Bu gerektiğini değil diğer bazı tatlar JavaScript cezası derlemek, ama olacak. Başka bir lezzete geçmek niyetinde ise, null durumu s === ''bağımsız olarak kontrol edilmelidir, şöyle:

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

Mozilla Geliştirici Ağının Düzenli İfadeler Kılavuzu bu kaçış işlevini sağlar:

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

JQueryUI'nin otomatik tamamlama widget'ında (sürüm 1.9.1) biraz farklı bir normal ifade kullanırlar (Satır 6753), @bobince yaklaşımıyla birleştirilmiş normal ifade.

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

Hiçbir şey sadece alfasayısal olmayan her karakterden kaçmanızı engellemez:

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

Yaparken belli derecede okunabilirliği kaybedersiniz, re.toString()ancak çok fazla basitlik (ve güvenlik) kazanırsınız.

ECMA-262 göre, bir yandan düzenli ifade "sözdizimi karakterler", alfanümerik olmayan daima sonuç güvenli ve özel kaçış dizileri (şekildedir \d, \w, \n) her zaman alfanümerik olan bu tür hiçbir yanlış kumanda kaçar üretilen olacağını .

En RegExp.escape için bir ES7 önerisi yoktur https://github.com/benjamingr/RexExp.escape/ adresinden ulaşılabilen Polyfill ile https://github.com/ljharb/regexp.escape .

Bu daha kısa bir versiyon.

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

Bu olmayan meta karakterler içerir %, &, ', ve ,, ancak JavaScript RegExp şartname buna izin verir.

XRegExp'in bir çıkış işlevi vardır:

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

Daha fazla bilgi için: http://xregexp.com/api/#escape

Sadece normal ifadenizde sorunlara neden olacak karakterlerden kaçmak yerine (ör. Bir kara liste), bunun yerine neden beyaz liste kullanmayı düşünmüyorsunuz? Bu şekilde, her karakter eşleşmediği takdirde renkli olarak kabul edilir.

Bu örnek için aşağıdaki ifadeyi varsayalım:

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

Bu, harfleri, sayıları ve boşlukları beyaz listeye ekler:

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

İadeler:

"be \|\| \! be"

Bu, kaçması gerekmeyen karakterlerden kaçabilir, ancak bu ifadenizi engellemez (belki bazı küçük zaman cezaları - ancak güvenlik için buna değer).

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

Diğer cevaplardaki işlevler, tüm normal ifadelerden kaçmak için aşırı derecede doludur ( daha sonra daha büyük regexps olarak birleştirilecek normal ifadelerin bölümlerinden kaçmak için yararlı olabilir ).

Eğer bütün bir regexp kaçmak ve ya tek başına olan meta karakterler alıntı, onunla yapılır (Eğer ., ?, +, *, ^, $, |, \şey) ya da başlatmak ( (, [, {) tek ihtiyacınız olan:

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

Ve evet, JavaScript'in bu gibi bir işleve sahip olmaması hayal kırıklığı yaratıyor.

Başka bir (çok daha güvenli) yaklaşım, unicode kaçış biçimini kullanarak tüm karakterlerden (ve şu anda bildiğimiz birkaç özel karakterden değil) kaçmaktır \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}'

uBu yöntemin çalışması için bayrağı geçmeniz gerektiğini lütfen unutmayın :

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

Değişmez sayılabilmesi için kaçması gereken 12 meta karakter olmuştur .

Dengeli bir
regex sargıya yerleştirilen kaçan dize ile ne yapıldığı önemli değil, önemli değil.

Bunu kullanarak bir dize değiştirme yapın

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