सभी फ़ाइलों को कैसे पार करें, और समर्थन रोकें और

Question

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

अब मेरा प्रश्न। मैं चाहता हूं कि मेरी एनओडीई प्रक्रिया बंद हो जाए? मैं इसे बंद होने से जारी रखने में सक्षम होना चाहता हूं। मैं कैसे करूं?

दूसरे शब्दों में: सभी फ़ाइलों और फ़ोल्डर में चलते समय वर्तमान स्थिति की अनुक्रमणिका कैसे रखें, इसलिए जब मैं इसे रोकता हूं तब से ट्रैवर्सिंग जारी रख सकता हूं।

var walkAll=function(options){ 
    var x=0 
    walk(options.dir,function(){}) 
    function walk(dir,callback) { 
     var files=fs.readdirSync(dir); 
     var stat; 
     async.eachSeries(files,function(file,next){ 
     file=dir +'/' + file 
     if (dir.match(/Recycle/)) return next() 
     if (dir.match(/.git/)) return next() 
     if (dir.match(/node_modules/)) return next() 
     fs.lstat(file,function(err,stat){ 
      if(err) return next() 
      if(stat.mode==41398) return next() 
      if (stat.isDirectory()) { 
       setTimeout(function(file){ 
        walk(file,next) 
       }.bind(null,file),5) 
      } 
      else{ 
       x++ 
       if(false || x % 1000===0) console.log((new Date().valueOf()-start)/1000,x,file) 
       next() 
      } 
     }) 
     },function(){ 
     callback() 
     }) 
    } 
} 

walkAll({ 
    dir:'c:/', 
    delay:1000 
}); 

Answer 1

उप निर्देशिका का दौरा किया जा करने के लिए की एक सूची रखें, और सूची हर यात्रा अद्यतन:

आप

मेरे कोड धन्यवाद।

walk निम्न उदाहरण में फ़ंक्शन पिछले राज्य को लेता है, और अगली स्थिति के साथ अगली उप निर्देशिका की फ़ाइलें देता है।

आप प्रक्रिया को रोकने से पहले राज्य को बचा सकते हैं, फिर पुनरारंभ करते समय ट्रैवर्सल जारी रखने के लिए सहेजे गए राज्य को लोड कर सकते हैं।

function walk(state, readdir) { 
    let files = [], next = []; 
    while (state.length > 0) { 
    try { 
     const current = state.shift() 
     files = readdir(current).map(file => current + '/' + file) 
     next = state.concat(files) 
     break 
    } catch(e) {} 
    } 
    return [next, files] 
} 

function main() { 
    const {writeFileSync: writeFile, readdirSync: readdir} = require('fs') 
    const save = './walk.json' 

    let state 
    try { 
    state = require(save) 
    } catch(e) {} 
    if (!state || state.length < 1) state = ['.'] 

    const [nextState, files] = walk(state, readdir) 
    console.log(files) 
    writeFile(save, JSON.stringify(nextState, null, 2)) 
} 

main() 

Answer 2

एक वैकल्पिक विचार,

var miss = require('mississippi') 
var fs = require("fs") 
var through2 = require("through2") 
var path = require("path") 

function traverseDir(dirPath) { 
    var stack = [path.resolve(dirPath)]; 
    var filesStack = [] 
    return miss.from.obj(function(size, next) { 

    if (filesStack.length) { 
     return next(null, filesStack.shift()) 
    } 

    var self = this; 

    try { 
     while(stack.length) { 
     readADir(stack.pop()).forEach(function (f) { 
      if (f.t=="d") { 
      stack.push(f.p) 
      } 
      filesStack.push(f) 
     }) 
     if (filesStack.length) { 
      return next(null, filesStack.shift()) 
     } 
     } 
     return next(null, null) 
    }catch(ex) { 
     return next(ex) 
    } 
    }) 
} 

function readADir (dir) { 
    return fs.readdirSync(dir) 
    .map(function (f) {return path.join(dir, f)}) 
    .filter(function (f) { return !f.match(/\.git/) }) 
    .filter(function (f) { return !f.match(/Recycle/)}) 
    .filter(function (f) { return !f.match(/node_modules/)}) 
    .map(function (p) { 
     try { 
     var stat = fs.lstatSync(p); 
     if(stat.mode==41398) return null 
     var t = stat.isDirectory() ? "d":"f" 
     return { t: t, p: p } 
     }catch (ex) {} 
     return null 
    }) 
    .filter(function (o) {return o!==null}) 
} 

function loadState(base){ 
    base = path.resolve(base) 
    var state = {base: base, last:null} 
    if (fs.existsSync("state.json")) { 
    state = JSON.parse(fs.readFileSync("state.json")) 
    } else { 
    saveState(state) 
    } 
    return state 
} 

function saveState(state){ 
    fs.writeFileSync("state.json", JSON.stringify(state)) 
} 

var state = loadState("..") 
var sincePath = state.last; 

var filesStream = traverseDir(state.base) 
.on('end', function() { 
    console.log("end") 
}) 
.pipe(through2.obj(function (chunk, enc, next) { 
    if(!sincePath) this.push(chunk) 
    if(chunk.p===sincePath) { 
    sincePath=null 
    } 
    next() 
})) 

var tr = through2.obj(function (chunk, enc, next) { 
    state.last = chunk.p 
    saveState(state) 
    console.log("data %v %j", chunk.t, chunk.p) 
    this.push(chunk) 
    setTimeout(next, 500) 
}).resume() 

require('keypress')(process.stdin); 
process.stdin.on('keypress', function (ch, key) { 
    if(!key) return 
    if (key.name == "c") { 
    console.log("continue") 
    filesStream.pipe(tr) 
    } else if (key.name=="p") { 
    console.log("pause") 
    filesStream.unpipe(tr) 
    } 
}); 

console.log("Press 'c' to start")