มีฟังก์ชั่น RegExp.escape ใน Javascript หรือไม่

ฉันแค่ต้องการสร้างการแสดงออกปกติจากสตริงที่เป็นไปได้ใด ๆ

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

มีวิธีการในตัวสำหรับที่? ถ้าไม่ใช่คนใช้อะไร RegExp.escapeทับทิมมี ฉันไม่รู้สึกว่าฉันจะต้องเขียนของตัวเองมันต้องมีอะไรบางอย่างที่เป็นมาตรฐาน ขอบคุณ!

ฟังก์ชั่นที่เชื่อมโยงด้านบนไม่เพียงพอ มันไม่สามารถหลบหนี^หรือ$(เริ่มต้นและสิ้นสุดของสตริง) หรือ-ซึ่งในกลุ่มตัวละครจะใช้สำหรับช่วง

ใช้ฟังก์ชั่นนี้:

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

ในขณะที่มันอาจดูเหมือนไม่จำเป็นตอนแรกการหลบหนี-(และ^) ทำให้ฟังก์ชั่นที่เหมาะสมสำหรับการหลบหนีตัวละครจะถูกแทรกลงในคลาสตัวละครรวมทั้งเนื้อหาของ regex

การหลบหนี/ทำให้ฟังก์ชั่นเหมาะสำหรับการหลบหนีตัวละครที่จะใช้ในตัวอักษร JS regex สำหรับการ eval ในภายหลัง

เนื่องจากไม่มีข้อเสียใด ๆ ในการหลีกเลี่ยงทั้งสองข้อจึงควรหลีกเลี่ยงที่จะครอบคลุมกรณีการใช้งานที่กว้างขึ้น

และใช่มันเป็นความล้มเหลวที่น่าผิดหวังที่นี่ไม่ใช่ส่วนหนึ่งของ JavaScript มาตรฐาน

สำหรับทุกคนที่ใช้ lodash เนื่องจาก v3.0.0มีฟังก์ชั่น_.escapeRegExpอยู่ในตัว:

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

และในกรณีที่คุณไม่ต้องการใช้ไลบรารี่เต็มคุณอาจจำเป็นต้องใช้ฟังก์ชั่นนั้น !

นิพจน์ส่วนใหญ่ที่นี่แก้ปัญหากรณีใช้งานที่เฉพาะเจาะจง

ไม่เป็นไร แต่ฉันชอบวิธีการ "ทำงานได้ตลอดเวลา"

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

นี่จะ "หลบหนีอย่างเต็มที่" สตริงตัวอักษรสำหรับการใช้งานใด ๆ ต่อไปนี้ในนิพจน์ทั่วไป

• การแทรกในนิพจน์ปกติ เช่นnew RegExp(regExpEscape(str))
• การแทรกในคลาสอักขระ เช่นnew RegExp('[' + regExpEscape(str) + ']')
• การแทรกตัวระบุจำนวนเต็ม เช่นnew RegExp('x{1,' + regExpEscape(str) + '}')
• การดำเนินการในเอ็นจินนิพจน์ทั่วไปที่ไม่ใช่ JavaScript

ตัวละครพิเศษที่ครอบคลุม:

• -: สร้างช่วงอักขระในคลาสอักขระ
• [/ ]: เริ่ม / จบคลาสอักขระ
• {/ }: เริ่ม / สิ้นสุดตัวระบุการคำนวณ
• (/ ): เริ่ม / สิ้นสุดกลุ่ม
• */ +/ ?: ระบุประเภทการทำซ้ำ
• .: ตรงกับตัวละครใด ๆ
• \: หนีอักขระและเริ่มเอนทิตี้
• ^: ระบุจุดเริ่มต้นของการจับคู่โซนและคัดค้านการจับคู่ในคลาสอักขระ
• $: ระบุจุดสิ้นสุดของโซนที่ตรงกัน
• |: ระบุการสลับ
• #: ระบุความคิดเห็นในโหมดระยะห่างฟรี
• \s: ข้ามไปในโหมดระยะห่างฟรี
• ,: คั่นค่าในตัวระบุการคำนวณ
• /: เริ่มหรือสิ้นสุดการแสดงออก
• :: เสร็จสิ้นประเภทกลุ่มพิเศษและเป็นส่วนหนึ่งของคลาสอักขระสไตล์ Perl
• !: ลบกลุ่มที่มีความกว้างเป็นศูนย์
• </ =: ส่วนหนึ่งของข้อมูลจำเพาะกลุ่มความกว้างเป็นศูนย์

หมายเหตุ:

• /ไม่จำเป็นอย่างเคร่งครัดในรสชาติของการแสดงออกปกติใด ๆ แต่ก็ปกป้องในกรณีที่มีคน(สั่น)eval("/" + pattern + "/");ไม่
• , ตรวจสอบให้แน่ใจว่าถ้าสตริงนั้นมีความหมายว่าเป็นจำนวนเต็มในตัวระบุตัวเลขมันจะทำให้เกิดข้อผิดพลาดในการรวบรวม RegExp อย่างถูกต้องแทนที่จะรวบรวมผิดอย่างเงียบ ๆ
• #และ\sไม่จำเป็นต้องหลบหนีใน JavaScript แต่ทำในรสชาติอื่น ๆ อีกมากมาย พวกเขาจะหลบหนีที่นี่ในกรณีที่การแสดงออกปกติจะถูกส่งต่อไปยังโปรแกรมอื่น

หากคุณต้องการหลักฐานในอนาคตเกี่ยวกับการแสดงออกปกติต่อการเพิ่มความสามารถของเอนจิน JavaScript regex ฉันขอแนะนำให้ใช้ paranoid เพิ่มเติม:

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

ฟังก์ชันนี้จะยกเว้นอักขระทั้งหมดยกเว้นที่รับประกันอย่างชัดเจนว่าจะไม่ใช้สำหรับไวยากรณ์ในรสชาติการแสดงออกปกติในอนาคต

สำหรับผู้ที่รักการสุขาภิบาลอย่างแท้จริงให้พิจารณากรณีขอบนี้:

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

สิ่งนี้ควรรวบรวมใน JavaScript แต่จะไม่อยู่ในรสชาติอื่น ๆ หากตั้งใจที่จะส่งผ่านไปยังรสชาติอื่นs === ''ควรตรวจสอบกรณีที่ว่างด้วยตนเองเช่น:

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

คำแนะนำของ Mozilla Developer Network สำหรับ Regular Expressionsมีฟังก์ชั่นหลบหนีนี้:

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

ในวิดเจ็ตการเติมข้อความอัตโนมัติของ jQueryUI (เวอร์ชั่น 1.9.1) พวกเขาใช้ regex ที่แตกต่างกันเล็กน้อย (Line 6753) นี่คือนิพจน์ทั่วไปที่รวมเข้ากับ @bobince

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

ไม่มีอะไรควรป้องกันคุณจากการหลบหนีอักขระที่ไม่ใช่ตัวอักษรและตัวเลขทุกตัว:

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

คุณสูญเสียความสามารถในการอ่านระดับหนึ่งเมื่อทำre.toString()แต่คุณจะได้รับความเรียบง่าย (และความปลอดภัย)

ตาม ECMA-262 บนมือข้างหนึ่งปกติสำนวนที่ว่า "ตัวละครไวยากรณ์" อยู่เสมอไม่ใช่ตัวเลขดังกล่าวว่าผลที่ได้คือการรักษาความปลอดภัยและลำดับหนีพิเศษ ( \d, \w, \n) อยู่เสมอและตัวเลขดังกล่าวว่าไม่มีการหลบหนีการควบคุมที่เป็นเท็จจะมีการผลิต .

มีข้อเสนอ ES7 สำหรับ RegExp.escape ที่ https://github.com/benjamingr/RexExp.escape/กับ polyfill ใช้ได้ที่https://github.com/ljharb/regexp.escape

นี่เป็นรุ่นที่สั้นกว่า

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

ซึ่งรวมถึงตัวละครที่ไม่ใช่เมตาของ%, &, 'และ,แต่สเปค JavaScript ช่วยให้ RegExp นี้

XRegExp มีฟังก์ชัน escape:

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

เพิ่มเติมเกี่ยวกับ: http://xregexp.com/api/#escape

แทนที่จะหนีจากตัวละครที่จะทำให้เกิดปัญหาในการแสดงออกปกติของคุณ (เช่นบัญชีดำ) ทำไมไม่ลองใช้บัญชีขาวแทน วิธีนี้จะถือว่าตัวละครแต่ละตัวเสีย

สำหรับตัวอย่างนี้ให้ถือว่านิพจน์ต่อไปนี้:

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

รายการตัวอักษรที่อนุญาตนี้จำนวนและช่องว่าง:

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

ผลตอบแทน:

"be \|\| \! be"

สิ่งนี้อาจหลบหนีตัวละครที่ไม่จำเป็นต้องหลบหนี แต่สิ่งนี้ไม่ได้ขัดขวางการแสดงออกของคุณ (อาจมีบทลงโทษเล็กน้อยบางครั้ง - แต่มันก็คุ้มค่าสำหรับความปลอดภัย)

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

ฟังก์ชั่นในคำตอบอื่น ๆ นั้นมากไปสำหรับการหลบหนีการแสดงออกปกติทั้งหมด (พวกเขาอาจมีประโยชน์สำหรับการหลบหนีบางส่วนของการแสดงออกปกติที่จะถูกนำมาต่อกันเป็น regexps ที่ใหญ่กว่า)

ถ้าคุณหนี regexp ทั้งหมดและจะทำกับมัน quoting metacharacters ที่มีทั้งแบบสแตนด์อโลน ( ., ?, +, *, ^, $, |, \) หรือเริ่มต้นสิ่งที่ ( (, [, {) เป็นสิ่งที่คุณจำเป็นต้องใช้:

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

และใช่มันน่าผิดหวังที่ JavaScript ไม่มีฟังก์ชั่นในตัวนี้

อีกวิธีหนึ่งที่ปลอดภัยกว่าคือการหลบหนีตัวละครทุกตัว (ไม่ใช่แค่ตัวละครพิเศษที่เรารู้จัก) โดยใช้รูปแบบการหลบหนีแบบ Unicode \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}'

โปรดทราบว่าคุณต้องผ่านการuตั้งค่าสถานะเพื่อให้วิธีนี้ทำงาน:

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

มีเพียงเคยและเคยจะเป็นตัวละครเมตา 12 ที่จะต้องมีการหลบหนี
เพื่อพิจารณาตัวอักษร

ไม่สำคัญว่าจะทำอะไรกับสตริง escaped แทรกลงใน
wrapper regex ที่สมดุลผนวกท้ายไม่สำคัญ

ทำสตริงแทนที่โดยใช้สิ่งนี้

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