nodejs 通过readdir方法 遍历指定文件夹下所有的文件夹(更新版) 第二种方法会在遍历完成后回调

通过readdir方法 遍历指定文件夹下所有的文件夹

文件结构

代码

var fs = require('fs');
// 指定是父级文件下的什么的文件夹
var dirfath = 'html1';

readDir(dirfath);

function readDir(dirfather) {
	fs.readdir(dirfather, function(err, data) {
		if (err) {
			console.log('停止迭代');
			return false;
		}
		// 这个data数组中装的是当前文件夹下所有的文件名(包括文件夹)
		data.forEach(function(el, index) {
			// 加上父级访问更深层的文件夹
			fs.stat( `${dirfather}/`+ el, function(errFiletype, dataFile) {
				// 如果触发这个就证明程序错误
				if (errFiletype) {
					console.log('读取文件错误', errFiletype);
					return false;
				}
				
				// 又是文件夹
				if( dataFile.isDirectory()) {
					// 遍历文件夹
					console.log('是文件夹:' + `${dirfather}/`+ el);
					// 迭代
					readDir(`${dirfather}/`+ el);
				} else {
					// 遍历文件
					console.log('是文件: ' + `${dirfather}/`+ el);
				}
			})
			
		})
	})

结果

第二种方法

• 第二种方法会在遍历完成后回调

把下面的这个封装到一个文件里面, 然后用CommonJS的方法引用就可以了

下面这个比较好的地方是通过类似查询的方式修改过的, 它可以在迭代完成的时候再将数据送到main函数中进行处理

const fs = require("fs")

let dirArray = [];         // 这个的作用是存储结果
let flieArray = [];         // 这个东西的作用是存储文件
let arrObj = {};
arrObj.dirArr = dirArray;
arrObj.fileArr = flieArray;
let number = 0;            // number的作用是找到迭代结束的位置

/**
 * 
 * @param {*} dir 路径
 * 迭代的函数本身, 它会调用foreach函数
 */
function readDirIter2(dir) {
    // 开始的时候加一
    number++;
    foreach(dir)
}

/**
 * 这个异步的作用是获取到结果
 */
async function getArray() {
    return new Promise((resolve, reject) => {
        let timer1 = setInterval(function() {
            if( number == 0 ) {
                resolve(arrObj)
                clearInterval(timer1)
            }
        }, 1)
    })
}

/**
 * 
 * @param {*} dir 读取文件夹的路径
 * 这个文件的作用是读取路径
 */
async function readDir(dir) {
    return new Promise((resolve, reject) => {
        fs.readdir(dir + "/", (err, data) => {
            if(err) {
                console.log("路径错误")
                console.error(err)
                return;
            }
            resolve(data)
        })
    })
}

/**
 * 
 * @param {} dir 
 * 这个的作用是遍历路径值, 看路径是文件还是文件夹
 * 如果是文件夹则又调用路径读取迭代
 */
async function foreach(dir) {
    let data = await readDir(dir);
    if( data.length == 0 ) {
        // 如果数组长度为0 number减一
        --number;
    }

    data.forEach((el, index, arr) => {
        fs.stat( dir + "/" + el, (err, data) => {
            if( err ) {
                // 这里代变整个代码错了
                console.log("路径错误")
                console.error(err)
                return;
            }

            if(!data.isFile()) {
                dirArray.push(dir + "/" + el);
                readDirIter2(dir + "/" + el)
            }

            if(data.isFile()) {
            	flieArray.push(dir + "/" + el);
            }

            // 如果是文件且是最后一个number减一
            if( arr.length == index + 1 ) {
                --number
            }
            
        })
    })
}

/**
 * 
 * @param {*} dir 要查找的路径
 * 入口函数
 */
async function main(dir) {
    readDirIter2(dir)
    let obj = await getArray();
    return obj;
}

exports.main = main;

使用

let fun = require("./app.js")

fun.main(".").then(res => {
	console.log(res);
});

这里可以对回调后的数据进行处理
可以在入口函数中对这个东西尽心处理

这样就可以使用了

let fun = require("./test.js")

fun.main(".")

如果不分开这个代码是这样的

分开了也是可以运行的

const fs = require("fs")

let dirArray = [];         // 这个的作用是存储结果
let number = 0;            // number的作用是找到迭代结束的位置


function readDirIter2(dir) {
    // 开始的时候加一
    number++;
    foreach(dir)
    // test().then(res => {
    //     console.log(res)
    // });
}

/**
 * 这个异步的作用是获取到结果
 */
async function getArray() {
    return new Promise((resolve, reject) => {
        let timer1 = setInterval(function() {
            if( number == 0 ) {
                resolve(dirArray)
                clearInterval(timer1)
            }
        }, 1)
    })
}

/**
 * 
 * @param {*} dir 读取文件夹的路径
 * 这个文件的作用是读取路径
 */
async function readDir(dir) {
    return new Promise((resolve, reject) => {
        fs.readdir(dir + "/", (err, data) => {
            if(err) {
                console.log("路径错误")
                console.error(err)
                return;
            }
            resolve(data)
        })
    })
}

/**
 * 
 * @param {} dir 
 * 这个的作用是遍历路径值, 看路径是文件还是文件夹
 * 如果是文件夹则又调用路径读取迭代
 */
async function foreach(dir) {
    let data = await readDir(dir);
    if( data.length == 0 ) {
        // 如果数组长度为0 number减一
        --number;
    }

    data.forEach((el, index, arr) => {
        fs.stat( dir + "/" + el, (err, data) => {
            if( err ) {
                // 这里代变整个代码错了
                console.log("路径错误")
                console.error(err)
                return;
            }

            if(!data.isFile()) {
                dirArray.push(dir + "/" + el);
                readDirIter2(dir + "/" + el)
            }

            // 如果是文件且是最后一个number减一
            if( arr.length == index + 1 ) {
                --number
            }
            
        })
    })
}

/**
 * 入口函数
 */
async function main() {
    readDirIter2(".")
    let arr = await getArray();
    console.log(arr)
}

main();