कॉलबैक की प्रतीक्षा में Node.js को बाहर निकलने से कैसे रोकें?

Question 1

मेरे पास इस तरह का कोड है:

var client = new mysql.Client(options);
console.log('Icanhasclient');

client.connect(function (err) {
  console.log('jannn');
  active_db = client;
  console.log(err);
  console.log('hest');

  if (callback) {
    if (err) {
      callback(err, null);
    }

    callback(null, active_db);
  }
});

मेरी समस्या यह है कि जब मैं इसे चलाता हूं तो नोड तुरंत समाप्त हो जाता है। यह 'Icanhasclient' को प्रिंट करता है, लेकिन कॉलबैक के अंदर कोई भी कंसोल नहीं है।

(इस उदाहरण में mysql नोड- mysql है ।

क्या ऐसा कुछ है जो नोड बनाने के लिए किया जा सकता है। बाहर निकलने से पहले कॉलबैक के पूरा होने की प्रतीक्षा करें?

Question 2

कॉलबैक कतारबद्ध नहीं है

नोड तब तक चलता है जब तक कि सभी ईवेंट कतार खाली न हो जाएं। कॉलबैक को इवेंट कतार में जोड़ा जाता है जब कोई कॉल जैसे

  emmiter1.on('this_event',callback).

निष्पादित किया गया है। यह कॉल मॉड्यूल डेवलपर द्वारा लिखे गए कोड का हिस्सा है।

यदि कोई मॉड्यूल सिंक्रोनस / ब्लॉकिंग संस्करण से एक त्वरित पोर्ट है, तो ऐसा नहीं हो सकता है कि ऑपरेशन का कुछ हिस्सा पूरा हो गया है और ऐसा होने से पहले सभी कतारें खाली हो सकती हैं, नोड को चुपचाप बाहर निकलने की अनुमति देता है।

यह एक डरपोक बग है, यह वह है जो मॉड्यूल डेवलपर विकास के दौरान नहीं चल सकता है, क्योंकि यह व्यस्त सिस्टम में कई कतारों के साथ कम बार होगा क्योंकि यह उन सभी के लिए दुर्लभ होगा जो महत्वपूर्ण समय पर खाली होंगे।

उपयोगकर्ता के लिए एक संभावित फिक्स / बग डिटेक्टर संदिग्ध फ़ंक्शन कॉल से पहले एक विशेष टाइमर इवेंट सम्मिलित करना है।

Question 3

आप बस एक सेट टाइमआउट जारी कर सकते हैं या सेटइंटरवल के साथ एक पुनरावृत्ति टाइमआउट कर सकते हैं।

यदि आप बाहर निकलने की स्थिति की जांच करना चाहते हैं, तो आप एक सशर्त समय-सीमा भी कर सकते हैं:

(function wait () {
   if (!SOME_EXIT_CONDITION) setTimeout(wait, 1000);
})();

इसे अपने कोड के अंत में रखें और कंसोल केवल प्रतीक्षा करेगा ... और प्रतीक्षा करें ... जब तक आप इसे बंद नहीं करना चाहते।

Question 4

मेरा समाधान एक EventEmitter को तुरंत करना था, और मेरे कस्टम इवेंट के लिए सुनना था।

var eventEmitter = new process.EventEmitter();

तब मुझे eventEmitter.emitasync कॉलबैक से कॉल किया गया:

client.connect(function (err) {
    eventEmitter.emit('myevent', {something: "Bla"})
});

मेरी स्क्रिप्ट में आखिरी चीज़ थी eventEmitter.on:

eventEmitter.on('myevent', function(myResult){
  // I needed the result to be written to stdout so that the calling process could get it
  process.stdout.write(JSON.stringify(myResult));
});

नोड तब तक प्रतीक्षा करेगा जब तक कि ईवेंट हैंडलर खत्म नहीं हो जाता।

Question 5

@ टॉड के उत्तर के आधार पर, मैंने एक-लाइनर बनाया। इसे अपनी स्क्रिप्ट की शुरुआत में शामिल करें, और सेट करें done = trueजब आप कर रहे हैं:

var done = (function wait () { if (!done) setTimeout(wait, 1000) })();

उदाहरण:

var done = (function wait () { if (!done) setTimeout(wait, 1000) })();

someAsyncOperation().then(() => {
  console.log('Good to go!');
  done = true;
});

यह कैसे काम करता है? यदि हम इसे थोड़ा बढ़ाएँ:

// Initialize the variable `done` to `undefined`
// Create the function wait, which is available inside itself
// Note: `var` is hoisted but `let` is not so we need to use `var`
var done = (function wait () {

  // As long as it's nor marked as done, create a new event+queue
  if (!done) setTimeout(wait, 1000);

  // No return value; done will resolve to false (undefined)
})();

Question 6

यहाँ मेरे दो सेंट हैं:

async function main()
{
    await new Promise(function () {});
    console.log('This text will never be printed');
}

function panic(error)
{
    console.error(error);
    process.exit(1);
}

// https://stackoverflow.com/a/46916601/1478566
main().catch(panic).finally(clearInterval.bind(null, setInterval(a=>a, 1E9)));

Question 7

यहाँ है कि मैं यह कैसे करते हैं। मैं अपना मुख्य प्रविष्टि बिंदु एक वादा वापस करता हूं, फिर मैं यह सुनिश्चित करने के लिए इस छोटे आवरण का उपयोग करता हूं कि जब तक वह वादा निपट नहीं जाता है, नोड नहीं होगा:

function wrapPromiseMain(entryPoint) {
    const pollTime = 1000000;
    let interval = setInterval(() => {}, pollTime);
    
    return entryPoint().finally(() => {clearInterval(interval)});
}

इसका उपयोग करने के लिए, बस अपने मुख्य प्रवेश बिंदु का वादा करें और इसे आवरण के तर्क के रूप में पास करें:

function main() {

    // ... main stuff ...

    return doSomethingAsync();
}

wrapPromiseMain(main);

मुझे यह मूल मतदान छोरों की तुलना में थोड़ा सा कठिन लगता है क्योंकि यह वादा पूरा होने पर टाइमर को स्वतः रद्द कर देगा, इसलिए इसमें कोई अतिरिक्त विलंबता नहीं है। इसलिए मतदान का समय मूल रूप से हमेशा के लिए हो सकता है यदि आप इसे चाहते हैं।

Question 8

मैंने felixge / node-mysql लाइब्रेरी को देखा और कमांड क्लाइंट का संदर्भ नहीं देखा। API में कनेक्ट करें। क्या यह वास्तविक कॉल है जिसे आप बनाने की कोशिश कर रहे हैं (यहां नाइटपिक होने की कोशिश नहीं कर रहे हैं)? भले ही, IMHO आपको इस बारे में अधिक सोचने की ज़रूरत है कि जावास्क्रिप्ट कैसे डिज़ाइन किया गया है, क्योंकि यह अन्य अन्य लोकप्रिय भाषाओं की तुलना में अलग प्रोग्रामिंग प्रतिमान का उपयोग करता है।

आपके कोड में पहला मुद्दा यह है कि आपने कॉलबैक को परिभाषित नहीं किया है, इसलिए यह वास्तव में मौजूद नहीं है। मुझे लगता है कि कंसोल.लॉग (कॉलबैक) अपरिभाषित है। आपके कोड से, अनाम फ़ंक्शन क्लाइंट.कनेक्ट फ़ंक्शन के लिए 'कॉलबैक' है। आपको यह परिभाषित करना होगा कि आप किस 'कॉलबैक' को उच्च दायरे में बुला रहे हैं। उदाहरण के लिए, मैं एक फ़ंक्शन myCallback को क्लाइंट से अधिक के दायरे में मौजूद होने के लिए परिभाषित करूंगा। अनाम फ़ंक्शन को गुमनाम करें। यह जावास्क्रिप्ट चर चर देखने के लिए उपयोगी हो सकता है ।

    var myCallback(err, response) {
      if (err) {
        console.log('err:%s',err);
      } else {
        console.log('response:%s',response);
      }
    }

    client.connect(err, function(response) {
      // this anonymous function is the callback to client.connect, the var
      // 'callback' would be undefined.
      if (err) {
        myCallback(err);
        return; // Explicit call to return, else the lines below would run.
      } 
      myCallback(null, response);
    });

दूसरा, यदि आप स्पष्ट रूप से जावास्क्रिप्ट के भीतर रिटर्न नहीं कहते हैं, तो फ़ंक्शन जारी रहेगा। मैं खुद इस बात से कन्नी काट गया । अंत में, जावास्क्रिप्ट एक ईवेंट-चालित लूप चलाता है जिसका अर्थ है कि यह मानों को वापस करने के लिए फ़ंक्शंस का कभी इंतजार नहीं करेगा, यही वजह है कि हमारे पास ये सभी कॉलबैक पहले स्थान पर हैं। आप जावास्क्रिप्ट को अलग तरह से व्यवहार करने के लिए मजबूर कर सकते हैं, उदाहरण के लिए जब तक कि एक शर्त सही न हो तब तक लूप का उपयोग करके। इवेंट लूप में हेरफेर करने की विभिन्न रणनीतियों के लिए, caolan द्वारा 'async' लाइब्रेरी देखें । इन तरीकों को अति प्रयोग करने का प्रमुख नुकसान यह है कि वास्तव में सीपीयू चक्रों को अवरुद्ध करना / अवरुद्ध करना जब आपको संभवतः अधिक कॉलबैक का उपयोग करना चाहिए और बस फिर से सोचना चाहिए कि आपके प्रोग्राम कैसे काम करते हैं।

Question 9

कृपया यह प्रयास करें। अगर यह मदद की जाँच करें।

var client = new mysql.Client(options);
console.log('Icanhasclient');
var verbose;

if (!verbose) {
    return new Promise(function (resolve, reject) {
        client.connect(function (err) {
            if (err) {
                console.log(Error in connecting
                SQL ${err}
            )
                ;
                return reject(err);
            }
            verbose = client;
            return resolve(verbose);
        })
    })
} else {
    return new Promise(function (resolve) {
        resolve(verbose);
    })
}