Mongoose.js: उपयोगकर्ता नाम LIKE मान द्वारा खोजें

Question

मैं मूंगडॉब में एक उपयोगकर्ता को खोजने के लिए जाना चाहता हूं जिसे मूल्य कहा जाता है। के साथ समस्या:

username: 'peter'

यह है कि अगर उपयोगकर्ता नाम "पीटर", या "Peter" .. या ऐसा कुछ है तो मुझे यह पता नहीं है।

इसलिए मैं sql की तरह करना चाहता हूं

SELECT * FROM users WHERE username LIKE 'peter'

आशा है कि आप लोगों को किसके लिए पूछूँ?

लघु: mongoose.js / mongodb में 'फ़ील्ड का मान'

Comments

बस एक तरफ, SQL क्वेरी नहीं मिलेगी Peterया PeTERतो LIKEकेस-असंवेदनशील नहीं है।

— बेनी

Answer 1

उन लोगों के लिए जो यहां समाधान की तलाश में थे:

var name = 'Peter';
model.findOne({name: new RegExp('^'+name+'$', "i")}, function(err, doc) {
  //Do your action here..
});

Comments

"i" तर्क का क्या अर्थ है? क्या केस सेंसिटिविटी से इसका कोई लेना-देना है?

— अज़फ्रोमकाज़ा

"I" एक खोज ध्वज चुनने का तर्क है। "मैं" तब केस-असंवेदनशील के लिए है। आप इसके बारे में यहां और अधिक पढ़ सकते हैं। developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/…

— PeterBechP

यह मानता है कि रेगेक्स अमान्य नहीं है। यदि आप उदाहरण के लिए उपयोगकर्ता नाम के रूप में "[" जोड़ते हैं, तो अपवाद को फेंक देगा। बस सुनिश्चित करें कि आप या तो अपने इनपुट को पहले से पकड़ने या रिजेक्ट कर रहे हैं या [^ a-zA-Z0-9] के लिए जांच कर रहे हैं, फिर आगे नहीं बढ़ रहे हैं। इस मामले में, इसका सिर्फ परीक्षण इनपुट तो समझ में आता है।

— जेसन सेब्रिंग

$ = स्ट्रिंग के अंत का मिलान करें

— पीटरबैच

@JasonSebring हालांकि मैं मानता हूं कि इनपुट सत्यापन एक बुरा विचार नहीं है, सबसे अच्छा तरीका एक वास्तविक पलायन एल्गोरिथ्म है। और अपवाद भी सबसे खराब समस्या नहीं है, लेकिन कल्पना करें कि आपने लॉगिन पृष्ठ पर समान कोड का उपयोग किया है और उपयोगकर्ता ने उपयोगकर्ता ".*"नाम के रूप में प्रवेश किया है।

— टोबियास

Answer 2

मुझे हाल ही में इसके साथ समस्या थी, मैं इस कोड का उपयोग करता हूं और मेरे लिए ठीक काम करता हूं।

var data = 'Peter';

db.User.find({'name' : new RegExp(data, 'i')}, function(err, docs){
    cb(docs);
});

सीधे /Peter/iकाम का उपयोग करें , लेकिन मैं उपयोग करता हूं '/'+data+'/i'और मेरे लिए काम नहीं करता।

Comments

खैर, मैंने अभी इसे कुछ और करने की कोशिश की। मैं देख रहा हूँ यह भी लगता है कि क्या मैं सिर्फ P लिखता हूँ ?? हममम।

— पीटरबेक

हां, मैं उपयोगकर्ताओं को खोजने के लिए अजाक्स याचिकाओं के लिए उपयोग करता हूं। आप RegExp को संशोधित कर सकते हैं।

— डॉनफ्लोपेज़

Answer 3

db.users.find( { 'username' : { '$regex' : req.body.keyWord, '$options' : 'i' } } )

Comments

@ मायकेशी इसका उदाहरण क्या है?

— लेन जोसफ

सामान्य तौर पर केवल ReDoS के हमले में LenJoseph: owasp.org/index.php/… , मैं इस बात से अनभिज्ञ हूँ कि क्या इस बिंदु पर मानस कमजोर है, या यदि ReDoS निविष्टियों का पता लगाने के लिए कोई इच्छित कार्यशीलता है और उन्हें मानस स्तर पर पवित्र करना है।

— माइक शी

Answer 4

collection.findOne({
    username: /peter/i
}, function (err, user) {
    assert(/peter/i.test(user.username))
})

Comments

क्या होगा अगर मूल्य एक var है? कैसे स्थापित करें? / varhere / i

— पीटरबेकपी

@PeterBechP एक नियमित अभिव्यक्ति का निर्माण करता है: \new RegExp(var, "i")

— Raynos

ठीक काम करता है .. अब मैं एक समस्या है .. यह केवल अगर पालतू पीटर है पीटर खोजने के लिए है। लेकिन अगर मैं var को 'p' पर सेट करता हूं तो यह अभी भी पीटर को ढूंढेगा।

— पीटरबेक

@PeterBechP फिर केस असंवेदनशीलता ध्वज को हटा दें: \

— Raynos

Answer 5

router.route('/product/name/:name')
.get(function(req, res) {

    var regex = new RegExp(req.params.name, "i")
    ,   query = { description: regex };

    Product.find(query, function(err, products) {
        if (err) {
            res.json(err);
        }

        res.json(products);
    });

});  

Answer 6

आपको उसके लिए एक regex का उपयोग करना चाहिए।

db.users.find({name: /peter/i});

हालांकि, सावधान रहें, कि यह क्वेरी इंडेक्स का उपयोग नहीं करता है।

Answer 7

खोजने के लिए mongoose doc। रेगेक्स के लिए मंगोल डॉक।

var Person = mongoose.model('Person', yourSchema);
// find each person with a name contains 'Ghost'
Person.findOne({ "name" : { $regex: /Ghost/, $options: 'i' } },
    function (err, person) {
             if (err) return handleError(err);
             console.log('%s %s is a %s.', person.name.first, person.name.last, person.occupation);
});

नोट पहला तर्क हम को पारित mongoose.findOneसमारोह: { "name" : { $regex: /Ghost/, $options: 'i' } }, "name"दस्तावेज़ को आप खोज रहे हैं के क्षेत्र है, "Ghost", रेगुलर एक्सप्रेशन है "i"केस संवेदी मैच के लिए है। आशा है कि यह आपकी मदद करेगा।

Comments

क्या $ विकल्प हैं

— kabuto178

Answer 8

निम्न क्वेरी आवश्यक स्ट्रिंग केस के साथ दस्तावेजों को असंवेदनशील और वैश्विक घटना के साथ भी पाएगी

var name = 'Peter';
    db.User.find({name:{
                         $regex: new RegExp(name, "ig")
                     }
                },function(err, doc) {
                                     //Your code here...
              });

Answer 9

यह मैं उपयोग कर रहा हूं।

module.exports.getBookByName = function(name,callback){
    var query = {
            name: {$regex : name}
    }
    User.find(query,callback);
}

Answer 10

यहाँ एक्सप्रेस के साथ मेरा कोड:

router.route('/wordslike/:word')
    .get(function(request, response) {
            var word = request.params.word;       
            Word.find({'sentence' : new RegExp(word, 'i')}, function(err, words){
               if (err) {response.send(err);}
               response.json(words);
            });
         });

Answer 11

अगर मैं किसी भी हालत में सभी रिकॉर्ड को क्वेरी करना चाहता हूं all मैं इसका उपयोग कर सकता हूं:

if (userId == 'admin')
  userId = {'$regex': '.*.*'};
User.where('status', 1).where('creator', userId);

Comments

$regexजब आप सिर्फ इस्तेमाल कर सकते थे तब एक अनावश्यक उपयोग की तरह लगता है { $exists: true }।

— सीन

Answer 12

बस @PeterBechP के उत्तर का पूरक है।

विशेष वर्णों का बलात्कार करना न भूलें। https://stackoverflow.com/a/6969486

function escapeRegExp(string) {
  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

var name = 'Peter+with+special+chars';

model.findOne({name: new RegExp('^'+escapeRegExp(name)+'$', "i")}, function(err, doc) {
  //Do your action here..
});

Answer 13

यह परिवर्तित करने के लिए मेरे समाधान है कि हर मूल्य एक में req.body एक नेवला के लिए की तरह परम:

let superQ = {}

Object.entries({...req.body}).map((val, i, arr) => {
    superQ[val[0]] = { '$regex': val[1], '$options': 'i' }
})

User.find(superQ)
  .then(result => {
    res.send(result)})
  .catch(err => { 
    res.status(404).send({ msg: err }) })