नोडजेएस: टीसीपी सॉकेट धाराओं को संभालने का सही तरीका क्या है? मुझे किस डिलीमीटर का उपयोग करना चाहिए?

Question

जो मुझे here समझा गया, "वी 8 में एक पीढ़ी का कचरा कलेक्टर है। वस्तुओं को यादृच्छिक रूप से बढ़ाता है। नोड को सॉकेट को लिखने के लिए कच्चे स्ट्रिंग डेटा को पॉइंटर नहीं मिल सकता है।" तो मुझे एक स्ट्रिंग में एक टीसीपी धारा से आने वाले डेटा को स्टोर नहीं करना चाहिए, विशेष रूप से यदि वह स्ट्रिंग Math.pow(2,16) बाइट्स से बड़ी हो जाती है। (उम्मीद है कि मैं अभी तक सही हूं ..)

टीसीपी सॉकेट से आने वाले सभी डेटा को संभालने का सबसे अच्छा तरीका क्या है? अब तक मैं _:_:_ को एक डेलीमीटर के रूप में उपयोग करने का प्रयास कर रहा हूं क्योंकि मुझे लगता है कि यह किसी भी तरह अद्वितीय है और अन्य चीजों के आसपास गड़बड़ नहीं करेगा।

डेटा का एक नमूना है कि आएगा something_:_:_maybe a large text_:_:_ maybe tons of lines_:_:_more and more data

होगा यह मैं करने की कोशिश की क्या है:

net = require('net'); 
var server = net.createServer(function (socket) { 
    socket.on('connect',function() { 
     console.log('someone connected'); 
     buf = new Buffer(Math.pow(2,16)); //new buffer with size 2^16 
     socket.on('data',function(data) { 
      if (data.toString().search('_:_:_') === -1) { // If there's no separator in the data that just arrived... 
       buf.write(data.toString()); // ... write it on the buffer. it's part of another message that will come. 
      } else {  // if there is a separator in the data that arrived 
       parts = data.toString().split('_:_:_'); // the first part is the end of a previous message, the last part is the start of a message to be completed in the future. Parts between separators are independent messages 
       if (parts.length == 2) { 
        msg = buf.toString('utf-8',0,4) + parts[0]; 
        console.log('MSG: '+ msg); 
        buf = (new Buffer(Math.pow(2,16))).write(parts[1]); 
       } else { 
        msg = buf.toString() + parts[0]; 
        for (var i = 1; i <= parts.length -1; i++) { 
         if (i !== parts.length-1) { 
          msg = parts[i]; 
          console.log('MSG: '+msg); 
         } else { 
          buf.write(parts[i]); 
         } 
        } 
       } 
      } 
     }); 
    }); 
}); 

server.listen(9999); 

जब भी मैं console.log('MSG' + msg) करने की कोशिश है, यह पूरे बफर बाहर प्रिंट होंगे, इसलिए यह है कुछ काम करने के लिए बेकार है।

मैं इस डेटा को उचित तरीके से कैसे संभाल सकता हूं? आलसी मॉड्यूल काम करेगा, भले ही यह डेटा लाइन उन्मुख नहीं है? क्या धाराओं को संभालने के लिए कुछ अन्य मॉड्यूल है जो रेखा उन्मुख नहीं हैं?

Answer 1

यह वास्तव में कहा गया है कि अतिरिक्त काम चल रहा है क्योंकि नोड को उस बफर को लेना है और फिर उसे v8 में धक्का देना/इसे स्ट्रिंग में डालना है। हालांकि, बफर पर एक toString() करना कोई बेहतर नहीं है। जहां तक ​​मुझे पता है, इस पर इसका कोई अच्छा समाधान नहीं है, खासकर यदि आपका अंतिम लक्ष्य एक स्ट्रिंग और मूर्खतापूर्ण है। चीजों में से एक ने रयान ने उस क्षेत्र के रूप में @ nodeconf का उल्लेख किया जहां काम करने की आवश्यकता है।

डिलीमीटर के लिए, आप जो चाहें चुन सकते हैं। बहुत से बाइनरी प्रोटोकॉल एक निश्चित शीर्षलेख को शामिल करना चुनते हैं, जैसे कि आप चीजों को सामान्य संरचना में डाल सकते हैं, जिसमें कई बार लंबाई शामिल होती है। इस तरह, आप एक ज्ञात शीर्षलेख को अलग करते हैं और पूरे बफर पर पुन: प्रयास किए बिना शेष डेटा के बारे में जानकारी प्राप्त करते हैं। ऐसे ही एक योजना के साथ, एक जैसे उपकरण भी कर सकते हैं:

• नोड बफर - https://github.com/substack/node-binary
• नोड CTYPE - https://github.com/rmustacc/node-ctype

एक अलग रूप में के रूप में, बफ़र्स सरणी वाक्य रचना के माध्यम से पहुँचा जा सकता है, और उन्हें .slice() के साथ अलग कटाई भी जा सकती है।

अंत में, यहां जांचें: https://github.com/joyent/node/wiki/modules - एक ऐसा मॉड्यूल ढूंढें जो एक साधारण टीसीपी प्रोटोकॉल को पार करता है और ऐसा लगता है, और कुछ कोड पढ़ता है।

Answer 2

आपको नई स्ट्रीम 2 एपीआई का उपयोग करना चाहिए। http://nodejs.org/api/stream.html

यहाँ कुछ बहुत ही उपयोगी उदाहरण हैं: https://github.com/substack/stream-handbook

https://github.com/lvgithub/stick