// 示例：類型檢查
function greet(name: string): void {
    console.log(`Hello, ${name}`);
}

greet("Tom"); // 正確
greet(123);   // 編譯報錯：參數(shù)類型不匹配

let age: number = 25;
age = "25"; // 報錯：不能將字符串賦值給 number 類型

function printId(id: number | string): void {
    console.log(`ID: ${id}`);
}

printId(101);      // OK
printId("101");    // OK
printId(true);     // 報錯

const input = document.getElementById("username") as HTMLInputElement;
input.value = "默認值";

// interface
interface User {
    name: string;
}

// type
type ID = string | number;

interface Person {
    name: string;
    age?: number; // 可選
}

const p: Person = { name: "Alice" }; // 合法

let user: [string, number];
user = ["Alice", 25]; // 合法
user = [25, "Alice"]; // 報錯：類型順序不符

enum WeekDay {
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday
}

console.log(WeekDay.Monday); // 輸出: 0
console.log(WeekDay[3]);     // 輸出: "Thursday"

function identity<T>(value: T): T {
    return value;
}

console.log(identity<string>("hello")); // 輸出: "hello"
console.log(identity<number>(123));     // 輸出: 123

let message = "Hello"; // 類型自動推斷為 string
message = 123;         // 報錯：不能將 number 賦值給 string

type Sum = (a: number, b: number) => number;

const add: Sum = (x, y) => x + y;
console.log(add(2, 3)); // 輸出: 5

function isNumber(x: any): x is number {
    return typeof x === "number";
}

function processValue(value: number | string): void {
    if (isNumber(value)) {
        console.log(value.toFixed(2));
    } else {
        console.log(value.toUpperCase());
    }
}

class Person {
    name: string;

    constructor(name: string) {
        this.name = name;
    }

    sayHello(): void {
        console.log(`Hello, my name is ${this.name}`);
    }
}

const p = new Person("Tom");
p.sayHello(); // 輸出: Hello, my name is Tom

class Animal {
    public name: string;
    private secret: string;
    protected family: string;

    constructor(name: string, secret: string, family: string) {
        this.name = name;
        this.secret = secret;
        this.family = family;
    }
}

class Dog extends Animal {
    showFamily() {
        console.log(this.family); // 合法
        // console.log(this.secret); // ILLEGAL
    }
}

interface Person {
    name: string;
}

interface Employee extends Person {
    id: number;
}

const emp: Employee = { name: "John", id: 1 };

interface User {
    readonly id: number;
    name: string;
}

const user: User = { id: 1, name: "Alice" };
user.id = 2; // 報錯：無法修改只讀屬性

function log(target: any, key: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;
    descriptor.value = function (...args: any[]) {
        console.log(`Calling "${key}" with`, args);
        return originalMethod.apply(this, args);
    };
}

class Calculator {
    @log
    add(a: number, b: number): number {
        return a + b;
    }
}

const calc = new Calculator();
calc.add(2, 3);
// 輸出: Calling "add" with [2, 3]

let value: unknown;
value = "hello";
if (typeof value === "string") {
    console.log(value.toUpperCase()); // 安全地使用
}

let val: any = 123;
val = "abc";
val = true;
console.log(val.foo.bar.baz); // 不會報錯（但運行時報錯）

interface StringArray {
    [index: number]: string;
}

const arr: StringArray = ["Apple", "Banana"];
console.log(arr[0]); // 輸出: "Apple"

interface Dictionary {
    [key: string]: number;
}

const data: Dictionary = { one: 1, two: 2 };

function throwError(message: string): never {
    throw new Error(message);
}

function infiniteLoop(): never {
    while (true) {}
}