TypeScript的主要内容

基础类型

number:

let a: number = 10 (NaN, Infinity)

string:

let str: string = "哈哈"

boolean:

let flag : boolean = true

数组:

let arr: Array<number> = [1, 2, 3, 4]

元组: 一个已知元素数量和类型的数组

let arr: [number, string] = [1, 'a']

void: 空值(只能为undefined和null)

let res: void = undefined

undefined:

let res: undefined = undefined

null:

let res: null = null

any: 任意类型

let res: any = 10

never: 永不存在值，无返回值的表达式，或无法到达的值

function error(message: string): never{
  throw new Error(message)
}

function infiniteLoop(): never{
  while(true){}
}

object

let o: object = { } ( [ ] )

enum: 枚举类型

enum Gender{
 /**男人 */
  male,
  female = 0,
  unknow
}
let gender: Gender = Gender.male

类型定义

type

type Action = 'eat' | 'run'
const a: Action = 'run'

interface

interface male{
  age: number;
  name: string
}

const zs: male = {
  age: 1,
  name: 'zs'
}

联合类型（满足其中一个）

interface A{
  age: number;
}

interface B{
  name: string
}

const zs: (A | B) = {
  age: 1,
}

交叉类型（满足所有）

interface A{
  age: number;
}

interface B{
  name: string
}

const zs: (A & B) = {
  age: 1,
  name: 'zs'
}

TypeScript中的类的修饰符

static

静态资源

private

私有属性： 仅仅能在这个类中进行在这个属性的访问。在子类和类的实现的对象中都不能访问。在子类可以通过调用使用这个属性的方法来间接来使用这个属性。

protected

被保护: 针对对象。因为一个类可以有很多实例，这些实例只可以访问但是不能修改被保护的对象

abstract

抽象类: 抽象方法 只有声明，没有实现，不可被实例化，只能被声明引用，不能创建对象

public

默认都是public

操作符

typeof

可以用来获取一个变量声明或对象的类型

function toArray(x: number): Array<number>{
  return [x]
}
type Func = typeof toArray // -> (x: number) => Array<number>

keyof

可以用来一个对象中的所有 key 值

interface Person{
  name: string;
  age: number
}

type k1 = keyof Person // "name" | "age"

const str: k1 = 'name'

in

in 用来遍历枚举类型

type Keys = 'a' | 'b' | 'c'
type Obj = {
  [p in Keys]: any
} // ->{ a: any, b: any, c: any }

extends

继承，可以做泛型约束

interface A{
  len: number
}
function B<T extends A>(arg: T): T{
  return arg
}
B({len: 1})

TypeScript常见面试题

ts的好处是什么

1. ts是js的加强版，给js添加了可选的静态类型或者基于类的面向对象编程，ts的功能比js只多不少
2. ts是面向对象的语言，包含了类、接口的概念
3. ts在开发时就能给出编译错误，js错误只能在运行时体现
4. 作为强类型的语言，可以明确知道所有数据的类型

type 和 interface的区别

用interface来描述数据结构，用type描述类型

• 相同点： 都能用来描述函数和对象，都允许extends
• 不同点： type可以使用联合类型，可以具体声明数组的每个位置

什么是泛型，泛型的具体使用

可以做类型的传参，可以通过extends约束泛型

如何基于一个已有的类型，扩展出一个大部分类容相似，但是部分区别的类型

interface Test{
    name: string;
    sex: number;
    height: string;
}
type sex = Pick<Test, 'sex'>;

type withOutSex = Omit<Test, 'sex'>