1// 基本語法
2function functionName(parameter1: Type1, parameter2: Type2): ReturnType {
3  // 函數體
4  return value;
5}
6
7// 實際範例
8function calculateArea(width: number, height: number): number {
9  return width * height;
10}
11
12// 函數提升 (Hoisting)
13console.log(add(5, 3)); // ✅ 可以在定義前調用，輸出 8
14
15function add(a: number, b: number): number {
16  return a + b;
17}

1// 匿名函數表達式
2const multiply = function(x: number, y: number): number {
3  return x * y;
4};
5
6// 具名函數表達式（便於除錯和遞迴）
7const factorial = function fact(n: number): number {
8  if (n <= 1) return 1;
9  return n * fact(n - 1); // 可以使用內部名稱 fact
10};
11
12// 不會被提升，必須在定義後調用
13// console.log(subtract(10, 5)); // ❌ 錯誤：在初始化前無法訪問
14
15const subtract = function(a: number, b: number): number {
16  return a - b;
17};
18
19console.log(subtract(10, 5)); // ✅ 正確，輸出 5

1// 基本語法
2const functionName = (param1: Type1, param2: Type2): ReturnType => {
3  return value;
4};
5
6// 簡化語法（單一表達式）
7const square = (x: number): number => x * x;
8
9// 無參數
10const getCurrentTime = (): string => new Date().toISOString();
11
12// 單一參數（可省略括號）
13const double = (x: number): number => x * 2;
14
15// 多行函數體
16const processData = (data: string[]): string => {
17  const processed = data.map(item => item.trim().toLowerCase());
18  return processed.join(', ');
19};
20
21// 返回物件字面量（需要括號）
22const createPoint = (x: number, y: number) => ({ x, y });

1// 基本類型參數
2function greetUser(name: string, age: number, isAdmin: boolean): void {
3  console.log(`Hello ${name}, age ${age}, admin: ${isAdmin}`);
4}
5
6// 物件參數
7interface User {
8  id: number;
9  name: string;
10  email: string;
11}
12
13function updateUser(user: User): void {
14  console.log(`Updating user: ${user.name}`);
15}
16
17// 陣列參數
18function processNumbers(numbers: number[]): number {
19  return numbers.reduce((sum, num) => sum + num, 0);
20}
21
22// 函數參數
23function executeCallback(callback: (message: string) => void): void {
24  callback("Operation completed");
25}

1// 聯合類型允許參數接受多種類型
2function formatId(id: string | number): string {
3  if (typeof id === "string") {
4    return id.toUpperCase();
5  }
6  return `ID-${id.toString().padStart(4, '0')}`;
7}
8
9console.log(formatId("abc123")); // "ABC123"
10console.log(formatId(42));       // "ID-0042"
11
12// 字面量類型聯合
13type Theme = "light" | "dark" | "auto";
14
15function setTheme(theme: Theme): void {
16  console.log(`Setting theme to: ${theme}`);
17}
18
19setTheme("dark"); // ✅ 正確
20// setTheme("blue"); // ❌ 錯誤：不在允許的值中

1// 解構參數與類型註解
2function createUser({ name, age, email }: { 
3  name: string; 
4  age: number; 
5  email: string 
6}): User {
7  return { id: Date.now(), name, age, email };
8}
9
10// 使用介面簡化
11interface CreateUserParams {
12  name: string;
13  age: number;
14  email: string;
15}
16
17function createUserV2({ name, age, email }: CreateUserParams): User {
18  return { id: Date.now(), name, age, email };
19}
20
21// 帶預設值的解構
22function configureApp({ 
23  theme = "light", 
24  language = "en", 
25  debug = false 
26}: {
27  theme?: "light" | "dark";
28  language?: string;
29  debug?: boolean;
30} = {}): void {
31  console.log(`App config: ${theme}, ${language}, debug: ${debug}`);
32}

1// 明確指定返回類型
2function calculateTax(amount: number, rate: number): number {
3  return amount * rate;
4}
5
6// void 返回類型
7function logError(message: string): void {
8  console.error(`Error: ${message}`);
9  // 不返回任何值，或返回 undefined
10}
11
12// never 返回類型（永不返回）
13function throwError(message: string): never {
14  throw new Error(message);
15}
16
17function infiniteLoop(): never {
18  while (true) {
19    // 永不結束的循環
20  }
21}

1// TypeScript 可以推斷返回類型
2function addNumbers(a: number, b: number) {
3  return a + b; // 推斷返回 number
4}
5
6// 但明確註解更好，特別是對於公共 API
7function addNumbersExplicit(a: number, b: number): number {
8  return a + b;
9}
10
11// 複雜返回類型的推斷
12function createResponse(success: boolean, data?: any) {
13  if (success) {
14    return { success: true, data };
15  }
16  return { success: false, error: "Operation failed" };
17}
18// 推斷類型：{ success: boolean; data?: any; error?: string }
19
20// 明確註解提供更好的契約
21interface ApiResponse<T> {
22  success: boolean;
23  data?: T;
24  error?: string;
25}
26
27function createResponseExplicit<T>(success: boolean, data?: T): ApiResponse<T> {
28  if (success) {
29    return { success: true, data };
30  }
31  return { success: false, error: "Operation failed" };
32}

1// 根據條件返回不同類型
2function parseValue(input: string, asNumber: true): number;
3function parseValue(input: string, asNumber: false): string;
4function parseValue(input: string, asNumber: boolean): string | number {
5  if (asNumber) {
6    return parseFloat(input);
7  }
8  return input.trim();
9}
10
11const numResult = parseValue("123.45", true);   // 類型：number
12const strResult = parseValue("  hello  ", false); // 類型：string

1// 可選參數使用 ? 標記
2function buildFullName(firstName: string, lastName?: string): string {
3  if (lastName) {
4    return `${firstName} ${lastName}`;
5  }
6  return firstName;
7}
8
9console.log(buildFullName("John"));        // "John"
10console.log(buildFullName("John", "Doe")); // "John Doe"
11
12// 可選參數必須在必需參數之後
13function createUser(name: string, age?: number, email?: string): User {
14  return {
15    id: Date.now(),
16    name,
17    age: age || 0,
18    email: email || ""
19  };
20}

1// 預設參數自動成為可選參數
2function greet(name: string, greeting: string = "Hello"): string {
3  return `${greeting}, ${name}!`;
4}
5
6console.log(greet("Alice"));           // "Hello, Alice!"
7console.log(greet("Bob", "Hi"));       // "Hi, Bob!"
8
9// 預設參數可以是表達式
10function createId(prefix: string = "user", timestamp: number = Date.now()): string {
11  return `${prefix}_${timestamp}`;
12}
13
14// 預設參數可以引用前面的參數
15function createUrl(protocol: string = "https", host: string, path: string = "/"): string {
16  return `${protocol}://${host}${path}`;
17}
18
19// 複雜預設值
20interface Config {
21  timeout: number;
22  retries: number;
23  debug: boolean;
24}
25
26function makeRequest(
27  url: string, 
28  config: Config = { timeout: 5000, retries: 3, debug: false }
29): Promise<any> {
30  console.log(`Making request to ${url} with config:`, config);
31  return Promise.resolve("Mock response");
32}

1// 預設參數不一定要在最後
2function formatMessage(
3  message: string,
4  level: "info" | "warn" | "error" = "info",
5  timestamp: boolean
6): string {
7  const prefix = timestamp ? `[${new Date().toISOString()}] ` : "";
8  return `${prefix}[${level.toUpperCase()}] ${message}`;
9}
10
11// 要跳過預設參數，需要明確傳入 undefined
12console.log(formatMessage("Test message", undefined, true));
13// 輸出：[2024-01-01T12:00:00.000Z] [INFO] Test message

1// 剩餘參數收集所有額外的參數到陣列中
2function sum(...numbers: number[]): number {
3  return numbers.reduce((total, num) => total + num, 0);
4}
5
6console.log(sum(1, 2, 3));        // 6
7console.log(sum(1, 2, 3, 4, 5));  // 15
8console.log(sum());               // 0
9
10// 剩餘參數與其他參數結合
11function logMessage(level: string, ...messages: string[]): void {
12  console.log(`[${level}] ${messages.join(" ")}`);
13}
14
15logMessage("INFO", "User", "logged", "in", "successfully");
16// 輸出：[INFO] User logged in successfully

1// 不同類型的剩餘參數
2function processValues(operation: string, ...values: (string | number)[]): void {
3  console.log(`Operation: ${operation}`);
4  values.forEach((value, index) => {
5    console.log(`  ${index}: ${value} (${typeof value})`);
6  });
7}
8
9processValues("mix", 1, "hello", 2, "world");
10
11// 物件剩餘參數
12function mergeObjects<T>(target: T, ...sources: Partial<T>[]): T {
13  return sources.reduce((result, source) => ({ ...result, ...source }), target);
14}
15
16const merged = mergeObjects(
17  { a: 1, b: 2 },
18  { b: 3, c: 4 },
19  { c: 5, d: 6 }
20);
21console.log(merged); // { a: 1, b: 3, c: 5, d: 6 }

1// 在函數參數中使用剩餘解構
2function processFirstAndRest(first: string, ...rest: string[]): void {
3  console.log(`First: ${first}`);
4  console.log(`Rest: ${rest.join(", ")}`);
5}
6
7// 陣列解構與剩餘參數
8function analyzeArray([first, second, ...others]: number[]): void {
9  console.log(`First: ${first}`);
10  console.log(`Second: ${second}`);
11  console.log(`Others: ${others.length} items`);
12}
13
14analyzeArray([1, 2, 3, 4, 5]);
15// First: 1, Second: 2, Others: 3 items

1// 重載簽名
2function combine(a: string, b: string): string;
3function combine(a: number, b: number): number;
4function combine(a: boolean, b: boolean): boolean;
5
6// 實現簽名
7function combine(a: any, b: any): any {
8  if (typeof a === "string" && typeof b === "string") {
9    return a + b;
10  }
11  if (typeof a === "number" && typeof b === "number") {
12    return a + b;
13  }
14  if (typeof a === "boolean" && typeof b === "boolean") {
15    return a && b;
16  }
17  throw new Error("Invalid argument types");
18}
19
20// 使用時會根據參數類型選擇對應的重載
21const str = combine("Hello", " World");  // 類型：string
22const num = combine(5, 3);               // 類型：number
23const bool = combine(true, false);       // 類型：boolean

1// 日期格式化函數的重載
2function formatDate(date: Date): string;
3function formatDate(date: Date, format: "short"): string;
4function formatDate(date: Date, format: "long"): string;
5function formatDate(date: Date, format: "iso"): string;
6function formatDate(date: Date, format: "custom", pattern: string): string;
7
8function formatDate(
9  date: Date, 
10  format?: "short" | "long" | "iso" | "custom", 
11  pattern?: string
12): string {
13  if (!format) {
14    return date.toLocaleDateString();
15  }
16  
17  switch (format) {
18    case "short":
19      return date.toLocaleDateString("en-US", { 
20        year: "2-digit", 
21        month: "2-digit", 
22        day: "2-digit" 
23      });
24    case "long":
25      return date.toLocaleDateString("en-US", { 
26        year: "numeric", 
27        month: "long", 
28        day: "numeric" 
29      });
30    case "iso":
31      return date.toISOString();
32    case "custom":
33      if (!pattern) throw new Error("Pattern required for custom format");
34      // 簡化的自定義格式實現
35      return pattern
36        .replace("YYYY", date.getFullYear().toString())
37        .replace("MM", (date.getMonth() + 1).toString().padStart(2, "0"))
38        .replace("DD", date.getDate().toString().padStart(2, "0"));
39    default:
40      return date.toLocaleDateString();
41  }
42}
43
44// 使用範例
45const now = new Date();
46console.log(formatDate(now));                    // 預設格式
47console.log(formatDate(now, "short"));           // 短格式
48console.log(formatDate(now, "long"));            // 長格式
49console.log(formatDate(now, "custom", "YYYY-MM-DD")); // 自定義格式

1// 使用聯合類型（較簡單但類型資訊較少）
2function processInput(input: string | number): string | number {
3  if (typeof input === "string") {
4    return input.toUpperCase();
5  }
6  return input * 2;
7}
8
9// 使用重載（更精確的類型資訊）
10function processInputOverload(input: string): string;
11function processInputOverload(input: number): number;
12function processInputOverload(input: string | number): string | number {
13  if (typeof input === "string") {
14    return input.toUpperCase();
15  }
16  return input * 2;
17}
18
19// 比較結果
20const result1 = processInput("hello");         // 類型：string | number
21const result2 = processInputOverload("hello"); // 類型：string（更精確）

1// this 的動態綁定
2const obj = {
3  name: "MyObject",
4  regularFunction: function() {
5    console.log(`Regular function this.name: ${this.name}`);
6  },
7  arrowFunction: () => {
8    // 箭頭函數中的 this 指向定義時的上下文
9    console.log(`Arrow function this:`, this);
10  }
11};
12
13obj.regularFunction(); // "Regular function this.name: MyObject"
14obj.arrowFunction();   // this 不是 obj
15
16// this 綁定的問題
17const regularFn = obj.regularFunction;
18// regularFn(); // 錯誤：this 為 undefined（嚴格模式）或 window（非嚴格模式）

1class EventHandler {
2  private message = "Hello from EventHandler";
3  
4  // 傳統方法 - this 可能丟失
5  handleEventTraditional() {
6    console.log(`Traditional: ${this.message}`);
7  }
8  
9  // 箭頭函數方法 - this 始終指向實例
10  handleEventArrow = () => {
11    console.log(`Arrow: ${this.message}`);
12  }
13  
14  setupEventListeners() {
15    // 模擬事件監聽器
16    setTimeout(this.handleEventTraditional.bind(this), 100);
17    setTimeout(this.handleEventArrow, 200); // 不需要 bind
18  }
19}
20
21const handler = new EventHandler();
22handler.setupEventListeners();

1interface Database {
2  host: string;
3  port: number;
4  connect(): void;
5}
6
7interface QueryBuilder {
8  query: string;
9  addWhere(this: QueryBuilder, condition: string): QueryBuilder;
10  execute(this: QueryBuilder & { db: Database }): Promise<any>;
11}
12
13const queryBuilder: QueryBuilder = {
14  query: "SELECT * FROM users",
15  
16  addWhere(this: QueryBuilder, condition: string) {
17    this.query += ` WHERE ${condition}`;
18    return this;
19  },
20  
21  execute(this: QueryBuilder & { db: Database }) {
22    console.log(`Executing: ${this.query} on ${this.db.host}:${this.db.port}`);
23    return Promise.resolve([]);
24  }
25};
26
27// 使用時需要正確的 this 上下文
28const builderWithDb = Object.assign(queryBuilder, {
29  db: { host: "localhost", port: 5432, connect() {} }
30});
31
32builderWithDb
33  .addWhere("age > 18")
34  .execute();

1// 回調函數類型定義
2type Callback<T> = (error: Error | null, result?: T) => void;
3type Predicate<T> = (item: T) => boolean;
4type Mapper<T, U> = (item: T, index: number) => U;
5
6// 高階函數範例
7function asyncOperation<T>(
8  operation: () => T,
9  callback: Callback<T>
10): void {
11  try {
12    const result = operation();
13    setTimeout(() => callback(null, result), 100);
14  } catch (error) {
15    setTimeout(() => callback(error as Error), 100);
16  }
17}
18
19// 陣列處理函數
20function filterMap<T, U>(
21  array: T[],
22  predicate: Predicate<T>,
23  mapper: Mapper<T, U>
24): U[] {
25  return array
26    .filter(predicate)
27    .map(mapper);
28}
29
30// 使用範例
31const numbers = [1, 2, 3, 4, 5, 6];
32const result = filterMap(
33  numbers,
34  x => x % 2 === 0,        // 過濾偶數
35  (x, i) => `${i}: ${x * 2}` // 映射為字串
36);
37console.log(result); // ["1: 4", "3: 8", "5: 12"]

1// 函數工廠
2function createValidator(pattern: RegExp) {
3  return function(value: string): boolean {
4    return pattern.test(value);
5  };
6}
7
8const emailValidator = createValidator(/^[^\s@]+@[^\s@]+\.[^\s@]+$/);
9const phoneValidator = createValidator(/^\d{10}$/);
10
11console.log(emailValidator("test@example.com")); // true
12console.log(phoneValidator("1234567890"));       // true
13
14// 柯里化函數
15function multiply(a: number) {
16  return function(b: number): number {
17    return a * b;
18  };
19}
20
21const double = multiply(2);
22const triple = multiply(3);
23
24console.log(double(5));  // 10
25console.log(triple(4));  // 12
26
27// 更複雜的函數組合
28function compose<T, U, V>(
29  f: (x: U) => V,
30  g: (x: T) => U
31): (x: T) => V {
32  return function(x: T): V {
33    return f(g(x));
34  };
35}
36
37const addOne = (x: number) => x + 1;
38const multiplyByTwo = (x: number) => x * 2;
39
40const addOneThenDouble = compose(multiplyByTwo, addOne);
41console.log(addOneThenDouble(3)); // (3 + 1) * 2 = 8

1type: simple_run
2instruction: 比較不同函數定義方式的特點和使用場景。
3---
4// 1. 命名函數 - 具有提升特性
5console.log("=== 命名函數 ===");
6console.log("調用 add:", add(5, 3)); // 可以在定義前調用
7
8function add(a: number, b: number): number {
9  return a + b;
10}
11
12// 2. 函數表達式 - 不會提升
13console.log("\n=== 函數表達式 ===");
14const multiply = function(a: number, b: number): number {
15  return a * b;
16};
17console.log("調用 multiply:", multiply(4, 6));
18
19// 3. 箭頭函數 - 簡潔語法
20console.log("\n=== 箭頭函數 ===");
21const divide = (a: number, b: number): number => a / b;
22const square = (x: number): number => x * x;
23const greet = (name: string): string => `Hello, ${name}!`;
24
25console.log("調用 divide:", divide(10, 2));
26console.log("調用 square:", square(7));
27console.log("調用 greet:", greet("TypeScript"));
28
29// 4. 比較語法差異
30console.log("\n=== 語法比較 ===");
31console.log("命名函數可以遞迴調用自己");
32console.log("函數表達式更靈活，可以條件性定義");
33console.log("箭頭函數語法最簡潔，適合簡單操作");
34
35console.log("✅ 函數基礎練習完成！");

1// 函數定義方式的選擇指南：
2
3// 1. 命名函數適用於：
4//    - 需要函數提升的場景
5//    - 遞迴函數
6//    - 主要的業務邏輯函數
7
8// 2. 函數表達式適用於：
9//    - 條件性函數定義
10//    - 需要明確控制函數創建時機
11//    - 作為物件方法
12
13// 3. 箭頭函數適用於：
14//    - 簡短的工具函數
15//    - 回調函數
16//    - 需要保持 this 上下文的場景
17//    - 函數式編程風格
18
19// 最佳實踐：
20// - 根據具體需求選擇合適的定義方式
21// - 保持團隊代碼風格一致
22// - 優先考慮可讀性和維護性

1type: output_check
2instruction: 實現一個靈活的日誌函數，支援不同級別和多個訊息。
3expectedOutput: [2024-01-01 12:00:00] [INFO] 系統啟動: 初始化完成, 準備就緒
4---
5// 日誌系統實現
6type LogLevel = "DEBUG" | "INFO" | "WARN" | "ERROR";
7
8interface LogOptions {
9  timestamp?: boolean;
10  prefix?: string;
11}
12
13class Logger {
14  private defaultOptions: LogOptions = {
15    timestamp: true,
16    prefix: ""
17  };
18
19  // 使用可選參數和預設參數
20  log(
21    level: LogLevel,
22    message: string,
23    ...additionalMessages: string[]
24  ): void;
25  
26  log(
27    level: LogLevel,
28    message: string,
29    options: LogOptions,
30    ...additionalMessages: string[]
31  ): void;
32
33  // 實現簽名
34  log(
35    level: LogLevel,
36    message: string,
37    optionsOrMessage?: LogOptions | string,
38    ...additionalMessages: string[]
39  ): void {
40    let options: LogOptions;
41    let messages: string[];
42
43    // 判斷第三個參數是選項還是訊息
44    if (typeof optionsOrMessage === "string") {
45      options = this.defaultOptions;
46      messages = [message, optionsOrMessage, ...additionalMessages];
47    } else {
48      options = { ...this.defaultOptions, ...optionsOrMessage };
49      messages = [message, ...additionalMessages];
50    }
51
52    // 格式化輸出
53    const timestamp = options.timestamp 
54      ? `[${new Date().toISOString().slice(0, 19).replace('T', ' ')}] `
55      : "";
56    
57    const prefix = options.prefix ? `${options.prefix} ` : "";
58    const levelTag = `[${level}]`;
59    const content = messages.join(", ");
60
61    console.log(`${timestamp}${levelTag} ${prefix}${content}`);
62  }
63
64  // 便利方法
65  info(message: string, ...additional: string[]): void {
66    this.log("INFO", message, ...additional);
67  }
68
69  warn(message: string, ...additional: string[]): void {
70    this.log("WARN", message, ...additional);
71  }
72
73  error(message: string, ...additional: string[]): void {
74    this.log("ERROR", message, ...additional);
75  }
76
77  debug(message: string, options?: LogOptions, ...additional: string[]): void {
78    if (options) {
79      this.log("DEBUG", message, options, ...additional);
80    } else {
81      this.log("DEBUG", message, ...additional);
82    }
83  }
84}
85
86// 測試日誌系統
87const logger = new Logger();
88
89// 模擬固定時間戳以便測試
90const originalDate = Date;
91global.Date = class extends Date {
92  constructor() {
93    super();
94    return new originalDate("2024-01-01T12:00:00.000Z");
95  }
96  
97  static now() {
98    return new originalDate("2024-01-01T12:00:00.000Z").getTime();
99  }
100  
101  toISOString() {
102    return "2024-01-01T12:00:00.000Z";
103  }
104} as any;
105
106// 使用不同的參數組合
107logger.info("系統啟動", "初始化完成", "準備就緒");
108
109// 恢復原始 Date
110global.Date = originalDate;

1// 參數處理的高級技巧：
2
3// 1. 函數重載處理不同參數組合：
4//    - 允許靈活的 API 設計
5//    - 提供更好的類型安全
6//    - 支援向後兼容
7
8// 2. 剩餘參數的妙用：
9//    - 收集可變數量的參數
10//    - 與解構結合使用
11//    - 類型安全的可變參數
12
13// 3. 預設參數最佳實踐：
14//    - 提供合理的預設值
15//    - 使用物件展開合併選項
16//    - 考慮參數順序的影響
17
18// 4. 類型判斷技巧：
19//    - 使用 typeof 檢查基本類型
20//    - 使用 instanceof 檢查物件類型
21//    - 使用類型守衛確保類型安全
22
23// 實際應用場景：
24// - API 設計中的靈活參數
25// - 配置系統的選項處理
26// - 工具函數的多種調用方式

1type: output_check
2instruction: 創建一個支援多種轉換模式的數據處理器，使用函數重載提供精確的類型資訊。
3expectedOutput: 字串轉換: HELLO WORLD, 數字轉換: 246, 陣列轉換: [2,4,6,8,10]
4---
5// 數據轉換器實現
6interface TransformOptions {
7  uppercase?: boolean;
8  multiplier?: number;
9  filter?: (item: any) => boolean;
10}
11
12class DataTransformer {
13  // 字串轉換重載
14  transform(input: string): string;
15  transform(input: string, options: { uppercase: boolean }): string;
16  
17  // 數字轉換重載
18  transform(input: number): number;
19  transform(input: number, options: { multiplier: number }): number;
20  
21  // 陣列轉換重載
22  transform<T>(input: T[]): T[];
23  transform<T>(input: T[], options: { filter: (item: T) => boolean }): T[];
24  transform<T>(input: T[], options: { multiplier: number }): number[] | T[];
25  
26  // 實現簽名
27  transform<T>(
28    input: string | number | T[], 
29    options?: TransformOptions
30  ): string | number | T[] | number[] {
31    if (typeof input === "string") {
32      if (options?.uppercase) {
33        return input.toUpperCase();
34      }
35      return input.toLowerCase();
36    }
37    
38    if (typeof input === "number") {
39      const multiplier = options?.multiplier || 2;
40      return input * multiplier;
41    }
42    
43    if (Array.isArray(input)) {
44      let result: any = input;
45      
46      // 先過濾
47      if (options?.filter) {
48        result = result.filter(options.filter);
49      }
50      
51      // 再轉換數字
52      if (options?.multiplier) {
53        result = result.map((item: any) => {
54          if (typeof item === "number") {
55            return item * options.multiplier!;
56          }
57          return item;
58        });
59      }
60      
61      return result;
62    }
63    
64    throw new Error("Unsupported input type");
65  }
66  
67  // 便利方法，利用重載提供更好的 API
68  toUpperCase(input: string): string {
69    return this.transform(input, { uppercase: true });
70  }
71  
72  multiply(input: number, factor: number): number {
73    return this.transform(input, { multiplier: factor });
74  }
75  
76  filterAndMultiply<T>(
77    input: T[], 
78    filter: (item: T) => boolean, 
79    multiplier: number
80  ): (T | number)[] {
81    return this.transform(input, { filter, multiplier });
82  }
83}
84
85// 測試數據轉換器
86const transformer = new DataTransformer();
87
88// 測試不同類型的轉換
89const stringResult = transformer.transform("hello world", { uppercase: true });
90const numberResult = transformer.transform(123, { multiplier: 2 });
91const arrayResult = transformer.transform(
92  [1, 2, 3, 4, 5], 
93  { 
94    filter: (x: number) => x % 2 === 0,  // 過濾偶數
95    multiplier: 2                        // 乘以2
96  }
97);
98
99console.log(`字串轉換: ${stringResult}, 數字轉換: ${numberResult}, 陣列轉換: [${arrayResult.join(",")}]`);