// 常用的方法 类型别名
  type Point = {
    x: number;
    y: number;
  };
  // 或者 接口声明 interfaces 
  //interface Point {
  //  x: number;
  //  y: number;
  //}
  // Exactly the same as the earlier example
  function printCoord(pt: Point) {
    console.log("The coordinate's x value is " + pt.x);
    console.log("The coordinate's y value is " + pt.y);
  }
  // interfaces 和 type 两者最关键的差别在于类型别名本身无法添加新的属性，而接口是可以扩展的。

function padLeft(padding: number | string, input: string) {
  if (typeof padding === "number") { // 如果不加这句类型判断，ts会把 padding + 1 这段标红，他在警告我们 直接这么相加并不会得到我们想要的结果，
    return new Array(padding + 1).join(" ") + input;
  }
  return padding + input;
}

  function isFish(pet: Fish | Bird): pet is Fish {//  pet is Fish 用来告诉 ts：如果函数返回 true，参数 pet 的类型就是 Fish。
    return (pet as Fish).swim !== undefined;
  }

  interface StartAction {
    type: "start";
    payload: { user: string };
  }
  interface StopAction {
    type: "stop";
  }
  interface ResetAction {
    type: "reset";
    payload: { reason: string };
  }
  type Action = StartAction | StopAction | ResetAction;

  // 通过检查可辨别字段，TypeScript 自动缩小类型范围，避免不必要的类型断言。
  function handleAction(action: Action) {
    switch (action.type) {
      case "start":
        console.log(`Starting for user: ${action.payload.user}`);
        break;

      case "stop":
        console.log("Stopping");
        break;

      case "reset":
        console.log(`Reset because: ${action.payload.reason}`);
        break;

      default:
        throw new Error("Unknown action type");
    }
  }

// <Type> ： 表示一个泛型参数的占位符,它的作用是让函数支持不同类型 
// Type[] ：表示元素类型为 Type 的数组
// Type | undefined ： 表示函数返回 Tpye 类型或者 undefined 类型
function firstElement<Type>(arr: Type[]): Type | undefined {
  return arr[0];
}

const nums = [1, 2, 3];
const firstNum = firstElement(nums); // 推断为 number | undefined
console.log(firstNum); // 输出: 1

const words = ["apple", "banana"];
const firstWord = firstElement(words); // 推断为 string | undefined
console.log(firstWord); // 输出: "apple"

const emptyList: boolean[] = [];
const firstEmpty = firstElement(emptyList); // 推断为 boolean | undefined
console.log(firstEmpty); // 输出: undefined

const obj= [{a:1, b:2}, {c:3, b: 4}];
const firstEmpty = firstElement(obj); // 推断为 Object | undefined
console.log(firstEmpty); // 输出: {a:1, b:2}

  //<T, K extends keyof T> 是泛型参数的声明
  // T 表示对象的类型。
  // K 是一个泛型 它必须是 T 的键之一  （通过 keyof T 约束）
  // (obj: T, key: K) 参数 一个是对象、一个是对象中的key
  // T[K] 表示对象 T 中键 K 对应的属性的类型。
  function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
    return obj[key];
  }
  const person = {
    name: "Alice",
    age: 30,
    job: "Engineer",
  };
  // 函数调用：获取 name 属性
  const personName = getProperty(person, "name"); // 推断类型为 string
  console.log(personName); // 输出: Alice
  // 函数调用：获取 age 属性
  const personAge = getProperty(person, "age"); // 推断类型为 number
  console.log(personAge); // 输出: 30