Truy cập nhóm theo thứ tự trong biểu thức chính quy Regexp

Chào các bạn

Trong bài viết này mình sẽ nói về cách truy cập nhóm theo thứ tự \n. Trong đó n là số lượng nhóm của chúng ta trong trận đấu. Tính từ 1 đến n

Nhóm

Nhóm theo thứ tự \n trong biểu thức chính quy regexp là một ký tự đặt biệt mà cũng bắt buộc bạn phải nhớ.

1let str = "012345 456 9012345367 3421";
2
3let reg = /012(3)4\d\1/;

Trận đấu /012(3)4\d\1/ này có ý nghĩa là. Bắt đầu bằng số 012 đến nhóm số (3) tiếp theo là số 4 tiếp theo là bất kỳ số nào từ 0 đến 9 \d tiếp theo chính là bộ nhớ của nhóm tính theo thứ tự. Ở trên là 1 nhóm thì nó là \1.

Khớp với: 0123403 đến 0123493

Chúng ta có thể viết lại trận đấu ở trên như thế này cho các bạn dể hình dung.

• /012(3)4\d\1/
• /012(3)4\d3/
• (3) = \1 = 3

Nếu giả sử nhóm chúng ta là số khác thì

• /012(369)4\d\1/
• /012(369)4\d369/
• (369) = \1 = 369

Bây giờ chúng ta cùng nhau xem kết quả của trận đấu ví dụ đầu tiên nhé.

• Trận đấu /012(3)4\d\1/

1let str = "012345 456 9012345367 3421";
2
3let reg = /012(3)4\d\1/;
4
5let ketQua = reg.exec(str);
6
7console.log(ketQua); // ['0123453', '3', index: 12, input: '012345 456 9012345367 3421', groups: undefined]
8
9// Dấu <=> mình gọi là tương đương
10
11// ketQua[0] = '0123453' <=> /012(3)4\d\1/
12// ketQua[1] = '3'       <=> (3) <=> \1

Ở ví dụ trên vì không có cờ g nên chức năng exec() sẽ chạy khắp chuỗi. Nếu gặp kết quả đầu tiên trùng với trận đấu thì kết quả sẻ trả về. Và chức năng sẻ dừng lại. Còn không thì chạy hết chuỗi rồi trả về null.

Bây giờ chúng ta thêm một nhóm khác vào nữa nhé. Để cho bạn dể hình dung. Và mình cũng có thay đổi chuỗi nguồn tí. Vì bây giờ mình nhóm thêm số (2) nữa.

• Trận đấu /01(2)(3)4\d\1\2/

1let str = "012345 456 901234523167 3421 0123452316789";
2
3let reg = /01(2)(3)4\d\1\2/;
4
5let ketQua = reg.exec(str);
6
7console.log(ketQua); // ['01234523', '2', '3', index: 12, input: '012345 456 901234523167 3421 0123452316789', groups: undefined]
8
9// Dấu <=> mình gọi là tương đương
10
11// ketQua[0] = '01234523' <=> /01(2)(3)4\d\1\2/
12// ketQua[1] = '2'        <=> (2) <=> \1
13// ketQua[2] = '3'        <=> (3) <=> \2

Ở ví dụ trên chúng ta có 2 nhóm (2) và (3) nó có bộ nhớ là \1 và \2 tương ứng với vị trí nhóm chúng ta từ trái sang phải. Mình có mô tả trong dòng comment trên ví dụ rồi.

Chúng ta nên bắt đầu tiếp. Bây giờ mình sẽ nhóm thêm số (1) nữa. Và đồng thời mình có sửa chuỗi nguồn lại tí. Bây giờ trận đấu của chúng ta là.

• Trận đấu /0(1)(2)(3)4\d\1\2\3/

1let str = "012345 456 9012345123167 3421 01234512316789";
2
3let reg = /0(1)(2)(3)4\d\1\2\3/;
4
5let ketQua = reg.exec(str);
6
7console.log(ketQua); // ['012345123', '1', '2', '3', index: 12, input: '012345 456 9012345123167 3421 01234512316789', groups: undefined]
8
9// Dấu <=> mình gọi là tương đương
10
11// ketQua[0] = '012345123' <=> /0(1)(2)(3)4\d\1\2\3/
12// ketQua[1] = '1' <=> (1) <=> \1
13// ketQua[2] = '2' <=> (2) <=> \2
14// ketQua[3] = '3' <=> (3) <=> \3

Như các bạn có thể thấy. Trận đấu của chúng ta bây giờ càng ngày càng phức tạp đúng không. Không chỉ như vậy. Đó chỉ là mình ví dụ thôi. Chứ ngoài đời thì phải tùy tình huống mà chúng ta áp dụng.

Bây giờ chúng ta cùng thay đổi chuỗi nguồn và nhóm nó lại tiếp. Để xem cách mà bộ nhớ \n này hoạt động nhé.

• Trận đấu /0((1)(2)(3)4)\d\1\2\3\4/

1let str = "012345 456 90123451234123167 3421 01234512316789";
2
3let reg = /0((1)(2)(3)4)\d\1\2\3\4/;
4
5let ketQua = reg.exec(str);
6
7console.log(ketQua); // ['0123451234123', '1234', '1', '2', '3', index: 12, input: '012345 456 90123451234123167 3421 01234512316789', groups: undefined]
8
9// Dấu <=> mình gọi là tương đương
10
11// ketQua[0] = '0123451234123' <=> /0((1)(2)(3)4)\d\1\2\3\4/
12// ketQua[1] = '1234' <=> ((1)(2)(3)4) <=> \1
13// ketQua[2] = '1'    <=> (1)          <=> \2
14// ketQua[3] = '2'    <=> (2)          <=> \3
15// ketQua[4] = '3'    <=> (3)          <=> \4

Nếu bây giờ chúng ta nhóm tiếp thì các bạn cùng nhau xem điều gì xảy ra nhé. Chúng ta cũng phải thay đổi chuỗi nguồn lại tí. Cho nó phù hợp với nhóm chúng ta.

• Trận đấu /0((1)((2)(3))4)\d\1\2\3\4\5/

1let str = "012345 456 9012345123412323167 3421 01234512316789";
2
3let reg = /0((1)((2)(3))4)\d\1\2\3\4\5/;
4
5let ketQua = reg.exec(str);
6
7console.log(ketQua); // ['012345123412323', '1234', '1', '23', '2', '3', index: 12, input: '012345 456 9012345123412323167 3421 01234512316789', groups: undefined]
8
9// Dấu <=> mình gọi là tương đương
10
11// ketQua[0] = '012345123412323' <=> /0((1)((2)(3))4)\d\1\2\3\4\5/
12// ketQua[1] = '1234' <=> ((1)((2)(3))4) <=> \1
13// ketQua[2] = '1'    <=> (1)            <=> \2
14// ketQua[3] = '23'   <=> ((2)(3))       <=> \3
15// ketQua[4] = '2'    <=> (2)            <=> \4
16// ketQua[5] = '3'    <=> (3)            <=> \5

Như các bạn có thể thấy. Bây giờ trận đấu của chúng ta thật sự phức tạp đúng không. Nhưng đó chưa là gì cả đâu. Chỉ cần thêm vài thứ nữa là các bạn ngồi ngẫm mệt nghĩ luôn.

Bây giờ mình sẽ hướng dẫn cách các bạn đọc nó nhé. Mỗi trận đấu thì sẽ có một cách đọc khác nhau. Nhưng hiểu về ý nghĩa của nó thì các bạn sẽ đọc được thôi.

Trước khi đọc ý nghĩa. Mình nói cách các bạn xác định thứ tự của nhóm. Khi các bạn nhìn thấy dấu ( là bắt đầu đếm nó từ 1. Nhưng nếu bạn thấy \( thì bây giờ nó không phải nhóm nữa. Mà là dấu ngoặc đơn ( bình thường.

Trận đấu này /0((1)((2)(3))4)\d\1\2\3\4\5/ có ý nghĩa là. Bắt đầu bằng 01234 tiếp theo là số từ 0 đến 9 \d tiếp theo là bộ nhớ của nhóm thứ nhất \1 tương đương 1234 tiếp theo bộ nhớ nhóm thứ \2 tương đương 1 tiếp theo bộ nhớ nhóm thứ \3 tương đương 23 tiếp theo bộ nhớ nhóm thứ \4 tương đương 2 tiếp theo bộ nhớ nhom thứ \5 tương đương 3.

Phù hợp với: 012340123412323 đến 012349123412323

Tổng kết

Trong bài viết này mình đã hướng dẫn các bạn cách truy cập vào bộ nhớ của nhóm () bằng \n rồi đó.

Trong bài viết tiếp theo mình sẽ nói tiếp về cách truy cập bộ nhớ của nhóm bằng cách đặt tên.