TypeScript 基础类型
- 元祖：已知元素数量和类型的数组，对应位置的类型需要相同
let x: [string, number];
x = ['Runoob', 1]; // 运行正常
x = [1, 'Runoob']; // 报错
console.log(x[0]); // 输出 Runoob
- 枚举(enum)：用于定义数值集合，生成双向的键值对（用key可以取value，用value可以取key）
//默认
enum Color {Red, Green, Blue}
//手动赋值
enum Color {
Red = 33,
Green = 22,
Blue = 11
}
- void：用于标识方法返回值的类型，表示该方法没有返回值
- null：表示对象值缺失。
- undefined：用于初始化变量为一个未定义的值，类似void
- never：never 是其它类型（包括 null 和 undefined）的子类型，代表从不会出现的值。通常表现为抛出异常或无法执行到终止点（例如无线循环）
let x: never;
x = (()=>{ throw new Error('exception')})();
function error(message: string): never {
throw new Error(message);
}
function loop(): never {
while (true) {}
}
keyof
将一个类型映射为它所有成员名称的联合类型(interface映射其对应的key，其余原生类型映射原型链上的key，如果不存在原型链则映射为never)
interface Person {
name: string;
age: number;
location: string;
}
type K1 = keyof Person; // "name" | "age" | "location"
type K2 = keyof Person[]; // "length" | "push" | "pop" | "concat" | ...
type K3 = keyof { [x: string]: Person }; // string
interface
用于将数据结构抽象定义
基本用法
用于定义一个对象的key-value
interface IPerson {
firstName:string,
lastName:string,
sayHi: ()=>string
}
定义数组
//定义常规数组
interface namelist {
[index:number]:string
}
var list2:namelist = ["John",1,"Bran"] / 错误元素 1 不是 string 类型
//定义key为字符串的数组（有问题）
interface ages {
[index:string]:number
}
var agelist:ages;
agelist["John"] = 15 // 正确
定义函数
interface SetUser {
(name: string, age: number): string
}
let b: SetUser = (name: string, age: number) => name
继承
使用extends可以继承一个或多个接口实例，type和interface可以相互继承
与type的区别
interface 能够声明合并
interface User {
name: string
age: number
}
interface User {
sex: string
}
/*
User 接口为 {
name: string
age: number
sex: string
}
*/
type
定义对象
type User = {
name: string
age: number
};
定义函数
type SetUser = (name: string, age: number) => string
let b: SetUser = (name: string, age: number) => name
继承
type和interface可以相互继承
type Name = {
name: string;
}
type User = Name & { age: number };
与interface的区别
联合类型，元组
// 联合类型
interface Dog {
wong();
}
interface Cat {
miao();
}
type Pet = Dog | Cat
// 具体定义数组每个位置的类型
type PetList = [Dog, Pet]
typeof
获取实例的 类型进行赋值
// 当你想获取一个变量的类型时，使用 typeof
let div = document.createElement('div');
type B = typeof div
其他骚操作
- 通过
type定义函数，并动态约定入参的类型
type Callback<T> = (data: T) => void;
interface A {
name: string
}
let a: Callback<A> = data => {
return data.name
}
type Dictionary<T1, T2> = (data1: T1, data2: T2) => string
type NameLookup = Dictionary<string, Person>;
- 通过
type定义元祖，并动态约定数据类型
interface A {
name: string
}
type Pair<T> = [T, T]
let c: Pair<A> = [{ name: 'asd' }, { name: 'asd' }]
type Tree<T> = T | { left: Tree<T>, right: Tree<T> };
class
static 关键字
static定义类的数据成员（属性和方法）为静态的,静态成员可以直接通过类名调用。
访问控制修饰符
public（默认） : 公有，可以在任何地方被访问。可被子类继承并实例化protected: 受保护，可以被其自身以及其子类和父类访问。可被子类继承，但不可被子类实例化private: 私有，只能被其定义所在的类访问。无法被子类继承static: 静态，只能通过类来访问。可被子类继承，并通过子类访问
get、set关键词
get：定义类中获取某个计算属性的方法set：定义修改类中某个计算属性的方法
class Point {
$x: number
constructor(x = 0) {
this.$x = +x
}
get x() {
return this.$x
}
set x(value) {
this.$x = +value
}
}
类和接口
类可以实现接口，使用关键字 implements，并将 interest 字段作为类的属性使用。
interface ILoan {
interest: number
say: () => string
}
class AgriLoan implements ILoan {
interest: number
constructor(interest: number, rebate: number) {
this.interest = interest
}
say() {
return '123'
}
}
namespace
在namespace中定义并被export导出的变量，可以通过命名空间名称来访问
namespace a {
export interface ISomeInterfaceName {
name: string
}
export const qwe = 123123
export class SomeClassName {}
}
namespace b {
let name: a.ISomeInterfaceName = {
name: 'asd'
}
}
export default a
声明文件
如果要引入第三方库时，需要使用declare module Module_Name定义引入第三方库的api
现在使用第三方库的@type文件作为第三方库的api定义文件
