TypeScript学习1——数据类型

说明

本文学习自掘金大神的文章https://juejin.cn/post/7003171767560716302，原作者是伟大的兔神。

JavaScript内置类型

// number
let n:number=1;
// string
let s:string="str";
// boolean
let b:boolean=true;
// undefined
let u:undefined=undefined;
// null
let ne:null=null;
// object
let obj:object={};
// bigint
let bi:bigint=10n;
// symbol
let sy:symbol=Symbol("mySymbol");

Array

两种定义方式：

// 定义方式1
let arr1:string[]={'你好','hello'};
// 定义方式2
let arr2:Array<string>={'你好','hello'};

Tuple

// 元组可以定义不同元素类型的数组
let t:[string,number,boolean]=['hello',522,false];

元组规定了数组的长度和元素类型，类型或长度不匹配均会报错。对于不确定类型和长度的数组，可以用any[]来定义。

undefined和null

默认情况下，null和undefined是所有类型的子类型。也就是说，可以把undefined和null赋给任意类型的变量。

let m:number=2;
m=undefined;

void

void表示没有任何类型。声明变量为void是没有意义的，只会在函数没有返回值时声明为void。

注意，没有返回值的函数将得到undefined，但仍然要声明为void，否则会报错。

unknown和any

any会跳过类型检查器对值的检查，任何值都可以赋值给any类型。

let a: any = 123;
a = '456';
a = false;

unknown可以实现同样的效果。

let a: unknown = 123;
a = '456';
a = false;

其最大区别是，任何类型的值可以赋值给any，同时any类型的值也可以赋值给任何类型；但对于unknown ，任何类型的值都可以赋值给它，但它只能赋值给unknown和any。

let a: unknown = 123;
let b: any = 123;
let c: number = 123;
// c = a;//报错
// a = c;//可以
// b = c;//可以
c = b;//可以

在对unknown类型执行操作之前，必须对其进行范围的缩小。

let obj: unknown = {
    x: 1,
}

// console.log(obj.getX());//报错

// 1、使用typeof
if (typeof obj === 'object' && obj !== null) {
    console.log(obj.toString());
}

// 2、类型断言
console.log((obj as object).toString())

never

never表示永远不存在的值的类型，分两种情况：函数执行过程中抛出异常，因此永远不会有返回值；函数体内是死循环，永远不会有返回值。

// 抛出异常
function tErr(): never {
    throw new Error('error');
}

// 死循环
function noRes(): never {
    while (true);
}

never与其他类型联合后，将没有never。

// type t = string | number
type t = string | number | never

类型断言

类似于类型转换。

let str: any = "hello";
// 1、括号语法
let l: number = (<string>str).length;
// 2、as语法
let l2: number = (str as string).length;

类型推论

没有指定变量类型时，TS会自动推断出具体的类型。

let s = 'hello';
// s = 123;//报错，因为上面s被推断为string类型

let temp;
temp = 'hello';
temp = 1;//可以，因为在最上面temp被推断为any类型

联合类型

类型取值为多种类型中的一种。

let a: string | number = 'hello';
a = 123;

交叉类型

将多个类型合并为一个类型，把现有的多种类型叠加到一起成为一种类型，它包含了所需的所有类型的特性。

interface IA {
    name: string
    age: number
}

interface IB {
    name: string
    id: number
}

// 需要包含IA和IB的所有属性
let a: IA & IB = {
    name: 'Jack',
    age: 11,
    id: 1
}

a既是IA类型，也是IB类型。