JS的数据类型你了解多少？

为 JavaScript 的⼊⻔级知识点，JS 数据类型在整个 JavaScript 的学习过程中其实尤为重要。因为

在 JavaScript 编程中，经常会遇到边界数据类型条件判断问题，很多代码只有在某种特定的数据

类型下，才能可靠地执⾏。

希望本章的学习，能让你熟练掌握数据类型的判断以及转换等知识，在遇到数据类型判断，隐式转换等问题时，

可以轻松应对。

数据类型概念

Javascript数据类型有下面的8种

其中，前面7种为基础类型，最后 1 种为引用类型，这也是要重点学习的。

因为各种不同的数据类型，创建的对象，最后都存放在内容当中。

因此数据类型大概可以分为两类来进行存储

基础类型，存放在栈内存，被引用或者拷贝时，会创建一个完全相等的变量
引用类型，存放在堆内容，存储的是地址，多个引用指向同一个地址。也就是说多个地址共享一块内存，这里会涉及到共享的概念

关于引用类型，“共享”的概念，可以通过两段代码来讲解，

片段一: 牛刀小试

let a = {
  site: "helloworld.net",
  name: "兔哥",
};

let b = a;
console.log(a.site);    //输出: helloworld.net
b.site = "csdn.net";

console.log(a.site);    //输出：csdn.net
console.log(b.site);    //输出：csdn.net

上面的例子比较简单，有一个对象 a , 又赋值给了 b , 结果就是a, b 是引用类型，并且指向同一块内存

a对象修改，b会受影响， b对象修改，a会受影响。

从打印结果就可以看出来：这两个值都指向同一块内存，一个发生了变化，另一个也跟着发生了变化。

其实，对于引用类型来说，变量保存的是地址，并不是真实的值，通过地址，找到内存，才能从内存中读出真实的值。

下面的例子能验证。

片段二：初有小成

let a = {
  name: "兔哥",
  age: 18,
};

function change(obj) {
  obj.age = 20;
  obj = {
    name: "张三",
    age: 30,
  };

  return obj;
}

let b = change(a);
console.log(b.age);     //输出：30
console.log(a.age);     //输出：20

console.log(a);			//输出 ：{ name: '兔哥', age: 20 }
console.log(b);			//输出 ：{ name: '张三', age: 30 }

是不是和你想象的有区别？需要注意的是，这里的 function 给我们带来了不一样的东西。

原因如下：

函数传进来的是 obj, 传递的是对象在堆中的内存地址，通过 obj.age = 20; 语句，改变了对象a中的 age 的值
接着又把一个新的对象赋值给了 b，此时 b 就指向了新的一堆内存，和以前的 a 没有关系了。

结论如下：

引用类型的变量，保存的是堆内存中的地址
小知识点：内存中的地址，其实就是一个16进制的数字表示。类似家里的门牌号一样。
函数传参数，其实是值传递，会拷贝一分变量的副本，包括引用也是，会拷贝一份引用的副本，只不过这个副本里面保存的还是同一个内存地址

数据类型检测

数据类型也是面试过程中，经常会被遇到的问题。

比如：如何判断是否为数组？

而且在平常写代码过程中，也会经常用到。

很多人只知道用 typeof 来判断，但这样的回答是不能够让面试官满意的。

所以我们要加深对 JS 数据类型的理解，做到对各种数据类型的判断方法了然于胸

再进行归纳总结，这样才能彻底掌握数据类型的判断方法。

第一种判断方法： typeof

这是最常见的一种方法，来一段代码，快速了解用法。

typeof 10			//‘number’
typeof '10'			//‘string’
typeof undefined	//‘undefined’
typeof Symbol()		//‘symbol’
typeof []			//‘object’
typeof {}			//‘object’
typeof console		//‘object’
typeof console.log	//‘object’
typeof null			//‘object’

最后一种要注意：判断null ，不要用typeof null ，虽然也会返回 object ，但是这是一个JS的bug

直接用 if( x === null) 判断就行

第二种判断方法：instanceof

我们 new ⼀个对象，那么这个新对象就是它原型链继承上⾯的对象了

通过 instanceof 我们能判断这个对象是否是之前那个构造函数⽣成的对象

这样就基本可以判断出这个新对象的数据类型。下⾯通过代码来了解⼀下。

let Phone = function () {};
let apple = new Phone();

console.log(apple instanceof Phone); //true

let phone = new String("小米手机");
console.log(phone instanceof String); //true

let str = "www.helloworld.net";
console.log(str instanceof String); //false

上面就是用instanceof 判断数据类型的大概流程，那么如果让你实现一个instanceof的底层实现，你会怎么写。

请看下面代码：

function myInstanceof(left, right) {

  // 这里先用typeof来判断基础数据类型，如果是，直接返回false
  if (typeof left !== "object" || left === null) 
    return false;


  // getProtypeOf是Object对象自带的API，能够拿到参数的原型对象
  let proto = Object.getPrototypeOf(left);
  while (true) {
    //循环往下寻找，直到找到相同的原型对象
    if (proto === null) 
        return false;

    //找到相同原型对象，返回true
    if (proto === right.prototype) 
        return true; 

    proto = Object.getPrototypeof(proto);
  }
}

// 验证一下自己实现的myInstanceof是否OK
console.log(myInstanceof(new Number(100), Number)); // true
console.log(myInstanceof(100, Number)); 			// false

现在你知道了两种判断数据类型的⽅法，那么它们之间有什么差异呢？

总结了下⾯两点：

instanceof 可以准确地判断复杂引⽤数据类型，但是不能正确判断基础数据类型；
⽽ typeof 也存在弊端，它虽然可以判断基础数据类型（null 除外），但是引⽤数据类型中，除了

function 类型以外，其他的也⽆法判断。

总之，不管单独⽤ typeof 还是 instanceof，都不能满⾜所有场景的需求，⽽只能通过⼆者混写的⽅式

来判断。

但是这种⽅式判断出来的其实也只是⼤多数情况，并且写起来也⽐较难受，你也可以试着写⼀下。

其实我个⼈还是⽐较推荐下⾯的第三种⽅法，相⽐上述两个⽽⾔，能更好地解决数据类型检测问题

第三种判断⽅法：Object.prototype.toString

toString() 是Object的原型⽅法，调⽤该⽅法，可以统⼀返回格式为 [object XXX]的字符串，其中

XXX 就是对象的类型。对于 Object 对象，直接调⽤ toString() 就能返回[object Object]；⽽对于其他对

象，则需要通过 call 来调⽤，才能返回正确的类型信息。我们来看⼀下代码。

Object.prototype.toString( {} ); 					// "[object Object]"
Object.prototype.toString.call( {} ); 				// 同上结果，加上call也ok
Object.prototype.toString.call(100); 				// "[object Number]"
Object.prototype.toString.call("100"); 				// "[object String]"
Object.prototype.toString.call(true); 				// "[object Boolean]"
Object.prototype.toString.call(function () {}); 	// "[object Function]"
Object.prototype.toString.call(null); 				//"[object Null]"
Object.prototype.toString.call(undefined); 			//"[object Undefined]"
Object.prototype.toString.call(/123/g); 			//"[object RegExp]"
Object.prototype.toString.call(new Date()); 		//"[object Date]"
Object.prototype.toString.call([]); 				//"[object Array]"
Object.prototype.toString.call(document); 			//"[object HTMLDocument]"
Object.prototype.toString.call(window); 			//"[object Window]"

从上⾯这段代码可以看出，Object.prototype.toString.call() 可以很好地判断引⽤类型，甚⾄可以把

document 和 window 都区分开来。

但是在写判断条件的时候⼀定要注意，使⽤这个⽅法最后返回统⼀字符串格式为 "[object XXX]" ，⽽这

⾥字符串⾥⾯的 "XXX" ，第⼀个⾸字⺟要⼤写（注意：使⽤ typeof 返回的是⼩写），这⾥需要多加留

意。

那么下⾯来实现⼀个全局通⽤的数据类型判断⽅法，来加深你的理解，代码如下。

function getType(obj) {
  let type = typeof obj;

  // 先进行typeof判断，如果是基础数据类型，直接返回
  if (type !== "object") {
    return type;
  }

  // 对于typeof返回结果是object的，再进行如下的判断，正则返回结果
  return Object.prototype.toString
    .call(obj)
    .replace(/^\[object (\S+)\]$/, "$1");
}

/* 代码验证，需要注意大小写，哪些是typeof判断，哪些是toString判断？思考下 */
getType([]); // "Array" typeof []是object，因此toString返回
getType("100"); // "string" typeof 直接返回
getType(window); // "Window" toString返回
getType(null); // "Null"首字母大写，typeof null是object，需toString来判断
getType(undefined); // "undefined" typeof 直接返回
getType(); // "undefined" typeof 直接返回
getType(function () {}); // "function" typeof能判断，因此首字母小写
getType(/100/g); //"RegExp" toString返回

至此，数据类型检测的三种方式介绍完了，也给出了示例代码，希望你可以对比着学习，使用。

下面我们来看下一个问题：数据类型的转换。

数据类型转换

在日常开发中，经常会遇到数据类型的转换问题

有时候需要主动进行强制转换

有时候JS会进行隐式转换，隐式转换的时候就要多留心了。

"123" == 123; // false or true?
"" == null; // false or true?
"" == 0; // false or true?
[] == 0 // false or true?
null == undefined; // false or true?
Number(null); // 返回什么？
Number(""); // 返回什么？
parseInt(""); // 返回什么？

{}+10; // 返回什么？

let obj = {
  [Symbol.toPrimitive]() {
    return 200;
  },
  valueOf() {
    return 300;
  },
  toString() {
    return "Hello";
  },
};
console.log(obj + 200); // 这里打印出来是多少？

上⾯的问题相信你并不陌⽣，基本涵盖了我们平常容易疏漏的⼀些情况，这就是在做数据类型转

换时经常会遇到的强制转换和隐式转换的⽅式，那么下⾯我就围绕数据类型的两种转换⽅式详细讲解

⼀下，希望可以为你提供⼀些借鉴。

强制类型转换

强制类型转换⽅式包括 Number()、parseInt()、parseFloat()、toString()、String()、Boolean()，这⼏

种⽅法都⽐较类似，都是通过⾃身的⽅法来进⾏数据类型的强制转换。

Number() 方法强制转换规则

如果是 boolean ，true和false ，分别转成 1 和 0
如果是是数字，返回自身
如果 null ，返回 0
如果是 undefined，返回 NaN
如果是字符串，有以下4种规则

如果只包含数字，则转为十进制
如果包含有效的浮点格式，则转为浮点数值
如果是空字符串，则转为 0
如果不是以上格式的字符串，则转为NaN

如果是Symbol，抛出错误
如果是对象，并且部署了 [Symbol.toPrimitive]，那么调用此方法，否则调用对象的valueOf() 方法
然后根据前面的规则返回值，如果转换后的结果是NaN，则调用对象的toString() 方法
再依次按照前面的转换顺序返回对应的值

下面通过一段代码来说明上面的规则

Number(true)	//1
Number(false)	//0
Number('0111')	//111
Number(null)	//0
Number('')		//0
Number('abc')	//NaN
Number(-0x11)	//-17
Number(0x11)	//17

其中，我分别列举了⽐较常⻅的 Number 转换的例⼦，它们都会把对应的⾮数字类型转换成数字类

型，⽽有⼀些实在⽆法转换成数字的，最后只能输出 NaN 的结果。

Boolean()⽅法的强制转换规则

这个⽅法的规则是：除了 undefined、 null、 false、 ''、 0（包括 +0，-0）、 NaN 转换出来是 false，

其他都是 true。

这个规则很简单，没有那么多规矩

Boolean(0) //false
Boolean(null) //false
Boolean(undefined) //false
Boolean(NaN) //false
Boolean(1) //true
Boolean(13) //true
Boolean('12') //true

隐式类型转换

凡是通过逻辑运算符 (&&、 ||、 !)、运算符 (+、-、*、/)、关系操作符 (>、 <、 <= 、>=)、相等运算符

(==) 或者 if/while 条件的操作，如果遇到两个数据类型不⼀样的情况，都会出现隐式类型转换。这⾥你

需要重点关注⼀下，因为⽐较隐蔽，特别容易让⼈忽视。

下⾯着重讲解⼀下⽇常⽤得⽐较多的“==”和“+”这两个符号的隐式转换规则

'=='的隐式类型转换规则

如果类型相同，⽆须进⾏类型转换；
如果其中⼀个操作值是 null 或者 undefined，那么另⼀个操作符必须为 null 或者 undefined，才会

返回 true，否则都返回 false；

如果其中⼀个是 Symbol 类型，那么返回 false；两个操作值如果为 string 和 number 类型，那么就会将字符串转换为 number；
如果⼀个操作值是 boolean，那么转换成 number；
如果⼀个操作值为 object 且另⼀⽅为 string、number 或者 symbol，就会把 object 转为原始类型再

进⾏判断（调⽤ object 的 valueOf/toString ⽅法进⾏转换）。

如果直接死记这些理论会有点懵，我们还是直接看代码，这样更容易理解⼀些，如下所示。

'+'的隐式类型转换规则

'+' 号操作符，不仅可以用作数字相加，还可以用作字符串拼接。仅当 '+' 两边都是数字时，进行的是加法运算

如果两边都是字符串，无须进行隐式类型转换

除了上面规则，还有一些特殊规则

如果其中有⼀个是字符串，另外⼀个是 undefined、null 或布尔型，则调⽤ toString() ⽅法进⾏字符
串拼接；如果是纯对象、数组、正则等，则默认调⽤对象的转换⽅法会存在优先级，然后再进⾏拼接。
如果其中有⼀个是数字，另外⼀个是 undefined、null、布尔型或数字，则会将其转换成数字进⾏加
法运算，对象的情况还是参考上⼀条规则

如果其中⼀个是字符串、⼀个是数字，则按照字符串规则进⾏拼接。

如果直接死记这些理论会有点懵，我们还是直接看代码，这样更容易理解⼀些，如下所示。

1 + 2 	//3 常规情况
'1' + '2' 	//'12' 常规情况 
'1' + undefined  // '1undefined' , 规则1：undefined 转成字符串
'1' + null // '1null' ，规则1：null转成字符串
'1' + true // '1true', 规则1：true转成字符串
'1' + 2 // '12' , 规则3， 字符串拼接

整体来看，如果数据中有字符串，JavaScript 类型转换还是更倾向于转换成字符串，因为第三条规则

中可以看到，在字符串和数字相加的过程中最后返回的还是字符串，这⾥需要关注⼀下。

了解了 '+' 的转换规则后，我们最后再看⼀下 Object 的转换规则。

Object 的转换规则

对象转换的规则，会先调⽤内置的 [ToPrimitive] 函数，其规则逻辑如下：

如果部署了 Symbol.toPrimitive ⽅法，优先调⽤再返回；

调⽤ valueOf()，如果转换为基础类型，则返回；

调⽤ toString()，如果转换为基础类型，则返回；

如果都没有返回基础类型，会报错。

直接理解有些晦涩，还是直接来看代码，你也可以在控制台⾃⼰敲⼀遍来加深印象。

var obj = {
  value: 1,
  valueOf() {
    return 2;
  },

  toString() {
    return "3";
  },

  [Symbol.toPrimitive]() {
    return 4;
  },
};

console.log(obj + 1); // 输出： 5  ， 因为有Symbol.toPrimitive方法，所以优先调用这个方法，所以结果是 5


10 + {} // "10[object Object]" , 调用的是valueOf函数


// "1,2,,4,510" , 会先调用valueOf，结果是个数组
//不是基础类型，然后再调用的是toString函数
[1,2,undefined,4,5] + 10

总结

数据类型的基本概念：这是必须掌握的知识点，作为深⼊理解 JavaScript 的基础
数据类型的判断⽅法：typeof 和 instanceof，以及 Object.prototype.toString 的判断数据类型、
⼿写 instanceof 代码⽚段，这些是⽇常开发中经常会遇到的，因此你需要好好掌握

数据类型的转换⽅式：两种数据类型的转换⽅式，⽇常写代码过程中隐式转换需要多留意，如果

理解不到位，很容易引起在编码过程中的 bug，得到⼀些意想不到的结果。

建议

Javascript语言不像是其它语言一样，Javascript是个残缺的语言，没有开发完就上了。

所以有些犄角旮旯的不符合常理的，我们知道就行了，没必要记住，知道有那回事就行了

但是自己写代码的时候，一定要严格要求自己，一定要注意类型的问题

强制要求自己，按照强类型语言开发要求自己，不要做一些骚操作因为那代表不了技术水平

reamweaver的CSS面板分类

type(类型)

background(背景)

block(区块)

box(方框) 或盒子意思

border(边框)

list(列表)

positioning(定位)

extensions(扩展)

共八个部分

1. type(类型)

type面板主要是对文字的字体，大小，颜色，效果等基本样式进行设置。

注意：属性名带*号的是指样式效果不能在编辑文档时显示，要用浏览器打开才能看到效果。

(1)font-family：设置字体系列。什么叫字体系列呢?是指对文字设定几个字体，当遇到第一个字体不能显示的文字时会自动用系列中的第二个

字体或后面的字体显示。

注意:一般英文字体我们用"Verdana, Arial, Helvetica, sans-serif"这个系列比较好看。如果不用这些字体系列，你就需要自己编辑字体系列，

也可以直接手动在下拉框里写字体名，字体之间用逗号隔开。中文网页默认字体是宋体, 一般就空着不要选取任何字体。

默认值： not specified(取决于浏览器,系统默认的字体, 如: 微软雅黑)

注意：

1.如果有汉字, 那么我们要加引号

2.如果有多个英文字母组成的单词, 我们也要加引号; "microsoft yahei" 中间用空格隔开

3.font-family:"黑体","宋体","华文隶书"; 首先找黑体, 没有黑体找宋体...

为了避免在CSS中使用 font 或 font-family 设置中文字体时乱码, 可以使用 Unicode 编码来表示字体。

/* 示例:使用Unicode字体编码设置字体为"微软雅黑" */
font-family: "\5FAE\8F6F\96C5\9ED1";

(2)font-size：定义文字的大小。你可以通过选取数字和度量单位来选择具体的字体大小，或者你也可以选择一个相对的字体大小。

最好使用pixels作为单位，这样不会在浏览器中文本变形。一般字体用比较标准的12px或14px, 默认值为16px。

注意：CSS中长度的单位分绝对长度单位和相对长度单位:

绝对长度单位有：

pt：磅(point)

mm、cn、in、pc：(毫米、厘米、英寸、活字)根据显示的实际尺寸来确定长度。

此类单位不随显示器的分辨率改变而改变。

相对长度单位有：

px：(像素)根据显示器的分辨率来确定长度。

em：当前文本的尺寸。例如：{font-size:2em}是指文字大小为原来的2倍。

比如自身font-size: 30px; 那么此时1em=30px;

ex：当前字母"x"的高度，一般为字体尺寸的一半。

%：是以当前文本的百分比定义尺寸。例如：{ font-size:300%}是指文字大小为原来的3倍。

small、large：表示比当前小一个级别或大一个级别的尺寸。

默认值：medium(标准大小)

(3)font-style：定义字体样式为normal、italic、oblique。默认设置为normal。

注意： italic 斜体 oblique 歪斜体 italic和oblique实际效果是一样的。

默认值:normal

(4)line-height：设置文本所在行的行高。默认为normal。可以是行内元素、行内块元素, 通常与height设置的高度值相同, 可以做到垂直居中的作用。

你也可以自己键入一个精确的数值并选取一个计量单位。

比较直观的写法用百分比, 例如140%是指行高等于文字大小的1.4倍。

最常用的方法: line-height:1.5em; /*行间距,相对数值,1.5倍行距,*/ 可有效的避免文字发生重叠

默认值： normal

(5)text-decoration：在文本中添加underline(下划线)、overline(上划线)、line-through(中划线)、blink(闪烁效果)。

这些效果可以同时存在，将效果前的复选框选定即可。

注意：链接的默认设置是underline，我们可以通过选none去除下划线。blink(闪烁效果)只在mozilla浏览器里可以看到, IE、opera不支持

默认值： none

(6)font-weight：给字体指定粗体字的磅值。

normal 默认值。定义标准的字符。

bold 定义粗体字符。

bolder 定义更粗的字符。

lighter 定义更细的字符。

100

200

300

400

500

600

700

800

900

inherit 规定应该从父元素继承字体的粗细。

定义由粗到细的字符。400 等同于 normal, 而 700 等同于 bold。

默认值: normal

(7)font-variant：允许你选取字体的变种, 选small-caps(小型大写字母)时, 此样式区域内所有字母大写。

normal表示正常的字体, 为默认值；

默认值: normal

(8)text-transform：将选区中每个单词的第一个字母转为大写, 或者令单词全部大写或全部小写。

参数：capitalize(单词首字母大写)、uppercase(转换成大写)、lowercase(转换成小写)、none(不转换)。

默认值：none

(9)color：定义文字颜色。包括对表单输入的文字颜色。

CSS中颜色的值有三种表示方法：

#RRGGBB格式，是由红绿蓝三种颜色的值组合，每种颜色的值为"00 – FF"的两位十六进制正整数。

例如：#FF0000表示红色，#FFFF00表示黄色。

rgb(R,G,B)格式, RGB为三色的值, 取0~255, 例如：rgb(255,0,0)表示红色, rgb(255,255,0)表示黄色。

用颜色名称。CSS可以使用已经定义好的颜色名称。例如：red表示红色, yellow表示黄色。

颜色值的缩写:

p{color:#000000} 可以缩写为：p{color:#000}

p{color:#336699} 可以缩写为：p{color:#369}

默认值： not specified

color: transparent; 透明色

rgba() 解释: rgba(红0-255, 绿0-255, 蓝0-255, 透明度0-1)

注意: 如果文字的颜色通过单独的类选择去设置没有改变颜色, 则应该通过组合选择器(.header .top .topR .blue)去设置, 改变它的优先级。

2. background(背景)

background面板主要是对元素的背景进行设置，包括背景颜色、背景图象、背景图象的控制。

一般是对body(页面)、table(表格)、div(区域)的设置。

(1)background-color：设置元素的背景色。包括对input表单输入框的背景颜色;

默认值: transparent(背景颜色为透明)

rgba() 解释: rgba(红0-255, 绿0-255, 蓝0-255, 透明度0-1) 一般用于背景色

(2)background-image：设置元素的背景图像。

默认值:none

CSS3支持多重背景图,只要加上一个url指定图片路径,并用逗号(,)将两组url分隔就可以了

background-image:url(a.jpg),url(b.jpg);

base64使用

background-image: url("data:image/png;base64,iVBORw0KGgo=...");

(3)background-repeat：确定背景图像是否以及如何重复。

repeat 默认值。背景图像将在垂直方向和水平方向重复。

repeat-x 背景图像将在水平方向重复。

repeat-y 背景图像将在垂直方向重复。

no-repeat 背景图像将仅显示一次。

inherit 规定应该从父元素继承background-repeat属性的设置。

注意：如果定义的元素的body，可以控制页面背景是否重复。

默认值: repeat

(4)background-attachment：固定背景图像或者跟随内容滚动。

参数fixed表示固定背景(不随屏幕滚动而滚动，决定背景图像是否要固定在原来的位置), scroll表示跟随内容滚动的背景。

注意：如果定义的元素的body, 可以使页面背景固定。

默认值: scroll

(5)background-position(X)：指定背景图像的水平位置。

可以指定为left(左边), center(居中)，right(右边)；

也可以指定数值，如20px是指背景距离左边20象素。

background-position(Y)：指定背景图像的垂直位置。

可以指定为top(顶部), center(居中), bottom(底部)；也可以指定数值。

background-position属性值:

left top

center top

right top

left center

center center

right center

left bottom

center bottom

right bottom

如果您仅规定了一个关键词，那么第二个值将是"center"。

注意:采用英文单词的水平位置和垂直位置的属性值可以调换

x% y% 第一个值是水平位置，第二个值是垂直位置。左上角是 0% 0%。右下角是 100% 100%。如果您仅规定了一个值，另一个值将是 50%。

xpos ypos 第一个值是水平位置，第二个值是垂直位置。左上角是 0 0。单位是像素 (0px 0px) 或任何其他的 CSS 单位。

如果您仅规定了一个值，另一个值将是50%。

您可以混合使用 % 和 position 值。

默认值：0% 0%

i，朋友，您来啦。带上小板凳，我们一起瞅一瞅今天的话题。

基础类型

undefined、null、boolean、number、string、symbol和BigInt。

BigInt：专治各种不服的大整数，海纳百川、超级无敌都不够形容它。

symbol：你我Ta可以共享一个名字，但就是不一样，横空出世时，就有全宇宙唯一标识。

复杂类型/对象

对象（普通对象、日期对象、错误对象等）、数组、函数、正则表达式、Promise、Map、Set、WeakMap、WeakSet、Generator、Proxy、……。

掌握了复杂类型，就拥有了魔法，有了魔法就能驾驭编程的洪流。[呲牙]

typeof 操作符检测类型

typeof 返回一个字符串，表示变量或表达式的类型。需要注意的是，typeof 在大多数情况下，针对某些类型都会返回 "object"，而不是具体的类型名称。

instanceof 运算符检查类型

instanceof 运算符用于检测构造函数的 prototype 属性是否出现在某个实例对象的原型链上。

最可靠的检测方法

Object.prototype.toString.call()

此方式返回一个表示该对象的字符串，其中包括了对象的类型信息。这种方法可以识别出更具体的类型。

关注作者：关注有趣的前端编程。

希望本文能够对您有所帮助，感谢您的阅读！

人人为我，我为人人，谢谢您的浏览，让我们一起加油吧。

在线咨询

上一篇：HTML代码编辑工具
下一篇：HTML表格制作

您的项目需求

*请认真填写需求信息，我们会在24小时内与您取得联系。

整合营销服务商