Misal:

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

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

Bir normal ifade kullanabilirsiniz .

Örneğinizde bu:

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

Söylemeliyim ki, belki de, her seferinde bulduğunuzda ekstra maliyete maruz kalmak yerine, yolda değeri küçümseyebilir (veya yükseltebilirsiniz). Açıkçası bu insanların isimleri ve benzeri için işe yaramaz, ama belki etiketler gibi kullanım örnekleri.

GÜNCELLEME:

Orijinal cevap artık kullanılmıyor. Mongodb artık birçok özelliğe sahip gelişmiş tam metin aramayı destekliyor.

ORİJİNAL CEVAP:

Regex'in büyük / küçük harf duyarsız / i ile arama yapmanın, mongodb'un dizine göre arama yapamayacağı, bu nedenle büyük veri kümelerine yönelik sorguların uzun sürebileceği anlamına gelir.

Küçük veri kümelerinde bile, çok verimli değildir. Sorgu garantilerinizden çok daha büyük bir cpu vuruşu alırsınız, bu da ölçek elde etmeye çalışıyorsanız bir sorun haline gelebilir.

Alternatif olarak, büyük harfli bir kopya saklayabilir ve buna karşı arama yapabilirsiniz. Örneğin, karışık durumda bir kullanıcı adı olan bir Kullanıcı tablo var, ancak id kullanıcı adının büyük harfli bir kopyasıdır. Bu, büyük / küçük harfe duyarlı çoğaltmanın imkansız olmasını sağlar (hem "Foo" hem de "foo" 'ya izin verilmez) ve kullanıcı adı için büyük / küçük harfe duyarlı olmayan bir arama elde etmek için id = username.toUpperCase () ile arama yapabilirim.

Alanınız bir ileti gövdesi gibi büyükse, verilerin çoğaltılması muhtemelen iyi bir seçenek değildir. Bu durumda Apache Lucene gibi yabancı bir dizinleyici kullanmak en iyi seçenek olduğuna inanıyorum.

Bir değişkenden regexp oluşturmanız gerekiyorsa, bunu yapmanın çok daha iyi bir yoludur: https://stackoverflow.com/a/10728069/309514

Daha sonra şöyle bir şey yapabilirsiniz:

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

Bunun daha programlı olma avantajı vardır veya çok fazla kullanıyorsanız, önceden derleyerek bir performans artışı elde edebilirsiniz.

Önceki örneğin:

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

bar içeren her girişin sorguyla (bar1, barxyz, openbar) eşleşmesine neden olur , bir yetkilendirme işlevinde kullanıcı adı araması yapmak çok tehlikeli olabilir ...

Uygun regexp sözdizimini şu şekilde kullanarak yalnızca arama terimiyle eşleşmesi gerekebilir:

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

Normal ifadelerde sözdizimi yardımı için http://www.regular-expressions.info/ adresine bakın.

MongoDB 3.4'ten başlayarak, büyük / küçük harfe duyarsız arama yapmanın önerilen yolu, Büyük / Küçük Harfe Duyarsız Bir Endeks kullanmaktır .

Şahsen bu çalışmayı sağlamak için kurucularından birine e-posta gönderdim ve bunu gerçekleştirdi! 2009'dan beri JIRA ile ilgili bir sorundu ve birçoğu bu özelliği talep etti. Şöyle çalışır:

Büyük / küçük harfe duyarlı olmayan bir dizin, 1 veya 2 gücünde bir harmanlama belirtilerek oluşturulur. Aşağıdaki gibi büyük / küçük harfe duyarlı olmayan bir dizin oluşturabilirsiniz:

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

Koleksiyon oluştururken koleksiyon başına varsayılan harmanlama da belirleyebilirsiniz:

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

Her iki durumda da, büyük / küçük harfe duyarlı olmayan dizini kullanmak için find, dizini veya koleksiyonu oluştururken kullanılan işlemde aynı harmanlamayı belirtmeniz gerekir :

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

Bu, "New York", "new york", "New york" vb.

Diğer notlar

• Tam metin araması kullanılmasını öneren yanıtlar bu durumda yanlıştır (ve potansiyel olarak tehlikelidir ). Soru harf duyarsız sorgu, örneğin yapma konusunda oldu username: 'bill'eşleştirme BILLveya Billayrıca maç olacağını değil, bir tam metin arama sorgusu, saplı sözlerini billgibi Bills, billedvb

• Düzenli ifadeler kullanılmasını öneren cevaplar yavaştır, çünkü dizinlerde bile belgeler şunları belirtmektedir :

  "Büyük / küçük harf duyarsız normal ifade sorguları genellikle dizinleri etkili bir şekilde kullanamaz. $ Regex uygulaması harmanlamaya duyarlı değildir ve büyük / küçük harfe duyarlı olmayan dizinleri kullanamaz."

  $regexcevaplar ayrıca kullanıcı girişi enjeksiyonu riskini de taşır .

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

TL; DR

Mongo'da bunu yapmanın doğru yolu

RegExp Kullanmayın

Doğal olun Ve mongodb'un dahili indekslemesini kullanın, arama yapın

Aşama 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 }
   ]
)

Adım 2 :

İhtiyaç hangisi üzerinde indeks oluşturmak METİN indeksleme sorgu son derece yavaş olacak olmaksızın, arama yapmak istediğiniz alan

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

Aşama 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 (geçerli sürüm 2.0.0) dizinlenmiş alanlara göre büyük / küçük harfe duyarlı olmayan aramalara izin vermez - belgelerine bakın . Dizine eklenmemiş alanlar için, diğer yanıtlarda listelenen normal ifadeler iyi olmalıdır.

Regex tabanlı bir sorgu kullanırken akılda tutulması gereken çok önemli bir şey - Bir giriş sistemi için bunu yaparken , aradığınız her karakterden kaçın ve ^ ve $ operatörlerini unutmayın. Lodash'ın bunun için güzel bir işlevi var , zaten kullanıyorsanız:

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

Neden? Bir kullanıcının kullanıcı .*adı olarak girdiğini düşünün . Bu, tüm kullanıcı adlarıyla eşleşir ve yalnızca herhangi bir kullanıcının şifresini tahmin ederek giriş yapılmasını sağlar.

En iyi yöntem seçtiğiniz dilde, nesneleriniz için bir model sarmalayıcı oluştururken, save () yönteminizin arama yapacağınız bir dizi alanda da dizine eklenmesini sağlayın; bu alan kümesinin daha sonra arama yapmak için kullanılan küçük harfli karşılıkları olmalıdır.

Nesne her kaydedildiğinde, küçük harf özellikleri ana özelliklerde yapılan değişikliklerle kontrol edilir ve güncellenir. Bu, verimli bir şekilde arama yapabilmenizi sağlar, ancak her seferinde lc alanlarını güncellemek için gereken ekstra işi gizleyin.

Küçük harfler anahtar: değer nesnesi deposu veya yalnızca lc_ önekine sahip alan adı olabilir. Ben sorgulama (derin nesne sorgulama bazen kafa karıştırıcı olabilir) basitleştirmek için ikincisini kullanın.

Not: lc_ alanlarını endekslemek istersiniz, temel aldıkları ana alanları değil.

"Tablo" da "sütun" u aramak ve büyük / küçük harf duyarsız arama yapmak istediğinizi varsayalım. En iyi ve verimli yol aşağıdaki gibidir;

//create empty JSON Object
mycolumn = {};

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

Yukarıdaki kod sadece arama değerinizi RegEx olarak ekler ve seçenek olarak "i" ile ayarlanmış duyarsız ölçütlerle arama yapar.

Herşey gönlünce olsun.

Mongoose'u kullanmak benim için işe yaradı:

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

Toplama çerçevesi mongodb 2.2'de tanıtıldı. Dizeler arasında büyük / küçük harfe duyarlı olmayan bir karşılaştırma yapmak için "$ strcasecmp" string operatörünü kullanabilirsiniz. Normal ifade kullanmaktan daha fazla tavsiye edilir ve daha kolaydır.

Toplama komutu operatörüyle ilgili resmi belge: https://docs.mongodb.com/manual/reference/operator/aggregation/strcasecmp/#exp._S_strcasecmp .

Büyük / Küçük Harfe Duyarsız Dizinleri kullanabilirsiniz :

Aşağıdaki örnek, varsayılan harmanlama içermeyen bir koleksiyon oluşturur, ardından ad alanına büyük / küçük harfe duyarlı olmayan harmanlama içeren bir dizin ekler. Unicode için Uluslararası Bileşenler

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

Dizini kullanmak için sorgular aynı harmanlamayı belirtmelidir.

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

veya varsayılan harmanlama ile bir koleksiyon oluşturabilirsiniz:

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

Bir değişkeni aramak ve bu değişkenten kaçmak için:

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

Değişkenden kaçmak sorguyu '. *' Veya başka bir normal ifadeyle yapılan saldırılara karşı korur.

kaçış-string-regexp

RegExp kullanın , Başka seçeneklerin sizin için işe yaramaması durumunda RegExp iyi bir seçenektir. Dize büyük / küçük harf duyarsız hale getirir.

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

sorgularda kullanıcı adını kullanın ve sonra bitirin.

Umarım senin için de çalışır. Herşey gönlünce olsun.

Filtremde kullandığım, duyarsız regex için basit bir Func oluşturdum.

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

Daha sonra bir alana aşağıdaki gibi filtre uygularsınız.

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

Bir filtre kullanmak benim için C # çalışır.

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();

Hatta indeksi kullanabilir çünkü ben dönüş gerçekleştikten sonra yöntemlerin çağrıldığına inanıyorum ama henüz test etmedim.

Bu aynı zamanda

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

mongodb p.Title.ToLower () 'nin bir özellik olduğunu ve düzgün eşleşmeyeceğini düşünecektir.

Golang kullanan herkes için ve mongodb ve mgo godoc globalsign kütüphanesi ile büyük / küçük harf duyarlı tam metin araması yapmak ister .

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


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

Moğol belgelerinde görebileceğiniz gibi - sürüm 3.2 $textdizini varsayılan olarak büyük / küçük harfe duyarsız olduğundan: https://docs.mongodb.com/manual/core/index-text/#text-index-case-insensitivity

Bir metin dizini oluşturun ve sorgunuzda $ text operatörünü kullanın .

Bunlar dize aramaları için test edilmiştir

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

Benzer bir sorunla karşılaşmıştım ve bu benim için işe yaradı:

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