基础类型与泛型

参数类型

ts支持在变量后面规定参数类型，使用方式是增加冒号 + 类型名。

声明变量时规定参数类型：

let str: string = 'hello';
let count: number = 14;

函数形参规定参数类型：

function add(start: number, count: number) {
    // ...
}

函数返回值增加返回值类型：

function test() : string {
    return "hello";
}

declare声明

作用：

在ts中，使用declare声明一个变量，告诉ts的编译器声明变量的信息，但并不实现他。使用declare关键字可以让我们在ts中引用js代码，而不需要实现他。

例如直接引用一个不带声明的js模块，不能进行ts类型检查，而通过declare声明模块，便可以在ts中使用这个模块，并可以进行类型检查。

应用：

• 声明全局变量、声明全局函数、类、模块。
• 作用于.d.ts类型声明文件中（因为在编译的过程中.d.ts文件不会生成对应的.js文件）

示例：

// 声明全局变量
declare const GLOBAL_ROLE: string;
// 声明全局函数
declare function globalUtil(str: string):void;
// 声明类
declare class GlobalPeople {
    constructor(name: string);
    method1(args1: string);
}
// 声明模块
declare module 'Util' {
    export function add(x: number);
}

// index.d.ts文件
declare var nums: number;
declare const secretKey: string;

type关键字

作用：

type关键字与interface有些类似，但type主要作用于类型，给类型定义一个别名

示例：

type Str = string; // string类型
type Fun = () => string; // 函数
type Combol = string | number; // 联合类型

泛型

概念：

泛型是指在定义接口、函数、类等的时候，不先定义具体的类型，而是在调用的时候再指定类型的一种方式。

语法：<T1, T2...>

默认值：

在代码中没有指定，且在使用的时候推论也没有成功时，默认值才生效，例如：

function add<T = any>(name: T) {
    // ...
}

TS新增的数据类型

基于javascript的基础类型，typescript增加了元组、枚举、void、any、never、高级类型。

元组 - []

用来表示已知元素数量和类型的数组。即每个位置的元素类型必须相同。

let arr: [number, string] = [18, 'hello'];
arr = ['test', 'hello']; // Error

枚举 - enum

枚举类型是对js类型的补充，声明的枚举成员只读，不能修改。

// 字符串类型
enum Message = {
    Success = '成功',
    Fail = '失败'
}

// 数值类型(初始值为0，其他递增；也可自定义初始值)
enum Role = {
    Develper: 1, // 自定义初始值为1
    Approver,
    Manager
    SystemManager
}
console.log(Role.Approver); // 2

// 常量类型
const enum Week = {
    Sun, // 0
    Mon, // 1
    Tus // 2
}

任意类型 - any

声明的any可以被赋予任意的数据类型。

let p1: any;
p1 = 18;
p1 = 'hello';

任意类型 - unknown

声明的unknown也可以被赋予任何类型的值。但是他比any更严格。在操作unknown类型的值之前，必须要进行类型检查；而any不需要检查，他更像是绕过了类型检查。

function add(x: unknown) {
    // ...
}

不存在的类型 - never

never是表示永远不存在的值的类型，例如抛出异常或箭头函数的表达式。

let error = (): never {
    throw new Error('new error');
}

特点：

never是任何类型的子类型，他可以赋值给任何类型，但是他不能被任何类型赋值，即使是any。

空类型 - void

空类型void通常用作返回值的类型，函数没有返回值时便可以使用void。

function test(pwd: string): void {
    // ...
}

高级类型 - 交叉类型

交叉类型是把多个类型通过&符号合并成一个类型，取并集。使用type关键字定义类型。

例如：

// 定义A类型
type A = {
    name: string;
    age: number;
}

// 定义B类型
type B = {
    name: string;
    height: number;
}

// 定义交叉类型C类型
type C = A & B;

// 实例化C类型的实例
let man: C = {
    name: '张三',
    age: 18,
    height: 178
}

高级类型 - 联合类型

与交叉类型相反，联合类型通过|符号，表示既可以是A类型，也可以是B类型。

例如：

// 定义A类型
type A = {
    name: string;
    age: number;
}

// 定义B类型
type B = {
    name: string;
    height: number;
}

// 定义联合类型C类型
type C = A | B;

// 实例化联合类型C的A类型实例
let man: C = {
    name: '张三',
    age: 18
}

// 实例化联合类型C的B类型实例
let man: C = {
    name: '张三',
    height: 178
}

高级类型 - 条件类型

条件类型是通过一个表达式来进行类型检测，使用?符号，从两个类型中选择一个类型。类似于js中的三元表达式。

// T如果继承布尔类型true，返回值T是string类型，否则返回值T是number类型
function fun(item: T): T extends true ? string : number {
    // ...
    return item;
}

is关键字

is关键字通常用在函数的返回值类型中，用来判断参数是否属于某一个类型。

function add(x: unkonwn) {
    if (x is number) {
        x = x + 1;
    } else if (x is string) {
        x = Number(x) + 1;
    } else {
        console.log(type of x);
    }
}

!与!!操作符

一个感叹号! - 表示取反，返回布尔值

两个感叹号!! - 表示强制类型转换为布尔值

let n = 'hello';
let m = 0;

console.log(!n); // false
console.log(!m); // true

console.log(!!n); // true
console.log(!!m); // false

类型断言

概念：

当一个变量类型不确定时，可以手动指定一个类型。

语法：<类型>变量

示例：

// 参数x的类型为string或者number
function muti(x: string | number) {
    let len = <string>x.length;    // 断言x为string类型，并应用
}