ts声明简单类型

let str : string = '123' 
let age : number = 123
let flag : boolean = false
let u : undefind = undefind
let n : null = null
//任意类型都可以赋值为null或undefined，当不确定类型时可以使用any
let Any : any = 123
let str : string = null`

ts声明数组

let arr : number[] = [123]
let arr : [number,string] = [1,'1'] // 元组

interface 接口

//不关注如何使用,只描述形状

//定义对象 只读id 字符名称  可选属性年龄
interface Person { 
  readonly id: number;
  name: string;
  age?: number;
}
let person: Person = {
  id: 1,
  name:'xiaoming',
}
// 定义方法 arguments和返回值均为number 第三个参数可选
interface isum{
 (x: number, y: number, z?: number): number
}
const add: isum =  (x,y,z)=>{
  if(z) return x+y+z
  return x+y
}

定义方法

const  add = (x: number, y: number, z?: number)=>{
  if(z) return x+y+z
  return x+y
}

类型推论

在不声明类型的情况下自动获得定义时的类型
let num = 1
num = '1'

error TS2322: Type 'string' is not assignable to type 'number'.

联合类型

//同时可以是多个类型 但在使用方法的时候只能使用联合类型中共有的方法 例如number和string的共有方法只有valueOf和toString
let numOrStr: number | string;

类型断言

//上面提到联合类型只能使用共有的方法，如果想使用单一类型的方法就需要类型断言
const getLength = (x: number | string): number => {
  const str = x as string;
  if (str.length) {
    return str.length;
  } else {
    const num = x as number;
    return num.toString().length;
  }
};

类型守卫 type guard

//使用条件语句typeof和instanceof可以自动缩小类型的范围 
const getLength2 = (x: number | string): number => {
  if (typeof x == "number") {
    return x.toString().length;
  }else {
    return x.length
  }
};

枚举 enum

//数字枚举
enum Direction {
  Up,
  Down,
  Left,
  Right,
}
console.log(Direction.Up);
console.log(Direction[0]);
//字符串枚举
enum Direction2 {
  Up = 'Up',
  Down = 'Down',
  Left = 'Left',
  Right = 'Right',
}

泛型

//在定义函数、接口或类的时候不先指定类型而是在使用的时候再指定类型的特征
function echo<T>(arg: T): T {
  return arg;
}
const result: string = echo("1");

function swap<T, U>(arr: [T, U]): [U, T] {
  return [arr[1], arr[0]];
}
const swapArr = swap([1, 2]);
console.log(swapArr);

约束泛型

function echoLength<T>(arg: T): T {
  console.log(arg.length);
  return arg;
}
//参数不一定有length属性所以会报错
error TS2339: Property 'length' does not exist on type 'T'
//给泛型 添加约束
interface hasLength {
  length: number;
}
function echoLength<T extends hasLength>(arg: T): T {
  console.log(arg.length);
  return arg;
}

泛型在接口中的使用

interface keyPair<T,U>{
    key:T,
    value: U
}
let kp1:keyPair<number,string> = {
    key: 1,
    value: '1'
}

类型别名

//相当于自定义类型
type strOrNum = string | number
let str : strOrNum = '1'
let num : strOrNum = 1

类型字面量

type Direction = 'Left'|'Right'|'Bottom'|'Top'

交叉类型

//多种类型特性合并的类型
interface Name {
  name: string;
}
type IPerson = Name & { age: number };
let person1: IPerson = { name: "p1", age: 22 };