Thí dụ:

> db.stuff.save({"foo":"bar"});

> db.stuff.find({"foo":"bar"}).count();
1
> db.stuff.find({"foo":"BAR"}).count();
0

Bạn có thể sử dụng một regex .

Trong ví dụ của bạn đó sẽ là:

db.stuff.find( { foo: /^bar$/i } );

Tuy nhiên, tôi phải nói rằng, có lẽ bạn chỉ có thể viết hoa (hoặc viết hoa) giá trị trên đường đi thay vì phát sinh thêm chi phí mỗi khi bạn tìm thấy nó. Rõ ràng điều này sẽ không hoạt động cho tên của mọi người và như vậy, nhưng có thể các trường hợp sử dụng như thẻ.

CẬP NHẬT:

Câu trả lời ban đầu đã lỗi thời. Mongodb hiện hỗ trợ tìm kiếm toàn văn nâng cao, với nhiều tính năng.

TRẢ LỜI GỐC:

Cần lưu ý rằng tìm kiếm với trường hợp không nhạy cảm của regex / i có nghĩa là mongodb không thể tìm kiếm theo chỉ mục, vì vậy các truy vấn đối với các bộ dữ liệu lớn có thể mất nhiều thời gian.

Ngay cả với các bộ dữ liệu nhỏ, nó không hiệu quả lắm. Bạn có một cú đánh cpu lớn hơn nhiều so với các lệnh truy vấn của bạn, điều này có thể trở thành vấn đề nếu bạn đang cố gắng đạt được quy mô.

Thay vào đó, bạn có thể lưu trữ một bản sao chữ hoa và tìm kiếm dựa vào đó. Chẳng hạn, tôi có một bảng Người dùng có tên người dùng là trường hợp hỗn hợp, nhưng id là bản sao của tên người dùng. Điều này đảm bảo không thể sao chép phân biệt chữ hoa chữ thường (không có cả "Foo" và "foo") và tôi có thể tìm kiếm theo id = username.toUpperCase () để tìm kiếm tên người dùng không phân biệt chữ hoa chữ thường.

Nếu trường của bạn lớn, chẳng hạn như nội dung thư, sao chép dữ liệu có thể không phải là một lựa chọn tốt. Tôi tin rằng sử dụng một bộ chỉ mục không liên quan như Apache Lucene là lựa chọn tốt nhất trong trường hợp đó.

Nếu bạn cần tạo regrec từ một biến, đây là cách tốt hơn nhiều để làm điều đó: https://stackoverflow.com/a/10728069/309514

Sau đó, bạn có thể làm một cái gì đó như:

var string = "SomeStringToFind";
var regex = new RegExp(["^", string, "$"].join(""), "i");
// Creates a regex of: /^SomeStringToFind$/i
db.stuff.find( { foo: regex } );

Điều này có lợi ích là được lập trình nhiều hơn hoặc bạn có thể tăng hiệu suất bằng cách biên dịch nó trước thời hạn nếu bạn sử dụng lại nhiều.

Hãy nhớ rằng ví dụ trước:

db.stuff.find( { foo: /bar/i } );

sẽ khiến mọi mục nhập chứa thanh khớp với truy vấn (bar1, barxyz, openbar), có thể rất nguy hiểm cho tìm kiếm tên người dùng trên chức năng xác thực ...

Bạn có thể cần làm cho nó chỉ khớp với cụm từ tìm kiếm bằng cách sử dụng cú pháp regrec thích hợp như:

db.stuff.find( { foo: /^bar$/i } );

Xem http://www.THER-expressions.info/ để biết trợ giúp cú pháp trên các biểu thức thông thường

Bắt đầu với MongoDB 3.4, cách được đề xuất để thực hiện các tìm kiếm không phân biệt chữ hoa chữ thường là sử dụng Chỉ số phân biệt chữ hoa chữ thường .

Cá nhân tôi đã gửi email cho một trong những người sáng lập để làm cho nó hoạt động, và anh ấy đã làm cho nó xảy ra! Đó là một vấn đề trên JIRA từ năm 2009 , và nhiều người đã yêu cầu tính năng này. Đây là cách nó hoạt động:

Một chỉ mục không phân biệt chữ hoa chữ thường được tạo bằng cách chỉ định đối chiếu với cường độ là 1 hoặc 2. Bạn có thể tạo một chỉ mục không phân biệt chữ hoa chữ thường như thế này:

db.cities.createIndex(
  { city: 1 },
  { 
    collation: {
      locale: 'en',
      strength: 2
    }
  }
);

Bạn cũng có thể chỉ định đối chiếu mặc định cho mỗi bộ sưu tập khi bạn tạo chúng:

db.createCollection('cities', { collation: { locale: 'en', strength: 2 } } );

Trong cả hai trường hợp, để sử dụng chỉ mục không phân biệt chữ hoa chữ thường, bạn cần chỉ định cùng một đối chiếu trong findthao tác được sử dụng khi tạo chỉ mục hoặc tập hợp:

db.cities.find(
  { city: 'new york' }
).collation(
  { locale: 'en', strength: 2 }
);

Điều này sẽ trả về "New York", "new york", "New york", v.v.

Ghi chú khác

• Các câu trả lời gợi ý sử dụng tìm kiếm toàn văn là sai trong trường hợp này (và có khả năng nguy hiểm ). Câu hỏi là về việc thực hiện một truy vấn không phân biệt chữ hoa chữ thường, ví dụ: username: 'bill'khớp BILLhoặc Billkhông phải là truy vấn tìm kiếm toàn văn bản, cũng sẽ khớp với các từ có nguồn gốcbill , chẳng hạn như Bills, billedv.v.

• Các câu trả lời gợi ý sử dụng biểu thức chính quy là chậm, bởi vì ngay cả với các chỉ mục, tài liệu nêu rõ :

  "Các truy vấn biểu thức chính quy không phân biệt chữ thường 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 $ regex không nhận biết đối chiếu và không thể sử dụng các chỉ mục không phân biệt chữ hoa chữ thường."

  $regexcâu trả lời cũng có nguy cơ tiêm người dùng đầu vào .

db.zipcodes.find({city : "NEW YORK"}); // Case-sensitive
db.zipcodes.find({city : /NEW york/i}); // Note the 'i' flag for case-insensitivity

TL; DR

Cách chính xác để làm điều này trong mongo

Không sử dụng RegExp

Tự nhiên và sử dụng lập chỉ mục sẵn có của mongodb, tìm kiếm

Bước 1 :

db.articles.insert(
   [
     { _id: 1, subject: "coffee", author: "xyz", views: 50 },
     { _id: 2, subject: "Coffee Shopping", author: "efg", views: 5 },
     { _id: 3, subject: "Baking a cake", author: "abc", views: 90  },
     { _id: 4, subject: "baking", author: "xyz", views: 100 },
     { _id: 5, subject: "Café Con Leche", author: "abc", views: 200 },
     { _id: 6, subject: "Сырники", author: "jkl", views: 80 },
     { _id: 7, subject: "coffee and cream", author: "efg", views: 10 },
     { _id: 8, subject: "Cafe con Leche", author: "xyz", views: 10 }
   ]
)

Bước 2 :

Cần phải tạo chỉ mục trên bất cứ TEXT lĩnh vực bạn muốn tìm kiếm, mà không cần truy vấn lập chỉ mục sẽ rất chậm

db.articles.createIndex( { subject: "text" } )

bước 3 :

db.articles.find( { $text: { $search: "coffee",$caseSensitive :true } } )  //FOR SENSITIVITY
db.articles.find( { $text: { $search: "coffee",$caseSensitive :false } } ) //FOR INSENSITIVITY

db.company_profile.find({ "companyName" : { "$regex" : "Nilesh" , "$options" : "i"}});

Mongo (phiên bản hiện tại 2.0.0) không cho phép tìm kiếm không phân biệt chữ hoa chữ thường đối với các trường được lập chỉ mục - xem tài liệu của họ . Đối với các trường không được lập chỉ mục, các biểu thức chính được liệt kê trong các câu trả lời khác sẽ ổn.

Một điều rất quan trọng cần ghi nhớ khi sử dụng truy vấn dựa trên Regex - Khi bạn đang thực hiện việc này cho hệ thống đăng nhập, hãy thoát mọi ký tự bạn đang tìm kiếm và đừng quên các toán tử ^ và $. Lodash có một chức năng tốt cho việc này , nếu bạn đang sử dụng nó:

db.stuff.find({$regex: new RegExp(_.escapeRegExp(bar), $options: 'i'})

Tại sao? Hãy tưởng tượng một người dùng nhập .*làm tên người dùng của mình. Điều đó sẽ phù hợp với tất cả tên người dùng, cho phép đăng nhập bằng cách đoán bất kỳ mật khẩu của người dùng.

Phương thức tốt nhất là theo ngôn ngữ bạn chọn, khi tạo trình bao bọc mô hình cho các đối tượng của bạn, hãy để phương thức save () lặp lại thông qua một tập hợp các trường mà bạn sẽ tìm kiếm trên đó cũng được lập chỉ mục; những trường này nên có các bản sao chữ thường được sử dụng để tìm kiếm.

Mỗi khi đối tượng được lưu lại, các thuộc tính chữ thường sẽ được kiểm tra và cập nhật với bất kỳ thay đổi nào đối với các thuộc tính chính. Điều này sẽ làm cho nó để bạn có thể tìm kiếm hiệu quả, nhưng ẩn công việc bổ sung cần thiết để cập nhật các trường lc mỗi lần.

Các trường viết thường có thể là một khóa: đối tượng lưu trữ giá trị hoặc chỉ tên trường có tiền tố lc_. Tôi sử dụng cái thứ hai để đơn giản hóa truy vấn (truy vấn đối tượng sâu có thể gây nhầm lẫn đôi khi).

Lưu ý: bạn muốn lập chỉ mục các trường lc_, không phải các trường chính mà chúng dựa trên.

Giả sử bạn muốn tìm kiếm "cột" trong "Bảng" và bạn muốn tìm kiếm không phân biệt chữ hoa chữ thường. Cách tốt nhất và hiệu quả là như dưới đây;

//create empty JSON Object
mycolumn = {};

//check if column has valid value
if(column) {
    mycolumn.column = {$regex: new RegExp(column), $options: "i"};
}
Table.find(mycolumn);

Mã ở trên chỉ thêm giá trị tìm kiếm của bạn dưới dạng RegEx và tìm kiếm với tiêu chí không nhạy cảm được đặt với tùy chọn "i".

Tất cả tốt nhất.

Sử dụng Mongoose điều này làm việc cho tôi:

var find = function(username, next){
    User.find({'username': {$regex: new RegExp('^' + username, 'i')}}, function(err, res){
        if(err) throw err;
        next(null, res);
    });
}

Khung tổng hợp đã được giới thiệu trong mongodb 2.2. Bạn có thể sử dụng toán tử chuỗi "$ strcasecmp" để so sánh không phân biệt chữ hoa chữ thường giữa các chuỗi. Đó là khuyến cáo và dễ dàng hơn so với sử dụng regex.

Đây là tài liệu chính thức về toán tử lệnh tổng hợp: https://docs.mongodb.com/manual/reference/operator/aggregation/strcasecmp/#api._S_strcasecmp .

Bạn có thể sử dụng Chỉ mục phân biệt chữ hoa chữ thường :

Ví dụ sau đây tạo ra một bộ sưu tập không có đối chiếu mặc định, sau đó thêm một chỉ mục trên trường tên với đối chiếu không phân biệt chữ hoa chữ thường. Các thành phần quốc tế cho Unicode

/* strength: CollationStrength.Secondary
* Secondary level of comparison. Collation performs comparisons up to secondary * differences, such as diacritics. That is, collation performs comparisons of 
* base characters (primary differences) and diacritics (secondary differences). * Differences between base characters takes precedence over secondary 
* differences.
*/
db.users.createIndex( { name: 1 }, collation: { locale: 'tr', strength: 2 } } )

Để sử dụng chỉ mục, các truy vấn phải chỉ định cùng đối chiếu.

db.users.insert( [ { name: "Oğuz" },
                            { name: "oğuz" },
                            { name: "OĞUZ" } ] )

// does not use index, finds one result
db.users.find( { name: "oğuz" } )

// uses the index, finds three results
db.users.find( { name: "oğuz" } ).collation( { locale: 'tr', strength: 2 } )

// does not use the index, finds three results (different strength)
db.users.find( { name: "oğuz" } ).collation( { locale: 'tr', strength: 1 } )

hoặc bạn có thể tạo một bộ sưu tập với đối chiếu mặc định:

db.createCollection("users", { collation: { locale: 'tr', strength: 2 } } )
db.users.createIndex( { name : 1 } ) // inherits the default collation

Để tìm kiếm một biến và thoát nó:

const escapeStringRegexp = require('escape-string-regexp')
const name = 'foo'
db.stuff.find({name: new RegExp('^' + escapeStringRegexp(name) + '$', 'i')})   

Thoát khỏi biến bảo vệ truy vấn chống lại các cuộc tấn công bằng '. *' Hoặc regex khác.

thoát-chuỗi-regrec

Sử dụng RegExp , trong trường hợp nếu bất kỳ tùy chọn nào khác không phù hợp với bạn, RegExp là một lựa chọn tốt. Nó làm cho trường hợp chuỗi không nhạy cảm.

var username = new RegExp("^" + "John" + "$", "i");;

sử dụng tên người dùng trong các truy vấn, và sau đó nó được thực hiện.

Tôi hy vọng nó sẽ làm việc cho bạn quá. Tất cả tốt nhất.

Tôi đã tạo một Func đơn giản cho trường hợp regex không nhạy cảm, mà tôi sử dụng trong bộ lọc của mình.

private Func<string, BsonRegularExpression> CaseInsensitiveCompare = (field) => 
            BsonRegularExpression.Create(new Regex(field, RegexOptions.IgnoreCase));

Sau đó, bạn chỉ cần lọc trên một lĩnh vực như sau.

db.stuff.find({"foo": CaseInsensitiveCompare("bar")}).count();

Sử dụng bộ lọc hoạt động với tôi trong C #.

string s = "searchTerm";
    var filter = Builders<Model>.Filter.Where(p => p.Title.ToLower().Contains(s.ToLower()));
                var listSorted = collection.Find(filter).ToList();
                var list = collection.Find(filter).ToList();

Nó thậm chí có thể sử dụng chỉ mục vì tôi tin rằng các phương thức được gọi sau khi hoàn trả xảy ra nhưng tôi chưa thử nghiệm điều này.

Điều này cũng tránh được vấn đề

var filter = Builders<Model>.Filter.Eq(p => p.Title.ToLower(), s.ToLower());

mongodb sẽ nghĩ p.Title.ToLower () là một tài sản và sẽ không ánh xạ đúng.

Đối với bất kỳ ai sử dụng Golang và mong muốn có trường hợp tìm kiếm toàn văn nhạy cảm với mongodb và thư viện mgo godoc globalalsign .

collation := &mgo.Collation{
    Locale:   "en",
    Strength: 2, 
}


err := collection.Find(query).Collation(collation)

Như bạn có thể thấy trong các tài liệu mongo - vì $textchỉ mục phiên bản 3.2 không phân biệt chữ hoa chữ thường: https://docs.mongodb.com/manual/core/index-text/#text-index-case-insensens

Tạo một chỉ mục văn bản và sử dụng toán tử $ text trong truy vấn của bạn .

Chúng đã được thử nghiệm để tìm kiếm chuỗi

{'_id': /.*CM.*/}               ||find _id where _id contains   ->CM
{'_id': /^CM/}                  ||find _id where _id starts     ->CM
{'_id': /CM$/}                  ||find _id where _id ends       ->CM

{'_id': /.*UcM075237.*/i}       ||find _id where _id contains   ->UcM075237, ignore upper/lower case
{'_id': /^UcM075237/i}          ||find _id where _id starts     ->UcM075237, ignore upper/lower case
{'_id': /UcM075237$/i}          ||find _id where _id ends       ->UcM075237, ignore upper/lower case

Tôi đã phải đối mặt với một vấn đề tương tự và đây là những gì làm việc cho tôi:

  const flavorExists = await Flavors.findOne({
    'flavor.name': { $regex: flavorName, $options: 'i' },
  });