2
JavaScript
中
的
数据
类
型
：
string
、
number
、
boolean
、
null
、
undefined
、
bigint
、
symbol
、
obje
ct
2.
类
型
推断
3.
类
型
总
览
备
注
：
其
中
object
包
含
：
Array
、
Function
、
Date
......
let a: string //
变
量
a
只
能
存
储
字
符
串
let b: number //
变
量
a
只
能
存
储
数
值
let c: boolean //
变
量
a
只
能
存
储
布尔
值
a = 'hello'
a = 100 //
警
告
：不
能
将
类
型
“number”
分
配
给类
型
“string”
b = 666
b = '
你
好
'//
警
告
：不
能
将
类
型
“string”
分
配
给类
型
“number”
c = true
c = 666 //
警
告
：不
能
将
类
型
“number”
分
配
给类
型
“boolean”
//
参
数
x
必
须
是
数
字
，
参
数
y
也
必
须
是
数
字
，
函
数
返
回
值
也
必
须
是
数
字
function demo(x:number,y:number):number{
return x + y
}
demo(100,200)
demo(100,'200') //
警
告
：
类
型
“string”
的
参
数
不
能
赋
给类
型
“number”
的
参
数
demo(100,200,300) //
警
告
：
应
有
2
个
参
数
，
但
获
得
3
个
demo(100) //
警
告
：
应
有
2
个
参
数
，
但
获
得
1
个
let d = -99 //TypeScript
会
推断
出
变
量
d
的
类
型
是
数
字
d = false //
警
告
：不
能
将
类
型
“boolean”
分
配
给类
型
“number”
3
TypeScript
中
的
数据
类
型
：
1.
以
上
所
有
2.
四
个
新
类
型
：
void
、
never
、
unknown
、
any
、
enum
、
tuple
3.
⾃
定
义
类
型
：
type
、
interface
注
意
点
：
JS
中
的
这
三个
构
造
函
数
：
Number
、
String
、
Boolean
，
他们
只
⽤
于
包
装
对
象
，
正
常开
发
时
，
很
少
去
使
⽤
他们
，
在
TS
中也
是
同
理
。
类
型
总
览
：
let n = 56
n.toFixed(2)
/*
当
执
⾏
n.toFixed(2)
，
底
层
做
了
这
⼏
件事
：
1.let temp = new Number(42)
2.value = temp.toFixed(2)
3.
删
除
value
4.
返
回
value
*/
类
型
描
述
举例
number
任
意
数
字
1
,
-33
,
2.5
string
任
意
字
符
串
'hello'
,
'ok'
,
'
你
好
'
boolean
布尔
值
true
或
false
true
、
false
字
⾯
量
值
只
能
是
字
⾯
量
值 值
本
身
any
任
意
类
型
1
、
'hello'
、
true
....
..
unknown
类
型
安
全
的
any
1
、
'hello'
、
true
....
..
never
不
能
是
任何
值
⽆
值
void
空
或
undefined
空
或
undefined
object
任
意
的
JS
对
象
{name:'
张
三
'}
4
any
的
含
义
是
：
任
意
类
型
，⼀
旦
将
变
量
类
型
限
制
为
any
，
那
就
意
味
着
放
弃
了
对
该
变
量
的
类
型
检
查
。
注
意
点
：
any
类
型
的
变
量
，
可
以
赋
值
给
任
意
类
型
的
变
量
4.
常
⽤
类
型
4.1.
字
⾯
量
4.2.
any
tuple
元
素
，
TS
新
增
类
型
，
固
定
⻓
度
数
组
[4,5]
enum
枚
举
，
TS
中
新
增
类
型
enum{A, B}
let a: '
你
好
' //a
的
值
只
能
为
字
符
串
“
你
好
”
let b: 100 //b
的
值
只
能
为
数
字
100
a = '
欢
迎
'//
警
告
：不
能
将
类
型
“"
欢
迎
"”
分
配
给类
型
“"
你
好
"”
b = 200 //
警
告
：不
能
将
类
型
“200”
分
配
给类
型
“100”
let gender: '
男
'|'
⼥
' //
定
义
⼀个
gender
变
量
，
值
只
能
为
字
符
串
“
男
”
或
“
⼥
”
gender = '
男
'
gender = '
未
知
' //
不
能
将
类
型
“"
未
知
"”
分
配
给类
型
“"
男
" | "
⼥
"”
//
明
确的
表
示
a
的
类
型
是
any ——
显
式
的
any
let a: any
//
以
下
对
a
的
赋
值
，
均
⽆
警
告
a = 100
a = '
你
好
'
a = false
//
没
有明
确的
表
示
b
的
类
型
是
any
，
但
TS
主
动
推断
了
出
来
——
隐
式
的
any
let b
//
以
下
对
b
的
赋
值
，
均
⽆
警
告
b = 100
b = '
你
好
'
b = false
5
unknown
的
含
义
是
：
未
知
类
型
。
若
就
是
想把
a
赋
值
给
x
，
可
以
⽤
以
下三
种
写
法
：
any
后
点
任何
的
东
⻄
都
不
会
报
错
，
⽽
unknown
正
好
与
之
相
反
。
4.3.
unknown
备
注
1
：
unknown
可
以
理
解
为
⼀个
类
型
安
全
的
any
备
注
2
：
unknown
适
⽤
于
：
开
始
不
知
道
数据
的
具
体
类
型
，
后
期
才
能
确
定
数据
的
类
型
/*
注
意
点
：
any
类
型
的
变
量
，
可
以
赋
值
给
任
意
类
型
的
变
量
*/
let a
let x: string
x = a //
⽆
警
告
//
设
置
a
的
类
型
为
unknown
let a: unknown
//
以
下
对
a
的
赋
值
，
均
正
常
a = 100
a = false
a = '
你
好
'
//
设
置
x
的
数据
类
型
为
string
let x: string
x = a //
警
告
：不
能
将
类
型
“unknown”
分
配
给类
型
“string”
//
设
置
a
的
类
型
为
unknown
let a: unknown
a = 'hello'
//
第
⼀
种
⽅
式
：
加
类
型
判
断
if(typeof a === 'string'){
x = a
}
//
第
⼆
种
⽅
式
：
加
断
⾔
x = a as string
//
第
三
种
⽅
式
：
加
断
⾔
x = <string>a
