Hướng dẫn math expression javascript - biểu thức toán học javascript

Tạo một biểu thức chính quy

Bạn xây dựng một biểu thức chính quy theo một trong hai cách:

• Sử dụng một biểu thức thông thường theo nghĩa đen, bao gồm một mẫu được bao quanh giữa các dấu gạch chéo, như sau: Biểu thức thông thường theo nghĩa đen cung cấp tổng hợp biểu thức chính quy khi tập lệnh được tải. Nếu biểu thức chính quy không đổi, sử dụng điều này có thể cải thiện hiệu suất.
• Hoặc gọi hàm hàm tạo của đối tượng

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

  7, như sau:

  const re = new RegExp('ab+c');
  

  Sử dụng hàm Constructor cung cấp biên dịch thời gian chạy của biểu thức chính quy. Sử dụng chức năng Constructor khi bạn biết mẫu biểu thức chính quy sẽ thay đổi hoặc bạn không biết mẫu và đang lấy nó từ một nguồn khác, chẳng hạn như đầu vào của người dùng.

Viết một mẫu biểu thức chính quy

Một mẫu biểu thức chính quy bao gồm các ký tự đơn giản, chẳng hạn như

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

Lưu ý: Nếu bạn đã quen thuộc với các hình thức của một biểu thức thông thường, bạn cũng có thể đọc tờ Cheatese để tìm kiếm nhanh chóng cho một mẫu/cấu trúc cụ thể. If you are already familiar with the forms of a regular expression, you may also read the cheatsheet for a quick lookup for a specific pattern/construct.

Sử dụng các mẫu đơn giản

Các mẫu đơn giản được xây dựng từ các ký tự mà bạn muốn tìm một trận đấu trực tiếp. Ví dụ, mẫu

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

const myArray = /d(b+)d/g.exec('cdbbdbsbz');
// similar to 'cdbbdbsbz'.match(/d(b+)d/g); however,
// 'cdbbdbsbz'.match(/d(b+)d/g) outputs [ "dbbd" ]
// while /d(b+)d/g.exec('cdbbdbsbz') outputs [ 'dbbd', 'bb', index: 1, input: 'cdbbdbsbz' ]

const myArray = /d(b+)d/g.exec('cdbbdbsbz');
// similar to 'cdbbdbsbz'.match(/d(b+)d/g); however,
// 'cdbbdbsbz'.match(/d(b+)d/g) outputs [ "dbbd" ]
// while /d(b+)d/g.exec('cdbbdbsbz') outputs [ 'dbbd', 'bb', index: 1, input: 'cdbbdbsbz' ]

const myArray = /d(b+)d/g.exec('cdbbdbsbz');
// similar to 'cdbbdbsbz'.match(/d(b+)d/g); however,
// 'cdbbdbsbz'.match(/d(b+)d/g) outputs [ "dbbd" ]
// while /d(b+)d/g.exec('cdbbdbsbz') outputs [ 'dbbd', 'bb', index: 1, input: 'cdbbdbsbz' ]

const myArray = /d(b+)d/g.exec('cdbbdbsbz');
// similar to 'cdbbdbsbz'.match(/d(b+)d/g); however,
// 'cdbbdbsbz'.match(/d(b+)d/g) outputs [ "dbbd" ]
// while /d(b+)d/g.exec('cdbbdbsbz') outputs [ 'dbbd', 'bb', index: 1, input: 'cdbbdbsbz' ]

const myArray = /d(b+)d/g.exec('cdbbdbsbz');
// similar to 'cdbbdbsbz'.match(/d(b+)d/g); however,
// 'cdbbdbsbz'.match(/d(b+)d/g) outputs [ "dbbd" ]
// while /d(b+)d/g.exec('cdbbdbsbz') outputs [ 'dbbd', 'bb', index: 1, input: 'cdbbdbsbz' ]

const myArray = /d(b+)d/g.exec('cdbbdbsbz');
// similar to 'cdbbdbsbz'.match(/d(b+)d/g); however,
// 'cdbbdbsbz'.match(/d(b+)d/g) outputs [ "dbbd" ]
// while /d(b+)d/g.exec('cdbbdbsbz') outputs [ 'dbbd', 'bb', index: 1, input: 'cdbbdbsbz' ]

const myArray = /d(b+)d/g.exec('cdbbdbsbz');
// similar to 'cdbbdbsbz'.match(/d(b+)d/g); however,
// 'cdbbdbsbz'.match(/d(b+)d/g) outputs [ "dbbd" ]
// while /d(b+)d/g.exec('cdbbdbsbz') outputs [ 'dbbd', 'bb', index: 1, input: 'cdbbdbsbz' ]

Sử dụng các ký tự đặc biệt

Khi tìm kiếm một trận đấu đòi hỏi một cái gì đó nhiều hơn một trận đấu trực tiếp, chẳng hạn như tìm một hoặc nhiều B hoặc tìm không gian trắng, bạn có thể bao gồm các ký tự đặc biệt trong mẫu. Ví dụ: để khớp với một

const myArray = /d(b+)d/g.exec('cdbbdbsbz');
// similar to 'cdbbdbsbz'.match(/d(b+)d/g); however,
// 'cdbbdbsbz'.match(/d(b+)d/g) outputs [ "dbbd" ]
// while /d(b+)d/g.exec('cdbbdbsbz') outputs [ 'dbbd', 'bb', index: 1, input: 'cdbbdbsbz' ]

const myArray = /d(b+)d/g.exec('cdbbdbsbz');
// similar to 'cdbbdbsbz'.match(/d(b+)d/g); however,
// 'cdbbdbsbz'.match(/d(b+)d/g) outputs [ "dbbd" ]
// while /d(b+)d/g.exec('cdbbdbsbz') outputs [ 'dbbd', 'bb', index: 1, input: 'cdbbdbsbz' ]

const myArray = /d(b+)d/g.exec('cdbbdbsbz');
// similar to 'cdbbdbsbz'.match(/d(b+)d/g); however,
// 'cdbbdbsbz'.match(/d(b+)d/g) outputs [ "dbbd" ]
// while /d(b+)d/g.exec('cdbbdbsbz') outputs [ 'dbbd', 'bb', index: 1, input: 'cdbbdbsbz' ]

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

const myRe = new RegExp('d(b+)d', 'g');
const myArray = myRe.exec('cdbbdbsbz');

const myArray = /d(b+)d/g.exec('cdbbdbsbz');
// similar to 'cdbbdbsbz'.match(/d(b+)d/g); however,
// 'cdbbdbsbz'.match(/d(b+)d/g) outputs [ "dbbd" ]
// while /d(b+)d/g.exec('cdbbdbsbz') outputs [ 'dbbd', 'bb', index: 1, input: 'cdbbdbsbz' ]

const myRe = new RegExp('d(b+)d', 'g');
const myArray = myRe.exec('cdbbdbsbz');

const myRe = new RegExp('d(b+)d', 'g');
const myArray = myRe.exec('cdbbdbsbz');

Các trang sau cung cấp danh sách các ký tự đặc biệt khác nhau phù hợp với từng danh mục, cùng với các mô tả và ví dụ.

Các xác nhận bao gồm các ranh giới, chỉ ra sự khởi đầu và kết thúc của các dòng và từ, và các mẫu khác chỉ ra theo một cách nào đó mà một trận đấu là có thể (bao gồm cả hướng trước, nhìn về phía sau và các biểu thức có điều kiện).

Phân biệt các loại ký tự khác nhau. Ví dụ, phân biệt giữa các chữ cái và chữ số.

Nhóm nhóm nhiều mẫu nói chung và các nhóm thu thập cung cấp thêm thông tin bài hát khi sử dụng mẫu biểu thức chính quy để khớp với chuỗi. BackReferences đề cập đến một nhóm đã bị bắt trước đó trong cùng một biểu thức chính quy.

Chỉ ra số lượng ký tự hoặc biểu thức để khớp.

Phân biệt dựa trên các thuộc tính ký tự unicode, ví dụ, các chữ cái trên và chữ cái, ký hiệu toán học và dấu câu.

Nếu bạn muốn xem tất cả các ký tự đặc biệt có thể được sử dụng trong các biểu thức thông thường trong một bảng, hãy xem phần sau:

const myRe = new RegExp('d(b+)d', 'g');
const myArray = myRe.exec('cdbbdbsbz');

const myRe = new RegExp('d(b+)d', 'g');
const myArray = myRe.exec('cdbbdbsbz');

const myRe = new RegExp('d(b+)d', 'g');
const myArray = myRe.exec('cdbbdbsbz');

const myRe = new RegExp('d(b+)d', 'g');
const myArray = myRe.exec('cdbbdbsbz');

const myRe = new RegExp('d(b+)d', 'g');
const myArray = myRe.exec('cdbbdbsbz');

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');
console.log(`The value of lastIndex is ${myRe.lastIndex}`);

// "The value of lastIndex is 5"

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');
console.log(`The value of lastIndex is ${myRe.lastIndex}`);

// "The value of lastIndex is 5"

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');
console.log(`The value of lastIndex is ${myRe.lastIndex}`);

// "The value of lastIndex is 5"

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');
console.log(`The value of lastIndex is ${myRe.lastIndex}`);

// "The value of lastIndex is 5"

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');
console.log(`The value of lastIndex is ${myRe.lastIndex}`);

// "The value of lastIndex is 5"

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');
console.log(`The value of lastIndex is ${myRe.lastIndex}`);

// "The value of lastIndex is 5"

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');
console.log(`The value of lastIndex is ${myRe.lastIndex}`);

// "The value of lastIndex is 5"

Phân biệt dựa trên các thuộc tính ký tự unicode, ví dụ, các chữ cái trên và chữ cái, ký hiệu toán học và dấu câu.

Nếu bạn muốn xem tất cả các ký tự đặc biệt có thể được sử dụng trong các biểu thức thông thường trong một bảng, hãy xem phần sau:

Ký tự đặc biệt trong biểu thức chính quy.

Ký tự / cấu trúc

Bài viết tương ứng

Nếu chuỗi thoát chưa phải là một phần trong mẫu của bạn, bạn có thể thêm chúng bằng cách sử dụng

const re = /\w+\s/g;
const str = 'fee fi fo fum';
const myArray = str.match(re);
console.log(myArray);

// ["fee ", "fi ", "fo "]

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

"G" sau khi biểu thức thông thường là một tùy chọn hoặc cờ thực hiện tìm kiếm toàn cầu, nhìn vào toàn bộ chuỗi và trả về tất cả các trận đấu. Nó được giải thích chi tiết dưới đây trong tìm kiếm nâng cao với cờ.

Tại sao điều này không được xây dựng trong JavaScript? Có một đề xuất để thêm một chức năng như vậy vào regexp.

Sử dụng dấu ngoặc đơn

Điểm dừng xung quanh bất kỳ phần nào của mẫu biểu thức chính quy gây ra một phần của chuỗi con phù hợp được ghi nhớ. Sau khi nhớ, phần phụ có thể được thu hồi cho việc sử dụng khác. Xem các nhóm và backrefer để biết thêm chi tiết.

Sử dụng các biểu thức chính quy trong JavaScript

Các biểu thức chính quy được sử dụng với các phương pháp

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

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

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

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

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

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

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

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

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

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

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

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

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

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

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

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

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

Khi bạn muốn biết liệu một mẫu được tìm thấy trong một chuỗi, hãy sử dụng các phương thức

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

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

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

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

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

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

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

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

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

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

Trong ví dụ sau, tập lệnh sử dụng phương thức

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

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

Nếu bạn không cần truy cập các thuộc tính của biểu thức thông thường, một cách khác để tạo

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

const myArray = /d(b+)d/g.exec('cdbbdbsbz');
// similar to 'cdbbdbsbz'.match(/d(b+)d/g); however,
// 'cdbbdbsbz'.match(/d(b+)d/g) outputs [ "dbbd" ]
// while /d(b+)d/g.exec('cdbbdbsbz') outputs [ 'dbbd', 'bb', index: 1, input: 'cdbbdbsbz' ]

(Xem bằng cách sử dụng cờ tìm kiếm toàn cầu với

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

Nếu bạn muốn xây dựng biểu thức thông thường từ một chuỗi, nhưng một giải pháp khác là tập lệnh này:

const myRe = new RegExp('d(b+)d', 'g');
const myArray = myRe.exec('cdbbdbsbz');

Với các tập lệnh này, trận đấu thành công và trả về mảng và cập nhật các thuộc tính được hiển thị trong bảng sau.

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

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

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

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

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

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

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

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

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

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

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

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

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');

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

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

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

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

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

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

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

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

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

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

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

Nếu bạn muốn xây dựng biểu thức thông thường từ một chuỗi, nhưng một giải pháp khác là tập lệnh này:

const myRe = /d(b+)d/g;
const myArray = myRe.exec('cdbbdbsbz');
console.log(`The value of lastIndex is ${myRe.lastIndex}`);

// "The value of lastIndex is 5"

Với các tập lệnh này, trận đấu thành công và trả về mảng và cập nhật các thuộc tính được hiển thị trong bảng sau.

const myArray = /d(b+)d/g.exec('cdbbdbsbz');
console.log(`The value of lastIndex is ${/d(b+)d/g.lastIndex}`);

// "The value of lastIndex is 0"

Kết quả thực thi biểu thức thường xuyên.

Sự vật

Tài sản hoặc chỉ mục

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

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

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

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

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

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

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

const myArray = /d(b+)d/g.exec('cdbbdbsbz');
console.log(`The value of lastIndex is ${/d(b+)d/g.lastIndex}`);

// "The value of lastIndex is 0"

const myArray = /d(b+)d/g.exec('cdbbdbsbz');
console.log(`The value of lastIndex is ${/d(b+)d/g.lastIndex}`);

// "The value of lastIndex is 0"

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

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

const myRe = new RegExp('d(b+)d', 'g');
const myArray = myRe.exec('cdbbdbsbz');

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

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

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

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

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

Để bao gồm một lá cờ có biểu thức thông thường, hãy sử dụng cú pháp này:

const re = /pattern/flags;

hoặc

const re = new RegExp('pattern', 'flags');

Lưu ý rằng các cờ là một phần không thể thiếu của biểu thức chính quy. Họ không thể được thêm hoặc loại bỏ sau này.

Ví dụ,

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

const re = /\w+\s/g;
const str = 'fee fi fo fum';
const myArray = str.match(re);
console.log(myArray);

// ["fee ", "fi ", "fo "]

Bạn có thể thay thế dòng:

with:

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

và nhận được kết quả tương tự.

Cờ

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

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

const myArray = /d(b+)d/g.exec('cdbbdbsbz');
console.log(`The value of lastIndex is ${/d(b+)d/g.lastIndex}`);

// "The value of lastIndex is 0"

const myArray = /d(b+)d/g.exec('cdbbdbsbz');
console.log(`The value of lastIndex is ${/d(b+)d/g.lastIndex}`);

// "The value of lastIndex is 0"

Sử dụng cờ tìm kiếm toàn cầu với Exec ()

Phương thức

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

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

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

Ngược lại, phương thức

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

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

Sử dụng các biểu thức chính quy Unicode

Cờ "U" được sử dụng để tạo các biểu thức chính quy "unicode"; Đó là, các biểu thức thường xuyên hỗ trợ khớp với văn bản Unicode. Điều này chủ yếu được thực hiện thông qua việc sử dụng các Escapes thuộc tính Unicode, chỉ được hỗ trợ trong các biểu thức chính quy "Unicode".

Ví dụ: biểu thức chính quy sau đây có thể được sử dụng để khớp với một "từ" unicode tùy ý: từ ":

Có một số khác biệt khác giữa các biểu thức chính quy Unicode và Nonicode mà người ta nên biết:

• Các biểu thức chính quy của Unicode không hỗ trợ cái gọi là "thoát khỏi danh tính"; Đó là, các mô hình không cần phải bỏ qua một dấu gạch chéo ngược và bị bỏ qua một cách hiệu quả. Ví dụ:

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

  73 là một biểu thức chính quy hợp lệ khớp với chữ 'A', nhưng

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

  74 thì không.
• Giá đỡ xoăn cần phải được thoát ra khi không được sử dụng làm định lượng. Ví dụ,

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

  75 là một biểu thức chính quy hợp lệ khớp với khung xoăn '{', nhưng

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

  76 thì không - thay vào đó, khung nên được thoát ra và

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

  77 nên được sử dụng thay thế.
• Nhân vật

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

  78 được giải thích khác nhau trong các lớp ký tự. Cụ thể, đối với các biểu thức chính quy Unicode,

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

  78 được hiểu là một

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

  78 theo nghĩa đen (và không phải là một phần của phạm vi) chỉ khi nó xuất hiện ở đầu hoặc cuối của lớp ký tự. Ví dụ,

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

  81 là một biểu thức chính quy hợp lệ khớp với ký tự từ,

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

  78 hoặc

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

  83, nhưng

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

  84 là một biểu thức chính quy không hợp lệ, vì

  const myRe = /d(b+)d/g;
  const myArray = myRe.exec('cdbbdbsbz');
  console.log(`The value of lastIndex is ${myRe.lastIndex}`);
  
  // "The value of lastIndex is 5"
  

  7 đến

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

  83 không phải là một phạm vi ký tự được xác định rõ.

Các biểu thức chính quy của Unicode cũng có hành vi thực thi khác nhau là tốt.

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

Ví dụ

Lưu ý: Một số ví dụ cũng có sẵn trong: Several examples are also available in:

• Các trang tham chiếu cho

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

  5,

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

  6,

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

  8,

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

  9,

  const myRe = /d(b+)d/g;
  const myArray = myRe.exec('cdbbdbsbz');
  

  2,

  const myRe = /d(b+)d/g;
  const myArray = myRe.exec('cdbbdbsbz');
  

  0,

  const myRe = /d(b+)d/g;
  const myArray = myRe.exec('cdbbdbsbz');
  

  3
• Các bài viết hướng dẫn: Các lớp nhân vật, xác nhận, nhóm và backrefer, định lượng, tài sản Unicode thoát khỏi

Sử dụng các ký tự đặc biệt để xác minh đầu vào

Trong ví dụ sau, người dùng dự kiến ​​sẽ nhập số điện thoại. Khi người dùng nhấn nút "Kiểm tra", tập lệnh sẽ kiểm tra tính hợp lệ của số. Nếu số là hợp lệ (khớp với chuỗi ký tự được chỉ định bởi biểu thức chính quy), tập lệnh hiển thị một thông báo cảm ơn người dùng và xác nhận số. Nếu số không hợp lệ, tập lệnh thông báo cho người dùng rằng số điện thoại không hợp lệ.

Biểu thức chính quy tìm kiếm:

1. Sự khởi đầu của dòng dữ liệu:

   const myArray = /d(b+)d/g.exec('cdbbdbsbz');
   console.log(`The value of lastIndex is ${/d(b+)d/g.lastIndex}`);
   
   // "The value of lastIndex is 0"
   

   4
2. tiếp theo là ba ký tự số

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

   96 hoặc

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

   97 Một dấu ngoặc trái
3. tiếp theo là một dấu gạch ngang, chém về phía trước hoặc dấu thập phân trong nhóm bắt giữ

   const myRe = /d(b+)d/g;
   const myArray = myRe.exec('cdbbdbsbz');
   

   02
4. tiếp theo là ba chữ số

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

   96
5. tiếp theo là trận đấu được ghi nhớ trong nhóm (đầu tiên) bị bắt

   const myRe = /d(b+)d/g;
   const myArray = myRe.exec('cdbbdbsbz');
   

   04
6. tiếp theo là bốn chữ số

   const myRe = /d(b+)d/g;
   const myArray = myRe.exec('cdbbdbsbz');
   

   05
7. theo sau là kết thúc dòng dữ liệu:

   const myArray = /d(b+)d/g.exec('cdbbdbsbz');
   console.log(`The value of lastIndex is ${/d(b+)d/g.lastIndex}`);
   
   // "The value of lastIndex is 0"
   

   5

HTML

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

JavaScript

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

Kết quả