TypeScript fs.readdir函數代碼示例

export async function requireDir(path: string, iterator: (mod: any, path?: string) => Promise<any>): Promise<void> {
    
    if (!Path.isAbsolute(path)) {
        path = Path.resolve(path);
    }

    let files = await fs.readdir(path);
    files.sort();

    for (let i = 0, ii = files.length; i < ii; i++) {
        let fp = Path.join(path, files[i])

        let stat = await fs.stat(fp);


        if (stat.isDirectory()) {
            await requireDir(fp, iterator);
            continue;
        }

        let mod;
        try {
            mod = require(fp);
        } catch (e) {
            e.path = fp;
            throw e

        }

        await iterator(mod, fp);
    }
}

export function render(inputPath) {

    return fs
        .readdir(inputPath)
        .then(files => {

            var rendering = files
                .filter(file => file.endsWith('.md'))
                .map(file => {
                    const pathToFile = path.join(inputPath, file);
                    const pathForHtml = path.join(outputPath, file.replace('.md', '.html'));

                    return fs
                        .readFile(pathToFile, 'utf8')
                        .then(raw => {
                            console.log(pathToFile);

                            const html = marked(raw);
                            return fs.writeFile(pathForHtml, html);
                        });
                });

            return Promise.all(rendering);
        });
};

async function buildDirectory(
  srcDirPath: string,
  outDirPath: string,
  options: CLIOptions,
): Promise<void> {
  const extension = options.sucraseOptions.transforms.includes("typescript") ? ".ts" : ".js";
  if (!(await exists(outDirPath))) {
    await mkdir(outDirPath);
  }
  for (const child of await readdir(srcDirPath)) {
    if (["node_modules", ".git"].includes(child) || options.excludeDirs.includes(child)) {
      continue;
    }
    const srcChildPath = join(srcDirPath, child);
    const outChildPath = join(outDirPath, child);
    if ((await stat(srcChildPath)).isDirectory()) {
      await buildDirectory(srcChildPath, outChildPath, options);
    } else if (srcChildPath.endsWith(extension)) {
      const outPath = `${outChildPath.substr(0, outChildPath.length - extension.length)}.${
        options.outExtension
      }`;
      await buildFile(srcChildPath, outPath, options);
    }
  }
}

// TODO(usergenic): Variants should support the directory naming convention in
// the .bowerrc instead of hardcoded 'bower_components' form seen here.
async function findVariants(options: ServerOptions) {
  const root = options.root || process.cwd();
  const filesInRoot = await fs.readdir(root);
  const variants = filesInRoot
                       .map(f => {
                         const match = f.match(/^bower_components-(.*)/!);
                         return match && {name: match[1], directory: match[0]};
                       })
                       .filter(f => f != null && f.name !== '');
  return variants;
}

    /**
     * Gets all subdirectories (not files) under a directory.
     */
    protected static async getSubdirectoriesAsync(directoryPath: string): Promise<string[]> {
        let directoryNames: string[] = [];
        let childNames: string[] = await fs.readdir(directoryPath);

        for (let i = 0; i < childNames.length; i++) {
            if ((await fs.stat(path.join(directoryPath, childNames[i]))).isDirectory()) {
                directoryNames.push(childNames[i]);
            }
        }

        return directoryNames;
    }

    static async $rmr(node?: string): Promise<void> {
        if (node) {
            if ((await fs.stat(node)).isDirectory()) {
                for (const file of await fs.readdir(node)) {
                    await Engine.$rmr(path.join(node, file));
                }

                await fs.rmdir(node);
            }
            else {
                await fs.unlink(node);
            }
        }
    }

export default async function mergeDirectoryContents(
  srcDirPath: string,
  destDirPath: string,
): Promise<void> {
  if (!(await exists(destDirPath))) {
    await mkdir(destDirPath);
  }
  for (const child of await readdir(srcDirPath)) {
    const srcChildPath = join(srcDirPath, child);
    const destChildPath = join(destDirPath, child);
    if ((await stat(srcChildPath)).isDirectory()) {
      await mergeDirectoryContents(srcChildPath, destChildPath);
    } else {
      await copyFile(srcChildPath, destChildPath);
    }
  }
}

  async function processDirectory(path: string): Promise<void> {
    let children = await readdir(path);

    for (let child of children) {
      let childPath = join(path, child);
      let childStat = await stat(childPath);

      if (childStat.isDirectory()) {
        await processDirectory(childPath);
      } else if (options.modernizeJS) {
        if (child.endsWith('.js')) {
          await processPath(childPath);
        }
      } else if (child.endsWith('.coffee') || child.endsWith('.litcoffee') || child.endsWith('.coffee.md')) {
        await processPath(childPath);
      }
    }
  }

 async function visit(path: string): Promise<void> {
   for (const child of await readdir(path)) {
     if (["node_modules", ".git"].includes(child)) {
       continue;
     }
     const childPath = join(path, child);
     if ((await stat(childPath)).isDirectory()) {
       await visit(childPath);
     } else if (
       childPath.endsWith(".js") ||
       childPath.endsWith(".jsx") ||
       childPath.endsWith(".ts") ||
       childPath.endsWith(".tsx")
     ) {
       const code = (await readFile(childPath)).toString();
       results.push({code, path: childPath});
     }
   }
 }