【TypeScript】TS入门

// 定义一个简单的TypeScript接口
interface Person {
  name: string;
  age: number;
}
 
// 实现接口
let person: Person = {
  name: 'Alice',
  age: 25
};
 
// 使用函数重载定义一个函数，该函数可以接收不同数量的参数
function buildName(firstName: string): string;
function buildName(firstName: string, lastName: string): string;
function buildName(firstName: string, lastName?: string): string {
  if (lastName) {
    return firstName + ' ' + lastName;
  } else {
    return firstName;
  }
}
 
// 使用函数重载
console.log(buildName('John')); // 输出: John
console.log(buildName('John', 'Doe')); // 输出: John Doe
 
// 使用类型别名定义一个字符串字面量类型
type EventNames = 'click' | 'scroll' | 'mousemove';
 
// 使用类型别名定义一个对象类型
type PersonInfo = {
  name: string;
  age?: number;
  [key: string]: any;
};
 
// 使用类型别名定义一个函数类型
type Handler = (event: { clientX: number; clientY: number }) => void;
 
// 使用类型断言确保赋值成功
let someValue: any = 'this is a string';
let stringLength: number = (<string>someValue).length;
 
// 使用泛型定义一个函数，该函数可以处理不同类型的数组
function getArrayItem<T>(arr: Array<T>, index: number): T {
  return arr[index];
}
 
// 使用泛型定义一个函数，该函数可以处理不同类型的对象
function setDefault<T, K extends keyof T>(obj: T, key: K, value: T[K]): T {
  if (!obj[key]) {
    obj[key] = value;
  }
  return obj;
}
 
// 使用泛型定义一个函数，该函数可以处理不同数量的参数
function addNumbers<T>(...args: T[]): T {
  let sum = 0;
  args.forEach((item) => {
    if (typeof item === 'number') {
      sum += item;
    }
  });
  return sum as T;
}
 
// 使用泛型和类型约束定义一个函数，该函数可以处理不同类型的数组
function sortArray<T>(arr: Array<T>, compare: (a: T, b: T) => number): T[] {
  return arr.sort(compare);
}
 
// 使用泛型和类型约束定义一个函数，该函数可以处理不同类型的对象
function printLabel<T extends { label: string }>(obj: T) {
  console.log(obj.label);
}
 
// 使用泛型和类型约束定义一个函数，该函数可以处理不同类型的对象数组
function printLabels<T extends { label: string }>(arr: T[]) {
  arr.forEach(item => console.log(item.label));
}
 
// 使用泛型和类型约束定义一个函数，该函数可以处理不同类型的对象数组，并返回特定的值
function getLabel<T extends { label: string }>(arr: T[]): string[] {
  return arr.map(item => item.label);
}
 
// 使用泛型和类型约束定义一个函数，该函数可以处理不同类型的对象数组，并返回特定的值
function getProperty<T, K extends keyof T>(obj: T, key: K) {
  return obj[key];
}
 
// 使用泛型和类型约束定义一