@lppx/nlearn 1.1.12 → 1.1.13

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();
+        });
+    }
+}

package/dist/src/demo/operators-expressions/02-/347/261/273/345/236/213/350/277/220/347/256/227/347/254/246.js

@@ -0,0 +1,212 @@
+"use strict";
+/**
+ * TypeScript 类型运算符
+ * =====================
+ * 涵盖 typeof、instanceof、in、as 等类型相关运算符
+ * 适用于 TypeScript 5.x
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeofOperator = typeofOperator;
+exports.instanceofOperator = instanceofOperator;
+exports.inOperator = inOperator;
+exports.typeAssertion = typeAssertion;
+exports.optionalChainingAndNullish = optionalChainingAndNullish;
+// #region 示例1: typeof 运算符
+function typeofOperator() {
+    console.log('=== typeof 运算符 ===');
+    // 基本类型检测
+    console.log(`typeof 42: ${typeof 42}`);
+    console.log(`typeof 'hello': ${typeof 'hello'}`);
+    console.log(`typeof true: ${typeof true}`);
+    console.log(`typeof undefined: ${typeof undefined}`);
+    console.log(`typeof null: ${typeof null}`); // 注意：这是 JavaScript 的历史遗留问题
+    console.log(`typeof Symbol(): ${typeof Symbol()}`);
+    console.log(`typeof 123n: ${typeof 123n}`);
+    // 复杂类型
+    console.log(`\ntypeof {}: ${typeof {}}`);
+    console.log(`typeof []: ${typeof []}`);
+    console.log(`typeof function(){}: ${typeof function () { }}`);
+    // 实际应用
+    function processValue(value) {
+        if (typeof value === 'string') {
+            console.log(`\n字符串长度: ${value.length}`);
+        }
+        else if (typeof value === 'number') {
+            console.log(`\n数字平方: ${value ** 2}`);
+        }
+        else {
+            console.log(`\n未知类型: ${typeof value}`);
+        }
+    }
+    processValue('TypeScript');
+    processValue(10);
+    processValue(true);
+}
+// #endregion
+// #region 示例2: instanceof 运算符
+class Animal {
+    constructor(name) {
+        this.name = name;
+    }
+}
+class Dog extends Animal {
+    bark() {
+        return `${this.name} says: Woof!`;
+    }
+}
+class Cat extends Animal {
+    meow() {
+        return `${this.name} says: Meow!`;
+    }
+}
+function instanceofOperator() {
+    console.log('\n=== instanceof 运算符 ===');
+    const dog = new Dog('旺财');
+    const cat = new Cat('咪咪');
+    const date = new Date();
+    const arr = [1, 2, 3];
+    // 类实例检测
+    console.log(`dog instanceof Dog: ${dog instanceof Dog}`);
+    console.log(`dog instanceof Animal: ${dog instanceof Animal}`);
+    console.log(`cat instanceof Dog: ${cat instanceof Dog}`);
+    // 内置对象检测
+    console.log(`\ndate instanceof Date: ${date instanceof Date}`);
+    console.log(`arr instanceof Array: ${arr instanceof Array}`);
+    console.log(`arr instanceof Object: ${arr instanceof Object}`);
+    // 实际应用：类型守卫
+    function handleAnimal(animal) {
+        if (animal instanceof Dog) {
+            console.log(`\n${animal.bark()}`);
+        }
+        else if (animal instanceof Cat) {
+            console.log(`\n${animal.meow()}`);
+        }
+    }
+    handleAnimal(dog);
+    handleAnimal(cat);
+}
+function inOperator() {
+    console.log('\n=== in 运算符 ===');
+    const user = {
+        name: '张三',
+        email: 'zhangsan@example.com'
+    };
+    const admin = {
+        name: '李四',
+        email: 'lisi@example.com',
+        role: 'admin',
+        permissions: ['read', 'write', 'delete']
+    };
+    // 检查属性是否存在
+    console.log(`'name' in user: ${'name' in user}`);
+    console.log(`'role' in user: ${'role' in user}`);
+    console.log(`'role' in admin: ${'role' in admin}`);
+    // 检查数组索引
+    const arr = [1, 2, 3];
+    console.log(`\n0 in arr: ${0 in arr}`);
+    console.log(`5 in arr: ${5 in arr}`);
+    console.log(`'length' in arr: ${'length' in arr}`);
+    // 实际应用：类型守卫
+    function printUserInfo(user) {
+        console.log(`\n姓名: ${user.name}`);
+        console.log(`邮箱: ${user.email}`);
+        if ('role' in user) {
+            console.log(`角色: ${user.role}`);
+            console.log(`权限: ${user.permissions.join(', ')}`);
+        }
+    }
+    printUserInfo(user);
+    printUserInfo(admin);
+}
+// #endregion
+// #region 示例4: 类型断言 (as)
+function typeAssertion() {
+    console.log('\n=== 类型断言 (as) ===');
+    // 基本类型断言
+    const someValue = 'this is a string';
+    const strLength = someValue.length;
+    console.log(`字符串长度: ${strLength}`);
+    // 模拟 DOM 元素
+    const element = { value: 'Hello' };
+    const inputElement = element;
+    console.log(`输入值: ${inputElement.value}`);
+    function handleResponse(response) {
+        if (response.success) {
+            const data = response.data;
+            console.log(`\n成功: ${data}`);
+        }
+        else {
+            const error = response.error;
+            console.log(`\n失败: ${error}`);
+        }
+    }
+    handleResponse({ success: true, data: '操作成功' });
+    handleResponse({ success: false, error: '网络错误' });
+    // 非空断言 (!)
+    function processString(str) {
+        // 当我们确定 str 不为 null 时使用
+        const length = str.length;
+        return length;
+    }
+    console.log(`\n非空断言示例: ${processString('TypeScript')}`);
+}
+// #endregion
+// #region 示例5: 可选链和空值合并
+function optionalChainingAndNullish() {
+    console.log('\n=== 可选链 (?.) 和空值合并 (??) ===');
+    const person1 = {
+        name: '张三',
+        address: {
+            city: '北京',
+            zipCode: '100000'
+        }
+    };
+    const person2 = {
+        name: '李四'
+    };
+    // 可选链操作符
+    console.log(`person1 城市: ${person1.address?.city}`);
+    console.log(`person1 街道: ${person1.address?.street}`);
+    console.log(`person2 城市: ${person2.address?.city}`);
+    // 空值合并操作符
+    const phone1 = person1.phone ?? '未提供';
+    const phone2 = person2.phone ?? '未提供';
+    console.log(`\nperson1 电话: ${phone1}`);
+    console.log(`person2 电话: ${phone2}`);
+    // 与逻辑或的区别
+    const value1 = 0;
+    const value2 = '';
+    const value3 = null;
+    console.log(`\n0 || 'default': ${value1 || 'default'}`);
+    console.log(`0 ?? 'default': ${value1 ?? 'default'}`);
+    console.log(`'' || 'default': ${value2 || 'default'}`);
+    console.log(`'' ?? 'default': ${value2 ?? 'default'}`);
+    console.log(`null ?? 'default': ${value3 ?? 'default'}`);
+    // 组合使用
+    const city = person2.address?.city ?? '未知城市';
+    console.log(`\nperson2 城市（带默认值）: ${city}`);
+}
+// #endregion
+if (require.main === module) {
+    const examples = [
+        typeofOperator,
+        instanceofOperator,
+        inOperator,
+        typeAssertion,
+        optionalChainingAndNullish
+    ];
+    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();
+        });
+    }
+}

package/dist/src/demo/operators-expressions/03-/344/275/215/350/277/220/347/256/227/347/254/246.js

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * TypeScript 位运算符
+ * ===================
+ * 涵盖位与、位或、位异或、位非、左移、右移等位运算操作
+ * 适用于 TypeScript 5.x
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicBitwiseOperators = basicBitwiseOperators;
+exports.shiftOperators = shiftOperators;
+exports.permissionSystem = permissionSystem;
+exports.colorProcessing = colorProcessing;
+exports.bitwiseTricks = bitwiseTricks;
+// #region 示例1: 基础位运算符
+function basicBitwiseOperators() {
+    console.log('=== 基础位运算符 ===');
+    const a = 5; // 二进制: 0101
+    const b = 3; // 二进制: 0011
+    console.log(`a = ${a} (二进制: ${a.toString(2).padStart(4, '0')})`);
+    console.log(`b = ${b} (二进制: ${b.toString(2).padStart(4, '0')})`);
+    // 位与 (AND)
+    const and = a & b; // 0101 & 0011 = 0001
+    console.log(`\na & b = ${and} (二进制: ${and.toString(2).padStart(4, '0')})`);
+    // 位或 (OR)
+    const or = a | b; // 0101 | 0011 = 0111
+    console.log(`a | b = ${or} (二进制: ${or.toString(2).padStart(4, '0')})`);
+    // 位异或 (XOR)
+    const xor = a ^ b; // 0101 ^ 0011 = 0110
+    console.log(`a ^ b = ${xor} (二进制: ${xor.toString(2).padStart(4, '0')})`);
+    // 位非 (NOT)
+    const notA = ~a; // ~0101 = ...11111010 (补码表示)
+    console.log(`~a = ${notA}`);
+}
+// #endregion
+// #region 示例2: 移位运算符
+function shiftOperators() {
+    console.log('\n=== 移位运算符 ===');
+    const num = 8; // 二进制: 1000
+    console.log(`原始值: ${num} (二进制: ${num.toString(2)})`);
+    // 左移 (<<)
+    const leftShift1 = num << 1; // 1000 << 1 = 10000 (16)
+    const leftShift2 = num << 2; // 1000 << 2 = 100000 (32)
+    console.log(`\n${num} << 1 = ${leftShift1} (相当于乘以 2)`);
+    console.log(`${num} << 2 = ${leftShift2} (相当于乘以 4)`);
+    // 右移 (>>)
+    const rightShift1 = num >> 1; // 1000 >> 1 = 0100 (4)
+    const rightShift2 = num >> 2; // 1000 >> 2 = 0010 (2)
+    console.log(`\n${num} >> 1 = ${rightShift1} (相当于除以 2)`);
+    console.log(`${num} >> 2 = ${rightShift2} (相当于除以 4)`);
+    // 无符号右移 (>>>)
+    const negNum = -8;
+    console.log(`\n负数: ${negNum}`);
+    console.log(`${negNum} >> 1 = ${negNum >> 1} (保留符号)`);
+    console.log(`${negNum} >>> 1 = ${negNum >>> 1} (不保留符号)`);
+}
+// #endregion
+// #region 示例3: 权限管理系统
+// 定义权限常量（使用位标志）
+const PERMISSION = {
+    READ: 1 << 0, // 0001 = 1
+    WRITE: 1 << 1, // 0010 = 2
+    DELETE: 1 << 2, // 0100 = 4
+    EXECUTE: 1 << 3 // 1000 = 8
+};
+function permissionSystem() {
+    console.log('\n=== 权限管理系统 ===');
+    console.log('权限定义:');
+    console.log(`READ: ${PERMISSION.READ} (${PERMISSION.READ.toString(2).padStart(4, '0')})`);
+    console.log(`WRITE: ${PERMISSION.WRITE} (${PERMISSION.WRITE.toString(2).padStart(4, '0')})`);
+    console.log(`DELETE: ${PERMISSION.DELETE} (${PERMISSION.DELETE.toString(2).padStart(4, '0')})`);
+    console.log(`EXECUTE: ${PERMISSION.EXECUTE} (${PERMISSION.EXECUTE.toString(2).padStart(4, '0')})`);
+    // 授予多个权限（使用位或）
+    let userPermissions = PERMISSION.READ | PERMISSION.WRITE;
+    console.log(`\n用户权限: ${userPermissions} (${userPermissions.toString(2).padStart(4, '0')})`);
+    // 检查权限（使用位与）
+    const hasRead = (userPermissions & PERMISSION.READ) !== 0;
+    const hasDelete = (userPermissions & PERMISSION.DELETE) !== 0;
+    console.log(`\n有读权限: ${hasRead}`);
+    console.log(`有删除权限: ${hasDelete}`);
+    // 添加权限
+    userPermissions |= PERMISSION.EXECUTE;
+    console.log(`\n添加执行权限后: ${userPermissions} (${userPermissions.toString(2).padStart(4, '0')})`);
+    // 移除权限（使用位与和位非）
+    userPermissions &= ~PERMISSION.WRITE;
+    console.log(`移除写权限后: ${userPermissions} (${userPermissions.toString(2).padStart(4, '0')})`);
+    // 切换权限（使用位异或）
+    userPermissions ^= PERMISSION.READ;
+    console.log(`切换读权限后: ${userPermissions} (${userPermissions.toString(2).padStart(4, '0')})`);
+}
+// #endregion
+// #region 示例4: 颜色处理
+function colorProcessing() {
+    console.log('\n=== 颜色处理（RGB） ===');
+    // RGB 颜色值存储在一个 32 位整数中
+    // 格式: 0xRRGGBB
+    const color = 0xFF5733; // 橙红色
+    console.log(`颜色值: 0x${color.toString(16).toUpperCase()}`);
+    // 提取 RGB 分量
+    const red = (color >> 16) & 0xFF;
+    const green = (color >> 8) & 0xFF;
+    const blue = color & 0xFF;
+    console.log(`\nRGB 分量:`);
+    console.log(`R: ${red} (0x${red.toString(16).toUpperCase()})`);
+    console.log(`G: ${green} (0x${green.toString(16).toUpperCase()})`);
+    console.log(`B: ${blue} (0x${blue.toString(16).toUpperCase()})`);
+    // 组合 RGB 分量
+    const newColor = (red << 16) | (green << 8) | blue;
+    console.log(`\n重新组合: 0x${newColor.toString(16).toUpperCase()}`);
+    // 修改颜色分量
+    const darkerRed = Math.max(0, red - 50);
+    const darkerColor = (darkerRed << 16) | (green << 8) | blue;
+    console.log(`\n降低红色分量后: 0x${darkerColor.toString(16).toUpperCase()}`);
+}
+// #endregion
+// #region 示例5: 实用位运算技巧
+function bitwiseTricks() {
+    console.log('\n=== 实用位运算技巧 ===');
+    // 判断奇偶
+    const num1 = 7;
+    const num2 = 8;
+    console.log(`${num1} 是奇数: ${(num1 & 1) === 1}`);
+    console.log(`${num2} 是奇数: ${(num2 & 1) === 1}`);
+    // 交换两个数（不使用临时变量）
+    let a = 5;
+    let b = 10;
+    console.log(`\n交换前: a = ${a}, b = ${b}`);
+    a ^= b;
+    b ^= a;
+    a ^= b;
+    console.log(`交换后: a = ${a}, b = ${b}`);
+    // 取绝对值
+    const n = -42;
+    const mask = n >> 31; // 负数为 -1，正数为 0
+    const abs = (n + mask) ^ mask;
+    console.log(`\n${n} 的绝对值: ${abs}`);
+    // 判断是否为 2 的幂
+    function isPowerOfTwo(n) {
+        return (n & (n - 1)) === 0 && n !== 0;
+    }
+    const power1 = 16;
+    const power2 = 15;
+    console.log(`\n${power1} 是 2 的幂: ${isPowerOfTwo(power1)}`);
+    console.log(`${power2} 是 2 的幂: ${isPowerOfTwo(power2)}`);
+    // 向下取整到最接近的 2 的幂
+    function floorPowerOfTwo(n) {
+        n |= n >> 1;
+        n |= n >> 2;
+        n |= n >> 4;
+        n |= n >> 8;
+        n |= n >> 16;
+        return n - (n >> 1);
+    }
+    const num = 100;
+    console.log(`\n${num} 向下取整到 2 的幂: ${floorPowerOfTwo(num)}`);
+    // 计算二进制中 1 的个数
+    function countOnes(n) {
+        let count = 0;
+        while (n) {
+            n &= n - 1; // 清除最右边的 1
+            count++;
+        }
+        return count;
+    }
+    const testNum = 15; // 1111
+    console.log(`\n${testNum} (${testNum.toString(2)}) 中 1 的个数: ${countOnes(testNum)}`);
+}
+// #endregion
+if (require.main === module) {
+    const examples = [
+        basicBitwiseOperators,
+        shiftOperators,
+        permissionSystem,
+        colorProcessing,
+        bitwiseTricks
+    ];
+    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();
+        });
+    }
+}

package/dist/src/demo/operators-expressions/04-/350/241/250/350/276/276/345/274/217/344/270/216/346/261/202/345/200/274.js

@@ -0,0 +1,202 @@
+"use strict";
+/**
+ * TypeScript 表达式与求值
+ * =======================
+ * 涵盖三元运算符、逗号运算符、运算符优先级和表达式求值顺序
+ * 适用于 TypeScript 5.x
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ternaryOperator = ternaryOperator;
+exports.commaOperator = commaOperator;
+exports.operatorPrecedence = operatorPrecedence;
+exports.shortCircuitEvaluation = shortCircuitEvaluation;
+exports.evaluationOrder = evaluationOrder;
+// #region 示例1: 三元运算符
+function ternaryOperator() {
+    console.log('=== 三元运算符 ===');
+    const age = 18;
+    const status = age >= 18 ? '成年人' : '未成年人';
+    console.log(`年龄 ${age}: ${status}`);
+    // 嵌套三元运算符
+    const score = 85;
+    const grade = score >= 90 ? 'A' :
+        score >= 80 ? 'B' :
+            score >= 70 ? 'C' :
+                score >= 60 ? 'D' : 'F';
+    console.log(`\n分数 ${score}: ${grade}`);
+    // 实际应用：条件渲染
+    const isLoggedIn = true;
+    const username = 'zhangsan';
+    const greeting = isLoggedIn ? `欢迎, ${username}!` : '请登录';
+    console.log(`\n${greeting}`);
+    // 与函数结合
+    const numbers = [1, 2, 3, 4, 5];
+    const result = numbers.map(n => n % 2 === 0 ? n * 2 : n);
+    console.log(`\n偶数翻倍: ${result}`);
+}
+// #endregion
+// #region 示例2: 逗号运算符
+function commaOperator() {
+    console.log('\n=== 逗号运算符 ===');
+    // 基本用法：返回最后一个表达式的值
+    let counter = 0;
+    let x = (counter++, counter++, counter++, counter++, counter);
+    console.log(`执行多个表达式后的值: ${x}`);
+    // 在 for 循环中使用
+    console.log('\nfor 循环中的逗号运算符:');
+    for (let i = 0, j = 10; i < 5; i++, j--) {
+        console.log(`i = ${i}, j = ${j}`);
+    }
+    // 在赋值中使用
+    let a = 0;
+    let b = (a = 1, a + 2);
+    console.log(`\na = ${a}, b = ${b}`);
+    // 实际应用：简化代码
+    function increment(value) {
+        return (console.log(`递增前: ${value}`), value + 1);
+    }
+    const newValue = increment(5);
+    console.log(`递增后: ${newValue}`);
+}
+// #endregion
+// #region 示例3: 运算符优先级
+function operatorPrecedence() {
+    console.log('\n=== 运算符优先级 ===');
+    // 算术运算符优先级
+    const result1 = 2 + 3 * 4;
+    const result2 = (2 + 3) * 4;
+    console.log(`2 + 3 * 4 = ${result1}`);
+    console.log(`(2 + 3) * 4 = ${result2}`);
+    // 比较和逻辑运算符
+    const result3 = 5 > 3 && 2 < 4;
+    const result4 = 5 > 3 || 2 > 4;
+    console.log(`\n5 > 3 && 2 < 4 = ${result3}`);
+    console.log(`5 > 3 || 2 > 4 = ${result4}`);
+    // 复杂表达式
+    const a = 10;
+    const b = 5;
+    const c = 2;
+    const result5 = a + b * c > 15 && a - b < 10;
+    console.log(`\n${a} + ${b} * ${c} > 15 && ${a} - ${b} < 10 = ${result5}`);
+    // 位运算符优先级
+    const result6 = 5 | 3 & 1; // & 优先级高于 |
+    const result7 = (5 | 3) & 1;
+    console.log(`\n5 | 3 & 1 = ${result6}`);
+    console.log(`(5 | 3) & 1 = ${result7}`);
+}
+// #endregion
+// #region 示例4: 短路求值
+function shortCircuitEvaluation() {
+    console.log('\n=== 短路求值 ===');
+    // 逻辑与短路
+    console.log('逻辑与 (&&) 短路:');
+    let count1 = 0;
+    const result1 = false && (count1++, true);
+    console.log(`result: ${result1}, count: ${count1}`); // count 不会增加
+    let count2 = 0;
+    const result2 = true && (count2++, true);
+    console.log(`result: ${result2}, count: ${count2}`); // count 会增加
+    // 逻辑或短路
+    console.log('\n逻辑或 (||) 短路:');
+    let count3 = 0;
+    const result3 = true || (count3++, false);
+    console.log(`result: ${result3}, count: ${count3}`); // count 不会增加
+    let count4 = 0;
+    const result4 = false || (count4++, true);
+    console.log(`result: ${result4}, count: ${count4}`); // count 会增加
+    // 实际应用：默认值
+    function greet(name) {
+        const displayName = name || '访客';
+        console.log(`\n你好, ${displayName}!`);
+    }
+    greet('张三');
+    greet();
+    // 实际应用：条件执行
+    const isDebug = true;
+    isDebug && console.log('\n调试模式已启用');
+    // 空值合并的短路
+    let nullValue = null;
+    const value1 = nullValue ?? '默认值';
+    let nonNullValue = 'hello';
+    const value2 = nonNullValue ?? '这不会使用';
+    console.log(`\nvalue1: ${value1}`);
+    console.log(`value2: ${value2}`);
+}
+// #endregion
+// #region 示例5: 表达式求值顺序
+function evaluationOrder() {
+    console.log('\n=== 表达式求值顺序 ===');
+    // 函数参数求值顺序（从左到右）
+    function log(a, b, c) {
+        console.log(`a=${a}, b=${b}, c=${c}`);
+    }
+    let counter = 0;
+    function next() {
+        return ++counter;
+    }
+    console.log('函数参数求值顺序:');
+    log(next(), next(), next());
+    // 赋值表达式求值
+    counter = 0;
+    let x = 0;
+    x = next() + next();
+    console.log(`\nx = next() + next() = ${x}`);
+    console.log(`counter = ${counter}`);
+    // 对象属性求值顺序
+    counter = 0;
+    const obj = {
+        a: next(),
+        b: next(),
+        c: next()
+    };
+    console.log(`\n对象属性: ${JSON.stringify(obj)}`);
+    // 数组元素求值顺序
+    counter = 0;
+    const arr = [next(), next(), next()];
+    console.log(`数组元素: ${JSON.stringify(arr)}`);
+    // 链式调用求值
+    console.log('\n链式调用求值:');
+    const calculator = {
+        value: 0,
+        add(n) {
+            console.log(`  add(${n})`);
+            this.value += n;
+            return this;
+        },
+        multiply(n) {
+            console.log(`  multiply(${n})`);
+            this.value *= n;
+            return this;
+        },
+        getResult() {
+            console.log(`  getResult()`);
+            return this.value;
+        }
+    };
+    const result = calculator.add(5).multiply(2).add(3).getResult();
+    console.log(`最终结果: ${result}`);
+}
+// #endregion
+if (require.main === module) {
+    const examples = [
+        ternaryOperator,
+        commaOperator,
+        operatorPrecedence,
+        shortCircuitEvaluation,
+        evaluationOrder
+    ];
+    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();
+        });
+    }
+}

package/package.json

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