Contoh:

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

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

Anda bisa menggunakan regex .

Dalam contoh Anda itu akan menjadi:

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

Namun, saya harus mengatakan, mungkin Anda bisa menurunkan (atau menaikkan) nilai di jalan daripada mengeluarkan biaya tambahan setiap kali Anda menemukannya. Jelas ini tidak akan bekerja untuk nama orang dan semacamnya, tapi mungkin menggunakan case seperti tag.

MEMPERBARUI:

Jawaban asli sekarang sudah usang. Mongodb sekarang mendukung pencarian teks lengkap tingkat lanjut, dengan banyak fitur.

JAWABAN ASLI:

Perlu dicatat bahwa pencarian dengan case regex tidak peka / i berarti mongodb tidak dapat mencari berdasarkan indeks, sehingga permintaan terhadap dataset besar dapat memakan waktu lama.

Bahkan dengan dataset kecil, itu tidak terlalu efisien. Anda menerima pukulan cpu yang jauh lebih besar daripada waran permintaan Anda, yang bisa menjadi masalah jika Anda mencoba mencapai skala.

Sebagai alternatif, Anda dapat menyimpan salinan huruf besar dan mencarinya. Misalnya, saya memiliki tabel Pengguna yang memiliki nama pengguna yang merupakan case campuran, tetapi id adalah salinan huruf besar dari nama pengguna. Ini memastikan duplikasi case-sensitive tidak mungkin (memiliki "Foo" dan "foo" tidak akan diizinkan), dan saya dapat mencari berdasarkan id = username.toUpperCase () untuk mendapatkan pencarian case-sensitive untuk nama pengguna.

Jika bidang Anda besar, seperti badan pesan, duplikasi data mungkin bukan pilihan yang baik. Saya percaya menggunakan pengindeks luar seperti Apache Lucene adalah pilihan terbaik dalam kasus itu.

Jika Anda perlu membuat regexp dari suatu variabel, ini adalah cara yang lebih baik untuk melakukannya: https://stackoverflow.com/a/10728069/309514

Anda kemudian dapat melakukan sesuatu seperti:

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

Ini memiliki manfaat menjadi lebih terprogram atau Anda bisa mendapatkan peningkatan kinerja dengan kompilasi sebelumnya jika Anda sering menggunakannya kembali.

Ingatlah bahwa contoh sebelumnya:

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

akan menyebabkan setiap entri yang berisi bilah cocok dengan kueri (bar1, barxyz, openbar), bisa sangat berbahaya bagi pencarian nama pengguna pada fungsi auth ...

Anda mungkin perlu membuatnya hanya cocok dengan istilah pencarian dengan menggunakan sintaksis regexp yang sesuai seperti:

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

Lihat http://www.regular-expressions.info/ untuk bantuan sintaks pada ekspresi reguler

Dimulai dengan MongoDB 3.4, cara yang disarankan untuk melakukan pencarian case-insensitive cepat adalah menggunakan Case Insensitive Index .

Saya secara pribadi mengirim email kepada salah satu pendiri untuk membuatnya bekerja, dan dia mewujudkannya! Itu adalah masalah pada JIRA sejak 2009 , dan banyak yang meminta fitur tersebut. Begini cara kerjanya:

Indeks case-insensitive dibuat dengan menentukan collation dengan kekuatan 1 atau 2. Anda dapat membuat indeks case-insensitive seperti ini:

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

Anda juga dapat menentukan susunan default per koleksi saat Anda membuatnya:

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

Dalam kedua kasus tersebut, untuk menggunakan indeks case-insensitive, Anda perlu menentukan susunan yang sama dalam findoperasi yang digunakan saat membuat indeks atau koleksi:

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

Ini akan mengembalikan "New York", "new york", "New york" dll.

Catatan lain

• Jawaban yang menyarankan untuk menggunakan pencarian teks lengkap salah dalam hal ini (dan berpotensi berbahaya ). Pertanyaannya adalah tentang membuat kueri yang tidak peka huruf besar-kecil, misalnya username: 'bill'mencocokkan BILLatau Bill, bukan kueri penelusuran teks lengkap, yang juga akan cocok dengan kata-kata yang berasal dari bill, seperti Bills, billeddll.

• Jawaban yang menyarankan untuk menggunakan ekspresi reguler lambat, karena bahkan dengan indeks, dokumentasi menyatakan :

  "Kueri ekspresi reguler case-insensitive umumnya tidak dapat menggunakan indeks secara efektif. Implementasi $ regex tidak sadar-kolasi dan tidak dapat memanfaatkan indeks case-insensitive."

  $regexjawaban juga menjalankan risiko injeksi input pengguna .

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

TL; DR

Cara yang benar untuk melakukan ini di mongo

Jangan Gunakan RegExp

Alami dan gunakan pengindeksan inbuilt mongodb, cari

Langkah 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 }
   ]
)
 

Langkah 2 :

Perlu membuat indeks pada bidang TEKS mana pun yang ingin Anda cari, tanpa kueri pengindeksan akan sangat lambat

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

langkah 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 (versi saat ini 2.0.0) tidak mengizinkan pencarian case-sensitive terhadap bidang yang diindeks - lihat dokumentasi mereka . Untuk bidang yang tidak diindeks, regex yang terdaftar di jawaban lain harus baik-baik saja.

Satu hal yang sangat penting untuk diingat ketika menggunakan kueri berbasis Regex - Ketika Anda melakukan ini untuk sistem login, lepaskan setiap karakter tunggal yang Anda cari, dan jangan lupa ^ dan $ operator. Lodash memiliki fungsi yang bagus untuk ini , jika Anda sudah menggunakannya:

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

Mengapa? Bayangkan seorang pengguna memasukkan .*nama pengguna. Itu akan cocok dengan semua nama pengguna, memungkinkan login dengan hanya menebak kata sandi pengguna mana pun.

Metode terbaik adalah dalam bahasa pilihan Anda, saat membuat pembungkus model untuk objek Anda, minta metode save () Anda beralih melalui seperangkat bidang yang akan Anda cari yang juga diindeks; kumpulan bidang tersebut harus memiliki mitra huruf kecil yang kemudian digunakan untuk pencarian.

Setiap kali objek disimpan lagi, properti huruf kecil kemudian diperiksa dan diperbarui dengan perubahan apa pun pada properti utama. Ini akan membuatnya sehingga Anda dapat mencari secara efisien, tetapi menyembunyikan pekerjaan tambahan yang diperlukan untuk memperbarui bidang lc setiap kali.

Bidang huruf kecil bisa menjadi kunci: menyimpan objek nilai atau hanya nama bidang dengan awalan lc_. Saya menggunakan yang kedua untuk menyederhanakan kueri (kueri objek dalam bisa membingungkan di kali)

Catatan: Anda ingin mengindeks bidang lc_, bukan bidang utama yang menjadi dasarnya.

Misalkan Anda ingin mencari "kolom" di "Tabel" dan Anda ingin pencarian tidak case-case. Cara terbaik dan efisien adalah seperti di bawah ini;

//create empty JSON Object
mycolumn = {};

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

Kode di atas hanya menambahkan nilai pencarian Anda sebagai RegEx dan mencari dengan kriteria tidak sensitif yang ditetapkan dengan "i" sebagai opsi.

Semua yang terbaik.

Menggunakan luwak ini bekerja untuk saya:

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

Kerangka agregasi diperkenalkan di mongodb 2.2. Anda dapat menggunakan operator string "$ strcasecmp" untuk membuat perbandingan case-insensitive antara string. Ini lebih direkomendasikan dan lebih mudah daripada menggunakan regex.

Berikut dokumen resmi pada operator perintah agregasi: https://docs.mongodb.com/manual/reference/operator/aggregation/strcasecmp/#exp._S_strcasecmp .

Anda dapat menggunakan Indeks Tidak Sensitif Kasus :

Contoh berikut membuat koleksi tanpa susunan default, lalu menambahkan indeks pada bidang nama dengan susunan case sensitif. Komponen Internasional untuk 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 } } )

Untuk menggunakan indeks, kueri harus menentukan susunan yang sama.

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 } )

atau Anda dapat membuat koleksi dengan susunan standar:

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

Untuk mencari variabel dan menghindarinya:

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

Melarikan diri dari variabel melindungi permintaan terhadap serangan dengan '. *' Atau regex lainnya.

escape-string-regexp

Gunakan RegExp , Jika ada opsi lain yang tidak bekerja untuk Anda, RegExp adalah pilihan yang baik. Itu membuat case string tidak sensitif.

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

gunakan nama pengguna dalam kueri, dan kemudian selesai.

Saya harap ini juga akan berhasil untuk Anda. Semua yang terbaik.

Saya telah membuat Func sederhana untuk case regex tidak sensitif, yang saya gunakan dalam filter saya.

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

Maka Anda cukup memfilter pada bidang sebagai berikut.

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

Menggunakan filter berfungsi untuk saya dalam 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();

Bahkan mungkin menggunakan indeks karena saya percaya metode dipanggil setelah pengembalian terjadi tetapi saya belum menguji ini.

Ini juga menghindari masalah

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

bahwa mongodb akan menganggap p.Title.ToLower () adalah properti dan tidak akan dipetakan dengan benar.

Untuk siapa pun yang menggunakan Golang dan ingin memiliki pencarian teks lengkap yang peka huruf dengan mongodb dan perpustakaan mgo godoc globalsign .

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


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

Seperti yang dapat Anda lihat di mongo docs - karena $textindeks versi 3.2 tidak peka huruf besar-kecil: https://docs.mongodb.com/manual/core/index-text/#text-index-case-insensitivity

Buat indeks teks dan gunakan $ text operator dalam permintaan Anda .

Ini telah diuji untuk pencarian string

{'_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

Saya telah menghadapi masalah yang sama dan inilah yang bekerja untuk saya:

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