Typescript 重新学习

可以用void来定义underfined和null类型

let test1: void = null
let test2: void = undefined

underfined和null类型的变量，可以赋给别的值（如string），但void不行。

---

top type顶级类型

1. any unknown
2. Object
3. Number String Boolean
4. number string boolean
5. 1, ‘why’
6. never

上面的类型可以包含下面的所有类型

注：

• unknown 只能赋值给自身或者是 any
• unknown 的值如果是对象，不能读任何属性，也不能调用方法

---

Object 支持所有
object 只支持引用类型（数组，对象，函数）

---

interface 接口

用于定义对象

//使用接口约束的时候不能多一个属性也不能少一个属性，必须与接口保持一致
// 可以用问号操作符来说明可选属性
// interface 后的第一个字母要大写
interface Person {
    b: string,
    a: string
}
const person:Person  = {
    a: "213"
    b: "456"
}

可以重名（联合在一起）
也可以继承 interface B extends A

可以定义[propName: string]: any来说明任意类型
用readonly来定义只读属性 eg:readonly a: string 一般用来定义id和函数

// 定义函数
interface Axxxs {
	cb:()=> boolean
}
let a: Axxxs = {
	cb:()=>{return false}
}

用于定义函数

interface Fn {
	(name: string):number[]  //参数类型:返回值类型
}
const fn:Fn = function (name: number) {
	return [1]
}

---

数组类型

普通：number[]
泛型：let arr: Array<boolean> = [true, false]

// 定义对象数组，只需在接口后面加上[]
interface X {
	name: string
}
let arr: X[] = [{name: 'why'}]

多维数组：let arr: number[][] = [[1],[2]]
其他：
用any[]定义…args
用IArguments定义arguments

---

函数类型

可选参数、默认值（不能一起用）

// 定义this 的类型
interface Obj {
  user: number[]
  // 第一个参数定义 this 的类型
  add: (this: Obj, num: number) => void
}
let obj: Obj = {
  user: [1, 2, 3],
  add(this, num) {
    this.user.push(num)
  }
}
obj.add(4)

// ts 也可以实现函数的重载
let user: number[] = [1,2,3]
function findNum(add:number[]):number[]  //传的是数组就做添加
function findNum(id:number):number[]     //传的是一个数字就做查询
function findNum():number[]              //没有传就查询全部
function findNum(ids?:number | number[]):number[] {
  if(typeof ids == 'number') {
    return user.filter(v=>v==ids)
  } else if(Array.isArray(ids)) {
    user.push(...ids)
    return user
  } else {
    return user
  }
}

---

联合类型 | 声明变量
交叉类型 & 声明对象

// 类型断言
let fn = (num: number | string) => {
  console.log((num as string).length)
  console.log((<string>num).length)
}
// 注：类型断言只能欺骗编译器

// as const: 将变量定义为常量，如果是数组，里面的值也不能改变

---

内置对象
let promise:Promise<number> = new Promise((r) => r(1))
返回值是number类型

---

定义class类

定义constructor变量

// 需要在 constructor 上先声明并使用/赋初值
class Person {
  name: string
  age: number = 0
  constructor(name: string, age: number) {
    this.name = name
  }
}

类的修饰符

// public  共有，在当前类，子类，类外面都可以访问
// protected: 保护类型，在当前类，子类可以访问，类外边不可访问
// private:私有类型，在当前类可以访问，子类，类外边不可访问
class Person {
  public name: string;
  protected age: number;
  private addr: string;
}

static 静态属性 和 静态方法

用static定义的属性和方法不能用this调用，只能通过类名调用
如果两个函数都是static定义，可以通过this互相调用

interface 类

interface Personclass {
  get(name:string):string
}
// 用 implements
class Person implements Personclass {
  get(name: string) {
    return name
  }
}

抽象类

在类前加abstract

• 抽象类不能被实例化，是被用来继承的
• 抽象类可以定义抽象属性和抽象方法(在前面加 abstract), 一定要在子类中重写

---

元组

// 基本用法
let arr:[number,string] = [1,'string']
// 用readonly表示只读
const arr:readonly [number, string] = [1, 'string']
用?表示可有可无
const arr: [x: number, y?: boolean] = [1]

枚举

// 红绿蓝默认为0 1 2
enum Types {
  Red,
  Green,
  BLue
}
// 也可以自己定义（字符串或者其他混用）

? const 枚举
? 反向映射

---

类型别名

type s = string
let str: s = 'why'

type a = 1 extends number ? 1 : 0 // 返回1

---

never类型 ？

---

泛型

// T相当于占位符
function Add<T>(a: T, b: T): Array<T> {
    return [a,b]
}
// 编译器会自己推断
Add(1,2)

// 泛型约束
function add<T extends number>(a: T, b: T) {
  return a + b
}

keyof 返回对象的所有键，类型是联合类型

---

命名空间

如果一个文件没有export或import，将其视为全局

namespace a {
	// 要export， 否则无法使用	
    export const Time: number = 1000
}

// 可以用三斜杠指令调用

未完待续。。。