一、原始数据类型
1.布尔值 在 TypeScript 中,使用 boolean
定义布尔值类型
2.数值 使用 number
定义数值类型
3.字符串 使用 string
定义字符串类型
4.空值 在 TypeScript 中,可以用 void
表示没有任何返回值的函数
5.Null 和 Undefined 在 TypeScript 中,可以使用 null
和 undefined
来定义这两个原始数据类型
二、任意值
任意值(Any)用来表示允许赋值为任意类型
在任意值上访问任何属性都是允许的,可以认为,声明一个变量为任意值之后,对它的任何操作,返回的内容的类型都是任意值
变量如果在声明的时候,未指定其类型,那么它会被识别为任意值类型
三、类型推论
如果没有明确的指定类型,那么 TypeScript 会依照类型推论(Type Inference)的规则推断出一个类型
TypeScript 会在没有明确的指定类型的时候推测出一个类型,这就是类型推论。
如果定义的时候没有赋值,不管之后有没有赋值,都会被推断成 any
类型而完全不被类型检查
四、联合类型
联合类型(Union Types)表示取值可以为多种类型中的一种
联合类型使用 |
分隔每个类型
let myFavoriteNumber: string | number;
myFavoriteNumber = 'seven';
myFavoriteNumber = 7;
当 TypeScript 不确定一个联合类型的变量到底是哪个类型的时候,我们只能访问此联合类型的所有类型里共有的属性或方法。
五、对象的类型—— 接口
在 TypeScript 中,我们使用接口(Interfaces)来定义对象的类型。
什么是接口:常用于对「对象的形状(Shape)」进行描述。
interface Person {
name: string;
age: number;
}
let tom: Person = {
name: 'Tom',
age: 25
};
赋值的时候,变量的形状必须和接口的形状保持一致。
接口中还存在:可选属性、任意属性、只读属性。
六、数组的类型
在 TypeScript 中,数组类型有多种定义方式,比较灵活。
最简单的方法是使用「类型 + 方括号」来表示数组
let fibonacci: number[] = [1, 1, 2, 3, 5];
数组的项中不允许出现其他的类型
数组泛型:我们也可以使用数组泛型(Array Generic) Array<elemType>
来表示数组
let fibonacci: Array<number> = [1, 1, 2, 3, 5];
七、函数的类型
函数声明:一个函数有输入和输出,要在 TypeScript 中对其进行约束,需要把输入和输出都考虑到,其中函数声明的类型定义较简单
function sum(x: number, y: number): number {
return x + y;
}
注意,输入多余的(或者少于要求的)参数,是不被允许的
函数表达式:
let mySum: (x: number, y: number) => number = function (x: number, y: number): number {
return x + y;
};
其中,还有可选参数、参数默认值、剩余参数、重载
八、类型断言
类型断言(Type Assertion)可以用来手动指定一个值的类型。
语法:值 as 类型 或 <类型>值
类型断言的用途:
将一个联合类型断言为其中一个类型
将一个父类断言为更加具体的子类
将任何一个类型断言为 any
将 any
断言为一个具体的类型
九、类型别名
类型别名用来给一个类型起个新名字
简单的例子
type Name = string;
type NameResolver = () => string;
type NameOrResolver = Name | NameResolver;
function getName(n: NameOrResolver): Name {
if (typeof n === 'string') {
return n;
} else {
return n();
}
}
十、字符串字面量类型
字符串字面量类型用来约束取值只能是某几个字符串中的一个。
简单的例子
type EventNames = 'click' | 'scroll' | 'mousemove';
function handleEvent(ele: Element, event: EventNames) {
// do something
}
handleEvent(document.getElementById('hello'), 'scroll'); // 没问题
handleEvent(document.getElementById('world'), 'dblclick'); // 报错,event 不能为 'dblclick'
十一、元组
数组合并了相同类型的对象,而元组(Tuple)合并了不同类型的对象。
简单的例子
let tom: [string, number] = ['Tom', 25];
十二、类
类的概念
- 类(Class):定义了一件事物的抽象特点,包含它的属性和方法
- 对象(Object):类的实例,通过
new
生成 - 面向对象(OOP)的三大特性:封装、继承、多态
- 封装(Encapsulation):将对数据的操作细节隐藏起来,只暴露对外的接口。外界调用端不需要(也不可能)知道细节,就能通过对外提供的接口来访问该对象,同时也保证了外界无法任意更改对象内部的数据
- 继承(Inheritance):子类继承父类,子类除了拥有父类的所有特性外,还有一些更具体的特性
- 多态(Polymorphism):由继承而产生了相关的不同的类,对同一个方法可以有不同的响应。比如
Cat
和Dog
都继承自Animal
,但是分别实现了自己的eat
方法。此时针对某一个实例,我们无需了解它是Cat
还是Dog
,就可以直接调用eat
方法,程序会自动判断出来应该如何执行eat
- 存取器(getter & setter):用以改变属性的读取和赋值行为
TypeScript 中类的用法
public private 和 protected
TypeScript 可以使用三种访问修饰符(Access Modifiers),分别是 public
、private
和 protected
。
public
修饰的属性或方法是公有的,可以在任何地方被访问到,默认所有的属性和方法都是public
的private
修饰的属性或方法是私有的,不能在声明它的类的外部访问protected
修饰的属性或方法是受保护的,它和private
类似,区别是它在子类中也是允许被访问的
十三、泛型
泛型(Generics)是指在定义函数、接口或类的时候,不预先指定具体的类型,而在使用的时候再指定类型的一种特性。
简单的例子
function fn<T>(arg:T):T{
return arg
}
let res = fn(123)
function swap<T,U>(fns:[T,U]) :[U,T]{
return [fns[1],fns[0]]
}
let res2 = swap(['string',123])
约束泛型
在函数内部使用泛型变量的时候,
由于事先不知道它是哪种类型,所以不能随意的操作它的属性或方法
interface lengths {
length:number
}
// 我们使用了 extends 约束了泛型 T 必须符合接口 lengths 的形状
function asd<T extends lengths>(arg:T) :T{
console.log(arg.length)
return arg
}
let sss = asd('asd')
let arr = asd([1,2,3])
let obj = asd({length:112})
泛型在类中使用
class q<T> {
private data = []
push(item:T){
return this.data.push(item)
}
pop():T{
return this.data.shift()
}
}
let s = new q()
s.push(1)
泛型在接口中的使用
interface k<T,U> {
key:T,
value:U
}
let k1:k<number, string> = {key:1,value:"123"}
let k2:k<string,number > = {key:'1',value:123}