nodejs redis क्यू वादे, यह कैसे काम करने के लिए?

Question

मैं रेडिस से कुछ मूल्य प्राप्त करने की कोशिश कर रहा हूं, उन्हें गठबंधन करता हूं और अंततः भेजता हूं। लेकिन मैं सिर्फ उन वादों को काम नहीं कर सकता।

इस से redis

client.get('user:1:id',function(err,data){ 
    // here I have data which contains user ID 
}); 
client.get('user:1:username',function(err,data){ 
    // here I have data which contains username 
}); 

अब मैं ID और username हो और उन्हें भेजना चाहते सरल get कार्यों है, लेकिन मैं कैसे कि काम करने के लिए पता नहीं है। मैं इसे कॉलबैक के साथ काम करने के लिए प्रबंधन, लेकिन यह बहुत गंदा परिणाम है, इसलिए तो मैं Q.fcall में अनाम प्रक्रियाएं रैप करने के लिए कोशिश की और कॉल .then के बाद जो कि

client.get('user:1:id',Q.fcall(function(err,data){ 
    return data; 
}).then(function(val) { 
    // do something 
})); 

तरह दिखता है, लेकिन है कि मुझे भी कई तर्क के लिए त्रुटि देता है पारित किया गया है और मुझे यह भी यकीन नहीं है कि अगर यह काम करेगा तो वह मेरी मदद करेगा।

Answer 1

Q.all([Q.ninvoke(client, 'get', 'user:1:id'), 
     Q.ninvoke(client, 'get', 'user:1:username')]).then(function (data) { 
    var id = data[0]; 
    var username = data[1]; 
    // do something with them 
}); 

देखें https://github.com/kriskowal/q#adapting-node

Answer 2

मैं नोड redis और एक को उठा लिया redis आवरण बनाने के लिए whenjs का उपयोग कर एक सरल RequireJS मॉड्यूल का उपयोग:

define [ 
    'redis/lib/commands' 
    'when' 
    'when/node/function' 
], (Commands, When, NodeFn) -> 
    'use strict' 

    lift = (redis) -> 
    wrapped = {} 
    Commands.map (cmd) -> 
     wrapped[cmd] = (args...) -> 
     def = When.defer() 
     args.push NodeFn.createCallback def.resolver 
     redis[cmd].apply redis, args 
     def.promise 
    wrapped 

    {lift} 

प्रयोग सीधा है:

client = lift redis.createClient() 
client.get("hello").then console.log, console.error 

Answer 3

वादा, Bluebird और node_redis का उपयोग करना:

import { RedisClient, createClient, ClientOpts } from "redis"; 
import { promisifyAll, PromisifyAllOptions } from "bluebird"; 


export module FMC_Redis { 

    export class Redis { 
     opt: ClientOpts; 
     private rc: RedisClient; 
     private rcPromise: any; 

     private static _instance: Redis = null; 
     public static current(_opt?: ClientOpts): Redis { 

      if (!Redis._instance) { 
       Redis._instance = new Redis(_opt); 
       Redis._instance.redisConnect(); 
      } 
      return Redis._instance; 
     } 

     public get client(): RedisClient { 
      if (!this.rc.connected) throw new Error("There is no connection to Redis DB!"); 
      return this.rc; 
     } 

     /******* BLUEBIRD ********/ 
     public get clientAsync(): any { 
      // promisifyAll functions of redisClient 
      // creating new redis client object which contains xxxAsync(..) functions. 
      return this.rcPromise = promisifyAll(this.client); 
     } 

     private constructor(_opt?: ClientOpts) { 
      if (Redis._instance) return; 

      this.opt = _opt 
       ? _opt 
       : { 
        host: "127.0.0.1", 
        port: 6379, 
        db: "0" 
       }; 
     } 

     public redisConnect(): void { 
      this.rc = createClient(this.opt); 
      this.rc 
       .on("ready", this.onReady) 
       .on("end", this.onEnd) 
       .on("error", this.onError); 
     } 

     private onReady(): void { console.log("Redis connection was successfully established." + arguments); } 
     private onEnd(): void { console.warn("Redis connection was closed."); } 
     private onError(err: any): void { console.error("There is an error: " + err); } 


     /****** PROMISE *********/ 
     // promise redis test 
     public getRegularPromise() { 
      let rc = this.client; 
      return new Promise(function (res, rej) { 
       console.warn("> getKeyPromise() ::"); 
       rc.get("cem", function (err, val) { 
        console.log("DB Response OK."); 
        // if DB generated error: 
        if (err) rej(err); 
        // DB generated result: 
        else res(val); 
       }); 
      }); 
     } 


     /******* ASYNC - AWAIT *******/ 
     // async - await test function 
     public delay(ms) { 
      return new Promise<string>((fnResolve, fnReject) => { 
       setTimeout(fnResolve("> delay(" + ms + ") > successfull result"), ms); 
      }); 
     } 

     public async delayTest() { 
      console.log("\n****** delayTest ") 
      let a = this.delay(500).then(a => console.log("\t" + a)); 

      let b = await this.delay(400); 
      console.log("\tb::: " + b); 
     } 

     // async - await function 
     public async getKey(key: string) { 
      let reply = await this.clientAsync.getAsync("cem"); 
      return reply.toString(); 
     } 
    } 
} 

let a = FMC_Redis.Redis.current(); 
// setTimeout(function() { 
//  console.warn(a.client.set("cem", "naber")); 
//  console.warn(a.client.get("cem")); 
//  console.warn(a.client.keys("cem")); 
// }, 1000); 

/***** async await test client *****/ 
a.delayTest(); 


/** Standart Redis Client test client */ 
setTimeout(function() { 
    a.client.get("cem", function (err, val) { 
     console.log("\n****** Standart Redis Client") 
     if (err) console.error("\tError: " + err); 
     else console.log("\tValue ::" + val); 
    }); 
}, 100) 

/***** Using regular Promise with Redis Client > test client *****/ 
setTimeout(function() { 
    a.getRegularPromise().then(function (v) { 
     console.log("\n***** Regular Promise with Redis Client") 
     console.log("\t> Then ::" + v); 
    }).catch(function (e) { 
     console.error("\t> Catch ::" + e); 
    }); 
}, 100); 

/***** Using bluebird promisify with Redis Client > test client *****/ 
setTimeout(function() { 
    var header = "\n***** bluebird promisify with Redis Client"; 
    a.clientAsync.getAsync("cem").then(result => console.log(header + result)).catch(console.error); 
}, 100);