Callbacks mit For-Schleife und Rekursion zu Verheißungen konvertieren

Question

Ich schrieb eine Funktion, die rekursiv ausgeführt wird, um Dateien zu finden, deren Name die angegebene Welt enthält. Ich verstehe nicht, wie Versprechungen funktionieren und finde keine Möglichkeit, diese Funktion mit Versprechen zu schreiben, obwohl ich mich sehr bemüht habe.

Ich versuchte, ein Versprechen innerhalb der Funktion findPath zurückzugeben, aber ich konnte es nicht verwenden, da extractFiles Aufrufe findPath. Ich habe versucht, eine Liste von Versprechungen zu erstellen und alle zurückzuschicken, aber auch keinen Erfolg.

Also wie könnte ich diese Funktionen mit Versprechen schreiben?

const fs = require('fs'); 
const path = require('path'); 


function findPath(targetPath, targetWord, done) { 
    if (!fs.existsSync(targetPath)) return; 

    fs.readdir(targetPath, (err, allPaths) => { 
    if (err) done(err, null); 

    for (aPath of allPaths) { 
     aPath = path.join(targetPath, aPath); 
     extractFiles(aPath, targetWord, done); 
    } 
    }); 

    function extractFiles(aPath, targetWord, done) { 
    fs.lstat(aPath, (err, stat) => { 
     if (err) done(err, null); 

     if (stat.isDirectory()) { 
     findPath(aPath, targetWord, done); 
     } 
     else if (aPath.indexOf(targetWord) >= 0) { 
     let fileName = aPath.split('.')[0]; 
     done(null, fileName); 
     } 
    }); 
    } 
} 

findPath('../modules', 'routes', file => { 
    console.log(file); 
}); 

Answer 1

Zum einen des "Kern" Code besser lesbar zu machen, ich

const promisify1p = fn => p1 => new Promise((resolve, reject) => { 
    fn(p1, (err, result) => { 
     if(err) { 
      reject(err); 
     } else { 
      resolve(result); 
     } 
    }); 
}); 
const readdirAsync = promisify1p(fs.readdir); 
const lstatAsync = promisify1p(fs.lstat); 

dann die fs-Funktionen promisify würde, die Kette nur die Versprechungen wie bei allen anderen Versprechungen

const fs = require('fs'); 
const path = require('path'); 

function findPath(targetPath, targetWord) { 
    const readPath = target => 
     readdirAsync(target) 
     .then(allPaths => 
      Promise.all(allPaths.map(aPath => extractFiles(path.join(target, aPath)))) 
      .then(x => x.filter(x=>x)) // remove all the "false" entries - i.e. that don't match targetWord 
      .then(x => [].concat.apply([], x)) // flatten the result 
     ); 
    const extractFiles = aPath => 
     lstatAsync(aPath).then(stat => { 
      if (stat.isDirectory()) { 
       return readPath(aPath); 
      } else if (aPath.includes(targetWord)) { 
       return aPath.split('.')[0]; 
      } 
      return false; 
     }); 
    return readPath(targetPath); 
} 

findPath('../modules', 'routes') 
.then(results => { 
    // do things with the results - which is an array of files that contain the targetWord 
}) 
.catch(err => console.error(err)); 

Nicht viel dabei.