👨🏿‍🎤 🤚🏻 🔙 C ++ का उपयोग करके नोड के लिए एसिंक्रोनस मॉड्यूल लिखना 👩🏻‍🎓 🔆 🗜️

Node.js विकसित हो रहा है, और आलेखीय अनुप्रयोगों या कुछ कंसोल उपयोगिताओं और सेवाओं को लिखने के साथ प्रयोग करना पहले से ही संभव है। विकास प्रक्रिया के दौरान, कुछ प्रकार के सिस्टम कॉल का उपयोग करना आवश्यक हो सकता है, उदाहरण के लिए, WMI (WMI को नोड से सीधे एक्सेस नहीं किया जा सकता है। JMI, और WMI अनुरोध लंबे हो सकते हैं, जो इवेंट लूप को ब्लॉक कर देंगे, और, उदाहरण के लिए, यदि आपके पास वेब के माध्यम से कनेक्शन है सॉकेट्स, संचार टूट सकता है)। कई विकल्प हैं। आप एक मॉड्यूल का उपयोग कर सकते हैं (उदाहरण के लिए, नोड- ffi) और इसके साथ खेलने का प्रयास करें। अभी भी एक रास्ता है, और अधिक सटीक, एक बैसाखी। विंडोज में तथाकथित WScript (विंडोज स्क्रिप्ट होस्ट) है - यह एक विंडोज घटक है जिसे चलाने के लिए डिज़ाइन किया गया है, उदाहरण के लिए, JScript, VBScript। JScript सीधे WMI तक पहुँच सकता है, ताकि हम child_process चला सकें, जिसमें JScript काम करेगा, और इससे डेटा प्राप्त करेगा (उदाहरण के लिए, JSON और इसे एक स्ट्रिंग के रूप में भेजें), लेकिन यह एक बैसाखी, अर्थहीन और निर्दयी है। और तीसरा तरीका है देशी मॉड्यूल। मैं WMI से डेटा प्राप्त करने का तरीका नहीं बताऊंगा, लेकिन मैं कुछ कम क्षमता का वर्णन करूंगा। कौन परवाह करता है - मैं एक बिल्ली के लिए पूछता हूं।

UPD: पर्यावरण की स्थापना

मैं VS2010 को संकलित और कॉन्फ़िगर करता था।

सबसे पहले, स्रोत नोड डाउनलोड करें। जेएस, अनपैक करें और vcbuild.bat चलाएं, जो रूट में निहित है। vcbuild.bat Visual Studio और config के लिए आवश्यक प्रोजेक्ट बनाता है। काम करने के लिए बैच फ़ाइल के लिए, पायथन 2.7 की आवश्यकता है। इसके बाद, नोड-जिप को npm npm install node-gyp साथ npm install node-gyp ।

अब चलिए Visual Studio (CLR Empty Project) में एक प्रोजेक्ट बनाते हैं, प्रोजेक्ट प्रॉपर्टीज पर जाते हैं, कॉन्फ़िगरेशन प्रकार को .dll, एक्सटेंशन को .node में बदलते हैं, और CLR वातावरण के लिए समर्थन सेट करते हैं। हम निर्देशिका अनुभाग में जाते हैं, समावेश निर्देशिकाओं में निम्नलिखित फ़ोल्डर में पथ जोड़ते हैं

node-v0.8.15\deps\v8\include

node-v0.8.15\deps\uv\include

node-v0.8.15\src

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

 { "targets": [ { "target_name": "getSummAsync", "sources": [ "async.cpp" ] } ] }

अब हम संकलन कर सकते हैं। हम निर्देशिका में कंसोल में बाइंडिंग के साथ लिखते हैं। लाइन node-gyp configure और फिर node-gyp build
अब हमारा संकलित मॉड्यूल बिल्ड / रिलीज़ फ़ोल्डर में होगा

उदाहरण खुद

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

उदाहरण के लिए, हम पूर्णांक का एक सरणी पास करेंगे, इसके योग की गणना करेंगे, सकारात्मक तत्व प्राप्त करेंगे और उन्हें उपयोगकर्ता को वापस करेंगे।

शुरू करने के लिए, हम एक संरचना की घोषणा करेंगे, जिसमें, बदले में, हम उन डेटा संरचनाओं की घोषणा करेंगे जिनकी हमें आवश्यकता है।

 struct Summ_req { vector<int> numbers; vector<int> gtz; int result; Persistent<Function> callback; };

यह वेक्टर है जिसमें हम अपनी संख्याओं को संग्रहीत करेंगे।

 vector<int> numbers;

वह वेक्टर जिसमें हम संख्या को शून्य से अधिक संग्रहीत करेंगे।

 vector<int> gtz;

यहां हम रिजल्ट को स्टोर करेंगे

 int result;

यह समझना महत्वपूर्ण है कि हम वेक्टर का उपयोग क्यों करेंगे, हालांकि, ऐसा लगता है, आप मानक v8 टेम्पलेट्स के साथ प्राप्त कर सकते हैं। लेकिन ऐसा है नहीं। इसके बारे में और नीचे।

मॉड्यूल में 3 फ़ंक्शन होंगे, मुख्य जिसे हम नोड.जेएस से कॉल करते हैं, और अन्य दो, जो वास्तव में, हमारे मॉड्यूल को अतुल्यकालिक बनाते हैं।
कार्य कार्य
getSummAsync दो तर्कों, तत्वों की हमारी सरणी और कॉलबैक स्वीकार करता है। हम यह जांचते हैं कि क्या पैरामीटर जिसके साथ फ़ंक्शन कहा जाता है, सही हैं, और यदि वे सत्य हैं, तो हम उन्हें अनुकूलित करते हैं, अर्थात्, तर्कों के साथ संवाद करने में सक्षम होने के लिए, उन्हें वांछित प्रकार में परिवर्तित किया जाना चाहिए।

 Local<Function> callback = Local<Function>::Cast(args[1]); Local<Array> numbers = Local<Array>::Cast(args[0]);

अगला, हम संरचना को इनिशियलाइज़ करते हैं और अपने कॉलबैक को पास करते हैं और वेक्टर को ऐरे लिखते हैं।

 Summ_req* request = new Summ_req; request->callback = Persistent<Function>::New(callback); for (size_t i = 0; i < numbers->Length(); i++) { request->numbers.push_back(numbers->Get(i)->Int32Value()); }

लगातार करना वांछनीय है क्योंकि फिर भी, हमारे कॉलबैक का उपयोग केवल इस फ़ंक्शन में ही नहीं किया जाता है।

और हम लाइन में अपने कार्यकर्ता शुरू करते हैं।

 uv_queue_work(uv_default_loop(), req, Worker, After);

getSummAsync

 static Handle<Value> getSummAsync (const Arguments& args) { HandleScope scope; if (args.Length() < 2 || !args[0]->IsArray()) { return ThrowException(Exception::TypeError(String::New("Bad arguments"))); } if (args[1]->IsFunction()) { Local<Function> callback = Local<Function>::Cast(args[1]); Local<Array> numbers = Local<Array>::Cast(args[0]); Summ_req* request = new Summ_req; request->callback = Persistent<Function>::New(callback); for (size_t i = 0; i < numbers->Length(); i++) { request->numbers.push_back(numbers->Get(i)->Int32Value()); } uv_work_t* req = new uv_work_t(); req->data = request; uv_queue_work(uv_default_loop(), req, Worker, After); } else { return ThrowException(Exception::TypeError(String::New("Callback missing"))); } return Undefined(); }

वर्कर फंक्शन में, मुझे लगता है कि सब कुछ स्पष्ट है। हम संख्याओं की गणना करते हैं और संरचना में परिणाम लौटाते हैं। अब हम एक वेक्टर का उपयोग क्यों करते हैं, वी 8 उपकरण नहीं। वर्कर फ़ंक्शन एक अलग थ्रेड में काम करता है, और नोड.जेएस और वी 8 केवल एक धागे को जेएस निष्पादित करने की अनुमति देता है, अर्थात, आप एक अलग थ्रेड में v8 सरणी नहीं बना सकते हैं।

मज़दूर

 void Worker(uv_work_t* req) { Summ_req* request = (Summ_req*)req->data; request->result = 0; for (vector<int>::iterator it = request->numbers.begin(); it != request->numbers.end(); ++it) { request->result += *it; if (*it > 0) { request->gtz.push_back(*it); } } // request->result = request->int1 + request->int2; }

अब आफ्टर फंक्शन। वर्कर के काम करने के बाद, आफ्टर फंक्शन को कहा जाता है, जो पहले से ही डेटा को वापस कर सकता है।
यहां, और वर्कर फ़ंक्शन में नहीं, हमें परिणामी सरणी मिलती है, जिस कारण मैंने ऊपर उल्लेख किया है।

  Handle<Value> argv[2];

यहाँ हम रिटर्न वैल्यूज़ डालते हैं

  request->callback->Call(Context::GetCurrent()->Global(), 2, argv);

और हम अपने कॉलबैक को उन मापदंडों के साथ कहेंगे जो argv को लिखे गए हैं।

के बाद

 void After(uv_work_t* req) { HandleScope scope; Summ_req* request = (Summ_req*)req->data; delete req; Handle<Value> argv[2]; argv[0] = Integer::New(request->result); Local<Array> gtz = Array::New(); size_t i = 0; for (vector<int>::iterator it = request->gtz.begin(); it != request->gtz.end(); ++it) { gtz->Set(i, Integer::New(*it)); i++; } argv[1] = gtz; TryCatch try_catch; request->callback->Call(Context::GetCurrent()->Global(), 2, argv); if (try_catch.HasCaught()) { FatalException(try_catch); } request->callback.Dispose(); delete request; }

अब हम नोड-जिप उपयोगिता का उपयोग करके इसे संकलित करने के बाद, नोड से हमारे मॉड्यूल को कॉल कर सकते हैं।

 var foo = require('./getSummAsync.node') foo.getSummAsync([1,2,3,6,-5],function(a, b){ console.log(a, b); });

परिणाम

7 [ 1, 2, 3, 6 ]

यह मेरा पहला लेख है, कृपया मुझे ज्यादा डांटें नहीं।
यदि आपके कोई प्रश्न हैं, तो कृपया पूछें!
संदर्भ

C ++ का उपयोग करके नोड के लिए एसिंक्रोनस मॉड्यूल लिखना

UPD: पर्यावरण की स्थापना

उदाहरण खुद

More articles: