Làm cách nào để kiểm tra xem một chuỗi có phải là chuỗi con của một chuỗi khác trong javascript không?

Một hoạt động phổ biến trong nhiều ngôn ngữ lập trình là kiểm tra xem một chuỗi có chứa chuỗi khác không. Mặc dù đây là một nhiệm vụ đơn giản và phổ biến nhưng tên phương thức thường khác nhau giữa các ngôn ngữ lập trình. Ví dụ: đây là một ví dụ nhỏ về các phương pháp được sử dụng để đạt được điều này bằng nhiều ngôn ngữ khác nhau

• Java.

  > let str = 'StackAbuse';
  > let substr = 'stack';
  > str.includes[substr];
  false
  

  3,

  > let str = 'StackAbuse';
  > let substr = 'stack';
  > str.includes[substr];
  false
  

  0, v.v.
• con trăn. Toán tử

  > let str = 'StackAbuse';
  > let substr = 'stack';
  > str.includes[substr];
  false
  

  1,

  > let str = 'StackAbuse';
  > let substr = 'stack';
  > str.includes[substr];
  false
  

  2,

  > let str = 'StackAbuse';
  > let substr = 'stack';
  > str.includes[substr];
  false
  

  3
• Đi.

  > let str = 'StackAbuse';
  > let substr = 'stack';
  > str.includes[substr];
  false
  

  4
• hồng ngọc.

  > let str = 'StackAbuse';
  > let substr = 'stack';
  > str.includes[substr];
  false
  

  5

Bạn sẽ có được điểm. Có một triệu cách để làm điều này và có vẻ như mỗi ngôn ngữ thực hiện nó một cách khác nhau

Dù sao đi nữa, hãy xem một số cách mà bạn có thể kiểm tra xem chuỗi có chứa chuỗi con hay không trong JavaScript

Ghi chú. Hai phương thức đầu tiên hiển thị bên dưới cũng hoạt động trên mảng, cho bạn biết nếu một mảng chứa một giá trị nhất định [hoặc chỉ mục của nó cho

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

6]. Hãy ghi nhớ điều này khi đọc bài viết vì nó có thể sẽ giúp ích cho bạn trong các trường hợp sử dụng tương tự

Phương pháp

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

7

Phương pháp này đã được giới thiệu trong ES6 và thường là phương pháp ưa thích cho các trường hợp sử dụng đơn giản. Nếu tất cả những gì bạn cần làm là lấy một giá trị boolean cho biết chuỗi con có nằm trong một chuỗi khác hay không, thì đây là thứ bạn sẽ muốn sử dụng

Nó hoạt động như thế này

________số 8

Như bạn có thể thấy, giá trị boolean được trả về do chuỗi "stack" là chuỗi con của "stackabuse"

Đây là một tìm kiếm phân biệt chữ hoa chữ thường, vì vậy phần sau sẽ không khớp với chuỗi con

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

Mặc dù điều này là đủ cho hầu hết các trường hợp sử dụng, nhưng phương pháp

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

8 cũng cung cấp một tùy chọn khác có thể hữu ích cho bạn. Một đối số thứ hai có thể được cung cấp cho biết phương thức bắt đầu tìm kiếm tại chỉ mục nào. Vì vậy, nếu bạn biết rằng chuỗi con không có trong 50 ký tự đầu tiên [hoặc bạn không muốn nó khớp với các ký tự đó], thì bạn có thể sử dụng phương pháp như sau

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

1

Độ lệch dưới 0 chỉ bắt đầu tìm kiếm từ chỉ mục 0 và độ lệch lớn hơn

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

9 trả về

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

10 vì tìm kiếm bắt đầu từ

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

9

Phương pháp

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

0

Phương thức

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

0 rất giống với phương thức trước đó của

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

8 [và nó cũng phù hợp để sử dụng trong một polyfill cho

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

8], nhưng điểm khác biệt duy nhất là giá trị trả về. Thay vì trả về một giá trị boolean cho biết sự hiện diện của chuỗi con, nó thực sự trả về vị trí chỉ mục của chuỗi con hoặc -1 nếu nó không xuất hiện

Đây là một ví dụ

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

9

Như bạn có thể thấy, phương thức này trả về vị trí chỉ mục dựa trên 0 của chuỗi con và -1 khi không tìm thấy chuỗi con

Cũng giống như phương thức

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

8, phương thức

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

6 phân biệt chữ hoa chữ thường và cũng hỗ trợ tham số offset

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

2

Phương pháp này hữu ích khi bạn cần biết chính xác vị trí của chuỗi con, tuy nhiên, nó không rõ ràng khi chỉ sử dụng nó dưới dạng boolean

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

3

Trong những trường hợp như thế này, bạn nên sử dụng phương thức

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

8 vì nó dễ bị lỗi hơn

biểu thức chính quy

Một trong những cách hữu ích và mạnh mẽ hơn để kiểm tra chuỗi con là sử dụng biểu thức chính quy hoặc biểu thức chính quy. Sử dụng regex cho một tác vụ như thế này mang lại cho bạn sự linh hoạt hơn rất nhiều so với các phương pháp trước đó, nơi bạn chỉ có thể kiểm tra một chuỗi không đổi. Mặc dù regex là một chủ đề quá lớn để trình bày hoàn toàn ở đây, nhưng ít nhất chúng ta có thể xem qua một số tính năng hữu ích cho trường hợp sử dụng của mình

Có thể kiểm tra các chuỗi con trong một chuỗi bằng biểu thức chính quy bằng cách sử dụng phương pháp

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

19

Hãy xem hướng dẫn thực hành, thực tế của chúng tôi để học Git, với các phương pháp hay nhất, tiêu chuẩn được ngành chấp nhận và bao gồm bảng gian lận. Dừng các lệnh Git trên Google và thực sự tìm hiểu nó

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

6

Không giống như hai phương pháp trước, giờ đây chúng ta có thể thực hiện tìm kiếm không phân biệt chữ hoa chữ thường với cờ

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

90

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

8

Ví dụ phức tạp hơn, giả sử bạn muốn xem liệu một chuỗi có chứa mã zip [mã bưu chính gồm 5 chữ số] hay không, nhưng bạn không thực sự quan tâm mã zip trong chuỗi là gì. Loại vấn đề này không thể được giải quyết bằng cách sử dụng

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

8 hoặc

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

6. Nhưng với regex, chúng ta có thể dễ dàng kiểm tra điều này

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

1

Mặc dù JavaScript không nhất thiết phải được biết đến với tốc độ của nó, nhưng hãy nhớ rằng điều này sẽ chậm hơn một phương pháp đơn giản hơn như

> let str = 'StackAbuse';
> let substr = 'stack';
> str.includes[substr];
false

8, vì vậy bạn chỉ nên sử dụng nó cho các trường hợp phức tạp hơn mà không thể giải quyết bằng một giải pháp đơn giản hơn

Phần kết luận

Thao tác và kiểm tra chuỗi là một trong những tác vụ phổ biến nhất được thực hiện trong nhiều ngôn ngữ lập trình, đặc biệt là với mã hướng tới người dùng. Vì nhiều lý do khác nhau, chẳng hạn như xác thực chuỗi, bạn sẽ cần kiểm tra xem chuỗi có chứa chuỗi con không. Trong bài viết này, chúng ta đã thấy một số phương thức khác nhau do JavaScript cung cấp cho phép bạn thực hiện chính xác điều đó

Làm cách nào để so sánh hai chuỗi trong JavaScript?

Làm cách nào để so sánh hai chuỗi trong điều kiện if trong JavaScript?