@lppx/nlearn 1.1.12 → 1.1.14

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

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * TypeScript 基础运算符
+ * =====================
+ * 涵盖算术运算符、赋值运算符、比较运算符和逻辑运算符
+ * 适用于 TypeScript 5.x
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arithmeticOperators = arithmeticOperators;
+exports.assignmentOperators = assignmentOperators;
+exports.comparisonOperators = comparisonOperators;
+exports.logicalOperators = logicalOperators;
+exports.stringOperators = stringOperators;
+// #region 示例1: 算术运算符
+function arithmeticOperators() {
+    console.log('=== 算术运算符 ===');
+    const a = 10;
+    const b = 3;
+    console.log(`加法: ${a} + ${b} = ${a + b}`);
+    console.log(`减法: ${a} - ${b} = ${a - b}`);
+    console.log(`乘法: ${a} * ${b} = ${a * b}`);
+    console.log(`除法: ${a} / ${b} = ${a / b}`);
+    console.log(`取余: ${a} % ${b} = ${a % b}`);
+    console.log(`幂运算: ${a} ** ${b} = ${a ** b}`);
+    // 自增自减
+    let count = 5;
+    console.log(`\n原始值: ${count}`);
+    console.log(`后置自增 count++: ${count++}`); // 先返回再加
+    console.log(`自增后的值: ${count}`);
+    console.log(`前置自增 ++count: ${++count}`); // 先加再返回
+    console.log(`后置自减 count--: ${count--}`);
+    console.log(`前置自减 --count: ${--count}`);
+}
+// #endregion
+// #region 示例2: 赋值运算符
+function assignmentOperators() {
+    console.log('\n=== 赋值运算符 ===');
+    let x = 10;
+    console.log(`初始值: x = ${x}`);
+    x += 5; // x = x + 5
+    console.log(`x += 5: ${x}`);
+    x -= 3; // x = x - 3
+    console.log(`x -= 3: ${x}`);
+    x *= 2; // x = x * 2
+    console.log(`x *= 2: ${x}`);
+    x /= 4; // x = x / 4
+    console.log(`x /= 4: ${x}`);
+    x %= 5; // x = x % 5
+    console.log(`x %= 5: ${x}`);
+    x **= 3; // x = x ** 3
+    console.log(`x **= 3: ${x}`);
+}
+// #endregion
+// #region 示例3: 比较运算符
+function comparisonOperators() {
+    console.log('\n=== 比较运算符 ===');
+    const num1 = 10;
+    const num2 = '10'; // 使用 any 来演示类型转换
+    const num3 = 20;
+    // 相等性比较
+    console.log(`${num1} == '${num2}': ${num1 == num2}`); // 宽松相等（类型转换）
+    console.log(`${num1} === '${num2}': ${num1 === num2}`); // 严格相等（不转换类型）
+    console.log(`${num1} != '${num2}': ${num1 != num2}`);
+    console.log(`${num1} !== '${num2}': ${num1 !== num2}`);
+    // 大小比较
+    console.log(`\n${num1} > ${num3}: ${num1 > num3}`);
+    console.log(`${num1} < ${num3}: ${num1 < num3}`);
+    console.log(`${num1} >= ${num1}: ${num1 >= num1}`);
+    console.log(`${num1} <= ${num3}: ${num1 <= num3}`);
+}
+// #endregion
+// #region 示例4: 逻辑运算符
+function logicalOperators() {
+    console.log('\n=== 逻辑运算符 ===');
+    const isAdult = true;
+    const hasLicense = false;
+    const age = 25;
+    // 逻辑与 (AND)
+    console.log(`isAdult && hasLicense: ${isAdult && hasLicense}`);
+    console.log(`可以开车: ${isAdult && hasLicense}`);
+    // 逻辑或 (OR)
+    console.log(`\nisAdult || hasLicense: ${isAdult || hasLicense}`);
+    console.log(`至少满足一个条件: ${isAdult || hasLicense}`);
+    // 逻辑非 (NOT)
+    console.log(`\n!isAdult: ${!isAdult}`);
+    console.log(`!hasLicense: ${!hasLicense}`);
+    // 组合使用
+    const canDrive = isAdult && hasLicense;
+    const needsPermission = !isAdult || !hasLicense;
+    console.log(`\n可以开车: ${canDrive}`);
+    console.log(`需要许可: ${needsPermission}`);
+    // 短路求值
+    console.log('\n短路求值示例:');
+    const result1 = false && console.log('这不会执行');
+    const result2 = true || console.log('这也不会执行');
+    console.log('短路求值完成');
+}
+// #endregion
+// #region 示例5: 字符串运算符
+function stringOperators() {
+    console.log('\n=== 字符串运算符 ===');
+    const firstName = 'Zhang';
+    const lastName = 'San';
+    // 字符串连接
+    const fullName = firstName + ' ' + lastName;
+    console.log(`全名: ${fullName}`);
+    // 使用 += 连接
+    let message = 'Hello';
+    message += ', ';
+    message += 'World!';
+    console.log(`消息: ${message}`);
+    // 模板字符串（推荐方式）
+    const greeting = `你好, ${firstName} ${lastName}!`;
+    console.log(greeting);
+    // 字符串与数字
+    const str = '100'; // 使用 any 来演示类型转换
+    const num = 50;
+    console.log(`\n字符串 + 数字: '${str}' + ${num} = ${str + num}`); // 字符串连接
+    console.log(`字符串 - 数字: '${str}' - ${num} = ${str - num}`); // 数字运算（自动转换）
+}
+// #endregion
+if (require.main === module) {
+    const examples = [
+        arithmeticOperators,
+        assignmentOperators,
+        comparisonOperators,
+        logicalOperators,
+        stringOperators
+    ];
+    const exampleNumber = parseInt(process.argv[2]);
+    if (exampleNumber && exampleNumber > 0 && exampleNumber <= examples.length) {
+        console.log(`\n运行示例 ${exampleNumber}:\n`);
+        examples[exampleNumber - 1]();
+    }
+    else {
+        console.log('运行所有示例:\n');
+        examples.forEach((example, index) => {
+            console.log(`\n${'='.repeat(50)}`);
+            console.log(`示例 ${index + 1}`);
+            console.log('='.repeat(50));
+            example();
+        });
+    }
+}