javascript - 通过键名获取值 mongodb node.js 驱动程序

标签 javascript node.js mongodb

我到处都看过,但找不到是否可以完成我试图通过仅按键名搜索来返回对象中的所有值。我的文档看起来像这样。

{
    "_id": ObjectID("5636e00c09431db4560ef063"),
    "username": "example@web.com",
    "credentials": {
        "password": "e5e0ba4ce8ae13d1d0291e98d9a62b4d68f1db737a36a9373f916185157500cc",
        "randomSalt": "00dfb37635ba7e5a513f9fd6e8bdf746f85ec3571df8288e1fdb44f399e331f0"
    }
}

有没有一种快速简便的方法可以使用 native node.js 驱动程序执行此操作

到目前为止我的代码

function getUserLoginFromDatabase(username, callback) {
    mongodb.connect(url, function(err, db) {
        if(err) {
                callback(err);
                db.close();
                return;
            }

        var collection = db.collection(username);

        collection.find({},{"credentials":1}, function(err, result) {
            console.log(result);
            callback(err, result);
            db.close();
        });
    });
};

更新 从 Alok Deshwal 所说的开始,我明白了。如果有区别的话,我正在使用 mongodb v3.0.7。

function getUserLoginFromDatabase(username, callback) {
    mongodb.connect(url, function(err, db) {
        if(err) {
                callback(err);
                db.close();
                return;
            }

        var collection = db.collection(username);

        collection.find({},{"credentials":1,"_id":0,"username":0}, function(err, result) {
            console.log(result);
            callback(err, result);
            db.close();
        });
    });
};

输出

Readable {                                                                                                                                           
  connection: null,                                                                                                                                  
  server: null,                                                                                                                                      
  disconnectHandler:                                                                                                                                 
   { s: { storedOps: [], storeOptions: [Object], topology: [Object] },                                                                               
     length: [Getter] },                                                                                                                             
  bson: {},                                                                                                                                          
  ns: 'mydb.exsample@web.com',                                                                                                                                
  cmd:                                                                                                                                               
   { find: 'mydb.exsample@web.com',                                                                                                                           
     limit: 0,                                                                                                                                       
     skip: 0,                                                                                                                                        
     query: {},                                                                                                                                      
     slaveOk: true,                                                                                                                                  
     readPreference: { preference: 'primary', tags: undefined, options: undefined },                                                                 
     fields: { credentials: 1, _id: 0, username: 0 } },                                                                                              
  options:                                                                                                                                           
   { skip: 0,                                                                                                                                        
     limit: 0,                                                                                                                                       
     raw: undefined,                                                                                                                                 
     hint: null,                                                                                                                                     
     timeout: undefined,                                                                                                                             
     slaveOk: true,                                                                                                                                  
     readPreference: { preference: 'primary', tags: undefined, options: undefined },                                                                 
     db:                                                                                                                                             
      EventEmitter {                                                                                                                                 
        domain: null,                                                                                                                                
        _events: {},                                                                                                                                 
        _eventsCount: 0,                                                                                                                             
        _maxListeners: undefined,                                                                                                                    
        s: [Object],                                                                                                                                 
        serverConfig: [Getter],                                                                                                                      
        bufferMaxEntries: [Getter],                                                                                                                  
        databaseName: [Getter],                                                                                                                      
        options: [Getter],                                                                                                                           
        native_parser: [Getter],                                                                                                                     
        slaveOk: [Getter],                                                                                                                           
        writeConcern: [Getter] },                                                                                                                    
     promiseLibrary: [Function: Promise],                                                                                                            
     disconnectHandler: { s: [Object], length: [Getter] } },                                                                                         
  topology:                                                                                                                                          
   EventEmitter {                                                                                                                                    
     domain: null,                                                                                                                                   
     _events:                                                                                                                                        
      { reconnect: [Function],                                                                                                                       
        timeout: [Object],                                                                                                                           
        error: [Object],                                                                                                                             
        close: [Function],                                                                                                                           
        destroy: [Object] },                                                                                                                         
     _eventsCount: 5,                                                                                                                                
     _maxListeners: undefined,                                                                                                                       
     s:                                                                                                                                              
      { options: [Object],                                                                                                                           
        callbacks: [Object],                                                                                                                         
        logger: [Object],                                                                                                                            
        state: 'connected',                                                                                                                          
        reconnect: true,                                                                                                                             
        reconnectTries: 30,                                                                                                                          
        reconnectInterval: 1000,                                                                                                                     
        emitError: true,                                                                                                                             
        currentReconnectRetry: 30,                                                                                                                   
        ismaster: [Object],                                                                                                                          
        readPreferenceStrategies: undefined,                                                                                                         
        authProviders: [Object],                                                                                                                     
        id: 1,                                                                                                                                       
        tag: undefined,                                                                                                                              
        disconnectHandler: [Object],                                                                                                                 
        wireProtocolHandler: {},                                                                                                                     
        Cursor: [Object],                                                                                                                            
        bsonInstance: {},                                                                                                                            
        bson: {},                                                                                                                                    
        pool: [Object],                                                                                                                              
        serverDetails: [Object] },                                                                                                                   
     name: [Getter],                                                                                                                                 
     bson: [Getter],                                                                                                                                 
     wireProtocolHandler: [Getter],                                                                                                                  
     id: [Getter] },                                                                                                                                 
  cursorState:                                                                                                                                       
   { cursorId: null,                                                                                                                                 
     cmd:                                                                                                                                            
      { find: 'mydb.exsample@web.com',                                                                                                                        
        limit: 0,                                                                                                                                    
        skip: 0,                                                                                                                                     
        query: {},                                                                                                                                   
        slaveOk: true,                                                                                                                               
        readPreference: [Object],                                                                                                                    
        fields: [Object] },                                                                                                                          
     documents: [],                                                                                                                                  
     cursorIndex: 0,                                                                                                                                 
     dead: false,                                                                                                                                    
     killed: false,                                                                                                                                  
     init: false,                                                                                                                                    
     notified: false,                                                                                                                                
     limit: 0,                                                                                                                                       
     skip: 0,                                                                                                                                        
     batchSize: 1000,                                                                                                                                
     currentLimit: 0,                                                                                                                                
     transforms: undefined },                                                                                                                        
  callbacks: null,                                                                                                                                   
  logger: { className: 'Cursor' },                                                                                                                   
  _readableState:                                                                                                                                    
   ReadableState {                                                                                                                                   
     objectMode: true,                                                                                                                               
     highWaterMark: 16,                                                                                                                              
     buffer: [],                                                                                                                                     
     length: 0,                                                                                                                                      
     pipes: null,                                                                                                                                    
     pipesCount: 0,                                                                                                                                  
     flowing: null,                                                                                                                                  
     ended: false,                                                                                                                                   
     endEmitted: false,                                                                                                                              
     reading: false,                                                                                                                                 
     sync: true,                                                                                                                                     
     needReadable: false,                                                                                                                            
     emittedReadable: false,                                                                                                                         
     readableListening: false,                                                                                                                       
     defaultEncoding: 'utf8',                                                                                                                        
     ranOut: false,                                                                                                                                  
     awaitDrain: 0,                                                                                                                                  
     readingMore: false,                                                                                                                             
     decoder: null,                                                                                                                                  
     encoding: null },                                                                                                                               
  readable: true,                                                                                                                                    
  domain: null,                                                                                                                                      
  _events: {},                                                                                                                                       
  _eventsCount: 0,                                                                                                                                   
  _maxListeners: undefined,                                                                                                                          
  s:                                                                                                                                                 
   { numberOfRetries: 5,                                                                                                                             
     tailableRetryInterval: 500,                                                                                                                     
     currentNumberOfRetries: 5,                                                                                                                      
     state: 0,                                                                                                                                       
     streamOptions: {},                                                                                                                              
     bson: {},                                                                                                                                       
     ns: 'mydb.exsample@web.com',                                                                                                                             
     cmd:                                                                                                                                            
      { find: 'mydb.exsample@web.com',                                                                                                                        
        limit: 0,                                                                                                                                    
        skip: 0,                                                                                                                                     
        query: {},                                                                                                                                   
        slaveOk: true,                                                                                                                               
        readPreference: [Object],                                                                                                                    
        fields: [Object] },                                                                                                                          
     options:                                                                                                                                        
      { skip: 0,                                                                                                                                     
        limit: 0,                                                                                                                                    
        raw: undefined,                                                                                                                              
        hint: null,                                                                                                                                  
        timeout: undefined,                                                                                                                          
        slaveOk: true,                                                                                                                               
        readPreference: [Object],                                                                                                                    
        db: [Object],                                                                                                                                
        promiseLibrary: [Function: Promise],                                                                                                         
        disconnectHandler: [Object] },                                                                                                               
     topology:                                                                                                                                       
      EventEmitter {                                                                                                                                 
        domain: null,                                                                                                                                
        _events: [Object],                                                                                                                           
        _eventsCount: 5,                                                                                                                             
        _maxListeners: undefined,                                                                                                                    
        s: [Object],                                                                                                                                 
        name: [Getter],                                                                                                                              
        bson: [Getter],                                                                                                                              
        wireProtocolHandler: [Getter],                                                                                                               
        id: [Getter] },                                                                                                                              
     topologyOptions:                                                                                                                                
      { socketOptions: {},                                                                                                                           
        auto_reconnect: true,                                                                                                                        
        host: 'localhost',                                                                                                                           
        port: 27017,                                                                                                                                 
        cursorFactory: [Object],                                                                                                                     
        reconnect: true,                                                                                                                             
        emitError: true,                                                                                                                             
        size: 5,                                                                                                                                     
        disconnectHandler: [Object],                                                                                                                 
        bson: {},                                                                                                                                    
        messageHandler: [Function],                                                                                                                  
        wireProtocolHandler: {} },                                                                                                                   
     promiseLibrary: [Function: Promise],                                                                                                            
     currentDoc: null },                                                                                                                             
  timeout: false,                                                                                                                                    
  sortValue: undefined,                                                                                                                              
  readPreference: { preference: 'primary', tags: undefined, options: undefined } }

最佳答案

您可以执行类似的操作以仅获取现有凭据。

var res = []; db.collection.find({credentials : {$exists:true}}).forEach(function(document){ res.push(document.credentials})

然后你可以回调数组: 回调(错误,恢复)

这对你有帮助吗?

关于javascript - 通过键名获取值 mongodb node.js 驱动程序,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/33470767/

相关文章:

javascript - 受到束缚的 Promise 响应

javascript - 替换文件中的标记而不写入新文件

javascript - JWT 登录 - 在中间件中未找到授权 token

MongoDB 无法启动服务器 : The default storage engine 'wiredTiger' is not available with this build of mongod

javascript - 使用nodejs和angularjs更新mongodb

javascript - 我无法将数据保存到我的 mongodb Atlas 数据库

javascript - 在选项中解析JSON响应值

javascript - 如何在 Angular JS 中使用自定义 json 数据格式创建下拉列表

javascript - Jasmine 在浏览器中传递,文件在 grunt-contrib-jasmine 中

javascript - 为什么 If then 中的这个爆炸在这里失败了