Typescript中Type check类型检查的实现

// 基本类型
let name: string = "John";
let age: number = 30;
let isActive: boolean = true;
let nothing: null = null;
let undef: undefined = undefined;

// 数组
let numbers: number[] = [1, 2, 3];
let names: Array<string> = ["Alice", "Bob"];

// 元组
let tuple: [string, number] = ["hello", 42];

interface User {
  id: number;
  name: string;
  email?: string; // 可选属性
  readonly createdAt: Date; // 只读属性
}

const user: User = {
  id: 1,
  name: "John",
  createdAt: new Date()
};

// 错误：缺少必需的属性
// const invalidUser: User = { id: 1 }; // Error: Property 'name' is missing

// 错误：修改只读属性
// user.createdAt = new Date(); // Error: Cannot assign to 'createdAt'

type Point = {
  x: number;
  y: number;
};

type ID = number | string;

// 函数声明
function add(a: number, b: number): number {
  return a + b;
}

// 函数表达式
const multiply: (x: number, y: number) => number = function(x, y) {
  return x * y;
};

// 箭头函数
const divide = (a: number, b: number): number => a / b;

// 可选参数和默认参数
function greet(name: string, greeting: string = "Hello"): string {
  return `${greeting}, ${name}!`;
}

// 剩余参数
function sum(...numbers: number[]): number {
  return numbers.reduce((acc, curr) => acc + curr, 0);
}

// 联合类型
type Status = "pending" | "success" | "error";
let currentStatus: Status = "pending";

type StringOrNumber = string | number;
let value: StringOrNumber = "hello";
value = 42;

// 交叉类型
interface Named {
  name: string;
}

interface Aged {
  age: number;
}

type Person = Named & Aged;
const person: Person = { name: "John", age: 30 };

// 泛型函数
function identity<T>(arg: T): T {
  return arg;
}

// 泛型接口
interface Response<T> {
  data: T;
  status: number;
}

const userResponse: Response<User> = {
  data: { id: 1, name: "John", createdAt: new Date() },
  status: 200
};

// 泛型约束
interface HasLength {
  length: number;
}

function logLength<T extends HasLength>(arg: T): void {
  console.log(arg.length);
}

function isString(value: any): value is string {
  return typeof value === "string";
}

function processValue(value: string | number) {
  if (isString(value)) {
    // TypeScript 知道这里 value 是 string 类型
    console.log(value.toUpperCase());
  } else {
    // TypeScript 知道这里 value 是 number 类型
    console.log(value.toFixed(2));
  }
}

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

type UserKeys = keyof User; // "id" | "name" | "email"

const user = { name: "John", age: 30 };
type UserType = typeof user; // { name: string; age: number; }

{
  "compilerOptions": {
    "strict": true,
    "noImplicitAny": true,
    "noImplicitReturns": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "exactOptionalPropertyTypes": true,
    "noImplicitOverride": true
  }
}

// 类型推断
let message = "hello"; // 推断为 string 类型
let count = 42; // 推断为 number 类型

// 函数返回类型推断
function createUser(name: string, age: number) {
  return { name, age }; // 推断返回类型为 { name: string; age: number }
}

// 上下文类型推断
const buttons = document.querySelectorAll("button");
buttons.forEach(button => {
  button.addEventListener("click", e => {
    // e 被推断为 MouseEvent
    console.log(e.target);
  });
});

interface Point {
  x: number;
  y: number;
}

interface NamedPoint {
  x: number;
  y: number;
  name: string;
}

let point: Point = { x: 1, y: 2 };
let namedPoint: NamedPoint = { x: 1, y: 2, name: "origin" };

point = namedPoint; // OK: NamedPoint 包含 Point 的所有属性
// namedPoint = point; // Error: Point 缺少 name 属性

interface User {
  id: number;
  name: string;
  email: string;
  age: number;
}

// Partial: 所有属性变为可选
type PartialUser = Partial<User>;

// Readonly: 所有属性变为只读
type ReadonlyUser = Readonly<User>;

// Pick: 选择部分属性
type UserBasicInfo = Pick<User, "id" | "name">;

// Omit: 排除部分属性
type UserWithoutEmail = Omit<User, "email">;

// Record: 创建键值对类型
type UserMap = Record<string, User>;