TypeScript 学习总结基础数据类型（一）-CSDN博客

写在前面：

因为typescript文档个人感觉写得不好(概念过于杂乱，示例代码有错误~)。所以总结一下TS的知识

这是个人学习笔记总结，并没有官方文档严谨。更多的是个人的大白话

代码部分推荐各位复制到支持TS的代码编辑器里看看什么效果。体验一下 TS在编译阶段的严谨~~

想学习TypeScript的朋友可以快速扫两眼，入个门~

基础数据类型:

首先typescript的基础数据类型：

布尔类型（boolean）
数字类型（number）
字符串类型（string）
数组类型（array）
元组类型（tuple）
枚举类型（enum）
任意值类型（any）
null 和 undefined
void类型
never类型
object 类型
类型断言
Symbol 类型

布尔类型（boolean）

布尔类型是最简单的数据类型，只能赋值为true和false两种值,不能赋予其他的值

类型注解： 其实就是指定各种类型, boolean， string之类的。其他语言也叫类型注解 所以统一一下

基础语法：
变量：类型注解 = 对应类型注解的值  
let bol: boolean = true  
let bol2: boolean  
bol2 =  false
bol = blo2  // 可以 bol是boolean类型 所以可以赋值false

bol = ' 1'  //Type '"1"' is not assignable to type'boolean'. 字符串不能赋值给boolean类型
复制代码

除了规定了变量类型之外，其他语法与javascript一样。

数字类型（number）

和JavaScript一样，TypeScript数字都是浮点型( 1 在JS眼里是 1.0)，也支持二进制、八进制、十进制和十六进制

let num1: number = 123       //十进制   
num1 = 0b01111011            //二进制 0b开头  ES6引入
num1 = 0o173                 //八进制 0o开头  ES6引入
num1= 0x7b                   //十六进制 0x开头

以下是特殊的number类型：
num1 = Infinity              //无穷大
num1 = -Infinity             //负无穷大
num1 = NaN                   //Not a Number
复制代码

字符串类型（string）

被"" ,''和ES6模板字符串\` `.包裹起来的值，都是字符串类型

let str: string = '哈哈哈'
let str2: string = `笑声${str}`
复制代码

数组类型（array）

TypeScript 提供了两种定义数组类型的方法。一种是在类型后加上 []表示这是一个数组。推荐优先使用这种写法

语法：
let 变量：类型注解[]

let arr1: number[]  //number类型数组，只能存number类型
arr1 = [5,1,3]   // true
arr1 = ['1']     // false  只可以赋值number类型
复制代码

另一种方法是使用泛型表示：Array < T> ，其中 T 为数组中元素的类型。

语法：
let 变量：Array<T>  //这里的 <T> 代指泛型。 可以简单的理解为就是一个占位符，'暂时'没有实际的类型。类型根据使用时传入的值而定。泛型后续会详解

let arr2 : Array<string> //string 数组
arr = ['1','a','haha']

let arr3 : Array<boolean> = [true,false,true] //boolean数组
复制代码

元组类型（tuple）

元组类型就是一个特殊的数组。

表示已知数量和已知元素类型的数组, 里面的每一项可以是不同的类型

语法：
let 变量：[类型1，类型2....]

let arr : [string, number, boolean,number[]] 
//1.数量固定，只能传四个元素，不可少传也不可多传
//2.各索引位的元素类型固定，不可改变。

arr = ['1', 2, true, numArr] // true 必须按照 固定数量和类型顺序赋值

以下是错误写法：
arr = [1, 2, true, numArr]      //error 第一个位置接收string类型，却传入number。类型不匹配
arr = [1, '2', true, numArr]    //error 同上 ，前两个位置类型不匹配
arr = ['2']                     // error arr必须接受4个参数，这里只传入一个
arr = [1, '2', true, numArr, 2] // error 传入过多的参数也不行，最后一个为越界元素。现在数组的length为4，不能传入第五个值

复制代码

数组与元组的区别

Array：数组，表示一组类型相同的元素
Tuple：元组，表示一组固定数量的元素（不要求元素类型相同）

枚举类型（enum）

枚举用来表示一些逻辑上有关联的数据，并且这些数据不能被修改的。让这些数据更有语义化。

枚举类型里面的值都是只读的，只能读取不能修改

语法:
enum 标识符 {
    值，
    值
    ...
}
------------------------------------------------------
//应用场景：假设根据后台传入数据，让我们来判断用户权限操作
//传递的数据里有id。id存储的number类型的数据，我们依次来判断
roles = {
id:xxx,
...
}

//无语义化写法：
switch(roles.id) {
    case 0:
        //普通用户
        break;
    case 1:
        //员工
        break;
    case 2:
        //管理员
        break;
}
//缺点需要写文档注释，表明0 , 1...是什么意思

//使用枚举，定义一组用户数据：
enum Roles {
    USER,   //0
    STAFF,  //1
    ADMIN   //2
}
// 每个枚举类型的值，都有对应的索引值，默认从0开始依次递增
// 取值操作类似于JS对象
Roles.USER // 0  通过属性取索引
Roles[0] // USER 通过索引取属性值   下面会解释是如何实现的

// 使用Roles来作为判断条件
switch(roles.id) {
    case Roles.USER:  // 0
        //普通用户
        break;
    case Roles.STAFF: // 1
        //员工
        break;
    case Roles.ADMIN: // 2
        //管理员
        break;
}
// 更有语义化，代码直观易读
--------------------------------------------------------------------------------------------------------------------
// 将枚举类型，转化为JS。看是如何实现的
enum Roles {
    USER,   //0
    STAFF,  //1
    ADMIN   //2
}

//JS代码
var Roles;
(function (Roles) {
    Roles[Roles["USER"] = 0] = "USER";
    Roles[Roles["STAFF"] = 1] = "STAFF";
    Roles[Roles["ADMIN"] = 2] = "ADMIN"; 
})(Roles || (Roles = {}));

解析：
首先Roles是个对象，然后立即执行函数会对这个对象进行赋值

Roles[Roles["USER"] = 0] = "USER";
可以分解为：
首先给Roles设置一个 USER 的属性，赋值为0
Roles["USER"] = 0  //这步操作是有返回值的 返回值就是 = 右边的值 此处为0， ~~可以测试自行创建一个对象，再赋值看返回的结果
然后将上一步的返回值作为属性名，再次赋值
Roles[0] = "USER"
所以可以通过索引或属性名取相互的值，非常巧妙
Roles[0]  // USER
Roles["USER"] // 0
--------------------------------------------------------------------------------------------------------------------
// 在定义枚举时，可以自定义索引值
enum English {
    A = 1,      // 1
    B,          // 2
    D = 4,      // 4
    E           // 5
}

let a = English.A   // 1
let c = English.B   // 2
let d = English.D   // 4
let e = English.E   // 5
let eng = English[5] // E

//自定义索引值只会影响，后续值的索引值(自动根据前一个增加)
enum english {
    a,         // 默认值 0
    b = 2,     // 2  影响排在其后的元素
    c,         // 3  
    d,         // 4
    e          // 5
}

english.a = 1 //error 枚举类型里的值是只读类型，只允许读取
english[a] //error  枚举类型里面的值，是字符串。这样取值是错误的，会去找同名变量，进行操作。
english['a'] //ok
------------------------------------------------------------------------------------------------------------------
枚举类型，后续还有很多用法。比如说使用redux时，用来存储Action的type
复制代码

any (任意类型)

any表示任意类型,任何值都可以传入any。

any类型 上是类型系统的逃生舱口(走后门)。TS不会对any类型进行检查

万物皆any~

let value: any;

value = true;             // OK
value = 42;               // OK
value = "Hello World";    // OK
value = [];               // OK
value = {};               // OK
value = Math.random;      // OK
value = null;             // OK
value = undefined;        // OK
value = new TypeError();  // OK
value = Symbol("type");   // OK
// 现在变量可以任意赋值，和原生JS平时操作没有任何限制一样
--------------------------------------------------------
let anyArr: any[] = [1,24,5,'hhh',['qqq'],true] 

// 虽然方便，但尽量少使用。否者就失去了使用TS的意义,没有类型检查的保障，代码容易出问题。
// 一般在将JS代码重构为TS时，使用的较多
复制代码

void 类型

void表示没有任何类型, 常用在函数没有返回值的情况下指定，表示一个函数没有返回值

// 例子：
let func = (name:string):void => {
    console.log(`hello， $(name)`)
    // 这个函数没有指定任何返回值
    // 但在JS里 函数都会默认返回undefined。void会默认兼容undefined类型
}
func(456) // error 参数必须是是string类型。这就体现了TS的好处了，编译阶段就会提醒错误
func('Bob') // true

let num:void 
num = undefined //true 
num = null    //error
num = 1      // error  

let V: any; 
num = V // true  再次强调 any类型可以兼容其他所有类型(除never外)~


void 大部分场景用在函数的返回值类型上,关于函数的知识后续会讲解
复制代码

null 和 undefined 类型

1.在TS中null 和 undefined既是类型，也可以作为普通的值使用。参考上面函数默认返回值undefined

2.在TS非严格模式下null和undefined同时也是其他类型的子类型(其他类型可以兼容这两个值)，严格模式下会报错

tsconfig.json(ts配置文件)：strict: false (非严格模式下)(其中一个选项，默认是true 严格模式)：

let isNull: null  // null类型只能接收 null类型 和 undefined类
let isUndefined: undefined // undefined类型只能接收 undefined类型 和 null类型
isNull = null //true
isNull = 1 //error
isNull = undefined //true
isUndefined = null //true
isUndefined = undefined //true
isUndefined = '2' //error

let str: string
str = null //true
str = undefined //true

--------------------------------------------------------------
tsconfig.json：strict: true (严格模式下)：

let isNull: null  // null类型只能接收null值
let isUndefined: undefined // undefined类型只能接收undefined值
isNull = null //true
isNull = 1 //error
isNull = undefined //error
isUndefined = null //error
isUndefined = undefined //true
isUndefined = '2' //error

let str: string
str = null //error   严格模式下报错，不能作为子类型
str = undefined //error

复制代码

never 类型

never 类型比较抽象，表示永远不存在的值

非严格模式下never类型是任何类型的子类型，也可以赋值给任何类型.

//常见的两种情况 抛出错误和死循环 
const errorFunc = (message: string): never => {
    throw new Error(message)
}

const infiniteFunc = ():never => {
    while(true){}
}
------------------------------------------------------
tsconfig.json中：strict: false (非严格模式下)：

let str: string
let isNever: never
str = isNever // true
isNever = str //error
复制代码

object 类型

object 类型,就是用来表示引用类型的。与JS对象无差别

let obj = {
    name: 'Bob'
}
obj.sex = 'man'

const getObject = (obj: object):void => { 
    console.log(obj)
}

getObject('hahah') // error
getObject(obj)    // true
复制代码

类型断言

指鹿为马，把某个值，强制指定为我们需要的类型，TS就会按照我们指定的类型进行检查

可以理解为类似于强制类型转换。只是类似┗|｀O′|┛ 嗷~~

语法： 两种写法。
1. <类型>值 
2. 值 as 类型   //react技术栈 编写JSX时，必须使用这个。上面的和JSX语法有歧义

// 需求 有个函数接收一个string或者number类型的值。
// 如果是string 我们直接返回字符串的长度
// 如果是number 我门把number转化为字符串，在返回长度

const getLength = (target: string | number): number => {
               // target的类型可以是string或number.  这是联合类型的语法。后续会讲解
    if(target.length) {  //提示错误
        return target.length //提示错误
    } else {
        return target.toString().length
    }
}
getLength(1) // 正常
getLength('hh') //正常
// 上面的代码，逻辑没有问题。
// 但在TS写代码过程中就会提示错误，TS会认为这个代码是有问题的。首先编译阶段参数类型还没确定，会把number 和 string 都作为参数类型进行检测
// string有length属性可以通过。number没有length属性，所以TS在编译阶段就会提示number没有length属性。
// 代码能正常编译为JS，也能正常运行。因为JS是运行时才会检测代码。但一直提示错误 属实不好看

//使用类型断言解决这个问题。 
const getLength2 = (target: string | number): number => { 
    // 把<string>target,把target指定为了string类型，这样代码就会按照string类型就行检测。
      if((<string>target).length) {
          return (target as string).length  //同上 类型断言第二种写法，加()是因为运算符优先级的问题
      } else {
          return target.toString().length
      }
    }
getLength2(1) //ok  
//如果传入number类型，运行阶段还是会走 toString 那行代码。
//类型断言并不是说把target转化为string类型了。仅仅是在编译阶段 让TS跟着你指定的类型进行检测

getLength2('hh') //ok


复制代码