@lppx/nlearn 1.1.12 → 1.1.14

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,169 @@
+"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);
+    // filter 过滤
+    const filtered = fruits.filter(fruit => fruit.length > 5);
+    console.log('filter 长度>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());
+    }
+}