दिलचस्प पोस्ट
आप कितने प्रोग्राम को एक बैश स्क्रिप्ट से समानांतर में चलाते हैं? सीरियलाइजेशन और मार्शलिंग में अंतर क्या है? बराबर और GetHashCode के लिए सबसे अच्छी रणनीति क्या है? एचटीएमएल 5 यूट्यूब वीडियो को बल दें सार्वभौमिक ऐप्स में आईपैड और आईफोन रेटिना ग्राफिक्स दोनों का समर्थन कैसे करें कंसोल में टाइमआउट कैसे जोड़ें। रीडलाइन ()? खोज इंजन – ल्यूसीन या सोलर सीएसएस का इस्तेमाल करते हुए होवर पर एक छवि पर एक ज़ूम प्रभाव बनाना है? सी ++ के लिए चेनिंग इटरेटर एक्लिप्स में विशिष्ट फ़ोल्डरों या फाइलों को मान्यता से बाहर कैसे करें? आप एक छवि दृश्य के लिए LayoutParams () कैसे सेट करते हैं? .htaccess XAMPP के साथ स्थानीय होस्ट पर काम नहीं कर रहा है जावास्क्रिप्ट डीबगर कैसे दोहराया कुंजी को रोकने के लिए दबाया () / कुंजी JPQL को दोबारा "JPEG 2" के रूप में "कहाँ" खंड के साथ "फ़ेच में शामिल करें" को व्यक्त करने के लिए?

Node.js में एक समय में एक पंक्ति एक फ़ाइल पढ़ें?

मैं एक समय में बड़ी फ़ाइल एक पंक्ति को पढ़ने की कोशिश कर रहा हूं। मुझे Quora पर एक प्रश्न मिला जो विषय से निपटा गया था, लेकिन मुझे कुछ सम्बन्ध नहीं मिल रहा है ताकि पूरी चीज एक साथ फिट हो सके।

var Lazy=require("lazy"); new Lazy(process.stdin) .lines .forEach( function(line) { console.log(line.toString()); } ); process.stdin.resume(); 

थोड़ा सा है कि मैं यह जानना चाहता हूं कि इस नमूने के रूप में एसटीडीआईएन की बजाए फाइल से एक समय में मैं एक पंक्ति कैसे पढ़ सकता हूं।

मैंने कोशिश की:

  fs.open('./VeryBigFile.csv', 'r', '0666', Process); function Process(err, fd) { if (err) throw err; // DO lazy read } 

लेकिन यह काम नहीं कर रहा है मुझे पता है कि एक चुटकी में मैं PHP की तरह कुछ का उपयोग करने के लिए वापस आ सकता हूं, लेकिन मैं इसे समझाना चाहता हूं।

मुझे नहीं लगता कि दूसरा जवाब काम करेगा क्योंकि फ़ाइल उस सर्वर से बहुत अधिक है जिस पर मैं इसे चला रहा हूं I

Solutions Collecting From Web of "Node.js में एक समय में एक पंक्ति एक फ़ाइल पढ़ें?"

चूंकि नोड.जेएस v0.12 और नोड.जेएस v4.0.0 के रूप में, एक स्थिर रीडलाइन कोर मॉड्यूल है। किसी बाहरी मॉड्यूल के बिना किसी फ़ाइल से लाइनों को पढ़ने का सबसे आसान तरीका यहां है:

 var lineReader = require('readline').createInterface({ input: require('fs').createReadStream('file.in') }); lineReader.on('line', function (line) { console.log('Line from file:', line); }); 

आखिरी पंक्ति को सही तरीके से पढ़ा जाता है (नोड v0.12 या उसके बाद के संस्करण के रूप में), भले ही अंतिम नहीं है \n

अद्यतनः यह उदाहरण नोड के एपीआई आधिकारिक दस्तावेजों में जोड़ा गया है।

ऐसे सरल ऑपरेशन के लिए तीसरे पक्ष के मॉड्यूल पर कोई निर्भरता नहीं होनी चाहिए। विनम्र रहो।

 var fs = require('fs'), readline = require('readline'); var rd = readline.createInterface({ input: fs.createReadStream('/path/to/file'), output: process.stdout, console: false }); rd.on('line', function(line) { console.log(line); }); 

आपको फाइल open की ज़रूरत नहीं है, बल्कि इसके बजाय आपको एक ReadStream बनाना ReadStream

fs.createReadStream

फिर उस स्ट्रीम को Lazy को पास करें

रेखा से एक फ़ाइल लाइन को पढ़ने के लिए एक बहुत अच्छा मॉड्यूल है, इसे लाइन-रीडर कहा जाता है

https://github.com/nickewing/line-reader

इसके साथ आप बस बस लिखते हैं:

 var lineReader = require('line-reader'); lineReader.eachLine('file.txt', function(line, last) { console.log(line); // do whatever you want with line... if(last){ // or check if it's the last one } }); 

यदि आप अधिक नियंत्रण की आवश्यकता है, तो आप "java-style" इंटरफ़ेस के साथ फाइल को फिर से पुन: चालू कर सकते हैं:

 lineReader.open('file.txt', function(reader) { if (reader.hasNextLine()) { reader.nextLine(function(line) { console.log(line); }); } }); 

पुराने विषय, लेकिन यह काम करता है:

 var rl = readline.createInterface({ input : fs.createReadStream('/path/file.txt'), output: process.stdout, terminal: false }) rl.on('line',function(line){ console.log(line) //or parse line }) 

सरल। बाहरी मॉड्यूल के लिए कोई ज़रूरत नहीं है

आप हमेशा अपना स्वयं का लाइन रीडर रोल कर सकते हैं मैंने अभी तक इस स्निपेट को बेंचमार्क नहीं किया है, लेकिन यह सही तरीके से इनकमिंग स्प्रैड को लाइनों में बिना पिछड़े '\ n'

 var last = ""; process.stdin.on('data', function(chunk) { var lines, i; lines = (last+chunk).split("\n"); for(i = 0; i < lines.length - 1; i++) { console.log("line: " + lines[i]); } last = lines[i]; }); process.stdin.on('end', function() { console.log("line: " + last); }); process.stdin.resume(); 

लॉग पर्सिंग के दौरान डेटा जमा करने के लिए आवश्यक त्वरित लॉग पार्सिंग स्क्रिप्ट पर काम करते समय मैंने इसके साथ आया था और मुझे लगा कि यह पर्ल या बैश का उपयोग करने के बजाय जेएस और नोड का उपयोग करके यह करने का प्रयास करना अच्छा होगा।

वैसे भी, मुझे लगता है कि छोटे नोडज स्क्रिप्ट स्वयं निहित हैं और तीसरे पक्ष के मॉड्यूल पर भरोसा नहीं करते हैं, इसलिए इस प्रश्न के सभी उत्तरों को पढ़ने के बाद, प्रत्येक रेखा के पार्सिंग को संभालने के लिए विभिन्न मॉड्यूल का उपयोग करते हुए, एक 13 स्लोक देशी नोडज समाधान ब्याज का हो सकता है।

वाहक मॉड्यूल के साथ :

 var carrier = require('carrier'); process.stdin.resume(); carrier.carry(process.stdin, function(line) { console.log('got one line: ' + line); }); 

मैं उन पंक्तियों पर प्रक्रिया करने और नोड कार्यों में नाली / रोकें / फिर से शुरू होने के कारण किसी अन्य धारा में लिखने की कोशिश करते हुए लाइन से लाइन पढ़ने के लिए आलिया का उपयोग करके बड़े पैमाने पर मेमोरी रिसाव के साथ समाप्त हुआ (देखें: http: // elegantcode .com / 2011/04/06 / ले-बेबी-पाएं-साथ-नोड-जेएस-पम्पिंग-डेटा-इन-स्ट्रीम / (मैं इस आदमी को बीटीडब्ल्यू प्यार करता हूँ))। मैं बिल्कुल आलसी पर पर्याप्त रूप से समझ नहीं पाया है, लेकिन मैं अपने पढ़ने वाली धारा को बिना आलसी निकास के लिए अनुमति देने के लिए रोक नहीं सकता था।

मैंने बड़े पैमाने पर सीएसवी फाइलों को XML डॉक्स में संसाधित करने के लिए कोड लिखा था, आप यहां कोड देख सकते हैं: https://github.com/j03m/node-csv2xml

यदि आप आलसी लाइन के साथ पिछले संशोधनों को चलाते हैं तो यह लीक होता है। नवीनतम संशोधन बिल्कुल रिसाव नहीं है और संभवतः आप इसे एक रीडर / प्रोसेसर के आधार के रूप में उपयोग कर सकते हैं। हालांकि मेरे पास कुछ कस्टम सामान हैं

संपादित करें: मुझे लगता है मुझे यह भी ध्यान देना चाहिए कि आलसी के साथ मेरा कोड ठीक काम नहीं करता जब तक कि मैं खुद को पर्याप्त पर्याप्त XML टुकड़े लिखने से रोकता / रोकता / छोटे हिस्से के लिए यह ठीक था।

संपादित करें:

ट्रांसफॉर्म स्ट्रीम का उपयोग करें।


एक बफ़रेड रीडर के साथ आप लाइनों को पढ़ सकते हैं

 new BufferedReader ("lorem ipsum", { encoding: "utf8" }) .on ("error", function (error){ console.log ("error: " + error); }) .on ("line", function (line){ console.log ("line: " + line); }) .on ("end", function (){ console.log ("EOF"); }) .read (); 
 function createLineReader(fileName){ var EM = require("events").EventEmitter var ev = new EM() var stream = require("fs").createReadStream(fileName) var remainder = null; stream.on("data",function(data){ if(remainder != null){//append newly received data chunk var tmp = new Buffer(remainder.length+data.length) remainder.copy(tmp) data.copy(tmp,remainder.length) data = tmp; } var start = 0; for(var i=0; i<data.length; i++){ if(data[i] == 10){ //\n new line var line = data.slice(start,i) ev.emit("line", line) start = i+1; } } if(start<data.length){ remainder = data.slice(start); }else{ remainder = null; } }) stream.on("end",function(){ if(null!=remainder) ev.emit("line",remainder) }) return ev } //---------main--------------- fileName = process.argv[2] lineReader = createLineReader(fileName) lineReader.on("line",function(line){ console.log(line.toString()) //console.log("++++++++++++++++++++") }) 
 require('fs').readFileSync('file.txt').toString().split(/\r?\n/).forEach(function(line){ console.log(line); }) 

मैं इसके लिए एक व्यापक समाधान की कमी से निराश था, इसलिए मैंने अपना प्रयास ( जीआईटी / एनपीएम ) को एक साथ रखा। सुविधाओं की कॉपी-पेस्ट की गई सूची:

  • इंटरैक्टिव लाइन प्रोसेसिंग (कॉलबैक-आधारित, पूरी फ़ाइल को राम में लोड नहीं करना)
  • वैकल्पिक रूप से, सभी पंक्तियों को एक सरणी में वापस करें (विस्तृत या कच्चे मोड)
  • इंटरैक्टिव स्ट्रीमिंग में बाधा डालना या प्रोसेसिंग जैसी नक्शा / फ़िल्टर करना
  • किसी भी नए लाइन सम्मेलन का पता लगाएं (पीसी / मैक / लिनक्स)
  • सही ईओफ़ / अंतिम पंक्ति उपचार
  • बहु-बाइट यूटीएफ -8 के अक्षरों का सही प्रबंधन
  • प्रति पंक्ति के आधार पर बाइट ऑफसेट और बाइट लम्बाई की जानकारी पुनर्प्राप्त करें
  • लाइन-आधारित या बाइट-आधारित ऑफसेट का उपयोग करके रैंडम एक्सेस
  • यादृच्छिक पहुंच को गति देने के लिए स्वचालित रूप से लाइन-ऑफसेट जानकारी को मैप करें
  • शून्य निर्भरताएं
  • टेस्ट

एनआईएच? आप तय करें 🙂

मेरे मूल उत्तर को पोस्ट करने के बाद से, मुझे पता चला कि एक फ़ाइल में लाइन पढ़ने के लिए विभाजन बहुत नोड मॉड्यूल का उपयोग करना आसान है; जो वैकल्पिक पैरामीटर भी स्वीकार करता है

 var split = require('split'); fs.createReadStream(file) .pipe(split()) .on('data', function (line) { //each chunk now is a seperate line! }); 

बहुत बड़ी फ़ाइलों पर परीक्षण नहीं किया है यदि आप करते हैं तो हमें बताएं

मैं इस समस्या से निपटना चाहता हूं, मूल रूप से पर्ल में क्या होगा:

 while (<>) { process_line($_); } 

मेरा उपयोग मामला सिर्फ एक स्टैंडअलोन स्क्रिप्ट था, सर्वर नहीं, इसलिए सिंक्रोनस ठीक था। ये मेरे मापदंड थे:

  • कम से कम तुल्यकालिक कोड जो कई परियोजनाओं में पुन: उपयोग कर सकता है
  • फ़ाइल आकार या लाइनों की संख्या पर कोई सीमा नहीं
  • लाइनों की लंबाई पर कोई सीमा नहीं
  • बीएमपी से परे अक्षर सहित यूटीएफ -8 में पूर्ण यूनिकोड को संभालने में सक्षम।
  • * निक्स और विंडोज लाइन के अंत (पुराने शैली वाले मैक को मेरे लिए आवश्यक नहीं) को संभालने में सक्षम
  • पंक्तियों में शामिल किए जाने वाले रेखा के अंत वाले चरित्र (ओं)
  • अंतिम पंक्ति के बिना या बिना-पंक्ति के वर्णों के अंतिम पंक्ति को संभालने में सक्षम।
  • नोड.जेएस वितरण में शामिल किसी भी बाहरी पुस्तकालयों का उपयोग नहीं करें।

यह मेरे लिए एक परियोजना है जो नोड। जेएस में निम्न स्तरीय स्क्रिप्टिंग प्रकार कोड के लिए महसूस करता है और तय करता है कि पर्ल जैसे अन्य स्क्रिप्टिंग भाषाओं के प्रतिस्थापन के रूप में यह कैसे व्यवहार्य है।

मेहनत की एक आश्चर्यजनक मात्रा के बाद और कुछ झूठी शुरूआत के साथ यह कोड है जिसका मैं साथ आया हूं। यह बहुत तेजी से है, लेकिन कम तुच्छ मैं उम्मीद कर रहा था: (यह GitHub पर कांटा)

 var fs = require('fs'), StringDecoder = require('string_decoder').StringDecoder, util = require('util'); function lineByLine(fd) { var blob = ''; var blobStart = 0; var blobEnd = 0; var decoder = new StringDecoder('utf8'); var CHUNK_SIZE = 16384; var chunk = new Buffer(CHUNK_SIZE); var eolPos = -1; var lastChunk = false; var moreLines = true; var readMore = true; // each line while (moreLines) { readMore = true; // append more chunks from the file onto the end of our blob of text until we have an EOL or EOF while (readMore) { // do we have a whole line? (with LF) eolPos = blob.indexOf('\n', blobStart); if (eolPos !== -1) { blobEnd = eolPos; readMore = false; // do we have the last line? (no LF) } else if (lastChunk) { blobEnd = blob.length; readMore = false; // otherwise read more } else { var bytesRead = fs.readSync(fd, chunk, 0, CHUNK_SIZE, null); lastChunk = bytesRead !== CHUNK_SIZE; blob += decoder.write(chunk.slice(0, bytesRead)); } } if (blobStart < blob.length) { processLine(blob.substring(blobStart, blobEnd + 1)); blobStart = blobEnd + 1; if (blobStart >= CHUNK_SIZE) { // blobStart is in characters, CHUNK_SIZE is in octets var freeable = blobStart / CHUNK_SIZE; // keep blob from growing indefinitely, not as deterministic as I'd like blob = blob.substring(CHUNK_SIZE); blobStart -= CHUNK_SIZE; blobEnd -= CHUNK_SIZE; } } else { moreLines = false; } } } 

यह संभवतः आगे साफ हो सकता है, यह परीक्षण और त्रुटि का परिणाम था

जेनरेटर आधारित लाइन रीडर: https://github.com/neurosnap/gen-readlines

 var fs = require('fs'); var readlines = require('gen-readlines'); fs.open('./file.txt', 'r', function(err, fd) { if (err) throw err; fs.fstat(fd, function(err, stats) { if (err) throw err; for (var line of readlines(fd, stats.size)) { console.log(line.toString()); } }); }); 

यदि आप लाइन द्वारा एक फ़ाइल लाइन पढ़ना चाहते हैं और इसे किसी अन्य में लिखना चाहते हैं:

 var fs = require('fs'); var readline = require('readline'); var Stream = require('stream'); function readFileLineByLine(inputFile, outputFile) { var instream = fs.createReadStream(inputFile); var outstream = new Stream(); outstream.readable = true; outstream.writable = true; var rl = readline.createInterface({ input: instream, output: outstream, terminal: false }); rl.on('line', function (line) { fs.appendFileSync(outputFile, line + '\n'); }); }; 
 var fs = require('fs'); function readfile(name,online,onend,encoding) { var bufsize = 1024; var buffer = new Buffer(bufsize); var bufread = 0; var fd = fs.openSync(name,'r'); var position = 0; var eof = false; var data = ""; var lines = 0; encoding = encoding || "utf8"; function readbuf() { bufread = fs.readSync(fd,buffer,0,bufsize,position); position += bufread; eof = bufread ? false : true; data += buffer.toString(encoding,0,bufread); } function getLine() { var nl = data.indexOf("\r"), hasnl = nl !== -1; if (!hasnl && eof) return fs.closeSync(fd), online(data,++lines), onend(lines); if (!hasnl && !eof) readbuf(), nl = data.indexOf("\r"), hasnl = nl !== -1; if (!hasnl) return process.nextTick(getLine); var line = data.substr(0,nl); data = data.substr(nl+1); if (data[0] === "\n") data = data.substr(1); online(line,++lines); process.nextTick(getLine); } getLine(); } 

मेरे पास एक ही समस्या थी और उपरोक्त समाधान के साथ आया था दूसरों के लिए समानांतर दिखता है लेकिन एक सिंक है और बड़ी फ़ाइलों को बहुत तेज़ी से पढ़ सकता है

उम्मीद है यह मदद करता है

ज्यादातर मामलों में यह पर्याप्त होना चाहिए:

 const fs = require("fs") fs.readFile('./file', 'utf-8', (err, file) => { const lines = file.split('\n') for (let line of lines) console.log(line) }); 

मेरे पास एक छोटा मॉड्यूल है जो यह अच्छी तरह से करता है और कुछ अन्य परियोजनाओं द्वारा उपयोग किया जाता है एनपीएम रीडलाइन नोट नोड वी 10 में नोट एक देशी रीडलाइन मॉड्यूल है, इसलिए मैंने अपने मॉड्यूल को लाइनबिलाइन के रूप में पुनः प्रकाशित किया है https://www.npmjs.com/package/ पंक्ति दर पंक्ति

यदि आप मॉड्यूल का उपयोग करना चाहते हैं, तो फ़ंक्शन बहुत सरल है:

 var fs = require('fs'), EventEmitter = require('events').EventEmitter, util = require('util'), newlines = [ 13, // \r 10 // \n ]; var readLine = module.exports = function(file, opts) { if (!(this instanceof readLine)) return new readLine(file); EventEmitter.call(this); opts = opts || {}; var self = this, line = [], lineCount = 0, emit = function(line, count) { self.emit('line', new Buffer(line).toString(), count); }; this.input = fs.createReadStream(file); this.input.on('open', function(fd) { self.emit('open', fd); }) .on('data', function(data) { for (var i = 0; i < data.length; i++) { if (0 <= newlines.indexOf(data[i])) { // Newline char was found. lineCount++; if (line.length) emit(line, lineCount); line = []; // Empty buffer. } else { line.push(data[i]); // Buffer new line data. } } }).on('error', function(err) { self.emit('error', err); }).on('end', function() { // Emit last line if anything left over since EOF won't trigger it. if (line.length){ lineCount++; emit(line, lineCount); } self.emit('end'); }).on('close', function() { self.emit('close'); }); }; util.inherits(readLine, EventEmitter); 
 const fs = require("fs") fs.readFile('./file', 'utf-8', (err, data) => { var innerContent; console.log("Asynchronous read: " + data.toString()); const lines = data.toString().split('\n') for (let line of lines) innerContent += line + '<br>'; }); 

एक और समाधान अनुक्रमिक निष्पादक nsynjs के माध्यम से तर्क को चलाने के लिए है यह नोड रीडलाइन मॉड्यूल का उपयोग करते हुए फ़ाइल लाइन-बाय-लाइन पढ़ता है, और यह वादे या पुनरावर्ती का उपयोग नहीं करता है, इसलिए बड़ी फ़ाइलों पर विफल नहीं होने वाला है। यहां बताया गया है कि कोड कैसे दिखता है:

 var nsynjs = require('nsynjs'); var textFile = require('./wrappers/nodeReadline').textFile; // this file is part of nsynjs function process(textFile) { var fh = new textFile(); fh.open('path/to/file'); var s; while (typeof(s = fh.readLine(nsynjsCtx).data) != 'undefined') console.log(s); fh.close(); } var ctx = nsynjs.run(process,{},textFile,function () { console.log('done'); }); 

उपरोक्त कोड इस परीक्षा पर आधारित है: https://github.com/amaksr/nsynjs/blob/master/examples/node-readline/index.js

मैं इसका उपयोग करता हूं:

 function emitLines(stream, re){ re = re && /\n/; var buffer = ''; stream.on('data', stream_data); stream.on('end', stream_end); function stream_data(data){ buffer += data; flush(); }//stream_data function stream_end(){ if(buffer) stream.emmit('line', buffer); }//stream_end function flush(){ var re = /\n/; var match; while(match = re.exec(buffer)){ var index = match.index + match[0].length; stream.emit('line', buffer.substring(0, index)); buffer = buffer.substring(index); re.lastIndex = 0; } }//flush }//emitLines 

इस फ़ंक्शन का उपयोग किसी स्ट्रीम पर करें और लाइन इवेंट्स को सुनें जो उत्सर्जन करेंगे।

gr-

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

 const EventEmitter = require('events').EventEmitter; class LineReader extends EventEmitter{ constructor(f, delim='\n'){ super(); this.totalChars = 0; this.totalLines = 0; this.leftover = ''; f.on('data', (chunk)=>{ this.totalChars += chunk.length; let lines = chunk.split(delim); if (lines.length === 1){ this.leftover += chunk; return; } lines[0] = this.leftover + lines[0]; this.leftover = lines[lines.length-1]; if (this.leftover) lines.pop(); this.totalLines += lines.length; for (let l of lines) this.onLine(l); }); // f.on('error', ()=>{}); f.on('end', ()=>{console.log('chars', this.totalChars, 'lines', this.totalLines)}); } onLine(l){ this.emit('line', l); } } //Command line test const f = require('fs').createReadStream(process.argv[2], 'utf8'); const delim = process.argv[3]; const lineReader = new LineReader(f, delim); lineReader.on('line', (line)=> console.log(line)); 

यहां 1 9 लाइनों पर आँकड़ों के बिना, एक छोटा संस्करण भी है:

 class LineReader extends require('events').EventEmitter{ constructor(f, delim='\n'){ super(); this.leftover = ''; f.on('data', (chunk)=>{ let lines = chunk.split(delim); if (lines.length === 1){ this.leftover += chunk; return; } lines[0] = this.leftover + lines[0]; this.leftover = lines[lines.length-1]; if (this.leftover) lines.pop(); for (let l of lines) this.emit('line', l); }); } } 

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

 (function () { var fs = require('fs'); var glob = require('glob-fs')(); var path = require('path'); var result = 0; var exclude = ['LICENSE', path.join('e2e', 'util', 'db-ca', 'someother-file'), path.join('src', 'favicon.ico')]; var files = []; files = glob.readdirSync('**'); var allFiles = []; var patternString = [ 'trade', 'order', 'market', 'securities' ]; files.map((file) => { try { if (!fs.lstatSync(file).isDirectory() && exclude.indexOf(file) === -1) { fs.readFileSync(file).toString().split(/\r?\n/).forEach(function(line){ patternString.map((pattern) => { if (line.indexOf(pattern) !== -1) { console.log(file + ' contain `' + pattern + '` in in line "' + line +'";'); result = 1; } }); }); } } catch (e) { console.log('Error:', e.stack); } }); process.exit(result); })();