Node.js गाइड, भाग 10: मानक मॉड्यूल, स्ट्रीम, डेटाबेस, NODE_ENV

यह सामग्री Node.js. मैन्युअल अनुवाद श्रृंखला का समापन करती है। आज हम ओएस, घटनाओं और http मॉड्यूल के बारे में बात करेंगे, धाराओं और डेटाबेस के साथ काम करने पर चर्चा करेंगे, और अनुप्रयोग विकास और उत्पादन में Node.js के उपयोग पर चर्चा करेंगे।

Node.js ओएस मॉड्यूल

os मॉड्यूल कई कार्यों तक पहुंच प्रदान करता है जिनका उपयोग ऑपरेटिंग सिस्टम और कंप्यूटर के हार्डवेयर के बारे में जानकारी प्राप्त करने के लिए किया जा सकता है। यह एक मानक मॉड्यूल है, आपको इसे कोड से काम करने के लिए इसे स्थापित करने की आवश्यकता नहीं है, बस इसे कनेक्ट करें:

 const os = require('os') 

यहां कई उपयोगी गुण हैं, जो विशेष रूप से, फाइलों के साथ काम करते समय काम में आ सकते हैं।

तो, os.EOL संपत्ति os.EOL सिस्टम में प्रयुक्त लाइन विभाजक (एक लाइन os.EOL ) का पता लगाने की अनुमति देती है। लिनक्स और मैकओएस पर, यह विंडोज पर \n , \r\n ।

यह ध्यान दिया जाना चाहिए कि जब हम यहां "लिनक्स और macOS" का उल्लेख करते हैं, तो हम POSIX- संगत प्लेटफार्मों के बारे में बात कर रहे हैं। संक्षिप्तता के लिए, हम यहां कम लोकप्रिय प्लेटफार्मों का उल्लेख नहीं करते हैं।

os.constants.signals प्रॉपर्टी, SIGKILL , जैसे सिग्नल, SIGKILL , और इतने पर प्रोसेस करने के लिए उपयोग किए जाने वाले स्थिरांक के बारे में जानकारी देती है। यहां आप उनके बारे में विवरण पा सकते हैं।

os.constants.errno संपत्ति में त्रुटि संदेशों के लिए उपयोग किए जाने वाले स्थिरांक शामिल हैं - जैसे EADDRINUSE , EOVERFLOW ।

अब os मॉड्यूल के मुख्य तरीकों पर विचार करें।

▍os.arch ()

यह विधि सिस्टम की वास्तुकला की पहचान करते हुए एक स्ट्रिंग लौटाती है, उदाहरण के लिए, arm , x64 , arm64 ।

▍os.cpus ()

सिस्टम में उपलब्ध प्रोसेसर के बारे में जानकारी देता है। उदाहरण के लिए, यह जानकारी इस तरह दिख सकती है:

 [ { model: 'Intel(R) Core(TM)2 Duo CPU     P8600 @ 2.40GHz',   speed: 2400,   times:    { user: 281685380,      nice: 0,      sys: 187986530,      idle: 685833750,      irq: 0 } }, { model: 'Intel(R) Core(TM)2 Duo CPU     P8600 @ 2.40GHz',   speed: 2400,   times:    { user: 282348700,      nice: 0,      sys: 161800480,      idle: 703509470,      irq: 0 } } ] 

▍os.endianness ()

बी.ई.ई. या LE अनुसार जो बाइट ऑर्डर (बिग एंगियन या लिटिल एंडियन) पर निर्भर करता है, का उपयोग Node.s.s.s.f फ़ाइल को संकलित करने के लिए किया गया था।

▍os.freemem ()

बाइट्स में मुफ्त सिस्टम मेमोरी की मात्रा देता है।

Omos.homedir ()

वर्तमान उपयोगकर्ता की होम निर्देशिका के लिए पथ देता है। उदाहरण के लिए, '/Users/flavio' ।

▍os.hostname ()

मेजबान नाम लौटाता है।

▍os.loadavg ()

एक सरणी में, ऑपरेटिंग सिस्टम द्वारा गणना की गई औसत लोड डेटा। यह जानकारी केवल लिनक्स और macOS पर समझ में आती है। यह इस तरह दिख सकता है:

 [ 3.68798828125, 4.00244140625, 11.1181640625 ] 

▍os.networkInterfaces ()

सिस्टम पर उपलब्ध नेटवर्क इंटरफेस के बारे में जानकारी देता है। उदाहरण के लिए:

 { lo0:  [ { address: '127.0.0.1',      netmask: '255.0.0.0',      family: 'IPv4',      mac: 'fe:82:00:00:00:00',      internal: true },    { address: '::1',      netmask: 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff',      family: 'IPv6',      mac: 'fe:82:00:00:00:00',      scopeid: 0,      internal: true },    { address: 'fe80::1',      netmask: 'ffff:ffff:ffff:ffff::',      family: 'IPv6',      mac: 'fe:82:00:00:00:00',      scopeid: 1,      internal: true } ], en1:  [ { address: 'fe82::9b:8282:d7e6:496e',      netmask: 'ffff:ffff:ffff:ffff::',      family: 'IPv6',      mac: '06:00:00:02:0e:00',      scopeid: 5,      internal: false },    { address: '192.168.1.38',      netmask: '255.255.255.0',      family: 'IPv4',      mac: '06:00:00:02:0e:00',      internal: false } ], utun0:  [ { address: 'fe80::2513:72bc:f405:61d0',      netmask: 'ffff:ffff:ffff:ffff::',      family: 'IPv6',      mac: 'fe:80:00:20:00:00',      scopeid: 8,      internal: false } ] } 

▍os.platform ()

उस मंच के बारे में जानकारी देता है जिसके लिए Node.js. को संकलित किया गया था। यहाँ कुछ संभावित रिटर्न मान दिए गए हैं:

• डार्विन
• FreeBSD
• linux
• OpenBSD
• Win32

▍os.release ()

ऑपरेटिंग सिस्टम की रिलीज़ संख्या की पहचान करने वाला एक स्ट्रिंग लौटाता है।

▍os.tmpdir ()

अस्थायी फ़ाइलों को संग्रहीत करने के लिए सिस्टम में निर्दिष्ट निर्देशिका का पथ देता है।

▍os.totalmem ()

बाइट्स में सिस्टम मेमोरी की कुल राशि लौटाता है।

▍os.type ()

ऑपरेटिंग सिस्टम की पहचान करने वाली जानकारी लौटाता है। उदाहरण के लिए:

• Linux - लिनक्स।
• Darwin - macOS।
• Windows_NT - विंडोज़।

▍os.uptime ()

अंतिम रिबूट के बाद से सेकंड में सिस्टम अपटाइम लौटाता है।

Node.js ईवेंट मॉड्यूल

events मॉड्यूल हमें EventEmitter क्लास प्रदान करता है, जिसे Node.js प्लेटफ़ॉर्म पर ईवेंट के साथ काम करने के लिए डिज़ाइन किया गया है। हमने पहले से ही सामग्री की इस श्रृंखला के सातवें हिस्से में इस मॉड्यूल के बारे में थोड़ी बात की। यहाँ इसके लिए प्रलेखन है। यहां हम इस मॉड्यूल के एपीआई को देखते हैं। याद रखें कि कोड में इसका उपयोग करने के लिए आपको इसे कनेक्ट करने की आवश्यकता है, जैसा कि आमतौर पर मानक मॉड्यूल के साथ होता है। उसके बाद, आपको एक नया EventEmitter ऑब्जेक्ट बनाने की आवश्यकता है। यह इस तरह दिखता है:

 const EventEmitter = require('events') const door = new EventEmitter() 

EventEmitter वर्ग की वस्तु मानक तंत्र का उपयोग करती है, विशेष रूप से, निम्नलिखित घटनाएँ:

• newListener - इस घटना को newListener जब एक घटना हैंडलर जोड़ा जाता है।
• removeListener - बुलाया जब हैंडलर हटा दिया जाता है।

EventEmitter वर्ग की वस्तुओं के सबसे उपयोगी तरीकों पर विचार करें (तरीकों के नाम में एक समान वस्तु को emitter रूप में इंगित किया गया है)।

▍emitter.addListener ()

emitter.on() विधि के लिए एक उपनाम।

▍emitter.emit ()

एक घटना उत्पन्न करता है। सभी ईवेंट हैंडलर को उस क्रम में सिंक्रोनाइज़ करता है जिस क्रम में वे पंजीकृत थे।

▍emitter.eventNames ()

एक सरणी लौटाता है जिसमें पंजीकृत घटनाएँ होती हैं।

▍emitter.getMaxListeners ()

EventEmitter वर्ग के ऑब्जेक्ट में जोड़े जा सकने वाले हैंडलर की अधिकतम संख्या लौटाता है। डिफ़ॉल्ट 10 है। यदि आवश्यक हो, तो इस पैरामीटर को setMaxListeners() पद्धति का उपयोग करके बढ़ाया या घटाया जा सकता है।

▍emitter.listenerCount ()

उस ईवेंट हैंडलर की संख्या लौटाता है, जिसका नाम इस विधि में एक पैरामीटर के रूप में दिया गया है:

 door.listenerCount('open') 

▍emitter.listeners ()

संबंधित इवेंट के लिए इवेंट हैंडलर की एक सरणी लौटाता है, जिसका नाम इस विधि में दिया गया है:

 door.listeners('open') 

▍emitter.off ()

emitter.removeListener() 10 में शुरू की गई emitter.removeListener() विधि के लिए एक उपनाम।

▍emitter.on ()

एक कॉलबैक रजिस्टर करें जो एक घटना उत्पन्न होने पर कहा जाता है। इसका उपयोग कैसे करें:

 door.on('open', () => { console.log('Door was opened') }) 

▍emitter.once ()

यह एक कॉलबैक को पंजीकृत करता है जिसे केवल एक बार कहा जाता है - किसी घटना की पहली घटना पर जिसके लिए यह कॉलबैक पंजीकृत है। उदाहरण के लिए:

 const EventEmitter = require('events') const ee = new EventEmitter() ee.once('my-event', () => { //         }) 

▍emitter.prependListener ()

on() या addListener() विधियों का उपयोग करके एक हैंडलर को पंजीकृत करते समय, इस हैंडलर को हैंडलर कतार के अंत में जोड़ा जाता है और इसे संबंधित ईवेंट को संभालने के लिए अंतिम कहा जाता है। prependListener() विधि का उपयोग करते prependListener() , हैंडलर को कतार के सामने जोड़ा जाता है, जिसके कारण इसे घटना को संसाधित करने के लिए पहले बुलाया जाता है।

▍emitter.prependOnceListener ()

यह विधि पिछले एक के समान है। अर्थात्, जब एक कॉल के लिए इच्छित हैंडलर को एक once() विधि का उपयोग करके पंजीकृत किया जाता है, तो यह हैंडलर की कतार में अंतिम और अंतिम कहा जाता है। prependOnceListener() विधि आपको कतार के सामने इस तरह के हैंडलर को जोड़ने की अनुमति देती है।

▍emitter.removeAllListeners ()

यह विधि संबंधित ऑब्जेक्ट में पंजीकृत किसी दिए गए ईवेंट के लिए सभी हैंडलर को हटा देती है। वे इसे इस तरह उपयोग करते हैं:

 door.removeAllListeners('open') 

▍emitter.removeListener ()

निर्दिष्ट हैंडलर को इस विधि में पारित किया जाना हटाता है। हैंडलर को बाद में हटाने के लिए सहेजने के लिए, संबंधित कॉलबैक को एक चर में सौंपा जा सकता है। यह इस तरह दिखता है:

 const doSomething = () => {} door.on('open', doSomething) door.removeListener('open', doSomething) 

▍emitter.setMaxListeners ()

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

 door.setMaxListeners(50) 

Node.js http मॉड्यूल

सामग्री की इस श्रृंखला के आठवें भाग में, हमने पहले ही मानक Node.js http मॉड्यूल के बारे में बात की है। वह HTTP सर्वर बनाने के लिए डिज़ाइन किए गए डेवलपर तंत्र के निपटान में डालता है। यह Node.js. में नेटवर्क पर डेटा विनिमय की समस्याओं को हल करने के लिए उपयोग किया जाने वाला मुख्य मॉड्यूल है आप इसे इस तरह से कोड में कनेक्ट कर सकते हैं:

 const http = require('http') 

इसमें गुण, विधियाँ और वर्ग शामिल हैं। आइए उनके बारे में बात करते हैं।

▍Svoystva

http.METHODS

यह गुण सभी समर्थित HTTP विधियों को सूचीबद्ध करता है:

 > require('http').METHODS [ 'ACL', 'BIND', 'CHECKOUT', 'CONNECT', 'COPY', 'DELETE', 'GET', 'HEAD', 'LINK', 'LOCK', 'M-SEARCH', 'MERGE', 'MKACTIVITY', 'MKCALENDAR', 'MKCOL', 'MOVE', 'NOTIFY', 'OPTIONS', 'PATCH', 'POST', 'PROPFIND', 'PROPPATCH', 'PURGE', 'PUT', 'REBIND', 'REPORT', 'SEARCH', 'SUBSCRIBE', 'TRACE', 'UNBIND', 'UNLINK', 'UNLOCK', 'UNSUBSCRIBE' ] 

http.STATUS_CODES

इसमें HTTP स्टेटस कोड और उनके विवरण शामिल हैं:

 > require('http').STATUS_CODES { '100': 'Continue', '101': 'Switching Protocols', '102': 'Processing', '200': 'OK', '201': 'Created', '202': 'Accepted', '203': 'Non-Authoritative Information', '204': 'No Content', '205': 'Reset Content', '206': 'Partial Content', '207': 'Multi-Status', '208': 'Already Reported', '226': 'IM Used', '300': 'Multiple Choices', '301': 'Moved Permanently', '302': 'Found', '303': 'See Other', '304': 'Not Modified', '305': 'Use Proxy', '307': 'Temporary Redirect', '308': 'Permanent Redirect', '400': 'Bad Request', '401': 'Unauthorized', '402': 'Payment Required', '403': 'Forbidden', '404': 'Not Found', '405': 'Method Not Allowed', '406': 'Not Acceptable', '407': 'Proxy Authentication Required', '408': 'Request Timeout', '409': 'Conflict', '410': 'Gone', '411': 'Length Required', '412': 'Precondition Failed', '413': 'Payload Too Large', '414': 'URI Too Long', '415': 'Unsupported Media Type', '416': 'Range Not Satisfiable', '417': 'Expectation Failed', '418': 'I\'ma teapot', '421': 'Misdirected Request', '422': 'Unprocessable Entity', '423': 'Locked', '424': 'Failed Dependency', '425': 'Unordered Collection', '426': 'Upgrade Required', '428': 'Precondition Required', '429': 'Too Many Requests', '431': 'Request Header Fields Too Large', '451': 'Unavailable For Legal Reasons', '500': 'Internal Server Error', '501': 'Not Implemented', '502': 'Bad Gateway', '503': 'Service Unavailable', '504': 'Gateway Timeout', '505': 'HTTP Version Not Supported', '506': 'Variant Also Negotiates', '507': 'Insufficient Storage', '508': 'Loop Detected', '509': 'Bandwidth Limit Exceeded', '510': 'Not Extended', '511': 'Network Authentication Required' } 

http.globalAgent

यह संपत्ति http.Agent वर्ग के वैश्विक उदाहरण की ओर http.Agent । इसका उपयोग कनेक्शन प्रबंधित करने के लिए किया जाता है। इसे Node.js. HTTP सबसिस्टम का एक प्रमुख घटक माना जा सकता है। हम नीचे http.Agent के वर्ग के बारे में अधिक बात करेंगे।

▍Metody

http.createServer ()

http.Server वर्ग का एक नया उदाहरण देता है। HTTP सर्वर बनाने के लिए इस विधि का उपयोग कैसे करें:

 const server = http.createServer((req, res) => { //      }) 

http.request ()

आपको http.ClientRequest वर्ग का एक उदाहरण बनाकर सर्वर से HTTP अनुरोध करने की अनुमति देता है।

http.get ()

यह विधि http.request() समान है, लेकिन यह स्वचालित रूप से HTTP विधि को GET सेट करता है और स्वचालित रूप से req.end() कमांड को कॉल करता है।

▍ कक्षाएं

HTTP मॉड्यूल 5 क्लासेस प्रदान करता है - Agent , ClientRequest , Server , ServerResponse और ServerResponse । उन पर विचार करें।

http.Agent

Node.js द्वारा बनाई गई http.Agent वर्ग के वैश्विक उदाहरण का उपयोग कनेक्शन प्रबंधित करने के लिए किया जाता है। यह सभी HTTP अनुरोधों के लिए डिफ़ॉल्ट मान के रूप में उपयोग किया जाता है और सॉकेट्स की कतार और पुन: उपयोग प्रदान करता है। इसके अलावा, यह एक सॉकेट पूल का समर्थन करता है, जो Node.js. नेटवर्क सबसिस्टम के उच्च प्रदर्शन की अनुमति देता है। यदि आवश्यक हो, तो आप अपनी खुद की http.Agent ऑब्जेक्ट बना सकते हैं।

http.ClientRequest

http.ClientRequest वर्ग का एक ऑब्जेक्ट, जो एक चल रहा अनुरोध है, जब http.request() या http.get() विधियों को बुलाया जाता है। जब किसी अनुरोध की प्रतिक्रिया प्राप्त होती है, तो प्रतिक्रिया घटना उठाई जाती है, जिसमें प्रतिक्रिया प्रसारित होती है - http.IncomingMessage का एक उदाहरण। क्वेरी पूरा होने के बाद प्राप्त डेटा को दो तरीकों से संसाधित किया जा सकता है:

• आप response.read() विधि को कॉल कर सकते हैं।
• response ईवेंट हैंडलर में, आप data ईवेंट के लिए एक श्रोता को कॉन्फ़िगर कर सकते हैं, जो आपको स्ट्रीमिंग डेटा के साथ काम करने की अनुमति देता है।

http.Server

इस श्रेणी के उदाहरणों का उपयोग http.createServer() कमांड का उपयोग करके सर्वर बनाने के लिए किया जाता है। सर्वर ऑब्जेक्ट होने के बाद, हम इसके तरीकों का उपयोग कर सकते हैं:

• सर्वर को शुरू करने और आने वाले अनुरोधों की प्रतीक्षा और प्रसंस्करण को व्यवस्थित करने के लिए listen() विधि का उपयोग किया जाता है।
• close() विधि सर्वर को रोकती है।

http.ServerResponse

यह ऑब्जेक्ट http.Server वर्ग द्वारा बनाया गया है और http.Server होने पर request इवेंट के दूसरे पैरामीटर के रूप में पारित किया गया है। आमतौर पर, इस तरह की वस्तुओं को कोड में नाम res सौंपा जाता है:

 const server = http.createServer((req, res) => { //res -   http.ServerResponse }) 

ऐसे हैंडलर में, क्लाइंट को भेजे जाने के लिए सर्वर रिस्पॉन्स तैयार होने के बाद, end() विधि को कहा जाता है, जो प्रतिक्रिया को पूरा करता है। प्रत्येक प्रतिक्रिया के पूरा होने के बाद इस विधि को बुलाया जाना चाहिए।

यहाँ HTTP हेडर के साथ काम करने के लिए उपयोग की जाने वाली विधियाँ हैं:

• getHeaderNames() - स्थापित हेडर के नामों की सूची देता है।
• getHeaders() - सेट HTTP हेडर की एक प्रति लौटाता है।
• setHeader('headername', value) - निर्दिष्ट शीर्ष लेख के लिए मान सेट करता है।
• getHeader('headername') शीर्ष लेख getHeader('headername') - सेट शीर्ष लेख लौटाता है।
• removeHeader('headername') शीर्ष लेख removeHeader('headername') - स्थापित शीर्ष लेख को हटाता है।
• hasHeader('headername') - प्रतिक्रिया true यदि प्रतिक्रिया में पहले से ही एक शीर्षक है जिसका नाम इस पद्धति से पारित हो गया है।
• headersSent() - हेडर पहले ही क्लाइंट को भेजे जाने पर सही है।

हेडर को संसाधित करने के बाद, उन्हें क्लाइंट को response.writeHead() विधि से कॉल करके भेजा जा सकता है, जो पहले पैरामीटर के रूप में, एक स्थिति कोड लेता है। दूसरे और तीसरे पैरामीटर के रूप में, स्थिति कोड और हेडर के अनुरूप एक संदेश को इसमें पारित किया जा सकता है।

क्लाइंट को डेटा भेजने के लिए, प्रतिक्रिया बॉडी में write() विधि का उपयोग किया जाता है। यह HTTP प्रतिसाद स्ट्रीम में बफ़र्ड डेटा भेजता है।

यदि शीर्ष लेख अभी तक response.writeHead() साथ सेट नहीं किए गए हैं। response.writeHead() कमांड, स्थिति कोड के साथ हेडर और अनुरोध में निर्दिष्ट संदेश पहले भेजा जाएगा। आप statusCode और statusMessage लिए मान सेट करके उनके मान सेट कर सकते statusMessage :

 response.statusCode = 500 response.statusMessage = 'Internal Server Error' 

http.IncomingMessage

http.IncomingMessage वर्ग की एक वस्तु निम्नलिखित तंत्रों के पाठ्यक्रम में बनाई गई है:

• http.Server - request घटना को संसाधित करते समय।
• http.ClientRequest - response घटना को संभालते समय।

इसका उपयोग प्रतिक्रिया डेटा के साथ काम करने के लिए किया जा सकता है। अर्थात्:

• प्रतिक्रिया स्थिति कोड और संबंधित संदेश का पता लगाने के लिए, statusCode और statusMessage गुणों का उपयोग किया जाता है।
• आप headers या rawHearders (कच्चे हेडर की सूची के लिए) rawHearders प्रतिक्रिया headers देख सकते हैं।
• आप method गुण का उपयोग करके अनुरोध विधि का पता लगा सकते हैं।
• यह पता लगाने के लिए कि HTTP के किस संस्करण का उपयोग किया जा रहा है, httpVersion संपत्ति का उपयोग करें।
• URL प्राप्त करने के लिए, url प्रॉपर्टी का इरादा है।
• socket गुण आपको net.Socket से कनेक्ट करने की अनुमति देता है। कनेक्शन के साथ जुड़ा हुआ net.Socket ऑब्जेक्ट।

प्रतिक्रिया डेटा http.IncomingMessage बाद से एक स्ट्रीम के रूप में प्रस्तुत किया जाता है। http.IncomingMessage वाली http.IncomingMessage ऑब्जेक्ट Readable Stream इंटरफ़ेस को लागू करता है।

Node.js में धाराओं के साथ काम करें

थ्रेड्स मूल अवधारणाओं में से एक हैं जिनका उपयोग Node.js अनुप्रयोगों में किया जाता है। धाराएँ ऐसे उपकरण हैं जो आपको फ़ाइलों को पढ़ने और लिखने की अनुमति देते हैं, सिस्टम के बीच नेटवर्क इंटरैक्शन को व्यवस्थित करते हैं, और सामान्य रूप से, प्रभावी रूप से डेटा विनिमय कार्यों को लागू करते हैं।

धागे की अवधारणा Node.js. के लिए अद्वितीय नहीं है वे दशकों पहले ओएस के यूनिक्स परिवार पर दिखाई दिए। विशेष रूप से, कार्यक्रम एक-दूसरे के साथ बातचीत कर सकते हैं, पाइपलाइनों का उपयोग करके डेटा धाराओं को प्रसारित कर सकते हैं (पाइप चरित्र का उपयोग - - | )।

यदि हम कल्पना करते हैं, कहते हैं, स्ट्रीम का उपयोग किए बिना किसी फ़ाइल को पढ़ना, तो, इसी कमांड के निष्पादन के दौरान, फ़ाइल की सामग्री को पूरी तरह से मेमोरी में पढ़ा जाएगा, जिसके बाद इन सामग्रियों के साथ काम करना संभव होगा।

प्रवाह तंत्र के उपयोग के लिए धन्यवाद, फ़ाइलों को भागों में पढ़ा और संसाधित किया जा सकता है, जो स्मृति में बड़ी मात्रा में डेटा संग्रहीत करने की आवश्यकता को समाप्त करता है।

Node.js स्ट्रीम मॉड्यूल वह नींव है जिस पर स्ट्रीमिंग का समर्थन करने वाले सभी API बनाए जाते हैं।

धाराओं का उपयोग करने के बारे में StrengthAbout ताकत

डेटा प्रोसेसिंग के अन्य तरीकों की तुलना में धाराएँ, निम्नलिखित फायदे हैं:

• स्मृति का कुशल उपयोग। एक स्ट्रीम के साथ काम करने से पहले से लोड की गई बड़ी मात्रा में मेमोरी में मेमोरी नहीं होती है, इससे पहले कि उन्हें प्रोसेस करना संभव हो जाए।
• समय की बचत। स्ट्रीम से प्राप्त डेटा को बहुत तेजी से संसाधित किया जा सकता है जब आपको उन्हें संसाधित करने के लिए पूरी तरह से लोड होने के लिए इंतजार करना पड़ता है।

Reams धाराओं के साथ काम का उदाहरण

धाराओं के साथ काम करने का एक पारंपरिक उदाहरण डिस्क से एक फ़ाइल पढ़ने को दर्शाता है।

पहले, उस कोड पर विचार करें जिसमें थ्रेड्स का उपयोग नहीं किया गया है। मानक Node.js fs मॉड्यूल आपको एक फ़ाइल पढ़ने की अनुमति देता है, जिसके बाद इसे HTTP सर्वर द्वारा प्राप्त अनुरोध के जवाब में HTTP के माध्यम से स्थानांतरित किया जा सकता है:

 const http = require('http') const fs = require('fs') const server = http.createServer(function (req, res) { fs.readFile(__dirname + '/data.txt', (err, data) => {   res.end(data) }) }) server.listen(3000) 

यहां इस्तेमाल की जाने वाली readFile() विधि से आप पूरी फाइल को पढ़ सकते हैं। जब रीडिंग पूरी हो जाती है, तो वह संबंधित कॉलबैक को कॉल करता है।

res.end(data) विधि, जिसे कॉलबैक में कहा जाता है, क्लाइंट को फ़ाइल की सामग्री भेजता है।

यदि फ़ाइल का आकार बड़ा है, तो इस ऑपरेशन में बहुत समय लगेगा। यहाँ धाराओं का उपयोग करते हुए एक ही उदाहरण लिखा गया है:

 const http = require('http') const fs = require('fs') const server = http.createServer((req, res) => { const stream = fs.createReadStream(__dirname + '/data.txt') stream.pipe(res) }) server.listen(3000) 

जब फ़ाइल पूरी तरह से पढ़ी जाती है, तो उस पल का इंतजार करने के बजाय, हम इस डेटा के पहले भाग को भेजने के तुरंत बाद क्लाइंट को उसका डेटा ट्रांसफर करना शुरू कर देते हैं।

▍पाइप () विधि

पिछले उदाहरण में, हमने फॉर्म स्ट्रीम stream.pipe(res) का निर्माण किया था, जिसमें pipe() फ़ाइल स्ट्रीम विधि कहा जाता है। यह विधि अपने स्रोत से डेटा लेती है और गंतव्य पर भेजती है।

इसे डेटा स्रोत का प्रतिनिधित्व करने वाली धारा के लिए कहा जाता है। इस स्थिति में, यह फ़ाइल स्ट्रीम है जो HTTP प्रतिसाद के लिए भेजी जाती है।

pipe() का वापसी मूल्य pipe() विधि लक्ष्य धारा है। यह बहुत सुविधाजनक है, क्योंकि यह आपको pipe() विधि में कई कॉल को चेन करने की अनुमति देता है:

 src.pipe(dest1).pipe(dest2) 

यह इस तरह के एक डिजाइन के बराबर है:

 src.pipe(dest1) dest1.pipe(dest2) 

▍API Node.js जो धाराओं का उपयोग करते हैं

धाराएँ एक उपयोगी तंत्र हैं, परिणामस्वरूप, Node.js कर्नेल के कई मॉड्यूल धाराओं के साथ काम करने के लिए मानक क्षमताएं प्रदान करते हैं। हम उनमें से कुछ को सूचीबद्ध करते हैं:

• process.stdin - stdin जुड़ा एक थ्रेड लौटाता है।
• process.stdout - स्टडआउट से जुड़ा थ्रेड लौटाता है।
• process.stderr - stderr जुड़ा एक धागा देता है।
• fs.createReadStream() - फ़ाइल के साथ काम करने के लिए एक पठनीय स्ट्रीम बनाता है।
• fs.createWriteStream() - फ़ाइल के साथ काम करने के लिए एक लिखने योग्य स्ट्रीम बनाता है।
• net.connect() - एक स्ट्रीम-आधारित कनेक्शन शुरू करता है।
• http.request() - http.ClientRequest वर्ग का एक उदाहरण देता है जो स्ट्रीम को लिखा जाने की सुविधा प्रदान करता है।
• zlib.createGzip() - gzip एल्गोरिथ्म का उपयोग करके डेटा को gzip करता है और इसे स्ट्रीम पर भेजता है।
• zlib.createGunzip() - एक gzip स्ट्रीम को विघटित करता है।
• zlib.createDeflate() - zlib.createDeflate() एल्गोरिथ्म का उपयोग करके डेटा को संपीड़ित करता है और इसे स्ट्रीम पर भेजता है।
• zlib.createInflate() - एक zlib.createInflate() धारा को विघटित करता है।

विभिन्न प्रकार की धाराएँ

चार प्रकार की धाराएँ हैं:

• एक पठनीय धारा एक धारा है जिसमें से डेटा को पढ़ा जा सकता है। आप ऐसी स्ट्रीम में डेटा नहीं लिख सकते। जब डेटा ऐसी स्ट्रीम में आता है, तो यह तब तक बफर हो जाता है जब तक डेटा उपभोक्ता इसे पढ़ना शुरू नहीं करता।
• राइटिंग (लेखन) के लिए एक स्ट्रीम एक स्ट्रीम है जिसमें आप डेटा भेज सकते हैं। आप इससे डेटा नहीं पढ़ सकते हैं।
• डुप्लेक्स स्ट्रीम ( Duplex ) - इस स्ट्रीम में आप डेटा भेज सकते हैं और उनसे पढ़ सकते हैं। मूलतः यह पढ़ने के लिए एक धारा का संयोजन है और लेखन के लिए एक धारा है।
• ट्रांसफ़ॉर्म स्ट्रीम ( Transform ) - ऐसी धाराएँ डुप्लेक्स धाराओं के समान होती हैं, अंतर यह है कि इन धाराओं के इनपुट में जो आता है, वह रूपांतरित करेगा जो उनसे पढ़ा जा सकता है।

▍ एक पढ़ें धारा बनाएँ

, stream :

 const Stream = require('stream') const readableStream = new Stream.Readable() 

, :

 readableStream.push('hi!') readableStream.push('ho!') 

▍

Writable _write() . :

 const Stream = require('stream') const writableStream = new Stream.Writable() 

_write() :

 writableStream._write = (chunk, encoding, next) => {   console.log(chunk.toString())   next() } 

, :

 process.stdin.pipe(writableStream) 

▍

, , :

 const Stream = require('stream') const readableStream = new Stream.Readable() const writableStream = new Stream.Writable() writableStream._write = (chunk, encoding, next) => {   console.log(chunk.toString())   next() } readableStream.pipe(writableStream) readableStream.push('hi!') readableStream.push('ho!') readableStream.push(null) 

readableStream.push(null) .

, readable :

 readableStream.on('readable', () => { console.log(readableStream.read()) }) 

▍

write() :

 writableStream.write('hey!\n') 

▍ ,

, , end() :

 writableStream.end() 

. , , .

MySQL Node.js

MySQL . Node.js , MySQL-, — , .

mysqljs/mysql . , , 12000 GitHub. , MySQL-.

▍

:

 npm install mysql 

▍

:

 const mysql = require('mysql') 

:

 const options = { user: 'the_mysql_user_name', password: 'the_mysql_user_password', database: 'the_mysql_database_name' } const connection = mysql.createConnection(options) 

:

 connection.connect(err => { if (err) {   console.error('An error occurred while connecting to the DB')   throw err } } 

▍

options :

 const options = { user: 'the_mysql_user_name', password: 'the_mysql_user_password', database: 'the_mysql_database_name' } 

. — :

• host — , MySQL-, — localhost .
• port — , — 3306 .
• socketPath — Unix .
• debug — , .
• trace — , .
• ssl — SSL- .

▍ SELECT

SQL- . query , . — , . . :

 connection.query('SELECT * FROM todos', (error, todos, fields) => { if (error) {   console.error('An error occurred while executing the query')   throw error } console.log(todos) }) 

, :

 const id = 223 connection.query('SELECT * FROM todos WHERE id = ?', [id], (error, todos, fields) => { if (error) {   console.error('An error occurred while executing the query')   throw error } console.log(todos) }) 

, , :

 const id = 223 const author = 'Flavio' connection.query('SELECT * FROM todos WHERE id = ? AND author = ?', [id, author], (error, todos, fields) => { if (error) {   console.error('An error occurred while executing the query')   throw error } console.log(todos) }) 

▍ INSERT

INSERT . , :

 const todo = { thing: 'Buy the milk' author: 'Flavio' } connection.query('INSERT INTO todos SET ?', todo, (error, results, fields) => { if (error) {   console.error('An error occurred while executing the query')   throw error } }) 

, , auto_increment , results.insertId :

 const todo = { thing: 'Buy the milk' author: 'Flavio' } connection.query('INSERT INTO todos SET ?', todo, (error, results, fields) => { if (error) {   console.error('An error occurred while executing the query')   throw error }} const id = results.resultId console.log(id) ) 

▍

— end() :

 connection.end() 

.

-

Node.js -.

Node.js . , -, NODE_ENV :

 NODE_ENV=production 

. Linux, , :

 export NODE_ENV=production 

, , .bash_profile ( Bash), .

, :

 NODE_ENV=production node app.js 

Node.js. NODE_ENV production :

• .
• .

, Pug — , Express, , NODE_ENV production . Express, , . - . .

Express . , , NODE_ENV :

 app.configure('development', () => { //... }) app.configure('production', () => { //... }) app.configure('production', 'staging', () => { //... }) 

, :

 app.configure('development', () => { app.use(express.errorHandler({ dumpExceptions: true, showStack: true })); }) app.configure('production', () => { app.use(express.errorHandler()) }) 

▍

, , Node.js , . , , , Node.js, - , Node.js.

प्रिय पाठकों! , Node.js, , .