设是它能够使情况不敏感的询问?

Question

例如：

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

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

Answer 1

您可以使用正则表达式。

在您的例子将是：

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

我必须说，虽然，也许你可以只downcase（或upcase）中，而途中值比每次都发现它的时候招致额外的费用。显然，对于人的姓名等，但也许用例类似标签这不会工作。

Answer 2

<强>更新

在原始答案现在已过时。 的MongoDB现在支持先进的全文检索，具有许多功能。

<强>原来的答案：

应当指出的是，正则表达式的大小写不敏感的搜索/ I意味着mongodb的不能由索引搜索，所以针对大型数据集的查询可能需要很长的时间。

即使有小的数据集，它不是很有效。你把一个大得多的CPU比打你的查询认股权证，这有可能成为一个问题，如果你想达到的规模。

作为替代方案，可以存储一个大写复制并搜索针对。举例来说，我有一个具有混合情况下，用户名的表，但id为用户名的大写副本。这确保区分大小写的复制是不可能的（具有两个“foo”和“富”将不会被允许），我可以按ID搜索= username.toUpperCase（）来获取用户名不区分大小写的搜索。

如果你的领域很大，如邮件正文，复制数据可能不是一个很好的选择。相信使用如Apache Lucene的外来索引是在这种情况下，最好的选择。

Answer 3

请注意，在前面的示例：

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

将导致含有每条目的栏以匹配查询（BAR1，barxyz，openbar），它可能是用于在AUTH功能...

用户名搜索非常危险的

您可能需要使用适当的正则表达式的语法，使其只匹配搜索词：

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

请参阅 http://www.regular-expressions.info/ 以正则表达式语法帮助

Answer 4

如果您需要从一个变量创建正则表达式，这是一种更好的方法来做到这一点： https：//开头计算器。 COM /一个/三十○万九千五百一十四分之一千零七十二万八千零六十九

然后，您可以这样做：

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

这一个好处可以更加程序化，也可以通过提前编译它，如果你打算重用了很多获得的性能提升。

Answer 5

开始，该建议的方式来执行快速情况不敏感的搜索是使用 情况不敏感的指数.

我个人电子邮件的创始人之一请获得这一工作，并且他做到这一点！这是一个 问题在吉拉自2009年, 和许多要求的功能。在这里，它是如何工作：

情况不敏感的指标是由可通过指定一个 排序规则 与强度1或2。你可以创建一个情况下-不敏感的指数是这样的：

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

你也可以指定一个默认排序规则收集每当你们创造:

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

在任何一种情况下，为了使用情况不敏感的指数，需要指定相同的排序规则在 find 操作时使用的创建指数或集合：

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

这将返回"纽约"，"纽约"，"纽约"等。

其他的笔记

• 答案建议使用 全文搜索是错的 在这种情况下(并可能 危险).这个问题是关于使情况不敏感的查询的，例如 username: 'bill' 匹配 BILL 或 Bill, 不全文搜索查询，其中还将匹配 因 话 bill, 如 Bills, billed 等等。

• 答案建议使用经常表达的缓慢，因为即使有索引， 文件的国家:

  "Case insensitive regular expression查询一般无法使用索引有效。美元regex执行不排序规则的知道和无法利用情况不敏感的指标。"

  $regex 答案也跑的危险 用户输入的注射.

Answer 6

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

Answer 7

TL博士

正确的方式做到这一点，在mongo

请勿使用 RegExp

去自然和使用mongodb的内在索引的，搜索

步骤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 }
   ]
)

步骤2：

需要建立指标在哪 文本 领你要搜索，没有索引，查询将是非常缓慢

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

步骤3：

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

Answer 8

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

Answer 9

蒙戈（当前版本2.0.0）不允许不区分大小写的搜索针对索引字段 - 见他们的文档。对于非索引字段，在其他的答案中列出的正则表达式要细。

Answer 10

最好的方法是在你选择的语言，为您创造对象的模型包装的时候，有你的save（）方法通过一组，你将在这也被编入索引搜索领域的重复;那些组字段应该具有小写同行接着被用于用于搜索。

每个对象被再次保存时间，小写属性然后检查并用任何变化的主要性能更新。这将使这样你就可以有效地搜索，却隐藏着每一次更新LC领域所需要的额外工作。

下壳体字段可能是一个键：值对象存储器或具有前缀LC_只是字段名称。我用第二个以简化查询（深对象查询有时可能混淆）。

请注意：您要编制索引的LC_领域，而不是他们都基于的主要领域。

Answer 11

假设你要搜索的“表”，“列”和你希望的情况下insenstive搜索。最好的和有效的方法是如以下;

//create empty JSON Object
mycolumn = {};

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

上面的代码只是增加了在与设置为“我”作为选项钝感标准为正则表达式搜索的价值和搜索。

所有最好的。

Answer 12

使用基于正则表达式查询时要记住的一个非常重要的事情 - 当你这样做的一个登录系统，的逃脱的每一个字符您正在搜索，不要忘了^和$运营商。 Lodash有这个一个不错的功能，你应该是已经使用它：

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

为什么呢？想象一下，一个用户进入.*为他的用户名。这会匹配所有的用户名，通过只是猜测任何用户的密码，启用登录。

Answer 13

使用猫鼬这个工作对我来说：

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

Answer 14

在聚合框架是在2.2的mongodb引入。您可以使用字符串操作符“$ strcasecmp”，使串之间的区分大小写的比较。它更推荐的和更容易比使用正则表达式。

下面是对聚合命令操作者的正式文件： https://docs.mongodb.com/manual/reference/operator/aggregation/strcasecmp/#exp._S_strcasecmp 。

Answer 15

您可以使用不区分大小写指数

下面的示例创建没有默认排序规则的集合，然后添加上的名字中的一个索引与一个不区分大小写的排序规则。 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 } } )

要使用索引，查询必须指定相同的排序规则。

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

也可以创建一个集合与默认排序规则：

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

Answer 16

有关搜索的变量和避开它：

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

逃逸可变防止与攻击的查询“*”或其它正则表达式。

逃生串的regexp

Answer 17

我已经创建了一个简单FUNC键的情况下不敏感的正则表达式，其中我在过滤器中使用。

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

然后，你只需在一个场滤波器如下：

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

Answer 18

使用的过滤器在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();

它甚至可以使用索引，因为我相信回报会发生，但我没有测试这一点，但之后的方法调用。

这也避免了这样的问题

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

这mongodb的会认为p.Title.ToLower（）是一个属性，不会正确映射。

Answer 19

对于任何一个使用Go语言和愿望的有情况下，敏感的全文搜索与mongodb和氧化镁 godoc globalsign库.

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


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

Answer 20

使用的正则表达式下，  在情况下，如果任何其他选项不为你工作，正则表达式是一个不错的选择。它使字符串不区分大小写。

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

在查询中使用的用户名，然后将其完成。

我希望它会为你工作了。所有最佳。

Answer 21

正如你可以看看在蒙戈文件-从3.2版 $text 索引的情况不敏感的默认： https://docs.mongodb.com/manual/core/index-text/#text-index-case-insensitivity

创建一个文索引 和 使用$text运营商在查询.

Answer 22

这些都被用于字符串搜索测试

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

Answer 23

我曾经遇到过类似的问题，这是对我工作：

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