简述本人项目中常用的Typescript的知识

Boolean

注意，使用构造函数 Boolean 创造的对象不是布尔值：

let createdBoolean: boolean = new Boolean(1)
//这样会报错 应为事实上 new Boolean() 返回的是一个 Boolean 对象 
 

事实上 new Boolean() 返回的是一个 Boolean 对象 需要改成

let createdBoolean: Boolean = new Boolean(1)

let booleand: boolean = true //可以直接使用布尔值
 
let booleand2: boolean = Boolean(1) //也可以通过函数返回布尔值

Number

支持十六进制、十进制、八进制和二进制；

let notANumber: number = NaN;//Nan
let num: number = 123;//普通数字
let infinityNumber: number = Infinity;//无穷大
let decimal: number = 6;//十进制
let hex: number = 0xf00d;//十六进制
let binary: number = 0b1010;//二进制
let octal: number = 0o744;//八进制s

String

字符串是使用string定义的

let a: string = '123'
//普通声明
 
//也可以使用es6的字符串模板
let str: string = `dddd${a}`

其中 ` 用来定义 ES6 中的模板字符串，${expr} 用来在模板字符串中嵌入表达式。

undefined和null

let u: undefined = undefined;//定义undefined
let n: null = null;//定义null

void 和 undefined 和 null 最大的区别
与 void 的区别是，undefined 和 null 是所有类型的子类型。也就是说 undefined 类型的变量，可以赋值给 string 类型的变量：

//这样写会报错 void类型不可以分给其他类型
let test: void = undefined
let num2: string = "1"
 
num2 = test

//这样是没问题的
let test: null = null
let num2: string = "1"
 
num2 = test
 
//或者这样的
let test: undefined = undefined
let num2: string = "1"
 
num2 = test

null 不能 赋予 void 类型

void

JavaScript 没有空值（Void）的概念，在 TypeScript 中，可以用 void 表示没有任何返回值的函数

function voidFn(): void {
    console.log('test void')
}

void 类型的用法，主要是用在我们不希望调用者关心函数返回值的情况下，比如通常的异步回调函数

void也可以定义undefined 和 null类型

let u: void = undefined
let n: void = null;

Array

//类型加中括号
let arr:number[] = [123]
//这样会报错定义了数字类型出现字符串是不允许的
let arr:number[] = [1,2,3,'1']
//操作方法添加也是不允许的
let arr:number[] = [1,2,3,]
arr.unshift('1')
 
 
var arr: number[] = [1, 2, 3]; //数字类型的数组
var arr2: string[] = ["1", "2"]; //字符串类型的数组
var arr3: any[] = [1, "2", true]; //任意类型的数组

数组泛型
规则 Array<类型>

let arr2: Array<number> = [1, 2, 3]
等同于
let arr1: number[] = [1, 2, 3]

从上面我们可以发现的是，和原生的 js 相比，数组中每个元素的类型都在声明的时候已经绑定好了，所以如果其中插入一些非数字类型的数据，编辑器将会报错。

那如果要使得在数组中可以插入其他类型的数据呢，则可以采用联合类型的方式，比如：

let arr: Array<number | string> = [1, 'abc']
let list: Array<any> = ['test', 1, [],{a:1}]

这样，数组就能包含多种数据类型了

元组

元组是一种特殊的数组，它控制了数组成员的类型和数量，比如：

let tuple: [number, string] = [1, 'abc']

上面代码就控制了三个条件：
数组中只能有两个元素；
数组第一个元素是数字类型；
数组第二个元素是字符串类型；

Function

函数的声明需要给参数添加类型注解，如下：

let add = (a: number, b: number) => a + b
或者
let add = (a: number, b: number): number => a + b // 最后的这个number是对函数返回值类型的注解，不过平时可以省略（TS的类型推断）

函数的声明还有一种形式：(先声明后实现)

let add:  (a: number, b: number) => number
add = (n, m) => n + m

Object

按照 JS 的用法，或许我们觉得可以如下方式声明与操作对象：

let obj: object = { x: 1, y: 2 }
obj['x'] = 2 // 报错，ts中不知道你声明的对象中有x属性

Ts 中应该这样做：

let obj: {x: number, y: number} = {x: 1, y: 2}
obj.x = 2

interface

在typescript中，我们定义对象的方式要用关键字interface（接口），我的理解是使用interface来定义一种约束，让数据的结构满足约束的格式。定义方式如下：

//这样写是会报错的 因为我们在person定义了a，b但是对象里面缺少b属性
//使用接口约束的时候不能多一个属性也不能少一个属性
//必须与接口保持一致
interface Person {
    b:string,
    a:string
}
 
const person:Person  = {
    a:"213"
}

//重名interface  可以合并
interface A{name:string}
interface A{age:number}
var x:A={name:'xx',age:20}
//继承
interface A{
    name:string
}
 
interface B extends A{
    age:number
}
 
let obj:B = {
    age:18,
    name:"string"
}

可选属性 使用?操作符

//可选属性的含义是该属性可以不存在
//所以说这样写也是没问题的
interface Person {
    b?:string,
    a:string
}
 
const person:Person  = {
    a:"213"
}

Any 类型 和 unknown 顶级类型

1.没有强制限定哪种类型，随时切换类型都可以 我们可以对 any 进行任何操作，不需要检查类型

let anys:any = 123
anys = '123'
anys = true

2.声明变量的时候没有指定任意类型默认为any

let anys;
anys = '888'
anys = true

3.弊端如果使用any 就失去了TS类型检测的作用

4.TypeScript 3.0中引入的 unknown 类型也被认为是 top type ，但它更安全。与 any 一样，所有类型都可以分配给unknown

unknow unknow类型比any更加严格当你要使用any 的时候可以尝试使用unknow

//unknown 可以定义任何类型的值
let value: unknown;
 
value = true;             // OK
value = 42;               // OK
value = "Hello World";    // OK
value = [];               // OK
value = {};               // OK
value = null;             // OK
value = undefined;        // OK
value = Symbol("type");   // OK
 
//这样写会报错unknow类型不能作为子类型只能作为父类型 any可以作为父类型和子类型
//unknown类型不能赋值给其他类型
let names:unknown = '123'
let names2:string = names
 
//这样就没问题 any类型是可以的
let names:any = '123'
let names2:string = names   
 
//unknown可赋值对象只有unknown 和 any
let bbb:unknown = '123'
let aaa:any= '456'
 
aaa = bbb

区别2

如果是any类型在对象没有这个属性的时候还在获取是不会报错的
let obj:any = {b:1}
obj.a
 
 
如果是unknow 是不能调用属性和方法
let obj:unknown = {b:1,ccc:():number=>213}
obj.b
obj.ccc()

type

用法

type MyName = string | number
let name: MyName = 'abc'
let name: MyName = 1
都可以

函数的使用 和泛指

//泛指
function maFn<T>(a: T, b:T ): T[] {
return [a, b]
}
maFn<number>(1 ,2)
//输入什么T就是什么类型
//函数
function maFn(a: number, b:number ): number[] {
return [a, b]
}

interface

interface 是对象的模板，可以看作是一种类型约定，中文译为“接口”。使用了某个模板的对象，就拥有了指定的类型结构。

typescript
interface Person {
  firstName: string;
  lastName: string;
  age: number;
}

上面示例中，定义了一个接口Person，它指定一个对象模板，拥有三个属性firstName、lastName和age。任何实现这个接口的对象，都必须部署这三个属性，并且必须符合规定的类型。
实现该接口很简单，只要指定它作为对象的类型即可。

const p: Person = {
  firstName: "John",
  lastName: "Smith",
  age: 25,
};