@lppx/nlearn 1.1.13 → 1.1.15

package/dist/src/demo/data-types/01-/345/237/272/347/241/200/347/261/273/345/236/213.js

@@ -0,0 +1,157 @@
+"use strict";
+/**
+ * TypeScript 基础数据类型
+ * =====================
+ * 本文件介绍 TypeScript 的基础数据类型，包括：
+ * - 原始类型（number, string, boolean）
+ * - null 和 undefined
+ * - symbol 和 bigint
+ *
+ * 适用版本：TypeScript 5.x
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.demonstrateNumberType = demonstrateNumberType;
+exports.demonstrateStringType = demonstrateStringType;
+exports.demonstrateBooleanType = demonstrateBooleanType;
+exports.demonstrateNullAndUndefined = demonstrateNullAndUndefined;
+exports.demonstrateSymbolType = demonstrateSymbolType;
+exports.demonstrateBigIntType = demonstrateBigIntType;
+// #region 示例1: 数字类型 (number)
+function demonstrateNumberType() {
+    console.log('\n=== 数字类型示例 ===');
+    // 整数
+    const integer = 42;
+    console.log('整数:', integer);
+    // 浮点数
+    const float = 3.14;
+    console.log('浮点数:', float);
+    // 十六进制
+    const hex = 0xff;
+    console.log('十六进制 0xff:', hex);
+    // 二进制
+    const binary = 0b1010;
+    console.log('二进制 0b1010:', binary);
+    // 八进制
+    const octal = 0o744;
+    console.log('八进制 0o744:', octal);
+    // 特殊数值
+    const infinity = Infinity;
+    const notANumber = NaN;
+    console.log('Infinity:', infinity);
+    console.log('NaN:', notANumber);
+}
+// #endregion
+// #region 示例2: 字符串类型 (string)
+function demonstrateStringType() {
+    console.log('\n=== 字符串类型示例 ===');
+    // 单引号
+    const singleQuote = 'Hello';
+    console.log('单引号:', singleQuote);
+    // 双引号
+    const doubleQuote = "World";
+    console.log('双引号:', doubleQuote);
+    // 模板字符串
+    const name = 'TypeScript';
+    const version = 5;
+    const template = `${name} 版本 ${version}`;
+    console.log('模板字符串:', template);
+    // 多行字符串
+    const multiline = `
+        这是一个
+        多行字符串
+        示例
+    `;
+    console.log('多行字符串:', multiline.trim());
+}
+// #endregion
+// #region 示例3: 布尔类型 (boolean)
+function demonstrateBooleanType() {
+    console.log('\n=== 布尔类型示例 ===');
+    const isTrue = true;
+    const isFalse = false;
+    console.log('真值:', isTrue);
+    console.log('假值:', isFalse);
+    // 布尔运算
+    const result = isTrue && !isFalse;
+    console.log('运算结果:', result);
+    // 类型推断
+    const inferred = 10 > 5; // TypeScript 自动推断为 boolean
+    console.log('推断类型的布尔值:', inferred);
+}
+// #endregion
+// #region 示例4: null 和 undefined
+function demonstrateNullAndUndefined() {
+    console.log('\n=== null 和 undefined 示例 ===');
+    // undefined - 变量已声明但未赋值
+    let notAssigned = undefined;
+    console.log('undefined:', notAssigned);
+    // null - 表示空值或不存在的对象
+    let empty = null;
+    console.log('null:', empty);
+    // 可选类型（联合类型）
+    let maybeString = null;
+    console.log('可为 null 的字符串:', maybeString);
+    maybeString = 'Hello';
+    console.log('赋值后:', maybeString);
+    // undefined 和 null 的区别
+    console.log('typeof undefined:', typeof undefined);
+    console.log('typeof null:', typeof null); // 注意：这是 JavaScript 的历史遗留问题
+}
+// #endregion
+// #region 示例5: Symbol 类型
+function demonstrateSymbolType() {
+    console.log('\n=== Symbol 类型示例 ===');
+    // 创建唯一的 symbol
+    const sym1 = Symbol('key');
+    const sym2 = Symbol('key');
+    console.log('sym1 === sym2:', sym1 === sym2); // false，每个 symbol 都是唯一的
+    // 使用 symbol 作为对象属性
+    const obj = {
+        [sym1]: 'value1',
+        [sym2]: 'value2'
+    };
+    console.log('obj[sym1]:', obj[sym1]);
+    console.log('obj[sym2]:', obj[sym2]);
+    // Symbol.for() 创建全局 symbol
+    const globalSym1 = Symbol.for('global');
+    const globalSym2 = Symbol.for('global');
+    console.log('globalSym1 === globalSym2:', globalSym1 === globalSym2); // true
+}
+// #endregion
+// #region 示例6: BigInt 类型
+function demonstrateBigIntType() {
+    console.log('\n=== BigInt 类型示例 ===');
+    // 创建 BigInt
+    const big1 = 9007199254740991n;
+    const big2 = BigInt('9007199254740991');
+    console.log('BigInt 字面量:', big1);
+    console.log('BigInt 构造函数:', big2);
+    // BigInt 运算
+    const sum = big1 + 1n;
+    console.log('BigInt 加法:', sum);
+    const product = big1 * 2n;
+    console.log('BigInt 乘法:', product);
+    // 注意：BigInt 不能与 number 混合运算
+    // const invalid = big1 + 1; // 错误！
+    const valid = big1 + BigInt(1);
+    console.log('正确的混合运算:', valid);
+}
+// #endregion
+if (require.main === module) {
+    const examples = [
+        demonstrateNumberType,
+        demonstrateStringType,
+        demonstrateBooleanType,
+        demonstrateNullAndUndefined,
+        demonstrateSymbolType,
+        demonstrateBigIntType
+    ];
+    const exampleNumber = process.argv[2] ? parseInt(process.argv[2]) : 0;
+    if (exampleNumber > 0 && exampleNumber <= examples.length) {
+        examples[exampleNumber - 1]();
+    }
+    else {
+        console.log('运行所有示例...\n');
+        examples.forEach(example => example());
+    }
+}

package/dist/src/demo/data-types/02-/346/225/260/347/273/204/344/270/216/345/205/203/347/273/204.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * TypeScript 数组与元组类型
+ * ========================
+ * 本文件介绍 TypeScript 的数组和元组类型，包括：
+ * - 数组的定义和使用
+ * - 只读数组
+ * - 元组类型
+ * - 元组的高级用法
+ *
+ * 适用版本：TypeScript 5.x
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.demonstrateArrayBasics = demonstrateArrayBasics;
+exports.demonstrateArrayOperations = demonstrateArrayOperations;
+exports.demonstrateReadonlyArray = demonstrateReadonlyArray;
+exports.demonstrateTupleBasics = demonstrateTupleBasics;
+exports.demonstrateTupleAdvanced = demonstrateTupleAdvanced;
+exports.demonstrateReadonlyTuple = demonstrateReadonlyTuple;
+// #region 示例1: 数组的基本定义
+function demonstrateArrayBasics() {
+    console.log('\n=== 数组基本定义示例 ===');
+    // 方式1：类型 + []
+    const numbers = [1, 2, 3, 4, 5];
+    console.log('数字数组:', numbers);
+    // 方式2：Array<类型>
+    const strings = ['a', 'b', 'c'];
+    console.log('字符串数组:', strings);
+    // 混合类型数组（联合类型）
+    const mixed = [1, 'two', 3, 'four'];
+    console.log('混合类型数组:', mixed);
+    // 多维数组
+    const matrix = [
+        [1, 2, 3],
+        [4, 5, 6],
+        [7, 8, 9]
+    ];
+    console.log('二维数组:', matrix);
+}
+// #endregion
+// #region 示例2: 数组的常用操作
+function demonstrateArrayOperations() {
+    console.log('\n=== 数组操作示例 ===');
+    const fruits = ['apple', 'banana', 'orange'];
+    // 添加元素
+    fruits.push('grape');
+    console.log('push 后:', fruits);
+    // 删除最后一个元素
+    const last = fruits.pop();
+    console.log('pop 返回:', last);
+    console.log('pop 后:', fruits);
+    // 数组遍历
+    console.log('\n遍历数组:');
+    fruits.forEach((fruit, index) => {
+        console.log(`  ${index}: ${fruit}`);
+    });
+    // map 转换
+    const upperFruits = fruits.map(fruit => fruit.toUpperCase());
+    console.log('\nmap 转大写:', upperFruits);
+    // reduce 累积计算
+    const numbers = [1, 2, 3, 4, 5];
+    const sum = numbers.reduce((acc, curr) => acc + curr, 0);
+    console.log('\nreduce 求和:', sum);
+    // reduce 统计字符串长度总和
+    const totalLength = fruits.reduce((total, fruit) => total + fruit.length, 0);
+    console.log('reduce 总长度:', totalLength);
+    // reduce 构建对象
+    const fruitLengths = fruits.reduce((obj, fruit) => {
+        obj[fruit] = fruit.length;
+        return obj;
+    }, {});
+    console.log('reduce 构建对象:', fruitLengths);
+    // filter 过滤
+    const filtered = fruits.filter(fruit => fruit.length > 5);
+    console.log('\nfilter 长度>5:', filtered);
+}
+// #endregion
+// #region 示例3: 只读数组
+function demonstrateReadonlyArray() {
+    console.log('\n=== 只读数组示例 ===');
+    // 方式1：readonly 修饰符
+    const readonlyNumbers = [1, 2, 3];
+    console.log('只读数组:', readonlyNumbers);
+    // 方式2：ReadonlyArray 类型
+    const readonlyStrings = ['a', 'b', 'c'];
+    console.log('ReadonlyArray:', readonlyStrings);
+    // 只读数组不能修改
+    // readonlyNumbers.push(4); // 错误！
+    // readonlyNumbers[0] = 10; // 错误！
+    // 但可以读取
+    console.log('第一个元素:', readonlyNumbers[0]);
+    console.log('数组长度:', readonlyNumbers.length);
+    // 可以使用不改变原数组的方法
+    const mapped = readonlyNumbers.map(n => n * 2);
+    console.log('map 结果:', mapped);
+}
+// #endregion
+// #region 示例4: 元组的基本使用
+function demonstrateTupleBasics() {
+    console.log('\n=== 元组基本使用示例 ===');
+    // 元组：固定长度和类型的数组
+    const person = ['Alice', 25];
+    console.log('元组:', person);
+    console.log('姓名:', person[0]);
+    console.log('年龄:', person[1]);
+    // 元组解构
+    const [name, age] = person;
+    console.log(`解构: ${name}, ${age}岁`);
+    // 多种类型的元组
+    const record = [1, 'active', true];
+    console.log('记录元组:', record);
+    // 元组数组
+    const users = [
+        ['Bob', 30],
+        ['Charlie', 35],
+        ['David', 28]
+    ];
+    console.log('\n用户列表:');
+    users.forEach(([name, age]) => {
+        console.log(`  ${name}: ${age}岁`);
+    });
+}
+// #endregion
+// #region 示例5: 可选元素和剩余元素
+function demonstrateTupleAdvanced() {
+    console.log('\n=== 元组高级特性示例 ===');
+    // 可选元素（使用 ?）
+    const optionalTuple = ['Alice'];
+    console.log('可选元素元组:', optionalTuple);
+    const fullTuple = ['Bob', 30];
+    console.log('完整元组:', fullTuple);
+    // 剩余元素
+    const restTuple = ['scores', 90, 85, 92, 88];
+    console.log('剩余元素元组:', restTuple);
+    const [label, ...scores] = restTuple;
+    console.log(`${label}:`, scores);
+    const point = [10, 20];
+    console.log('\n命名元组 Point:', point);
+    const range1 = [0, 10];
+    const range2 = [0, 10, 2];
+    console.log('Range 示例1:', range1);
+    console.log('Range 示例2:', range2);
+}
+// #endregion
+// #region 示例6: 只读元组
+function demonstrateReadonlyTuple() {
+    console.log('\n=== 只读元组示例 ===');
+    // 只读元组
+    const readonlyTuple = ['Alice', 25];
+    console.log('只读元组:', readonlyTuple);
+    // 不能修改
+    // readonlyTuple[0] = 'Bob'; // 错误！
+    // readonlyTuple.push('extra'); // 错误！
+    // 可以读取
+    const [name, age] = readonlyTuple;
+    console.log(`读取: ${name}, ${age}岁`);
+    // 实际应用：函数返回值
+    function getCoordinates() {
+        return [100, 200];
+    }
+    const coords = getCoordinates();
+    console.log('坐标:', coords);
+}
+// #endregion
+if (require.main === module) {
+    const examples = [
+        demonstrateArrayBasics,
+        demonstrateArrayOperations,
+        demonstrateReadonlyArray,
+        demonstrateTupleBasics,
+        demonstrateTupleAdvanced,
+        demonstrateReadonlyTuple
+    ];
+    const exampleNumber = process.argv[2] ? parseInt(process.argv[2]) : 0;
+    if (exampleNumber > 0 && exampleNumber <= examples.length) {
+        examples[exampleNumber - 1]();
+    }
+    else {
+        console.log('运行所有示例...\n');
+        examples.forEach(example => example());
+    }
+}

package/dist/src/demo/data-types/03-/345/257/271/350/261/241/347/261/273/345/236/213.js

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * TypeScript 对象类型
+ * ==================
+ * 本文件介绍 TypeScript 的对象类型，包括：
+ * - 对象类型的定义
+ * - 可选属性和只读属性
+ * - 索引签名
+ * - 对象类型的扩展
+ *
+ * 适用版本：TypeScript 5.x
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.demonstrateObjectBasics = demonstrateObjectBasics;
+exports.demonstrateOptionalAndReadonly = demonstrateOptionalAndReadonly;
+exports.demonstrateIndexSignature = demonstrateIndexSignature;
+exports.demonstrateNestedObjects = demonstrateNestedObjects;
+exports.demonstrateIntersectionAndUnion = demonstrateIntersectionAndUnion;
+exports.demonstrateUtilityTypes = demonstrateUtilityTypes;
+// #region 示例1: 对象类型的基本定义
+function demonstrateObjectBasics() {
+    console.log('\n=== 对象类型基本定义示例 ===');
+    // 内联对象类型
+    const user = {
+        name: 'Alice',
+        age: 25
+    };
+    console.log('用户对象:', user);
+    const person = {
+        name: 'Bob',
+        age: 30,
+        email: 'bob@example.com'
+    };
+    console.log('Person 对象:', person);
+    const product = {
+        id: 1,
+        name: 'Laptop',
+        price: 999.99
+    };
+    console.log('Product 对象:', product);
+}
+// #endregion
+// #region 示例2: 可选属性和只读属性
+function demonstrateOptionalAndReadonly() {
+    console.log('\n=== 可选属性和只读属性示例 ===');
+    const user1 = {
+        name: 'Alice',
+        age: 25
+    };
+    console.log('没有可选属性:', user1);
+    const user2 = {
+        name: 'Bob',
+        age: 30,
+        email: 'bob@example.com'
+    };
+    console.log('有可选属性:', user2);
+    const config = {
+        apiUrl: 'https://api.example.com',
+        timeout: 5000,
+        retries: 3
+    };
+    console.log('\n配置对象:', config);
+    // config.apiUrl = 'new-url'; // 错误！只读属性不能修改
+    config.retries = 5; // 可以修改
+    console.log('修改 retries 后:', config);
+}
+// #endregion
+// #region 示例3: 索引签名
+function demonstrateIndexSignature() {
+    console.log('\n=== 索引签名示例 ===');
+    const translations = {
+        hello: '你好',
+        goodbye: '再见',
+        thanks: '谢谢'
+    };
+    console.log('翻译映射:', translations);
+    console.log('hello:', translations['hello']);
+    const colors = {
+        0: 'red',
+        1: 'green',
+        2: 'blue'
+    };
+    console.log('\n颜色数组:', colors);
+    const dict = {
+        count: 3,
+        apple: 5,
+        banana: 3,
+        orange: 7
+    };
+    console.log('\n字典对象:', dict);
+}
+// #endregion
+// #region 示例4: 嵌套对象类型
+function demonstrateNestedObjects() {
+    console.log('\n=== 嵌套对象类型示例 ===');
+    const employee = {
+        id: 1,
+        name: 'Alice',
+        company: {
+            name: 'Tech Corp',
+            address: {
+                street: '123 Main St',
+                city: 'San Francisco',
+                country: 'USA'
+            }
+        }
+    };
+    console.log('员工信息:', JSON.stringify(employee, null, 2));
+    console.log('公司名称:', employee.company.name);
+    console.log('城市:', employee.company.address.city);
+}
+// #endregion
+// #region 示例5: 对象类型的交叉与联合
+function demonstrateIntersectionAndUnion() {
+    console.log('\n=== 对象类型的交叉与联合示例 ===');
+    const user = {
+        id: 1,
+        name: 'Alice',
+        email: 'alice@example.com'
+    };
+    console.log('交叉类型 User:', user);
+    function handleResponse(response) {
+        if (response.status === 'success') {
+            console.log('成功:', response.data);
+        }
+        else {
+            console.log('错误:', response.message);
+        }
+    }
+    console.log('\n处理成功响应:');
+    handleResponse({ status: 'success', data: 'Hello' });
+    console.log('处理错误响应:');
+    handleResponse({ status: 'error', message: 'Not found' });
+}
+// #endregion
+// #region 示例6: Record 和 Partial 工具类型
+function demonstrateUtilityTypes() {
+    console.log('\n=== 工具类型示例 ===');
+    const permissions = {
+        admin: ['read', 'write', 'delete'],
+        user: ['read', 'write'],
+        guest: ['read']
+    };
+    console.log('权限映射:', permissions);
+    const updateUser = {
+        name: 'Bob' // 只更新 name
+    };
+    console.log('\n部分更新:', updateUser);
+    const fullUser = {
+        id: 1,
+        name: 'Charlie' // 两个属性都必须提供
+    };
+    console.log('必需属性:', fullUser);
+    const immutableUser = {
+        id: 1,
+        name: 'David',
+        email: 'david@example.com'
+    };
+    console.log('只读用户:', immutableUser);
+    // immutableUser.name = 'Eve'; // 错误！
+}
+// #endregion
+if (require.main === module) {
+    const examples = [
+        demonstrateObjectBasics,
+        demonstrateOptionalAndReadonly,
+        demonstrateIndexSignature,
+        demonstrateNestedObjects,
+        demonstrateIntersectionAndUnion,
+        demonstrateUtilityTypes
+    ];
+    const exampleNumber = process.argv[2] ? parseInt(process.argv[2]) : 0;
+    if (exampleNumber > 0 && exampleNumber <= examples.length) {
+        examples[exampleNumber - 1]();
+    }
+    else {
+        console.log('运行所有示例...\n');
+        examples.forEach(example => example());
+    }
+}

package/dist/src/demo/data-types/04-/345/207/275/346/225/260/347/261/273/345/236/213.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * TypeScript 函数类型
+ * ==================
+ * 本文件介绍 TypeScript 的函数类型，包括：
+ * - 函数类型的定义
+ * - 可选参数和默认参数
+ * - 剩余参数
+ * - 函数重载
+ *
+ * 适用版本：TypeScript 5.x
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.demonstrateFunctionBasics = demonstrateFunctionBasics;
+exports.demonstrateFunctionTypes = demonstrateFunctionTypes;
+exports.demonstrateOptionalAndDefaultParams = demonstrateOptionalAndDefaultParams;
+exports.demonstrateRestParameters = demonstrateRestParameters;
+exports.demonstrateFunctionOverloads = demonstrateFunctionOverloads;
+exports.demonstrateReturnTypes = demonstrateReturnTypes;
+// #region 示例1: 函数类型的基本定义
+function demonstrateFunctionBasics() {
+    console.log('\n=== 函数类型基本定义示例 ===');
+    // 函数声明
+    function add(a, b) {
+        return a + b;
+    }
+    console.log('add(2, 3):', add(2, 3));
+    // 函数表达式
+    const subtract = function (a, b) {
+        return a - b;
+    };
+    console.log('subtract(5, 2):', subtract(5, 2));
+    // 箭头函数
+    const multiply = (a, b) => {
+        return a * b;
+    };
+    console.log('multiply(3, 4):', multiply(3, 4));
+    // 简写箭头函数
+    const divide = (a, b) => a / b;
+    console.log('divide(10, 2):', divide(10, 2));
+}
+// #endregion
+// #region 示例2: 函数类型表达式
+function demonstrateFunctionTypes() {
+    console.log('\n=== 函数类型表达式示例 ===');
+    const add = (a, b) => a + b;
+    const multiply = (a, b) => a * b;
+    console.log('add(2, 3):', add(2, 3));
+    console.log('multiply(2, 3):', multiply(2, 3));
+    // 使用函数类型作为参数
+    function calculate(op, a, b) {
+        return op(a, b);
+    }
+    console.log('calculate(add, 5, 3):', calculate(add, 5, 3));
+    console.log('calculate(multiply, 5, 3):', calculate(multiply, 5, 3));
+}
+// #endregion
+// #region 示例3: 可选参数和默认参数
+function demonstrateOptionalAndDefaultParams() {
+    console.log('\n=== 可选参数和默认参数示例 ===');
+    // 可选参数（使用 ?）
+    function greet(name, greeting) {
+        return greeting ? `${greeting}, ${name}!` : `Hello, ${name}!`;
+    }
+    console.log(greet('Alice'));
+    console.log(greet('Bob', 'Hi'));
+    // 默认参数
+    function createUser(name, role = 'user') {
+        return { name, role };
+    }
+    console.log('默认角色:', createUser('Charlie'));
+    console.log('指定角色:', createUser('David', 'admin'));
+    // 可选参数必须在必需参数之后
+    function buildUrl(protocol, domain, port) {
+        return port ? `${protocol}://${domain}:${port}` : `${protocol}://${domain}`;
+    }
+    console.log(buildUrl('https', 'example.com'));
+    console.log(buildUrl('http', 'localhost', 3000));
+}
+// #endregion
+// #region 示例4: 剩余参数
+function demonstrateRestParameters() {
+    console.log('\n=== 剩余参数示例 ===');
+    // 剩余参数（使用 ...）
+    function sum(...numbers) {
+        return numbers.reduce((total, n) => total + n, 0);
+    }
+    console.log('sum(1, 2, 3):', sum(1, 2, 3));
+    console.log('sum(1, 2, 3, 4, 5):', sum(1, 2, 3, 4, 5));
+    // 混合使用普通参数和剩余参数
+    function introduce(greeting, ...names) {
+        return `${greeting} ${names.join(', ')}!`;
+    }
+    console.log(introduce('Hello', 'Alice', 'Bob', 'Charlie'));
+    // 剩余参数必须是最后一个参数
+    function logWithPrefix(prefix, ...messages) {
+        messages.forEach(msg => console.log(`[${prefix}] ${msg}`));
+    }
+    console.log('\n日志示例:');
+    logWithPrefix('INFO', 'Server started', 'Port 3000', 'Ready');
+}
+// #endregion
+// #region 示例5: 函数重载
+function demonstrateFunctionOverloads() {
+    console.log('\n=== 函数重载示例 ===');
+    // 实现签名
+    function format(value) {
+        if (typeof value === 'string') {
+            return `"${value}"`;
+        }
+        else if (typeof value === 'number') {
+            return value.toFixed(2);
+        }
+        else {
+            return value ? 'Yes' : 'No';
+        }
+    }
+    console.log('format("hello"):', format('hello'));
+    console.log('format(3.14159):', format(3.14159));
+    console.log('format(true):', format(true));
+    function makeDate(yearOrTimestamp, month, day) {
+        if (month !== undefined && day !== undefined) {
+            return new Date(yearOrTimestamp, month - 1, day);
+        }
+        else {
+            return new Date(yearOrTimestamp);
+        }
+    }
+    console.log('\nmakeDate(1609459200000):', makeDate(1609459200000));
+    console.log('makeDate(2024, 1, 1):', makeDate(2024, 1, 1));
+}
+// #endregion
+// #region 示例6: void、never 和返回类型
+function demonstrateReturnTypes() {
+    console.log('\n=== 返回类型示例 ===');
+    // void - 没有返回值
+    function logMessage(message) {
+        console.log('Log:', message);
+    }
+    logMessage('This is a void function');
+    // never - 永远不会返回（抛出异常或无限循环）
+    function throwError(message) {
+        throw new Error(message);
+    }
+    function infiniteLoop() {
+        while (true) {
+            // 无限循环
+        }
+    }
+    console.log('\nnever 类型用于永不返回的函数');
+    // 类型推断
+    function inferredReturn(x) {
+        return x * 2; // TypeScript 推断返回类型为 number
+    }
+    console.log('inferredReturn(5):', inferredReturn(5));
+    // 联合类型返回值
+    function parseValue(input) {
+        const parsed = parseInt(input);
+        return isNaN(parsed) ? null : parsed;
+    }
+    console.log('parseValue("123"):', parseValue('123'));
+    console.log('parseValue("abc"):', parseValue('abc'));
+}
+// #endregion
+if (require.main === module) {
+    const examples = [
+        demonstrateFunctionBasics,
+        demonstrateFunctionTypes,
+        demonstrateOptionalAndDefaultParams,
+        demonstrateRestParameters,
+        demonstrateFunctionOverloads,
+        demonstrateReturnTypes
+    ];
+    const exampleNumber = process.argv[2] ? parseInt(process.argv[2]) : 0;
+    if (exampleNumber > 0 && exampleNumber <= examples.length) {
+        examples[exampleNumber - 1]();
+    }
+    else {
+        console.log('运行所有示例...\n');
+        examples.forEach(example => example());
+    }
+}

package/dist/src/demo/data-types/05-/351/253/230/347/272/247/347/261/273/345/236/213.js

@@ -0,0 +1,220 @@
+"use strict";
+/**
+ * TypeScript 高级类型
+ * ==================
+ * 本文件介绍 TypeScript 的高级类型，包括：
+ * - 联合类型和交叉类型
+ * - 类型别名和接口
+ * - 字面量类型
+ * - 类型断言和类型守卫
+ *
+ * 适用版本：TypeScript 5.x
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.demonstrateUnionTypes = demonstrateUnionTypes;
+exports.demonstrateIntersectionTypes = demonstrateIntersectionTypes;
+exports.demonstrateLiteralTypes = demonstrateLiteralTypes;
+exports.demonstrateTypeVsInterface = demonstrateTypeVsInterface;
+exports.demonstrateTypeAssertion = demonstrateTypeAssertion;
+exports.demonstrateTypeGuards = demonstrateTypeGuards;
+// #region 示例1: 联合类型
+function demonstrateUnionTypes() {
+    console.log('\n=== 联合类型示例 ===');
+    // 基本联合类型
+    let value;
+    value = 'hello';
+    console.log('字符串值:', value);
+    value = 42;
+    console.log('数字值:', value);
+    // 函数参数使用联合类型
+    function formatId(id) {
+        if (typeof id === 'string') {
+            return id.toUpperCase();
+        }
+        else {
+            return `ID-${id}`;
+        }
+    }
+    console.log('formatId("abc"):', formatId('abc'));
+    console.log('formatId(123):', formatId(123));
+    // 数组的联合类型
+    const mixed = [1, 'two', 3, 'four'];
+    console.log('混合数组:', mixed);
+}
+// #endregion
+// #region 示例2: 交叉类型
+function demonstrateIntersectionTypes() {
+    console.log('\n=== 交叉类型示例 ===');
+    const staff = {
+        name: 'Alice',
+        age: 30,
+        employeeId: 1001,
+        department: 'Engineering'
+    };
+    console.log('员工信息:', staff);
+}
+// #endregion
+// #region 示例3: 字面量类型
+function demonstrateLiteralTypes() {
+    console.log('\n=== 字面量类型示例 ===');
+    // 字符串字面量类型
+    let direction;
+    direction = 'up';
+    console.log('方向:', direction);
+    function rollDice() {
+        return (Math.floor(Math.random() * 6) + 1);
+    }
+    console.log('骰子点数:', rollDice());
+    function alwaysSucceed() {
+        return true;
+    }
+    console.log('总是成功:', alwaysSucceed());
+    function handleStatus(status) {
+        console.log('处理状态:', status);
+    }
+    handleStatus('pending');
+    handleStatus(404);
+}
+// #endregion
+// #region 示例4: 类型别名 vs 接口
+function demonstrateTypeVsInterface() {
+    console.log('\n=== 类型别名 vs 接口示例 ===');
+    const point = { x: 10, y: 20 };
+    console.log('Point (type):', point);
+    const rect = { width: 100, height: 50 };
+    console.log('Rectangle (interface):', rect);
+    const square = {
+        width: 50,
+        height: 50,
+        color: 'red'
+    };
+    console.log('Square (extends):', square);
+    function describeShape(shape) {
+        if ('x' in shape) {
+            console.log('这是一个点');
+        }
+        else if ('color' in shape) {
+            console.log('这是一个彩色方形');
+        }
+        else {
+            console.log('这是一个矩形');
+        }
+    }
+    console.log('\n形状描述:');
+    describeShape(point);
+    describeShape(square);
+}
+// #endregion
+// #region 示例5: 类型断言
+function demonstrateTypeAssertion() {
+    console.log('\n=== 类型断言示例 ===');
+    // as 语法
+    const someValue = 'this is a string';
+    const strLength = someValue.length;
+    console.log('字符串长度:', strLength);
+    // 尖括号语法（在 JSX 中不可用）
+    const anotherValue = 'hello';
+    const upperCase = anotherValue.toUpperCase();
+    console.log('大写:', upperCase);
+    // DOM 元素类型断言
+    // const input = document.getElementById('myInput') as HTMLInputElement;
+    // input.value = 'Hello';
+    // 非空断言（!）
+    function getLength(str) {
+        // 确信 str 不为 null
+        return str.length;
+    }
+    console.log('非空断言:', getLength('hello'));
+    // const 断言
+    const config = {
+        host: 'localhost',
+        port: 3000
+    };
+    // config.port = 4000; // 错误！所有属性都是只读的
+    console.log('只读配置:', config);
+}
+// #endregion
+// #region 示例6: 类型守卫
+function demonstrateTypeGuards() {
+    console.log('\n=== 类型守卫示例 ===');
+    // typeof 类型守卫
+    function processValue(value) {
+        if (typeof value === 'string') {
+            console.log('字符串长度:', value.length);
+        }
+        else {
+            console.log('数字平方:', value * value);
+        }
+    }
+    processValue('hello');
+    processValue(5);
+    // instanceof 类型守卫
+    class Dog {
+        bark() {
+            console.log('Woof!');
+        }
+    }
+    class Cat {
+        meow() {
+            console.log('Meow!');
+        }
+    }
+    function makeSound(animal) {
+        if (animal instanceof Dog) {
+            animal.bark();
+        }
+        else {
+            animal.meow();
+        }
+    }
+    console.log('\n动物叫声:');
+    makeSound(new Dog());
+    makeSound(new Cat());
+    function move(animal) {
+        if ('swim' in animal) {
+            console.log('游泳');
+            animal.swim();
+        }
+        else {
+            console.log('飞行');
+            animal.fly();
+        }
+    }
+    console.log('\n动物移动:');
+    move({ swim: () => console.log('  鱼在游泳') });
+    move({ fly: () => console.log('  鸟在飞翔') });
+    // 自定义类型守卫
+    function isString(value) {
+        return typeof value === 'string';
+    }
+    function processUnknown(value) {
+        if (isString(value)) {
+            console.log('处理字符串:', value.toUpperCase());
+        }
+        else {
+            console.log('不是字符串');
+        }
+    }
+    console.log('\n处理未知类型:');
+    processUnknown('hello');
+    processUnknown(123);
+}
+// #endregion
+if (require.main === module) {
+    const examples = [
+        demonstrateUnionTypes,
+        demonstrateIntersectionTypes,
+        demonstrateLiteralTypes,
+        demonstrateTypeVsInterface,
+        demonstrateTypeAssertion,
+        demonstrateTypeGuards
+    ];
+    const exampleNumber = process.argv[2] ? parseInt(process.argv[2]) : 0;
+    if (exampleNumber > 0 && exampleNumber <= examples.length) {
+        examples[exampleNumber - 1]();
+    }
+    else {
+        console.log('运行所有示例...\n');
+        examples.forEach(example => example());
+    }
+}

package/dist/src/demo/data-types/06-/346/263/233/345/236/213/347/261/273/345/236/213.js

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * TypeScript 泛型类型
+ * ==================
+ * 本文件介绍 TypeScript 的泛型，包括：
+ * - 泛型函数
+ * - 泛型接口和类
+ * - 泛型约束
+ * - 泛型工具类型
+ *
+ * 适用版本：TypeScript 5.x
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.demonstrateGenericFunctions = demonstrateGenericFunctions;
+exports.demonstrateGenericInterfaces = demonstrateGenericInterfaces;
+exports.demonstrateGenericClasses = demonstrateGenericClasses;
+exports.demonstrateGenericConstraints = demonstrateGenericConstraints;
+exports.demonstrateGenericUtilityTypes = demonstrateGenericUtilityTypes;
+exports.demonstrateAdvancedGenericPatterns = demonstrateAdvancedGenericPatterns;
+// #region 示例1: 泛型函数基础
+function demonstrateGenericFunctions() {
+    console.log('\n=== 泛型函数基础示例 ===');
+    // 基本泛型函数
+    function identity(arg) {
+        return arg;
+    }
+    const num = identity(42);
+    console.log('identity<number>(42):', num);
+    const str = identity('hello');
+    console.log('identity<string>("hello"):', str);
+    // 类型推断
+    const inferred = identity('world'); // TypeScript 自动推断为 string
+    console.log('identity("world"):', inferred);
+    // 泛型数组函数
+    function getFirst(arr) {
+        return arr[0];
+    }
+    console.log('getFirst([1, 2, 3]):', getFirst([1, 2, 3]));
+    console.log('getFirst(["a", "b"]):', getFirst(['a', 'b']));
+}
+// #endregion
+// #region 示例2: 泛型接口
+function demonstrateGenericInterfaces() {
+    console.log('\n=== 泛型接口示例 ===');
+    const numberBox = { value: 42 };
+    console.log('Number Box:', numberBox);
+    const stringBox = { value: 'hello' };
+    console.log('String Box:', stringBox);
+    const myIdentity = (x) => x;
+    console.log('myIdentity(10):', myIdentity(10));
+    const pair = {
+        key: 'age',
+        value: 25
+    };
+    console.log('Pair:', pair);
+}
+// #endregion
+// #region 示例3: 泛型类
+function demonstrateGenericClasses() {
+    console.log('\n=== 泛型类示例 ===');
+    // 泛型类
+    class Stack {
+        constructor() {
+            this.items = [];
+        }
+        push(item) {
+            this.items.push(item);
+        }
+        pop() {
+            return this.items.pop();
+        }
+        peek() {
+            return this.items[this.items.length - 1];
+        }
+        size() {
+            return this.items.length;
+        }
+    }
+    const numberStack = new Stack();
+    numberStack.push(1);
+    numberStack.push(2);
+    numberStack.push(3);
+    console.log('Number Stack size:', numberStack.size());
+    console.log('Pop:', numberStack.pop());
+    console.log('Peek:', numberStack.peek());
+    const stringStack = new Stack();
+    stringStack.push('a');
+    stringStack.push('b');
+    console.log('\nString Stack size:', stringStack.size());
+    console.log('Pop:', stringStack.pop());
+}
+// #endregion
+// #region 示例4: 泛型约束
+function demonstrateGenericConstraints() {
+    console.log('\n=== 泛型约束示例 ===');
+    function logLength(arg) {
+        console.log('Length:', arg.length);
+    }
+    logLength('hello'); // string 有 length
+    logLength([1, 2, 3]); // array 有 length
+    logLength({ length: 10, value: 'test' }); // 对象有 length
+    // logLength(123); // 错误！number 没有 length
+    // 使用类型参数约束
+    function getProperty(obj, key) {
+        return obj[key];
+    }
+    const person = { name: 'Alice', age: 25 };
+    console.log('\ngetProperty(person, "name"):', getProperty(person, 'name'));
+    console.log('getProperty(person, "age"):', getProperty(person, 'age'));
+    // getProperty(person, 'email'); // 错误！email 不是 person 的属性
+}
+// #endregion
+// #region 示例5: 泛型工具类型
+function demonstrateGenericUtilityTypes() {
+    console.log('\n=== 泛型工具类型示例 ===');
+    const preview = { id: 1, name: 'Alice' };
+    console.log('Pick:', preview);
+    const userNoEmail = { id: 2, name: 'Bob', age: 30 };
+    console.log('Omit:', userNoEmail);
+    const partialUser = { name: 'Charlie' };
+    console.log('Partial:', partialUser);
+    const requiredUser = { id: 3, name: 'David' };
+    console.log('Required:', requiredUser);
+    const readonlyUser = {
+        id: 4,
+        name: 'Eve',
+        email: 'eve@example.com',
+        age: 28
+    };
+    console.log('Readonly:', readonlyUser);
+    // readonlyUser.name = 'Frank'; // 错误！
+}
+// #endregion
+// #region 示例6: 高级泛型模式
+function demonstrateAdvancedGenericPatterns() {
+    console.log('\n=== 高级泛型模式示例 ===');
+    console.log('条件类型已定义');
+    const nullableUser = {
+        name: 'Alice',
+        age: null
+    };
+    console.log('Nullable User:', nullableUser);
+    const deepReadonly = {
+        a: {
+            b: {
+                c: 42
+            }
+        }
+    };
+    console.log('Deep Readonly:', deepReadonly);
+    const defaultContainer = { value: 'default' };
+    const numberContainer = { value: 42 };
+    console.log('Default Container:', defaultContainer);
+    console.log('Number Container:', numberContainer);
+}
+// #endregion
+if (require.main === module) {
+    const examples = [
+        demonstrateGenericFunctions,
+        demonstrateGenericInterfaces,
+        demonstrateGenericClasses,
+        demonstrateGenericConstraints,
+        demonstrateGenericUtilityTypes,
+        demonstrateAdvancedGenericPatterns
+    ];
+    const exampleNumber = process.argv[2] ? parseInt(process.argv[2]) : 0;
+    if (exampleNumber > 0 && exampleNumber <= examples.length) {
+        examples[exampleNumber - 1]();
+    }
+    else {
+        console.log('运行所有示例...\n');
+        examples.forEach(example => example());
+    }
+}

package/dist/src/demo/operators-expressions/01-/345/237/272/347/241/200/350/277/220/347/256/227/347/254/246.js

@@ -11,6 +11,7 @@ exports.assignmentOperators = assignmentOperators;
 exports.comparisonOperators = comparisonOperators;
 exports.logicalOperators = logicalOperators;
 exports.stringOperators = stringOperators;
+exports.spreadOperator = spreadOperator;
 // #region 示例1: 算术运算符
 function arithmeticOperators() {
     console.log('=== 算术运算符 ===');
@@ -119,13 +120,72 @@ function stringOperators() {
     console.log(`字符串 - 数字: '${str}' - ${num} = ${str - num}`); // 数字运算（自动转换）
 }
 // #endregion
+// #region 示例6: 展开运算符 (...)
+function spreadOperator() {
+    console.log('\n=== 展开运算符 (...) ===');
+    // 数组展开
+    const arr1 = [1, 2, 3];
+    const arr2 = [4, 5, 6];
+    const combined = [...arr1, ...arr2];
+    console.log(`合并数组: [${combined}]`);
+    // 数组复制（浅拷贝）
+    const original = [1, 2, 3];
+    const copy = [...original];
+    copy.push(4);
+    console.log(`\n原数组: [${original}]`);
+    console.log(`复制数组: [${copy}]`);
+    // 在数组中插入元素
+    const numbers = [1, 2, 5, 6];
+    const inserted = [1, 2, ...[3, 4], 5, 6];
+    console.log(`\n插入元素: [${inserted}]`);
+    // 对象展开
+    const person = { name: '张三', age: 25 };
+    const employee = { ...person, job: '工程师', salary: 10000 };
+    console.log(`\n员工信息:`, employee);
+    // 对象合并（后面的属性会覆盖前面的）
+    const defaults = { theme: 'light', fontSize: 14, showSidebar: true };
+    const userSettings = { fontSize: 16, showSidebar: false };
+    const finalSettings = { ...defaults, ...userSettings };
+    console.log(`\n最终设置:`, finalSettings);
+    // 对象复制（浅拷贝）
+    const originalObj = { x: 1, y: 2 };
+    const copiedObj = { ...originalObj };
+    copiedObj.x = 10;
+    console.log(`\n原对象:`, originalObj);
+    console.log(`复制对象:`, copiedObj);
+    // 函数参数展开
+    function sum(a, b, c) {
+        return a + b + c;
+    }
+    const nums = [1, 2, 3];
+    const result = sum(...nums);
+    console.log(`\nsum(...[1, 2, 3]) = ${result}`);
+    // Math 函数中使用
+    const values = [5, 2, 8, 1, 9, 3];
+    const max = Math.max(...values);
+    const min = Math.min(...values);
+    console.log(`\n数组 [${values}]`);
+    console.log(`最大值: ${max}`);
+    console.log(`最小值: ${min}`);
+    // 字符串展开为字符数组
+    const str = 'Hello';
+    const chars = [...str];
+    console.log(`\n字符串展开: '${str}' => [${chars.map(c => `'${c}'`).join(', ')}]`);
+    // 去重（结合 Set）
+    const duplicates = [1, 2, 2, 3, 3, 3, 4, 5, 5];
+    const unique = [...new Set(duplicates)];
+    console.log(`\n去重前: [${duplicates}]`);
+    console.log(`去重后: [${unique}]`);
+}
+// #endregion
 if (require.main === module) {
     const examples = [
         arithmeticOperators,
         assignmentOperators,
         comparisonOperators,
         logicalOperators,
-        stringOperators
+        stringOperators,
+        spreadOperator
     ];
     const exampleNumber = parseInt(process.argv[2]);
     if (exampleNumber && exampleNumber > 0 && exampleNumber <= examples.length) {

package/package.json

@@ -3,8 +3,8 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.1.13",
-  "description": "一个nodejs学习工具",
+  "version": "1.1.15",
+  "description": "ts test",
   "bin": {
     "nlearn": "dist/src/cli/index.js",
     "nn": "dist/src/cli/index.js"