Hướng dẫn nodejs mongodb regex - nodejs mongodb regex

Question

Tôi muốn thực hiện truy vấn MongoDB cho các tài liệu dựa trên biểu thức regex mà tôi đã phản đối. Ví dụ, tôi đã xây dựng một regex đơn giản như sau đó là sự kết hợp của một chữ cái ngẫu nhiên và một số ngẫu nhiên cho trong nodejs

var randnum = Math.floor((Math.random() * 10) + 1);
var alpha = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','X','Y','Z'];
var randletter = alpha[Math.floor(Math.random() * alpha.length)];
var val = randletter + randnum + '.*;

Tôi đã thử các kết hợp khác nhau cho biến regex như

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

Không có o nó dường như hoạt động. Tuy nhiên, khi tôi viết Regex thực tế, tôi nhận được các hồ sơ cho ví dụ:

var stream = collection.find({"FirstName": /J.*/).stream();

Bất kỳ trợ giúp sẽ được đánh giá cao.

Cảm ơn Ganesh

Tài liệu về nhà → Hướng dẫn sử dụng MongoDB → MongoDB Manual

Đối với dữ liệu được lưu trữ trên Atlas MongoDB, MongoDB cung cấp giải pháp tìm kiếm toàn văn bản, MongoDB Atlas Search. Nếu bạn thường xuyên chạy các truy vấn regex không nhạy cảm trường hợp (sử dụng tùy chọn

var stream = collection.find({"FirstName": /J.*/).stream();

9), MongoDB khuyên bạn nên truy vấn tìm kiếm ATLAS sử dụng giai đoạn đường ống tổng hợp
{ <field>: { $regex: /pattern/, $options: '<options>' } } { <field>: { $regex: 'pattern', $options: '<options>' } } { <field>: { $regex: /pattern/<options> } }
0., MongoDB offers a full-text search solution, MongoDB Atlas Search. If you frequently run case-insensitive regex queries (utilizing the

var stream = collection.find({"FirstName": /J.*/).stream();

9 option), MongoDB recommends Atlas Search queries that use the

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

0 aggregation pipeline stage.

Các truy vấn tìm kiếm ATLAS có ý nghĩa cải thiện hiệu suất của các truy vấn văn bản và cung cấp nhiều tùy chọn hơn để tùy chỉnh các tham số truy vấn. Để tìm hiểu thêm, hãy xem MongoDB Atlas tìm kiếm. significiantly improve the performance of text queries and offer more options for customizing query parameters. To learn more, see MongoDB Atlas Search.

Để triển khai tự quản lý, bạn có thể tìm thấy thông tin về khả năng Regex của chúng tôi dưới đây., you can find information on our regex capability below.

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1

Cung cấp khả năng biểu thức thường xuyên cho các chuỗi khớp mẫu trong các truy vấn. MongoDB sử dụng các biểu thức thông thường tương thích Perl (tức là "PCRE") phiên bản 8.42 với hỗ trợ UTF-8.

Để sử dụng

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1, hãy sử dụng một trong các cú pháp sau:

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1, use one of the following syntaxes:

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

Trong MongoDB, bạn cũng có thể sử dụng các đối tượng biểu thức chính quy (nghĩa là

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

3) để chỉ định các biểu thức chính quy:

{ <field>: /pattern/<options> }

Để hạn chế sử dụng cú pháp cụ thể, xem $ regex so với / mẫu / cú pháp.$regex vs. /pattern/ Syntax.

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

4

Các

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

5 sau đây có sẵn để sử dụng với biểu thức thông thường.

Quyền mua

Sự mô tả

Hạn chế cú pháp

var stream = collection.find({"FirstName": /J.*/).stream();

9

Trường hợp vô cảm để phù hợp với các trường hợp trên và dưới. Ví dụ, xem thực hiện kết hợp biểu thức thông thường không nhạy cảm trường hợp.Perform Case-Insensitive Regular Expression Match.

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

7

Đối với các mẫu bao gồm các neo (nghĩa là

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

8 cho bắt đầu,

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

9 cho cuối), khớp ở đầu hoặc cuối của mỗi dòng cho các chuỗi có giá trị đa dòng. Không có tùy chọn này, các neo này khớp với đầu hoặc cuối chuỗi. Ví dụ, xem khớp đa dòng cho các dòng bắt đầu với mẫu được chỉ định.Multiline Match for Lines Starting with Specified Pattern.

Nếu mẫu không chứa neo hoặc nếu giá trị chuỗi không có ký tự dòng mới (ví dụ:

{ <field>: /pattern/<options> }

0), tùy chọn

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

7 không có hiệu lực.

{ <field>: /pattern/<options> }

2

Khả năng "mở rộng" để bỏ qua tất cả các ký tự không gian trắng trong mẫu

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1 trừ khi thoát hoặc được đưa vào một lớp ký tự.

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1 pattern unless escaped or included in a character class.

Ngoài ra, nó bỏ qua các ký tự ở giữa và bao gồm ký tự băm/pound không được giới thiệu (

{ <field>: /pattern/<options> }

4) và dòng mới tiếp theo, để bạn có thể bao gồm các bình luận trong các mẫu phức tạp. Điều này chỉ áp dụng cho các ký tự dữ liệu; Các ký tự không gian trắng có thể không bao giờ xuất hiện trong các chuỗi ký tự đặc biệt trong một mẫu.

Tùy chọn

{ <field>: /pattern/<options> }

2 không ảnh hưởng đến việc xử lý ký tự VT (tức là mã 11).

Yêu cầu

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1 với cú pháp

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

4

{ <field>: /pattern/<options> }

8

Cho phép ký tự DOT (tức là

{ <field>: /pattern/<options> }

9) phù hợp với tất cả các ký tự bao gồm các ký tự mới. Ví dụ, xem Sử dụng ký tự DOT

{ <field>: /pattern/<options> }

9 để phù hợp với dòng mới.Use the

{ <field>: /pattern/<options> }

9 Dot Character to Match New Line.

Yêu cầu

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1 với cú pháp

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

4

Cho phép ký tự DOT (tức là

{ <field>: /pattern/<options> }

9) phù hợp với tất cả các ký tự bao gồm các ký tự mới. Ví dụ, xem Sử dụng ký tự DOT

{ <field>: /pattern/<options> }

9 để phù hợp với dòng mới.

Ghi chú

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1 operator does not support the global search modifier

{ name: { $in: [ /^acme/i, /^ack/ ] } }

4.

Toán tử

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1 không hỗ trợ công cụ sửa đổi tìm kiếm toàn cầu

{ name: { $in: [ /^acme/i, /^ack/ ] } }

4.

{ name: { $in: [ /^acme/i, /^ack/ ] } }

Để bao gồm một biểu thức chính quy trong biểu thức truy vấn

{ name: { $in: [ /^acme/i, /^ack/ ] } }

5, bạn chỉ có thể sử dụng các đối tượng biểu thức chính quy JavaScript (tức là

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

3). Ví dụ:

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1 operator expressions inside an

{ name: { $in: [ /^acme/i, /^ack/ ] } }

5.

Bạn không thể sử dụng các biểu thức toán tử

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1 bên trong

{ name: { $in: [ /^acme/i, /^ack/ ] } }

5.

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1 operator. For example:

{ name: { $regex: /acme.*corp/i, $nin: [ 'acmeblahcorp' ] } }
{ name: { $regex: /acme.*corp/, $options: 'i', $nin: [ 'acmeblahcorp' ] } }
{ name: { $regex: 'acme.*corp', $options: 'i', $nin: [ 'acmeblahcorp' ] } }

Để bao gồm một biểu thức chính quy trong danh sách các điều kiện truy vấn được phân tách bằng dấu phẩy cho trường, hãy sử dụng toán tử

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1. Ví dụ:

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1 operator expression with the

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

4 operator. For example, to specify the

var stream = collection.find({"FirstName": /J.*/).stream();

9 and the

{ <field>: /pattern/<options> }

8 options, you must use

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

4 for both:

{ name: { $regex: /acme.*corp/, $options: "si" } }
{ name: { $regex: 'acme.*corp', $options: "si" } }

Để sử dụng tùy chọn

{ <field>: /pattern/<options> }

2 hoặc các tùy chọn

{ <field>: /pattern/<options> }

8, bạn phải sử dụng biểu thức toán tử

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1 với toán tử

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

4. Ví dụ: để chỉ định các tùy chọn

var stream = collection.find({"FirstName": /J.*/).stream();

9 và

{ <field>: /pattern/<options> }

8, bạn phải sử dụng

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

4 cho cả hai:

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1 operator and specify the regular expression as a string.

Để sử dụng các tính năng được hỗ trợ của PCRE trong một biểu thức thông thường không được hỗ trợ trong JavaScript, bạn phải sử dụng toán tử

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1 và chỉ định biểu thức thông thường dưới dạng chuỗi.

Để phù hợp với các chuỗi không nhạy cảm trường hợp:

{ name: { $regex: /acme.*corp/i, $nin: [ 'acmeblahcorp' ] } }
{ name: { $regex: /acme.*corp/, $options: 'i', $nin: [ 'acmeblahcorp' ] } }
{ name: { $regex: 'acme.*corp', $options: 'i', $nin: [ 'acmeblahcorp' ] } }

8 bắt đầu một trận đấu không phân biệt trường hợp.

{ name: { $regex: /acme.*corp/i, $nin: [ 'acmeblahcorp' ] } }
{ name: { $regex: /acme.*corp/, $options: 'i', $nin: [ 'acmeblahcorp' ] } }
{ name: { $regex: 'acme.*corp', $options: 'i', $nin: [ 'acmeblahcorp' ] } }

9 kết thúc một trận đấu không phân biệt trường hợp.

Ví dụ: biểu thức thông thường

{ name: { $regex: /acme.*corp/, $options: "si" } }
{ name: { $regex: 'acme.*corp', $options: "si" } }

0 khớp với các chuỗi đó:

Bắt đầu với

{ name: { $regex: /acme.*corp/, $options: "si" } }
{ name: { $regex: 'acme.*corp', $options: "si" } }

1 hoặc

{ name: { $regex: /acme.*corp/, $options: "si" } }
{ name: { $regex: 'acme.*corp', $options: "si" } }

2. Đây là một trận đấu không nhạy cảm trường hợp.

Kết thúc với

{ name: { $regex: /acme.*corp/, $options: "si" } }
{ name: { $regex: 'acme.*corp', $options: "si" } }

3. Đây là một trận đấu nhạy cảm trường hợp.

{ name: { $regex: /acme.*corp/, $options: "si" } }
{ name: { $regex: 'acme.*corp', $options: "si" } }

4

{ name: { $regex: /acme.*corp/, $options: "si" } }
{ name: { $regex: 'acme.*corp', $options: "si" } }

5

Các chuỗi này phù hợp với biểu thức thông thường ví dụ:

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1 operator to find

{ name: { $regex: /acme.*corp/, $options: "si" } }
{ name: { $regex: 'acme.*corp', $options: "si" } }

7 field strings that match the regular expression

{ name: { $regex: /acme.*corp/, $options: "si" } }
{ name: { $regex: 'acme.*corp', $options: "si" } }

0:

{ name: { $regex: "(?i)a(?-i)cme" } }

Ví dụ sau sử dụng toán tử

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1 để tìm chuỗi trường

{ name: { $regex: /acme.*corp/, $options: "si" } }
{ name: { $regex: 'acme.*corp', $options: "si" } }

7 phù hợp với biểu thức thông thường

{ name: { $regex: /acme.*corp/, $options: "si" } }
{ name: { $regex: 'acme.*corp', $options: "si" } }

0:

Bắt đầu từ 4.0.7, toán tử

{ name: { $regex: /acme.*corp/, $options: "si" } }
{ name: { $regex: 'acme.*corp', $options: "si" } }

9 có thể thực hiện hoạt động logic

{ name: { $regex: "(?i)a(?-i)cme" } }

0 trên cả hai:

Các đối tượng biểu thức chính quy (tức là

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

3)

db.inventory.find( { item: { $not: /^p.*/ } } )

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1 Biểu thức toán tử (bắt đầu bằng MongoDB 4.0.7). operator expressions (starting in MongoDB 4.0.7).

Ví dụ:

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

0

Trong 4.0.6 và sớm hơn, bạn có thể sử dụng toán tử

{ name: { $regex: /acme.*corp/, $options: "si" } }
{ name: { $regex: 'acme.*corp', $options: "si" } }

9 với các đối tượng biểu thức thông thường (nghĩa là

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

3) nhưng không phải với các biểu thức toán tử

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1.

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1 operator expressions.

Đối với các truy vấn biểu thức chính quy nhạy cảm của trường hợp, nếu một chỉ mục tồn tại cho trường, thì MongoDB khớp với biểu thức chính quy với các giá trị trong chỉ mục, có thể nhanh hơn so với quét thu thập.

Tối ưu hóa hơn nữa có thể xảy ra nếu biểu thức chính quy là "biểu thức tiền tố", điều đó có nghĩa là tất cả các khớp tiềm năng bắt đầu với cùng một chuỗi. Điều này cho phép MongoDB xây dựng một "phạm vi" từ tiền tố đó và chỉ khớp với các giá trị đó từ chỉ số nằm trong phạm vi đó.

Biểu thức chính quy là "biểu thức tiền tố" nếu nó bắt đầu bằng một cái thân xe (

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

8) hoặc neo bên trái (

{ name: { $regex: "(?i)a(?-i)cme" } }

7), theo sau là một chuỗi các ký hiệu đơn giản. Ví dụ, Regex

{ name: { $regex: "(?i)a(?-i)cme" } }

8 sẽ được tối ưu hóa bằng cách chỉ khớp với các giá trị từ chỉ mục bắt đầu với

{ name: { $regex: "(?i)a(?-i)cme" } }

9.

Ngoài ra, trong khi

db.inventory.find( { item: { $not: /^p.*/ } } )

0,

db.inventory.find( { item: { $not: /^p.*/ } } )

1 và

db.inventory.find( { item: { $not: /^p.*/ } } )

2 khớp các chuỗi tương đương, chúng có các đặc điểm hiệu suất khác nhau. Tất cả các biểu thức này sử dụng một chỉ mục nếu một chỉ mục thích hợp tồn tại; Tuy nhiên,

db.inventory.find( { item: { $not: /^p.*/ } } )

1 và

db.inventory.find( { item: { $not: /^p.*/ } } )

2 chậm hơn.

db.inventory.find( { item: { $not: /^p.*/ } } )

0 có thể ngừng quét sau khi khớp tiền tố.

Trường hợp các truy vấn biểu thức chính quy không nhạy cảm thường không thể sử dụng các chỉ mục một cách hiệu quả. Việc triển khai

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1 không nhận thức được đối chiếu và không thể sử dụng các chỉ số không nhạy cảm trường hợp.

Các ví dụ trong phần này sử dụng bộ sưu tập

db.inventory.find( { item: { $not: /^p.*/ } } )

7 sau:

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

1

Ví dụ sau phù hợp với tất cả các tài liệu trong đó trường

db.inventory.find( { item: { $not: /^p.*/ } } )

8 giống như

db.inventory.find( { item: { $not: /^p.*/ } } )

9:

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

2

Ví dụ tương tự như câu lệnh SQL giống như sau:

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

3

Ví dụ đầu ra:

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

4

Ví dụ sau đây sử dụng tùy chọn

var stream = collection.find({"FirstName": /J.*/).stream();

9 thực hiện phù hợp không phân biệt trường hợp cho các tài liệu có giá trị

db.inventory.find( { item: { $not: /^p.*/ } } )

8 bắt đầu bằng

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

02.

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

5

Ví dụ đầu ra:

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

6

Ví dụ sau đây sử dụng tùy chọn

var stream = collection.find({"FirstName": /J.*/).stream();

9 thực hiện phù hợp không phân biệt trường hợp cho các tài liệu có giá trị

db.inventory.find( { item: { $not: /^p.*/ } } )

8 bắt đầu bằng

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

02.

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

7

Ví dụ đầu ra:

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

6

Ví dụ sau đây sử dụng tùy chọn

var stream = collection.find({"FirstName": /J.*/).stream();

9 thực hiện phù hợp không phân biệt trường hợp cho các tài liệu có giá trị

db.inventory.find( { item: { $not: /^p.*/ } } )

8 bắt đầu bằng

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

02.

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

9

Ví dụ sau sử dụng tùy chọn

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

7 để khớp các dòng bắt đầu với chữ cái

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

04 cho các chuỗi đa dòng:

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

1 pattern does not contain an anchor, the pattern matches against the string as a whole, as in the following example:

Không có tùy chọn

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

7, đầu ra ví dụ là:

Ví dụ đầu ra:

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

6

Ví dụ sau đây sử dụng tùy chọn

var stream = collection.find({"FirstName": /J.*/).stream();

9 thực hiện phù hợp không phân biệt trường hợp cho các tài liệu có giá trị

db.inventory.find( { item: { $not: /^p.*/ } } )

8 bắt đầu bằng

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

02.

var stream = collection.find({"FirstName": /J.*/).stream();

2

Ví dụ đầu ra:

var stream = collection.find({"FirstName": /J.*/).stream();

3

Ví dụ sau đây sử dụng tùy chọn

var stream = collection.find({"FirstName": /J.*/).stream();

9 thực hiện phù hợp không phân biệt trường hợp cho các tài liệu có giá trị

db.inventory.find( { item: { $not: /^p.*/ } } )

8 bắt đầu bằng

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

02.

var stream = collection.find({"FirstName": /J.*/).stream();

4

Ví dụ sau sử dụng tùy chọn

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

7 để khớp các dòng bắt đầu với chữ cái

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

04 cho các chuỗi đa dòng:

var stream = collection.find({"FirstName": /J.*/).stream();

5

Ví dụ đầu ra:

var stream = collection.find({"FirstName": /J.*/).stream();

6

Ví dụ sau đây sử dụng tùy chọn

var stream = collection.find({"FirstName": /J.*/).stream();

9 thực hiện phù hợp không phân biệt trường hợp cho các tài liệu có giá trị

db.inventory.find( { item: { $not: /^p.*/ } } )

8 bắt đầu bằng

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

02.

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

16

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

17

var stream = collection.find({"FirstName": /J.*/).stream();

7

Ví dụ đầu ra:

var stream = collection.find({"FirstName": /val/).stream();
&&
var stream = collection.find({"FirstName": /$val/).stream();
&&
var stream = collection.find({"FirstName": {$in : [{$regex:val}]}}).stream()
&&
var stream = collection.find({"FirstName": {$in : [{$regex:$val}]}}).stream()

6

programming nodejs Fuzzy search mongodb Regex MongoDB Text MongoDB