TypeScript

发表于 | 分类于

type 关键字 （可以给一个类型定义一个名字） 多用于符合类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//定义类型别名
type str = string
let new:str = 'CNY'

//定义函数别名
type fn = () => string
let fun:fn = () => 'CNY'

//定义联合类型别名
type str = string | number
let str2:str = 22
let str3:str = '22'

//定义值的别名
type value = boolean | 0 | ’123‘
let a:value = false

nerver类型

使用 never 类型来表示不应该存在的状态

1
2
3
4
5
6
7
8
9
10
11
12
// 返回never的函数必须存在无法达到的终点
 
// 因为必定抛出异常，所以 error 将不会有返回值
function error(message: string): never {
    throw new Error(message);
}
 
// 因为存在死循环，所以 loop 将不会有返回值
function loop(): never {
    while (true) {
    }
}

never和void的差异

1
2
3
4
5
6
7
8
9
//void类型只是没有返回值 但本身不会出错
function Void():void {
    onsole.log();
}
 
//只会抛出异常没有返回值
function Never():never {
    throw new Error('aaa')
}

Symbol

symbol类型的值是通过Symbol构造函数创建的

可以传递参数作为唯一标识，只支持string 和 number 类型的参数

1
2
let sym1 = Symbol(123)
let sym2 = Symbol('key')  //可选的字符串key

Symbol的值是唯一的

1
2
3
const s1 = Symbol()
const s2 = Symbol()
// s1 === s2 =>false

可以用作对象属性的键

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
let sym = Symbol();
 
let obj = {
    [sym]: "value"
};
 
console.log(obj[sym]); // "value"

//拿不到symbol的键名
//for in
//Object.keys()
//Object.getOwnPropertyNames()
//JSON.stringify()


Object.getOwnPropertySymbols()    //拿到具体的symbol值
Reflext.ownKeys()    //拿到对象的所有属性

Symbol.iterator 迭代器

支持遍历大部分类型迭代器 arr nodeList arguments set map

1
2
var arr  = [1,2,3,4]
let iterator = arr[Symbol.iterator]()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
interface Item {
	age:number,
    name:string
}

const array: Array<Item> = [{ age: 123, name: "1" }, { age: 123, name: "2" }, { age: 123, name: "3" }]


type mapTypes = string | number
const map:Map<mapTypes,mapTypes> = new Map()


map.set('1','CNY')
map.set('2','CNY2')

const obj = {
    A:123,
    B:456
}

let set:Set<number> = new Set([1,2,3,4,5,6])

const gen = (erg:any):void => {
    let it:Iterator<any> =erg[Symbol.iterator]()
    let next:any = {done:false}
    whilte(!next.done){
		next = it.next()
        if(!next.done){
            console.log(next.value)
        }
    }
}

gen(array)

  • Symbol.hasInstance
    方法，会被instanceof运算符调用。构造器对象用来识别一个对象是否是其实例。

  • Symbol.isConcatSpreadable
    布尔值，表示当在一个对象上调用Array.prototype.concat时，这个对象的数组元素是否可展开。

  • Symbol.iterator
    方法，被for-of语句调用。返回对象的默认迭代器。

  • Symbol.match
    方法，被String.prototype.match调用。正则表达式用来匹配字符串。

  • Symbol.replace
    方法，被String.prototype.replace调用。正则表达式用来替换字符串中匹配的子串。

  • Symbol.search
    方法，被String.prototype.search调用。正则表达式返回被匹配部分在字符串中的索引。

  • Symbol.species
    函数值，为一个构造函数。用来创建派生对象。

  • Symbol.split
    方法，被String.prototype.split调用。正则表达式来用分割字符串。

  • Symbol.toPrimitive
    方法，被ToPrimitive抽象操作调用。把对象转换为相应的原始值。

  • Symbol.toStringTag
    方法，被内置方法Object.prototype.toString调用。返回创建对象时默认的字符串描述。

  • Symbol.unscopables
    对象，它自己拥有的属性会被with作用域排除在外。