@lppx/nlearn 1.1.8 → 1.1.10

package/dist/src/demo/promise-async/02-/345/271/266/345/217/221/346/216/247/345/210/266.js

@@ -0,0 +1,304 @@
+"use strict";
+/**
+ * Promise 并发控制
+ * ================
+ * 本文件介绍 Promise 的并发处理方法：Promise.all、Promise.race、Promise.allSettled、Promise.any
+ * 适用于 Node.js >= 14.0.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseAllDemo = promiseAllDemo;
+exports.promiseAllWithFailure = promiseAllWithFailure;
+exports.promiseAllSettledDemo = promiseAllSettledDemo;
+exports.promiseRaceDemo = promiseRaceDemo;
+exports.timeoutControl = timeoutControl;
+exports.promiseAnyDemo = promiseAnyDemo;
+exports.comparePromiseMethods = comparePromiseMethods;
+// #region 示例1: Promise.all - 等待所有 Promise 完成
+/**
+ * Promise.all 会等待所有 Promise 都成功，如果有一个失败则立即失败
+ */
+async function promiseAllDemo() {
+    console.log('=== Promise.all 示例 ===\n');
+    // 模拟多个异步任务
+    function fetchUser(id) {
+        return new Promise((resolve) => {
+            const delay = Math.random() * 1000 + 500;
+            setTimeout(() => {
+                console.log(`用户 ${id} 数据获取完成 (耗时 ${delay.toFixed(0)}ms)`);
+                resolve({ id, name: `用户${id}` });
+            }, delay);
+        });
+    }
+    try {
+        console.log('开始并发获取多个用户数据...\n');
+        const startTime = Date.now();
+        // 并发执行多个 Promise
+        const users = await Promise.all([
+            fetchUser(1),
+            fetchUser(2),
+            fetchUser(3),
+            fetchUser(4),
+        ]);
+        const endTime = Date.now();
+        console.log('\n所有用户数据:', users);
+        console.log(`总耗时: ${endTime - startTime}ms`);
+    }
+    catch (error) {
+        console.error('获取失败:', error);
+    }
+}
+// #endregion
+// #region 示例2: Promise.all 的失败处理
+/**
+ * 演示 Promise.all 在遇到失败时的行为
+ */
+async function promiseAllWithFailure() {
+    console.log('\n=== Promise.all 失败处理 ===\n');
+    function fetchData(id, shouldFail) {
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                if (shouldFail) {
+                    console.log(`任务 ${id} 失败`);
+                    reject(new Error(`任务 ${id} 失败`));
+                }
+                else {
+                    console.log(`任务 ${id} 成功`);
+                    resolve(`任务 ${id} 的结果`);
+                }
+            }, 1000);
+        });
+    }
+    try {
+        console.log('开始执行任务（其中一个会失败）...\n');
+        const results = await Promise.all([
+            fetchData(1, false),
+            fetchData(2, true), // 这个会失败
+            fetchData(3, false),
+        ]);
+        console.log('所有结果:', results);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error('\nPromise.all 被中断:', error.message);
+            console.log('注意：即使只有一个失败，Promise.all 也会立即失败');
+        }
+    }
+}
+// #endregion
+// #region 示例3: Promise.allSettled - 等待所有 Promise 完成（无论成功或失败）
+/**
+ * Promise.allSettled 会等待所有 Promise 完成，无论成功还是失败
+ * Node.js >= 12.9.0
+ */
+async function promiseAllSettledDemo() {
+    console.log('\n=== Promise.allSettled 示例 ===\n');
+    function fetchData(id, shouldFail) {
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                if (shouldFail) {
+                    reject(new Error(`任务 ${id} 失败`));
+                }
+                else {
+                    resolve(`任务 ${id} 的结果`);
+                }
+            }, 1000);
+        });
+    }
+    console.log('开始执行任务（部分会失败）...\n');
+    const results = await Promise.allSettled([
+        fetchData(1, false),
+        fetchData(2, true),
+        fetchData(3, false),
+        fetchData(4, true),
+    ]);
+    console.log('\n所有任务完成，结果如下:\n');
+    results.forEach((result, index) => {
+        if (result.status === 'fulfilled') {
+            console.log(`任务 ${index + 1}: 成功 - ${result.value}`);
+        }
+        else {
+            console.log(`任务 ${index + 1}: 失败 - ${result.reason.message}`);
+        }
+    });
+    // 统计成功和失败的数量
+    const successCount = results.filter((r) => r.status === 'fulfilled').length;
+    const failureCount = results.filter((r) => r.status === 'rejected').length;
+    console.log(`\n成功: ${successCount} 个, 失败: ${failureCount} 个`);
+}
+// #endregion
+// #region 示例4: Promise.race - 返回最快完成的 Promise
+/**
+ * Promise.race 返回最快完成的 Promise（无论成功还是失败）
+ */
+async function promiseRaceDemo() {
+    console.log('\n=== Promise.race 示例 ===\n');
+    function fetchWithDelay(id, delay) {
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                console.log(`任务 ${id} 完成 (延迟 ${delay}ms)`);
+                resolve(`任务 ${id} 的结果`);
+            }, delay);
+        });
+    }
+    console.log('开始竞速...\n');
+    const winner = await Promise.race([
+        fetchWithDelay(1, 2000),
+        fetchWithDelay(2, 1000),
+        fetchWithDelay(3, 1500),
+    ]);
+    console.log('\n最快完成的任务:', winner);
+}
+// #endregion
+// #region 示例5: Promise.race 实现超时控制
+/**
+ * 使用 Promise.race 实现请求超时控制
+ */
+async function timeoutControl() {
+    console.log('\n=== 使用 Promise.race 实现超时控制 ===\n');
+    // 创建超时 Promise
+    function timeout(ms) {
+        return new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new Error(`请求超时 (${ms}ms)`));
+            }, ms);
+        });
+    }
+    // 模拟慢速请求
+    function slowRequest() {
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                resolve('请求成功');
+            }, 3000);
+        });
+    }
+    try {
+        console.log('发起请求（超时时间 2 秒）...\n');
+        const result = await Promise.race([
+            slowRequest(),
+            timeout(2000),
+        ]);
+        console.log('结果:', result);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error('错误:', error.message);
+        }
+    }
+}
+// #endregion
+// #region 示例6: Promise.any - 返回第一个成功的 Promise
+/**
+ * Promise.any 返回第一个成功的 Promise，所有都失败才失败
+ * Node.js >= 15.0.0
+ */
+async function promiseAnyDemo() {
+    console.log('\n=== Promise.any 示例 ===\n');
+    function fetchFromServer(serverId, delay, shouldFail) {
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                if (shouldFail) {
+                    console.log(`服务器 ${serverId} 失败`);
+                    reject(new Error(`服务器 ${serverId} 不可用`));
+                }
+                else {
+                    console.log(`服务器 ${serverId} 成功`);
+                    resolve(`来自服务器 ${serverId} 的数据`);
+                }
+            }, delay);
+        });
+    }
+    try {
+        console.log('尝试从多个服务器获取数据...\n');
+        // 模拟从多个服务器获取数据，只要有一个成功就返回
+        const result = await Promise.any([
+            fetchFromServer(1, 2000, true), // 失败
+            fetchFromServer(2, 1500, false), // 成功
+            fetchFromServer(3, 1000, true), // 失败
+        ]);
+        console.log('\n获取成功:', result);
+    }
+    catch (error) {
+        console.error('所有服务器都失败了:', error);
+    }
+}
+// #endregion
+// #region 示例7: 并发控制对比
+/**
+ * 对比不同并发控制方法的行为
+ */
+async function comparePromiseMethods() {
+    console.log('\n=== 并发控制方法对比 ===\n');
+    function task(id, delay, shouldFail) {
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                if (shouldFail) {
+                    reject(new Error(`任务 ${id} 失败`));
+                }
+                else {
+                    resolve(`任务 ${id} 成功`);
+                }
+            }, delay);
+        });
+    }
+    const tasks = [
+        task(1, 1000, false),
+        task(2, 1500, true),
+        task(3, 500, false),
+    ];
+    console.log('Promise.all: 所有成功才成功，一个失败就失败');
+    console.log('Promise.allSettled: 等待所有完成，返回每个状态');
+    console.log('Promise.race: 返回最快完成的（成功或失败）');
+    console.log('Promise.any: 返回第一个成功的，所有失败才失败\n');
+    // 注意：这里为了演示，我们需要重新创建 tasks
+    console.log('--- Promise.allSettled 结果 ---');
+    const settledResults = await Promise.allSettled([
+        task(1, 1000, false),
+        task(2, 1500, true),
+        task(3, 500, false),
+    ]);
+    console.log(settledResults.map((r, i) => `任务${i + 1}: ${r.status}`));
+    console.log('\n--- Promise.race 结果 ---');
+    try {
+        const raceResult = await Promise.race([
+            task(1, 1000, false),
+            task(2, 1500, true),
+            task(3, 500, false),
+        ]);
+        console.log('最快完成:', raceResult);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.log('最快完成（失败）:', error.message);
+        }
+    }
+}
+// #endregion
+// 主函数：根据参数运行指定示例
+if (require.main === module) {
+    const exampleNumber = process.argv[2];
+    const examples = {
+        '1': promiseAllDemo,
+        '2': promiseAllWithFailure,
+        '3': promiseAllSettledDemo,
+        '4': promiseRaceDemo,
+        '5': timeoutControl,
+        '6': promiseAnyDemo,
+        '7': comparePromiseMethods,
+    };
+    if (exampleNumber && examples[exampleNumber]) {
+        console.log(`\n运行示例 ${exampleNumber}:\n`);
+        examples[exampleNumber]().catch(console.error);
+    }
+    else {
+        console.log('请指定要运行的示例编号 (1-7)');
+        console.log('例如: ts-node src/demo/promise-async/02-并发控制.ts 1');
+        console.log('\n可用示例:');
+        console.log('1 - Promise.all 基础用法');
+        console.log('2 - Promise.all 失败处理');
+        console.log('3 - Promise.allSettled 用法');
+        console.log('4 - Promise.race 基础用法');
+        console.log('5 - Promise.race 实现超时控制');
+        console.log('6 - Promise.any 用法');
+        console.log('7 - 并发控制方法对比');
+    }
+}

package/dist/src/demo/promise-async/03-/351/253/230/347/272/247/346/250/241/345/274/217.js

@@ -0,0 +1,311 @@
+"use strict";
+/**
+ * Promise 与 async/await 高级模式
+ * ===============================
+ * 本文件介绍 Promise 的高级使用模式：串行执行、并发限制、重试机制等
+ * 适用于 Node.js >= 14.0.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serialExecution = serialExecution;
+exports.serialWithReduce = serialWithReduce;
+exports.concurrencyLimit = concurrencyLimit;
+exports.retryMechanism = retryMechanism;
+exports.promiseCache = promiseCache;
+exports.lazyPromise = lazyPromise;
+exports.promiseQueue = promiseQueue;
+// #region 示例1: 串行执行多个异步任务
+/**
+ * 使用 async/await 串行执行多个异步任务
+ */
+async function serialExecution() {
+    console.log('=== 串行执行异步任务 ===\n');
+    function processTask(id) {
+        return new Promise((resolve) => {
+            const delay = 1000;
+            setTimeout(() => {
+                console.log(`任务 ${id} 完成`);
+                resolve(`任务 ${id} 的结果`);
+            }, delay);
+        });
+    }
+    console.log('开始串行执行...\n');
+    const startTime = Date.now();
+    const results = [];
+    for (let i = 1; i <= 3; i++) {
+        const result = await processTask(i);
+        results.push(result);
+    }
+    const endTime = Date.now();
+    console.log('\n所有结果:', results);
+    console.log(`总耗时: ${endTime - startTime}ms (约 3 秒)`);
+}
+// #endregion
+// #region 示例2: 使用 reduce 实现串行执行
+/**
+ * 使用 reduce 优雅地实现串行执行
+ */
+async function serialWithReduce() {
+    console.log('\n=== 使用 reduce 串行执行 ===\n');
+    function fetchData(id) {
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                console.log(`获取数据 ${id}`);
+                resolve(id * 10);
+            }, 500);
+        });
+    }
+    const ids = [1, 2, 3, 4, 5];
+    const results = await ids.reduce(async (previousPromise, id) => {
+        const acc = await previousPromise;
+        const result = await fetchData(id);
+        return [...acc, result];
+    }, Promise.resolve([]));
+    console.log('\n最终结果:', results);
+}
+// #endregion
+// #region 示例3: 并发限制（控制同时执行的任务数量）
+/**
+ * 实现并发限制，控制同时执行的 Promise 数量
+ */
+async function concurrencyLimit() {
+    console.log('\n=== 并发限制 ===\n');
+    function task(id) {
+        return new Promise((resolve) => {
+            const delay = Math.random() * 1000 + 500;
+            console.log(`任务 ${id} 开始 (预计 ${delay.toFixed(0)}ms)`);
+            setTimeout(() => {
+                console.log(`任务 ${id} 完成`);
+                resolve(`任务 ${id} 的结果`);
+            }, delay);
+        });
+    }
+    // 并发限制函数
+    async function runWithLimit(tasks, limit) {
+        const results = [];
+        const executing = [];
+        for (const taskFn of tasks) {
+            const promise = taskFn().then((result) => {
+                results.push(result);
+                executing.splice(executing.indexOf(promise), 1);
+            });
+            executing.push(promise);
+            if (executing.length >= limit) {
+                await Promise.race(executing);
+            }
+        }
+        await Promise.all(executing);
+        return results;
+    }
+    // 创建 10 个任务，但限制同时只能执行 3 个
+    const tasks = Array.from({ length: 10 }, (_, i) => () => task(i + 1));
+    console.log('开始执行 10 个任务，并发限制为 3\n');
+    const startTime = Date.now();
+    const results = await runWithLimit(tasks, 3);
+    const endTime = Date.now();
+    console.log(`\n完成 ${results.length} 个任务，总耗时: ${endTime - startTime}ms`);
+}
+// #endregion
+// #region 示例4: 重试机制
+/**
+ * 实现带重试机制的异步操作
+ */
+async function retryMechanism() {
+    console.log('\n=== 重试机制 ===\n');
+    let attemptCount = 0;
+    // 模拟可能失败的操作
+    function unreliableOperation() {
+        attemptCount++;
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                // 前两次失败，第三次成功
+                if (attemptCount < 3) {
+                    console.log(`第 ${attemptCount} 次尝试失败`);
+                    reject(new Error('操作失败'));
+                }
+                else {
+                    console.log(`第 ${attemptCount} 次尝试成功`);
+                    resolve('操作成功');
+                }
+            }, 500);
+        });
+    }
+    // 重试函数
+    async function retry(fn, maxRetries, delay = 1000) {
+        for (let i = 0; i < maxRetries; i++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                if (i === maxRetries - 1) {
+                    throw error;
+                }
+                console.log(`等待 ${delay}ms 后重试...\n`);
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+        throw new Error('不应该到达这里');
+    }
+    try {
+        console.log('开始执行不可靠的操作（最多重试 3 次）\n');
+        const result = await retry(unreliableOperation, 3, 1000);
+        console.log('\n最终结果:', result);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error('所有重试都失败了:', error.message);
+        }
+    }
+}
+// #endregion
+// #region 示例5: Promise 缓存
+/**
+ * 实现 Promise 结果缓存，避免重复请求
+ */
+async function promiseCache() {
+    console.log('\n=== Promise 缓存 ===\n');
+    const cache = new Map();
+    function fetchWithCache(key, fetcher) {
+        if (cache.has(key)) {
+            console.log(`从缓存获取: ${key}`);
+            return cache.get(key);
+        }
+        console.log(`首次请求: ${key}`);
+        const promise = fetcher();
+        cache.set(key, promise);
+        // 如果请求失败，从缓存中移除
+        promise.catch(() => {
+            cache.delete(key);
+        });
+        return promise;
+    }
+    // 模拟数据获取
+    function fetchUser(id) {
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                resolve({ id, name: `用户${id}` });
+            }, 1000);
+        });
+    }
+    // 多次请求同一个用户
+    console.log('发起 3 次相同的请求...\n');
+    const [user1, user2, user3] = await Promise.all([
+        fetchWithCache('user-1', () => fetchUser(1)),
+        fetchWithCache('user-1', () => fetchUser(1)),
+        fetchWithCache('user-1', () => fetchUser(1)),
+    ]);
+    console.log('\n结果:', user1, user2, user3);
+    console.log('注意：虽然发起了 3 次请求，但实际只执行了 1 次');
+}
+// #endregion
+// #region 示例6: 延迟执行（Lazy Promise）
+/**
+ * 创建延迟执行的 Promise（只有在需要时才执行）
+ */
+async function lazyPromise() {
+    console.log('\n=== 延迟执行的 Promise ===\n');
+    // 普通 Promise 会立即执行
+    console.log('创建普通 Promise:');
+    const eagerPromise = new Promise((resolve) => {
+        console.log('  立即执行！');
+        resolve('结果');
+    });
+    // 延迟 Promise 只有在调用时才执行
+    console.log('\n创建延迟 Promise:');
+    const lazyPromiseFactory = () => new Promise((resolve) => {
+        console.log('  现在才执行！');
+        resolve('结果');
+    });
+    console.log('延迟 Promise 已创建，但还没执行');
+    console.log('等待 2 秒...\n');
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    console.log('现在调用延迟 Promise:');
+    await lazyPromiseFactory();
+}
+// #endregion
+// #region 示例7: Promise 队列
+/**
+ * 实现 Promise 队列，按顺序执行任务
+ */
+async function promiseQueue() {
+    console.log('\n=== Promise 队列 ===\n');
+    class PromiseQueue {
+        constructor() {
+            this.queue = [];
+            this.running = false;
+        }
+        add(task) {
+            return new Promise((resolve, reject) => {
+                this.queue.push(async () => {
+                    try {
+                        const result = await task();
+                        resolve(result);
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                });
+                if (!this.running) {
+                    this.run();
+                }
+            });
+        }
+        async run() {
+            this.running = true;
+            while (this.queue.length > 0) {
+                const task = this.queue.shift();
+                await task();
+            }
+            this.running = false;
+        }
+    }
+    const queue = new PromiseQueue();
+    function task(id, delay) {
+        return new Promise((resolve) => {
+            console.log(`任务 ${id} 开始`);
+            setTimeout(() => {
+                console.log(`任务 ${id} 完成 (耗时 ${delay}ms)`);
+                resolve(`任务 ${id} 的结果`);
+            }, delay);
+        });
+    }
+    console.log('添加 5 个任务到队列\n');
+    // 同时添加多个任务，但它们会按顺序执行
+    const results = await Promise.all([
+        queue.add(() => task(1, 1000)),
+        queue.add(() => task(2, 500)),
+        queue.add(() => task(3, 800)),
+        queue.add(() => task(4, 300)),
+        queue.add(() => task(5, 600)),
+    ]);
+    console.log('\n所有任务完成:', results);
+}
+// #endregion
+// 主函数：根据参数运行指定示例
+if (require.main === module) {
+    const exampleNumber = process.argv[2];
+    const examples = {
+        '1': serialExecution,
+        '2': serialWithReduce,
+        '3': concurrencyLimit,
+        '4': retryMechanism,
+        '5': promiseCache,
+        '6': lazyPromise,
+        '7': promiseQueue,
+    };
+    if (exampleNumber && examples[exampleNumber]) {
+        console.log(`\n运行示例 ${exampleNumber}:\n`);
+        examples[exampleNumber]().catch(console.error);
+    }
+    else {
+        console.log('请指定要运行的示例编号 (1-7)');
+        console.log('例如: ts-node src/demo/promise-async/03-高级模式.ts 1');
+        console.log('\n可用示例:');
+        console.log('1 - 串行执行异步任务');
+        console.log('2 - 使用 reduce 串行执行');
+        console.log('3 - 并发限制');
+        console.log('4 - 重试机制');
+        console.log('5 - Promise 缓存');
+        console.log('6 - 延迟执行的 Promise');
+        console.log('7 - Promise 队列');
+    }
+}