Các ký tự thoát trong javascript là gì?

Như chúng ta đã thấy, dấu gạch chéo ngược

alert( "function g()".match(/g\(\)/) ); // "g()"
14 được sử dụng để biểu thị các lớp ký tự, e. g.
alert( "function g()".match(/g\(\)/) ); // "g()"
15. Vì vậy, nó là một ký tự đặc biệt trong biểu thức chính quy (giống như trong các chuỗi thông thường)

Ngoài ra còn có các ký tự đặc biệt khác có ý nghĩa đặc biệt trong biểu thức chính quy, chẳng hạn như ________ 00. Chúng được sử dụng để thực hiện các tìm kiếm mạnh mẽ hơn

Đừng cố ghi nhớ danh sách – chúng ta sẽ sớm xử lý từng danh sách và bạn sẽ tự động thuộc lòng chúng

Giả sử chúng ta muốn tìm một dấu chấm theo đúng nghĩa đen. Không phải "bất kỳ ký tự nào", mà chỉ là một dấu chấm

Để sử dụng ký tự đặc biệt làm ký tự thông thường, hãy thêm dấu gạch chéo ngược vào trước ký tự đó.

alert( "function g()".match(/g\(\)/) ); // "g()"
1

Đó cũng được gọi là "thoát khỏi một nhân vật"

Ví dụ

alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)

Dấu ngoặc đơn cũng là ký tự đặc biệt nên nếu muốn chúng ta dùng

alert( "function g()".match(/g\(\)/) ); // "g()"
2. Ví dụ dưới đây tìm kiếm một chuỗi
alert( "function g()".match(/g\(\)/) ); // "g()"
3

alert( "function g()".match(/g\(\)/) ); // "g()"

Nếu chúng ta đang tìm dấu gạch chéo ngược

alert( "function g()".match(/g\(\)/) ); // "g()"
14, thì đó là một ký tự đặc biệt trong cả chuỗi thông thường và biểu thức chính quy, vì vậy chúng ta nên nhân đôi nó

alert( "1\\2".match(/\\/) ); // '\'

Ký hiệu dấu gạch chéo

alert( "function g()".match(/g\(\)/) ); // "g()"
5 không phải là một ký tự đặc biệt, nhưng trong JavaScript, nó được sử dụng để mở và đóng biểu thức chính quy.
alert( "function g()".match(/g\(\)/) ); // "g()"
6, vì vậy chúng ta cũng nên thoát khỏi nó

Đây là cách tìm kiếm dấu gạch chéo

alert( "function g()".match(/g\(\)/) ); // "g()"
5

alert( "function g()".match(/g\(\)/) ); // "g()"
0

Mặt khác, nếu chúng tôi không sử dụng

alert( "function g()".match(/g\(\)/) ); // "g()"
8, nhưng tạo biểu thức chính quy bằng cách sử dụng
alert( "function g()".match(/g\(\)/) ); // "g()"
9, thì chúng tôi không cần phải thoát khỏi nó

alert( "function g()".match(/g\(\)/) ); // "g()"
3

Nếu chúng ta đang tạo một biểu thức chính quy với

alert( "function g()".match(/g\(\)/) ); // "g()"
9, thì chúng ta không cần phải thoát khỏi
alert( "1\\2".match(/\\/) ); // '\'
1 mà cần thực hiện một số thao tác thoát khác

Ví dụ, hãy xem xét điều này

alert( "function g()".match(/g\(\)/) ); // "g()"
6

Tìm kiếm tương tự trong một trong các ví dụ trước đã hoạt động với

alert( "1\\2".match(/\\/) ); // '\'
2, nhưng
alert( "1\\2".match(/\\/) ); // '\'
3 không hoạt động, tại sao?

Lý do là các dấu gạch chéo ngược được "tiêu thụ" bởi một chuỗi. Như chúng ta có thể nhớ lại, các chuỗi thông thường có các ký tự đặc biệt của riêng chúng, chẳng hạn như

alert( "1\\2".match(/\\/) ); // '\'
4 và dấu gạch chéo ngược được sử dụng để thoát

Một ký tự thoát cho phép bạn xuất các ký tự mà thông thường bạn không thể làm được, thường là do trình duyệt sẽ diễn giải ký tự đó theo cách khác với những gì bạn dự định

Phương pháp-1. Thoát các ký tự đặc biệt HTML trong JavaScript

Đoạn mã sau cho thấy phương pháp đơn giản và dễ dàng để thoát các ký tự đặc biệt HTML trong JavaScript

Nguồn đầy đủ. JavaScript

Phương pháp-2. Thoát tất cả các ký tự đặc biệt trong JavaScript

Trong phương pháp này, hãy sử dụng HTML Phương thức DOM createTextNode() để thoát các ký tự đặc biệt HTML trong JavaScript

Nguồn đầy đủ. JavaScript

Phương pháp-3. Thoát các ký tự đặc biệt trong JavaScript

Trong phương pháp này, hãy sử dụng phương thức thay thế () của JavaScript để thoát các ký tự đặc biệt trong JavaScript

Nguồn đầy đủ. JavaScript

Ký tự thoát JavaScript

ví dụ

Đoạn code trên khi chạy sẽ báo lỗi do trình duyệt gặp dấu ngoặc kép đầu tiên, nó sẽ tưởng là chuỗi đã kết thúc

Sử dụng ký tự thoát

Đoạn mã trên sẽ chạy thành công, vì trình duyệt gặp dấu gạch chéo ngược, nó biết không cố diễn giải ký tự tiếp theo

Gần đây đã viết về các tham chiếu ký tự trong HTML và các chuỗi ký tự thoát trong CSS, tôi cho rằng sẽ rất thú vị nếu xem xét cả các ký tự thoát trong JavaScript

Mã ký tự, điểm mã và đơn vị mã

Điểm mã (còn được gọi là “mã ký tự”) là biểu thị bằng số của một ký tự Unicode cụ thể

Ví dụ: mã ký tự của ký hiệu bản quyền

alert( "function g()".match(/g\(\)/) ); // "g()"
17 là
alert( "function g()".match(/g\(\)/) ); // "g()"
18, có thể viết là
alert( "function g()".match(/g\(\)/) ); // "g()"
19 ở dạng hex

Trong JavaScript, có thể sử dụng

alert( "function g()".match(/g\(\)/) ); // "g()"
20 để lấy điểm mã Unicode dạng số của bất kỳ ký tự nào lên tới U+FFFF (i. e. ký tự có điểm mã
alert( "function g()".match(/g\(\)/) ); // "g()"
21, là
alert( "function g()".match(/g\(\)/) ); // "g()"
22 ở dạng thập phân)

Vì JavaScript sử dụng mã hóa UCS-2 bên trong, nên các điểm mã cao hơn được biểu thị bằng một cặp ký tự giả “thay thế” (có giá trị thấp hơn) được sử dụng để tạo thành ký tự thực. Để lấy mã ký tự thực của các ký tự có điểm mã cao hơn này trong JavaScript, bạn sẽ phải làm. Về cơ bản, JavaScript sử dụng các đơn vị mã thay vì các điểm mã

Bây giờ thì không còn cách nào khác, chúng ta hãy xem các loại trình tự thoát ký tự khác nhau trong chuỗi JavaScript

Trình tự thoát ký tự đơn

Có một số chuỗi thoát ký tự đơn để sử dụng trong chuỗi

  • alert( "function g()".match(/g\(\)/) ); // "g()"
    23. xóa lùi (U+0008 BACKSPACE)
  • alert( "function g()".match(/g\(\)/) ); // "g()"
    24. nguồn cấp dữ liệu biểu mẫu (U+000C FORM FEED)
  • alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
    alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
    00. nguồn cấp dữ liệu (U+000A LINE FEED)
  • alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
    alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
    01. trả lại vận chuyển (U+000D CARRIAGE RETURN)
  • alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
    alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
    02. tab ngang (BẢNG BẢNG KÝ TỰ U+0009)
  • alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
    alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
    03. tab dọc (LẬP BẢNG DÒNG U+000B)
  • alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
    alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
    04. ký tự null (U+0000 NULL) (chỉ khi ký tự tiếp theo không phải là chữ số thập phân; nếu không thì đó là ký tự )
  • alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
    alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
    05. trích dẫn đơn (U+0027 APOSTROPHE)
  • alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
    alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
    06. trích dẫn kép (U+0022 QUOTATION MARK)
  • alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
    alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
    07. dấu gạch chéo ngược (U+005C REVERSE SOLIDUS)

Tất cả các ký tự thoát có thể dễ dàng được ghi nhớ bằng biểu thức chính quy sau.

alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
08

Lưu ý rằng ký tự thoát

alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
09 biến các ký tự đặc biệt thành chữ

Chỉ có một ngoại lệ cho quy tắc này

alert( "function g()".match(/g\(\)/) ); // "g()"
0

alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
09 theo sau bởi một dòng mới không phải là một chuỗi thoát ký tự, mà là một
alert( "function g()".match(/g\(\)/) ); // "g()"
171. Đây chỉ đơn giản là một cách để trải một chuỗi trên nhiều dòng (ví dụ: để chỉnh sửa mã dễ dàng hơn), mà không có chuỗi thực sự bao gồm bất kỳ ký tự dòng mới nào. Tôi cho rằng bạn có thể nghĩ về
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
09 theo sau bởi một dòng mới như một chuỗi thoát cho chuỗi rỗng

Các ký tự không có ý nghĩa đặc biệt cũng có thể được thoát (e. g.

alert( "function g()".match(/g\(\)/) ); // "g()"
173), nhưng điều này tất nhiên là không cần thiết. Tuy nhiên, việc sử dụng
alert( "function g()".match(/g\(\)/) ); // "g()"
174 bên ngoài a hoặc
alert( "function g()".match(/g\(\)/) ); // "g()"
175 bên ngoài a is và khiến một số công cụ đưa ra lỗi cú pháp

Ghi chú. IE < 9 coi

alert( "function g()".match(/g\(\)/) ); // "g()"
176 là
alert( "function g()".match(/g\(\)/) ); // "g()"
177 thay vì tab dọc (
alert( "function g()".match(/g\(\)/) ); // "g()"
178). Nếu lo ngại về khả năng tương thích giữa nhiều trình duyệt, hãy sử dụng
alert( "function g()".match(/g\(\)/) ); // "g()"
179 thay vì
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
03

Một điều khác cần lưu ý là các lần thoát

alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
03 và
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
04 không được phép trong các chuỗi JSON

Trình tự thoát bát phân

Bất kỳ ký tự nào có mã ký tự thấp hơn

alert( "function g()".match(/g\(\)/) ); // "g()"
183 (i. e. bất kỳ ký tự nào trong phạm vi ASCII mở rộng) có thể được thoát bằng cách sử dụng mã ký tự được mã hóa theo hệ bát phân của nó, có tiền tố là
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
09. (Lưu ý rằng đây là cùng một phạm vi ký tự có thể thoát qua. )

Để sử dụng ví dụ tương tự, ký hiệu bản quyền (

alert( "function g()".match(/g\(\)/) ); // "g()"
185) có mã ký tự
alert( "function g()".match(/g\(\)/) ); // "g()"
18, cung cấp cho
alert( "function g()".match(/g\(\)/) ); // "g()"
187 trong ký hiệu bát phân, vì vậy bạn có thể viết nó là
alert( "function g()".match(/g\(\)/) ); // "g()"
188

Thoát bát phân có thể bao gồm hai, ba trong số bốn ký tự.

alert( "function g()".match(/g\(\)/) ); // "g()"
189,
alert( "function g()".match(/g\(\)/) ); // "g()"
190 và
alert( "function g()".match(/g\(\)/) ); // "g()"
191 là tương đương; . Tuy nhiên, nếu thoát bát phân (e. g.
alert( "function g()".match(/g\(\)/) ); // "g()"
189) là một phần của chuỗi lớn hơn và ngay sau nó là một ký tự trong phạm vi
alert( "function g()".match(/g\(\)/) ); // "g()"
193 (e. g.
alert( "function g()".match(/g\(\)/) ); // "g()"
194), ký tự tiếp theo sẽ được coi là một phần của chuỗi thoát cho đến khi có tối đa ba chữ số được khớp. Nói cách khác,
alert( "function g()".match(/g\(\)/) ); // "g()"
195 (thoát một ký tự bát phân đơn tương đương với
alert( "function g()".match(/g\(\)/) ); // "g()"
196) không giống với
alert( "function g()".match(/g\(\)/) ); // "g()"
197 (thoát bát phân
alert( "function g()".match(/g\(\)/) ); // "g()"
191 theo sau là ký tự không thoát
alert( "function g()".match(/g\(\)/) ); // "g()"
199). Bằng cách đơn giản là thoát số bát phân đệm bằng không, bạn có thể tránh được sự cố này

Lưu ý rằng có một ngoại lệ ở đây. bản thân nó,

alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
04 không phải là một chuỗi thoát bát phân. Nó trông giống như một, và nó thậm chí còn bằng với
alert( "function g()".match(/g\(\)/) ); // "g()"
201 và
alert( "function g()".match(/g\(\)/) ); // "g()"
202, cả hai đều là chuỗi thoát hệ bát phân — nhưng trừ khi nó được theo sau bởi một chữ số thập phân, nó hoạt động giống như một. Hoặc,.
alert( "function g()".match(/g\(\)/) ); // "g()"
203. Có lẽ dễ nhất để xác định cú pháp thoát bát phân bằng biểu thức chính quy sau.
alert( "function g()".match(/g\(\)/) ); // "g()"
204

Lưu ý rằng

Các phiên bản trước đây của ECMAScript đã bao gồm cú pháp và ngữ nghĩa bổ sung để chỉ định chuỗi ký tự bát phân và chuỗi thoát bát phân. Chúng đã bị xóa khỏi phiên bản ECMAScript này. Phụ lục không quy chuẩn này trình bày cú pháp và ngữ nghĩa thống nhất cho các chuỗi ký tự bát phân và chuỗi thoát bát phân để tương thích với một số chương trình ECMAScript cũ hơn

Ngoài ra,

Một triển khai phù hợp, khi xử lý mã chế độ nghiêm ngặt (xem 10. 1. 1), không thể mở rộng cú pháp của

alert( "function g()".match(/g\(\)/) ); // "g()"
205 để bao gồm cả
alert( "function g()".match(/g\(\)/) ); // "g()"
206 như được mô tả trong B. 1. 2

Chúng cũng ở dạng chữ mẫu

TL; DR Không sử dụng thoát bát phân;

Trình tự thoát thập lục phân

Bất kỳ ký tự nào có mã ký tự thấp hơn

alert( "function g()".match(/g\(\)/) ); // "g()"
183 (i. e. bất kỳ ký tự nào trong phạm vi ASCII mở rộng) có thể được thoát bằng cách sử dụng mã ký tự được mã hóa hex của nó, có tiền tố là
alert( "function g()".match(/g\(\)/) ); // "g()"
175. (Lưu ý rằng đây là cùng một phạm vi ký tự có thể thoát qua. )

Thoát thập lục phân dài bốn ký tự. Họ yêu cầu chính xác hai ký tự sau

alert( "function g()".match(/g\(\)/) ); // "g()"
175. Nếu mã ký tự thập lục phân chỉ dài một ký tự (trường hợp này áp dụng cho tất cả các mã ký tự nhỏ hơn
alert( "function g()".match(/g\(\)/) ); // "g()"
210 hoặc
alert( "function g()".match(/g\(\)/) ); // "g()"
211 ở dạng thập lục phân), bạn sẽ cần đệm nó bằng một ký tự
alert( "function g()".match(/g\(\)/) ); // "g()"
212 ở đầu

Ví dụ: ký hiệu bản quyền (______1185) có mã ký tự

alert( "function g()".match(/g\(\)/) ); // "g()"
18, mã này cung cấp cho
alert( "function g()".match(/g\(\)/) ); // "g()"
215 ở dạng hex, vì vậy bạn có thể viết nó là
alert( "function g()".match(/g\(\)/) ); // "g()"
216

Phần thập lục phân của thoát này không phân biệt chữ hoa chữ thường;

Bạn có thể xác định cú pháp thoát thập lục phân bằng biểu thức chính quy sau.

alert( "function g()".match(/g\(\)/) ); // "g()"
219

Có một chút khó hiểu khi đề cập đến loại trình tự thoát này là "thập lục phân", vì cũng sử dụng hex

Trình tự thoát Unicode

Bất kỳ ký tự nào có mã ký tự thấp hơn

alert( "function g()".match(/g\(\)/) ); // "g()"
220 đều có thể được thoát bằng giá trị thập lục phân của mã ký tự, có tiền tố là
alert( "function g()".match(/g\(\)/) ); // "g()"
174. (, mã ký tự cao hơn được biểu thị bằng một cặp ký tự thay thế. )

Thoát Unicode dài sáu ký tự. Họ yêu cầu chính xác bốn ký tự sau

alert( "function g()".match(/g\(\)/) ); // "g()"
174. Nếu mã ký tự thập lục phân chỉ dài một, hai hoặc ba ký tự, bạn sẽ cần thêm các số 0 vào đầu mã đó

Biểu tượng bản quyền (

alert( "function g()".match(/g\(\)/) ); // "g()"
185) có mã ký tự
alert( "function g()".match(/g\(\)/) ); // "g()"
18, cung cấp cho
alert( "function g()".match(/g\(\)/) ); // "g()"
215 trong ký hiệu thập lục phân, vì vậy bạn có thể viết nó là
alert( "function g()".match(/g\(\)/) ); // "g()"
226. Tương tự,
alert( "function g()".match(/g\(\)/) ); // "g()"
227 có thể được viết là
alert( "function g()".match(/g\(\)/) ); // "g()"
228

Phần thập lục phân của loại thoát ký tự này không phân biệt chữ hoa chữ thường;

Bạn có thể xác định cú pháp thoát Unicode bằng biểu thức chính quy sau.

alert( "function g()".match(/g\(\)/) ); // "g()"
231

Ghi chú. Khác với , các lối thoát Unicode là những lối thoát duy nhất được đặc tả JSON cho phép

ECMAScript 6. Thoát điểm mã Unicode

ECMAScript 6 một loại trình tự thoát mới trong chuỗi, cụ thể là thoát điểm mã Unicode. Ngoài ra, nó sẽ xác định

alert( "function g()".match(/g\(\)/) ); // "g()"
232 và
alert( "function g()".match(/g\(\)/) ); // "g()"
233, cả hai đều chấp nhận các điểm mã thay vì các đơn vị mã giống như UCS-2/UTF-16

Khi điều này được triển khai, bất kỳ ký tự nào cũng có thể được thoát bằng cách sử dụng giá trị thập lục phân của mã ký tự, có tiền tố là

alert( "function g()".match(/g\(\)/) ); // "g()"
234 và có hậu tố là
alert( "function g()".match(/g\(\)/) ); // "g()"
235. Điều này được phép cho các điểm mã lên tới
alert( "function g()".match(/g\(\)/) ); // "g()"
236, đây là điểm mã cao nhất được xác định bởi Unicode

Thoát điểm mã Unicode bao gồm ít nhất năm ký tự. Ít nhất một ký tự thập lục phân có thể được bao bọc trong

alert( "function g()".match(/g\(\)/) ); // "g()"
237. Không có giới hạn trên đối với số chữ số hex được sử dụng (ví dụ:
alert( "function g()".match(/g\(\)/) ); // "g()"
238) nhưng đối với các mục đích thực tế, bạn sẽ không cần nhiều hơn 6, trừ khi bạn thực hiện thao tác đệm số 0 không cần thiết

Tetragram cho biểu tượng trung tâm (

alert( "function g()".match(/g\(\)/) ); // "g()"
239) có điểm mã U+1D306, vì vậy bạn có thể viết nó là
alert( "function g()".match(/g\(\)/) ); // "g()"
240. Để so sánh, nếu bạn định sử dụng biểu tượng này để biểu thị, bạn phải viết riêng các nửa thay thế.
alert( "function g()".match(/g\(\)/) ); // "g()"
241

Phần thập lục phân của loại thoát ký tự này không phân biệt chữ hoa chữ thường;

Bạn có thể xác định cú pháp thoát điểm mã Unicode bằng biểu thức chính quy sau.

alert( "function g()".match(/g\(\)/) ); // "g()"
244

Kiểm soát trình tự thoát

Trong biểu thức chính quy (không phải trong chuỗi. ), bất kỳ ký tự nào có mã ký tự lớn hơn

alert( "function g()".match(/g\(\)/) ); // "g()"
212 và thấp hơn ________ 1246 đều có thể được thoát bằng cách sử dụng ký tự ký hiệu dấu mũ, có tiền tố là ________ 1247

Các lối thoát điều khiển dài ba ký tự. Họ yêu cầu chính xác một ký tự sau

alert( "function g()".match(/g\(\)/) ); // "g()"
247

Ví dụ: U+000A LINE FEED là

alert( "function g()".match(/g\(\)/) ); // "g()"
249 trong ký hiệu dấu mũ (vì
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
000 và
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
001 là chữ cái thứ 10 của bảng chữ cái). Vì vậy, một biểu thức chính quy hợp lệ phù hợp với biểu tượng này sẽ là
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
002, e. g.
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
003

Ký tự ký hiệu dấu mũ theo sau

alert( "function g()".match(/g\(\)/) ); // "g()"
247 trong loại thoát ký tự này không phân biệt chữ hoa chữ thường;

Dưới đây là danh sách tất cả các chuỗi thoát điều khiển có sẵn và các ký tự điều khiển mà chúng ánh xạ tới

Escape sequenceUnicode code point
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
007 or
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
008U+0001 START OF HEADING
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
009 or
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
010U+0002 START OF TEXT
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
011 or
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
012U+0003 END OF TEXT
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
013 or
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
014U+0004 END OF TRANSMISSION
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
015 or
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
016U+0005 ENQUIRY
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
017 or
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
018U+0006 ACKNOWLEDGE
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
019 or
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
020U+0007 BELL
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
021 or
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
022U+

Bạn có thể xác định cú pháp thoát điều khiển bằng biểu thức chính quy sau.

alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
059

Một công cụ để thoát nhân vật

Tôi đã viết một trình thoát chuỗi JavaScript kết hợp các loại thoát khác nhau này (ngoại trừ chuỗi không dùng nữa) và trả về chuỗi kết quả nhỏ nhất có thể. Hãy thử nó tại mẹeff. trong/js-thoát

Bạn có thể sử dụng nó để thoát bất kỳ ký tự nào, nhưng có một tùy chọn để chỉ thoát các ký tự ASCII không phải ASCII và không thể in được (có lẽ là hữu ích nhất). Bằng cách này, bạn có thể dễ dàng biến các chuỗi như

alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
060 thành chuỗi tương đương chỉ có mã ASCII nhỏ nhất có thể là
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
061. Quay lại khi tôi đang làm việc trên Punycode. js, công cụ này giúp tôi tiết kiệm khá nhiều thời gian

Cần thoát chuỗi trong ứng dụng JavaScript của bạn?

Về tôi

Chào bạn. Tôi là Mathias. Tôi làm việc trên Chrome DevTools và công cụ JavaScript V8 tại Google. HTML, CSS, JavaScript, Unicode, hiệu suất và bảo mật khiến tôi phấn khích. Theo dõi tôi trên Twitter, Mastodon và GitHub

Bình luận

pomeh đã viết trên.

Cảm ơn Mathias. Điều này thật tuyệt. )

Deian đã viết trên.

Bạn là một trong những nhà phát triển THỰC SỰ hữu ích nhất xung quanh. Cảm ơn bạn cho tất cả các bài viết của bạn Mathias. Chúc bạn một Giáng sinh vui vẻ & Năm mới hạnh phúc

.mario đã viết trên.

Visual Basic Script cho phép sử dụng một dạng thoát khác để biểu thị số thập phân

  • ________ 2062 hoặc ________ 2063 đại diện cho các giá trị số (Hệ thập lục phân)
  • alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
    alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
    064 hoặc
    alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
    alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
    065 đại diện cho các giá trị số (Bát phân)
  • alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
    alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
    066 hoặc
    alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
    alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
    066 đại diện cho các giá trị số (Bát phân, không bắt buộc phải có O)

Thiemo đã viết trên.

Tôi đã làm một cái gì đó rất giống với 140byte. nhập cảnh một lần. http. //maettig. com/code/javascript/encode-javascript-string-in-140byt. là. html

Không đã viết trên.

Nếu tôi cần chèn chính

alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
09 vào chuỗi thì sao?. e. không sử dụng nó làm ký tự thoát?

Cập nhật. Xin lỗi, tôi quên đề cập đến ngôn ngữ. JS, sử dụng JSON, cố gắng thêm dữ liệu vào ô Google Trang tính thông qua chức năng 'Blockspring' đã sửa đổi

Mathias đã viết trên.

.

Flimm đã viết về.

Nếu bạn không cẩn thận khi thêm phần đệm vào biểu thức chính quy, nó có thể hoạt động lạ

alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
0

Mathias đã viết trên.

Phần đệm là bắt buộc, không chỉ trong biểu thức chính quy mà ở mọi nơi.

alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
071 và
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
072 không phải là chuỗi thoát hợp lệ

Stan đã viết trên.

Cảm ơn. Tôi đang cố mã hóa

alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
073 bằng cách sử dụng
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
074 và không thể hiểu tại sao nó không hoạt động cho đến khi tôi thấy rằng mã hex chỉ hoạt động với
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
075 và tôi cần sử dụng
alert( "Chapter 5.1".match(/\d\.\d/) ); // 5.1 (match!)
alert( "Chapter 511".match(/\d\.\d/) ); // null (looking for a real dot \.)
076

Đó là những ký tự thoát?

Ví dụ .
\' trích dẫn đơn
\" trích dẫn kép
\\ dấu gạch chéo ngược
\n dòng mới
\r vận chuyển trở lại
thẻ \t
\b xóa lùi
\f nguồn cấp dữ liệu biểu mẫu

Làm cách nào để thoát khỏi các ký tự đặc biệt trong JavaScript?

Để sử dụng ký tự đặc biệt làm ký tự thông thường, hãy thêm dấu gạch chéo ngược vào trước ký tự đó. \ . . Đó cũng được gọi là "thoát khỏi một nhân vật".

Các ký tự thoát trong mã hóa là gì?

Một chuỗi thoát chứa ký hiệu dấu gạch chéo ngược (\) theo sau là một trong các ký tự chuỗi thoát hoặc một số bát phân hoặc thập lục phân . Chuỗi thoát thập lục phân chứa một x theo sau là một hoặc nhiều chữ số thập lục phân (0-9, A-F, a-f). Chuỗi thoát bát phân sử dụng tối đa ba chữ số bát phân (0-7).

Có bao nhiêu kiểu thoát hiểm?

hai dạng chính mà các phòng thoát hiểm có, đó là tuyến tính và phi tuyến tính.