JavaScript常用方法合集：从入门到精通，一篇文章搞定！

const fs = require('fs');
const glob = require('glob');
const iconv = require('iconv-lite');

/**
 * 异步函数findFilesWithExtensions用于在指定文件夹中查找具有特定后缀名的文件
 * @param {string} folderPath - 要搜索的文件夹路径
 * @param {Array<string>} [suffixes=['*.txt', '*.word']] - 可选参数，文件后缀名数组，默认为['*.txt', '*.word']
 * @returns {Array<string>} - 返回匹配后缀名的文件路径数组
 * @throws {Error} - 如果在搜索过程中发生错误，则抛出异常
 * 示例用法：
 * findFilesWithExtensions('/path/to/folder', ['*.js', '*.json'])
 * // 返回 ['/path/to/folder/file1.js', '/path/to/folder/file2.json'] 等
 */
async function findFilesWithExtensions(folderPath, suffixes = ['*.txt', '*.word']) {
    try {
        const patterns = suffixes.map(suffix => `${folderPath}/${suffix}`);
        const bracket = suffixes.length === 1 ? `${patterns.join(',')}` : `{${patterns.join(',')}}`;
        return glob.sync(bracket);
    } catch (error) {
        throw error;
    }
}

/**
 * 异步读取指定文件路径的文本文件内容。
 * @param {string} filePath - 要读取的文件的路径。
 * @returns {Promise<string>} 返回一个解析为文件内容的 Promise 对象。
 * @throws {Error} 如果读取文件过程中发生错误，则抛出异常。
 */
async function readTextFile(filePath) {
    try {
        const contentBuffer = await fs.promises.readFile(filePath);
        const encoding = iconv.encodingExists(contentBuffer) || 'utf8';
        const content = iconv.decode(contentBuffer, encoding);
        return content;
    } catch (error) {
        throw error;
    }

}

### 异步写入文本文件
```javascript

// 异步写入文本文件
/**
 * 异步写入文本内容到指定文件路径。
 * @param {string} filePath - 要写入的文件路径。
 * @param {string} content - 要写入的文本内容。
 * @param {string} [encoding='utf8'] - 文本的编码格式，默认为'utf8'。
 * @throws {Error} 如果写入过程中发生错误，则抛出异常。
 * 
 * @example
 * // 写入'Hello, World!'到'/path/to/file.txt'
 * writeTextFile('/path/to/file.txt', 'Hello, World!');
 */
async function writeTextFile(filePath, content, encoding = 'utf8') {
    try {
        const contentBuffer = iconv.encode(content, encoding);
        await fs.promises.appendFile(filePath, contentBuffer);
    } catch (error) {
        throw error;
    }
}

/**
 * 异步读取图像文件的函数
 * @param {string} filePath - 图像文件的路径
 * @returns {Promise<Buffer>} 返回一个包含图像数据的 Buffer 对象的 Promise
 * @throws {Error} 如果读取文件时发生错误，将抛出异常
 *
 * 该函数使用 fs.promises.readFile 方法来异步读取指定路径的图像文件，并返回一个包含图像数据的 Buffer 对象。
 * 如果在读取过程中遇到任何错误，它将被捕获并作为异常抛出。
 */
async function forceDeleteFile(filePath) {
    try {
        await fs.promises.unlink(filePath);
        console.log(`File ${filePath} successfully deleted.`);
    } catch (error) {
        if (error.code === 'ENOENT') {
            console.log(`File ${filePath} not found.`);
        } else {
            throw error;
        }
    }
}

/**
 * 异步读取图像文件并返回其缓冲区。
 *
 * @param {string} filePath - 图像文件的路径。
 * @returns {Promise<Buffer>} 返回一个包含图像数据的 Buffer 对象的 Promise。
 * @throws {Error} 如果读取文件时发生错误，则抛出异常。
 *
 * @example
 * const imageBuffer = await readImageFile('/path/to/image.jpg');
 */
async function readImageFile(filePath) {
    try {
        const imageBuffer = await fs.promises.readFile(filePath);
        return imageBuffer;
    } catch (error) {
        throw error;
    }
}

/**
 * 异步函数writeImageFile用于将图像缓冲区写入指定文件路径。
 * @param {string} filePath - 图像文件的保存路径。
 * @param {Buffer} imageBuffer - 要写入的图像数据缓冲区。
 * @throws {Error} 如果写入文件过程中发生错误，则抛出异常。
 * @returns {Promise<void>} 写入操作完成时返回一个解决的Promise。
 */
async function writeImageFile(filePath, imageBuffer) {
    try {
        await fs.promises.writeFile(filePath, imageBuffer);
        console.log(`Image successfully written to ${filePath}`);
    } catch (error) {
        throw error;
    }
}

/**
 * 异步创建目录函数
 * @param {string} path - 要创建的目录路径
 * 此函数用于判断指定路径是否存在，若不存在则创建文件夹。
 * 若路径已存在，则输出提示信息。
 */
async function createDirectory(path) {
// 判断指定路径是否存在
    // 检查路径是否存在
    if (!fs.existsSync(path)) {
        // 如果路径不存在，则创建文件夹
        fs.mkdirSync(path, { recursive: true });
        console.log(`文件夹已创建: ${path}`);
    } else {
        console.log(`文件夹已存在: ${path}`);
    }
}

/**
 * 异步等待函数，用于在指定的时间后继续执行后续代码。
 * @param {number} [timeout=1000] - 等待的毫秒数，默认为1000毫秒（1秒）。
 * @returns {Promise<void>} 返回一个在指定延迟后解决的Promise对象。
 * 
 * @example
 * // 等待2秒后继续执行
 * await sleep(2000);
 */
async function sleep(timeout = 1000) {
    return new Promise(resolve => {
        setTimeout(() => {
            resolve(); // 延迟完成时，调用 resolve
        }, timeout);
    });
}

//use function,延时1秒
// await sleep(1000)

/**
 * 从给定数组中随机选择指定数量的元素。
 *
 * @param {Array} arr - 要选择元素的源数组。
 * @param {number} count - 要选择的元素数量。
 * @returns {Array} 包含随机选择的元素的新数组。
 *
 * @example
 * // 返回一个包含 arr 中随机两个元素的新数组
 * getRandomElements([1, 2, 3, 4, 5], 2);
 *
 * // 如果请求的元素数量超过数组长度，则返回整个数组的一个随机排列
 * getRandomElements([1, 2, 3], 5);
 *
 * // 如果请求的元素数量为零，则返回一个空数组
 * getRandomElements([1, 2, 3], 0);
 */
function getRandomElements(arr, count) {
    count = Math.min(count, arr.length);
    // 创建数组副本，以免修改原数组
    const arrCopy = arr.slice();
    // 打乱数组顺序
    for (let i = arrCopy.length - 1; i > 0; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        [arrCopy[i], arrCopy[j]] = [arrCopy[j], arrCopy[i]];
    }
    // 取出前 count 个元素
    return arrCopy.slice(0, count);
}