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
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.{ <field>: { $regex: /pattern/, $options: '<options>' } } { <field>: { $regex: 'pattern', $options: '<options>' } } { <field>: { $regex: /pattern/<options> } }
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> } } |
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> } } |
{ <field>: { $regex: /pattern/, $options: '<options>' } } |
{ <field>: { $regex: 'pattern', $options: '<options>' } } |
{ <field>: { $regex: /pattern/<options> } } |
{ <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> } } |
{ <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> } } |
Các
{ <field>: { $regex: /pattern/, $options: '<options>' } } |
{ <field>: { $regex: 'pattern', $options: '<options>' } } |
{ <field>: { $regex: /pattern/<options> } } |
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. | |||||||||||||
| Đối với các mẫu bao gồm các neo (nghĩa là
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>: /pattern/<options> } | Khả năng "mở rộng" để bỏ qua tất cả các ký tự không gian trắng trong mẫu
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>: /pattern/<options> } | Cho phép ký tự DOT (tức là { <field>: /pattern/<options> } { <field>: /pattern/<options> } { <field>: /pattern/<options> } | Yêu cầu |
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ú
1 operator does not support the global search modifier { <field>: { $regex: /pattern/, $options: '<options>' } } { <field>: { $regex: 'pattern', $options: '<options>' } } { <field>: { $regex: /pattern/<options> } }
{ name: { $in: [ /^acme/i, /^ack/ ] } }
4.Toán tử
{ <field>: { $regex: /pattern/, $options: '<options>' } } |
{ <field>: { $regex: 'pattern', $options: '<options>' } } |
{ <field>: { $regex: /pattern/<options> } } |
{ 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> } } |
{ <field>: { $regex: /pattern/, $options: '<options>' } } |
{ <field>: { $regex: 'pattern', $options: '<options>' } } |
{ <field>: { $regex: /pattern/<options> } } |
{ 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> } } |
{ name: { $in: [ /^acme/i, /^ack/ ] } }
5.{ <field>: { $regex: /pattern/, $options: '<options>' } } |
{ <field>: { $regex: 'pattern', $options: '<options>' } } |
{ <field>: { $regex: /pattern/<options> } } |
{ 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> } } |
{ <field>: { $regex: /pattern/, $options: '<options>' } } |
{ <field>: { $regex: 'pattern', $options: '<options>' } } |
{ <field>: { $regex: /pattern/<options> } } |
{ <field>: { $regex: /pattern/, $options: '<options>' } } |
{ <field>: { $regex: 'pattern', $options: '<options>' } } |
{ <field>: { $regex: /pattern/<options> } } |
{ <field>: /pattern/<options> }
8 options, you must use{ <field>: { $regex: /pattern/, $options: '<options>' } } |
{ <field>: { $regex: 'pattern', $options: '<options>' } } |
{ <field>: { $regex: /pattern/<options> } } |
{ 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> } } |
{ <field>: { $regex: /pattern/, $options: '<options>' } } |
{ <field>: { $regex: 'pattern', $options: '<options>' } } |
{ <field>: { $regex: /pattern/<options> } } |
{ <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> } } |
{ <field>: { $regex: /pattern/, $options: '<options>' } } |
{ <field>: { $regex: 'pattern', $options: '<options>' } } |
{ <field>: { $regex: /pattern/<options> } } |
Để 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> } } |
Để phù hợp với các chuỗi không nhạy cảm trường hợp:
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' ] } }
{ name: { $regex: /acme.*corp/i, $nin: [ 'acmeblahcorp' ] } } |
{ name: { $regex: /acme.*corp/, $options: 'i', $nin: [ 'acmeblahcorp' ] } } |
{ name: { $regex: 'acme.*corp', $options: 'i', $nin: [ 'acmeblahcorp' ] } } |
Ví dụ: biểu thức thông thường
0 khớp với các chuỗi đó:{ name: { $regex: /acme.*corp/, $options: "si" } } { name: { $regex: 'acme.*corp', $options: "si" } } Bắt đầu với
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.{ name: { $regex: /acme.*corp/, $options: "si" } } { name: { $regex: 'acme.*corp', $options: "si" } }
Kết thúc với
{ 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{ name: { $regex: /acme.*corp/, $options: "si" } } { name: { $regex: 'acme.*corp', $options: "si" } }
Các chuỗi này phù hợp với biểu thức thông thường ví dụ:
1 operator to find { <field>: { $regex: /pattern/, $options: '<options>' } } { <field>: { $regex: 'pattern', $options: '<options>' } } { <field>: { $regex: /pattern/<options> } }
{ name: { $regex: /acme.*corp/, $options: "si" } } |
{ name: { $regex: 'acme.*corp', $options: "si" } } |
{ name: { $regex: /acme.*corp/, $options: "si" } } |
{ name: { $regex: 'acme.*corp', $options: "si" } } |
{ 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> } } |
{ name: { $regex: /acme.*corp/, $options: "si" } } |
{ name: { $regex: 'acme.*corp', $options: "si" } } |
{ name: { $regex: /acme.*corp/, $options: "si" } } |
{ name: { $regex: 'acme.*corp', $options: "si" } } |
Bắt đầu từ 4.0.7, toán tử
9 có thể thực hiện hoạt động logic{ name: { $regex: /acme.*corp/, $options: "si" } } { name: { $regex: 'acme.*corp', $options: "si" } } { 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à
3){ <field>: { $regex: /pattern/, $options: '<options>' } } { <field>: { $regex: 'pattern', $options: '<options>' } } { <field>: { $regex: /pattern/<options> } } db.inventory.find( { item: { $not: /^p.*/ } } )
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).{ <field>: { $regex: /pattern/, $options: '<options>' } } { <field>: { $regex: 'pattern', $options: '<options>' } } { <field>: { $regex: /pattern/<options> } } 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" } } |
{ <field>: { $regex: /pattern/, $options: '<options>' } } |
{ <field>: { $regex: 'pattern', $options: '<options>' } } |
{ <field>: { $regex: /pattern/<options> } } |
{ <field>: { $regex: /pattern/, $options: '<options>' } } |
{ <field>: { $regex: 'pattern', $options: '<options>' } } |
{ <field>: { $regex: /pattern/<options> } } |
{ <field>: { $regex: /pattern/, $options: '<options>' } } |
{ <field>: { $regex: 'pattern', $options: '<options>' } } |
{ <field>: { $regex: /pattern/<options> } } |
Đố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> } } |
{ 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> } } |
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() 1Ví 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() 2Ví 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() 3Ví 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() 4Ví 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() 5Ví 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() 6Ví 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() 7Ví 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() 6Ví 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() 9Ví dụ sau sử dụng tùy chọn
{ <field>: { $regex: /pattern/, $options: '<options>' } } |
{ <field>: { $regex: 'pattern', $options: '<options>' } } |
{ <field>: { $regex: /pattern/<options> } } |
{ <field>: { $regex: /pattern/, $options: '<options>' } } |
{ <field>: { $regex: 'pattern', $options: '<options>' } } |
{ <field>: { $regex: /pattern/<options> } } |
{ <field>: { $regex: /pattern/, $options: '<options>' } } |
{ <field>: { $regex: 'pattern', $options: '<options>' } } |
{ <field>: { $regex: /pattern/<options> } } |
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() 6Ví 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(); 2Ví dụ đầu ra:
var stream = collection.find({"FirstName": /J.*/).stream(); 3Ví 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(); 4Ví dụ sau sử dụng tùy chọn
{ <field>: { $regex: /pattern/, $options: '<options>' } } |
{ <field>: { $regex: 'pattern', $options: '<options>' } } |
{ <field>: { $regex: /pattern/<options> } } |
Ví dụ đầu ra:
var stream = collection.find({"FirstName": /J.*/).stream(); 6Ví 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
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