ts 新增类型

js
any :任意类型
void :没有类型
never:不存在类型
unknow:未知类型

tule:
void 配合 undefined
unknow 可以写任意类型 配合 类型推导使用 typeof instanceof
tuple: 元组固定类型长度
enum:枚举
interface:接口
class
泛型

never

js
1.函数永远不会返回
如果一个函数要么抛异常，要么进入死循环，那它的返回值类型就是 never：
function throwError(message: string): never {
  throw new Error(message); // 永远不会正常返回
}

function infiniteLoop(): never {
  while (true) {} // 死循环
}

2.用在类型推断中（类型保护兜底）
never 常用来确保类型分支被穷尽处理（exhaustive check）：

type Shape = 'circle' | 'square' | 'triangle';

function getArea(shape: Shape) {
  switch (shape) {
    case 'circle':
      return '圆';
    case 'square':
      return '方';
    case 'triangle':
      return '三角';
    default:
      // 如果上面漏了某个类型，这里 shape 会是 never
      const _exhaustiveCheck: never = shape;
      return _exhaustiveCheck;
  }
}

tuple

js
const t :[string,number] = ['11',123]

enum

js
enum Direction {
  Up,    // 0
  Down,  // 1
  Left,  // 2
  Right  // 3
}

let dir: Direction = Direction.Up;
console.log(dir); // 0


enum Direction {
  Up = 1,
  Down,   // 2
  Left,   // 3
  Right   // 4
}

enum Direction {
  Up = 1,
  Down,
  Left,
  Right
}

console.log(Direction.Up);    // 1
console.log(Direction[1]);    // "Up"

interface

js
interface Person {
  name: string;
  age: number;
}

let p1: Person = {
  name: "Tom",
  age: 20
};

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

let p2: Person = { name: "Jerry" }; // ✅ age 可省略

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

let pt: Point = { x: 10, y: 20 };
pt.x = 30; // ❌ 无法修改

interface A { a: number }
interface B { b: number }
interface C extends A, B { c: number }


定义函数类型

interface Add {
  (x: number, y: number): number;
}

const add: Add = (a, b) => a + b;


接口合并（独有特性）
接口同名时会自动合并：

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

let u: User = { name: "Tom", age: 20 };


索引签名
interface StringArray {
    [index:number]:string;
    
}

let arr: StringArray = ["a", "b", "c"];

绕开多余的属性检查
1.类型断言
interface BaseParams {
    t1:string;
   2.索引签名
   [prop:string]:any;
}
const getType = (p:BaseParams):string=>{
return `${p.t1}` 
}

getType({
t1:'1'
} as BaseParams)

3.类型兼容
let p = {
t1,t2
}
getType({p})

接口定义方法
interface Base { 
  (n:number):string
}
const find: Base = (n) => {
  return n.toString();
}

class

js
多继承，单实现
接口继承类，类实现接口
class A {
  c = 1;
  constructor(c?: string) {}
}
let adcsd = new A();
console.log("print ~ adcsd:1", adcsd);
class B extends A {
  d = 2;
  constructor(d?: string) {
    super();
  }
}
interface D {
  a: string;
  b: string;
}
class C implements D {
  constructor(public a: string, public b: string) {}
}

let c = new C("1", "2");
console.log("print ~ c:", c);

泛型

js
const test = <T>(t1: T): T => {
  return t1;
};
console.log("print ~ test:", typeof test<string | number>("1"));