枚举类型

数字枚举

例如 红绿蓝 Red = 0 Green = 1 Blue= 2 分别代表红色0 绿色为1 蓝色为2

1
2
3
4
5
enum Types{
   Red,
   Green,
   BLue
}

这样写就可以实现应为ts定义的枚举中的每一个组员默认都是从0开始的所以也就是

1
2
3
4
5
6
7
enum Types{
   Red = 0,
   Green = 1,
   BLue = 2
}

//默认就是从0开始的 可以不写值

增长枚举

1
2
3
4
5
enum Types{
   Red = 1,
   Green,
   BLue
}

如上，我们定义了一个数字枚举， Red使用初始化为 1。 其余的成员会从 1开始自动增长。 换句话说， Type.Red的值为 1， Green为 2， Blue为 3。

字符串枚举

字符串枚举的概念很简单。 在一个字符串枚举里，每个成员都必须用字符串字面量，或另外一个字符串枚举成员进行初始化。

1
2
3
4
5
enum Types{
   Red = 'red',
   Green = 'green',
   BLue = 'blue'
}

由于字符串枚举没有自增长的行为，字符串枚举可以很好的序列化。 换句话说，如果你正在调试并且必须要读一个数字枚举的运行时的值，这个值通常是很难读的 - 它并不能表达有用的信息，字符串枚举允许你提供一个运行时有意义的并且可读的值，独立于枚举成员的名字。

异构枚举

枚举可以混合字符串和数字成员

1
2
3
4
enum Types{
   No = "No",
   Yes = 1,
}

接口枚举

定义一个枚举Types 定义一个接口A 他有一个属性red 值为Types.yyds

声明对象的时候要遵循这个规则

1
2
3
4
5
6
7
8
9
10
11
enum Types {
   yyds,
   dddd
}
interface A {
   red:Types.yyds
}
 
let obj:A = {
   red:Types.yyds
}

const枚举

let 和 var 都是不允许的声明只能使用const

大多数情况下，枚举是十分有效的方案。 然而在某些情况下需求很严格。 为了避免在额外生成的代码上的开销和额外的非直接的对枚举成员的访问，我们可以使用 const枚举。 常量枚举通过在枚举上使用 const修饰符来定义

const 声明的枚举会被编译成常量

普通声明的枚举编译完后是个对象

1
2
3
4
const enum Types{
   No = "No",
   Yes = 1,
}

Const 声明编译之后

普通声明编译之后

反向映射

它包含了正向映射（ name -> value）和反向映射（ value -> name）

要注意的是 不会为字符串枚举成员生成反向映射。

1
2
3
4
5
6
7
enum Enum {
   fall
}
let a = Enum.fall;
console.log(a); //0
let nameOfA = Enum[a]; 
console.log(nameOfA); //fall

原文地址：https://xiaoman.blog.csdn.net/article/details/122380754

类型推论与类型别名

当我声明了一个变量但是没有定义类型，ts会自己推测出一个类型，这就是类型推论

如果你只有声明了，但是没有赋值，ts会推测出是一个any类型

定义类型别名

1
2
3
4
5
type str =（string

let s:str = "111";

consloe.log(s);

定义函数别名

1
2
3
4
5
type str = ()=>string;

let s:str = () = >"111";

consloe.log(s);

定义联合类型别名

1
2
3
4
5
6
7
8
type str = string | number
 
 
let s: str = 123
 
let s2: str = '123'
 
console.log(s,s2);

定义值的别名

1
2
3
4
5
type value = boolean | 0 | '213'
 
 
let s:value = true
//变量s的值  只能是上面value定义的值

type 和 interface 还是一些区别的 虽然都可以定义类型

1.interface可以继承 type 只能通过 & 交叉类型合并

2.type 可以定义 联合类型 和 可以使用一些操作符 interface不行

3.interface 遇到重名的会合并 type 不行

type高级用法

左边的值会作为右边值的子类型遵循图中上下的包含关系

1
2
3
4
5
6
7
8
9
10
11
type a = 1 extends number ? 1 : 0 //1
 
type a = 1 extends Number ? 1 : 0 //1
 
type a = 1 extends Object ? 1 : 0 //1
 
type a = 1 extends any ? 1 : 0 //1
 
type a = 1 extends unknow ? 1 : 0 //1
 
type a = 1 extends never ? 1 : 0 //0

alt text