简单地谈谈Javaｓｃｒｉｐｔ中的判断类型

判断数据类型有几种方法。

1、一元运算符typeof

2。关系运算符instanceof

3，构造函数属性

4，原型属性

1。类型

返回值的类型有以下
类型
结构

未定义
未定义
无效的
对象（见下文）
布尔值
布尔
数值
数字
字符串
字符串
符号（ECMAｓｃｒｉｐｔ 6添加）
符号
宿主对象（由JS环境提供，如浏览器）
依赖于实现的
函数对象（实现{ {电话} }在ECMA-262条款）
函数
任何其他对象
对象
查看代码的一种简单而粗鲁的方式
以下的眉来眼去铬45.0.2454.101 M测试版代码 / /
数字
console.log（typeof = 37'number）；
console.log（typeof = 3.14'number）；
console.log（typeof math.ln2 =数）；
console.log（typeof无限=数）；
console.log（南= = =若干类型'）； / /楠虽然是非数字的缩写
console.log（typeof数（1）= = =数'）； / /不使用！

字符串
console.log（、= 'String'）；
console.log（typeof BLA = 'String'）；
console.log（typeof（类型1）= = = 'String'）； / / console.log（typeof返回肯定是一个字符串
console.log（类型的字符串（ABC）； / / = = = 'String'）不使用！

/ /布尔运算
console.log（typeof真实= 'boolean）；
console.log（typeof假= 'boolean）；
console.log（typeof布尔（真）= = = 'boolean '）； / /不使用！

符号
console.log（类）（符号= 'symbol）；
console.log（typeof符号（'foo）= 'symbol）；
console.log（typeof symbol.iterator = 'symbol）；

未定义
console.log（typeof定义= 'undefined）；
console.log（typeof么= 'undefined '）； / /一个未定义的变量，或一个定义而不是变量的初始值

对object.prototype.tostring.call或array.isarray / /对象的方法可以区分对象从基本类型数组的使用
console.log（typeof { 1 } = 'object：）；
console.log（typeof { 1, 2, 4 } = 'object）；
console.log（typeof / ^ { } { } a-za-z 5美元/ = 'object）；
console.log（typeof {姓名：'wenzi，年龄：25 } = 'object）；
Console.log (typeof null ='object'//true);

以下容易混淆，不要使用！
console.log（typeof新布尔（真）= 'object）；
console.log（typeof的新号码（1）= = = 'object）；
console.log（类）新（日期= 'object）；
console.log（typeof新的字符串（ABC）= 'object）；
console.log（类）新（误差= 'object）；

函数
Console.log (typeof) function ('function'= = = {});
console.log（typeof math.sin = 'function）；
TYPEOF只能检查出以上7种类型

二、实例

instanceof运算符用于识别所处理的对象的类型，并要求开发商明确确认的对象是一个特定的类型

1、实例构造函数无关
Var（a =函数）{ }；
a.prototype = { }；

var；
console.log（a.constructor）； / /函数（）{ } } {本地代码
console.log（b.constructor）； / /函数对象（）{ } } {本地代码

var =新的a（）；
a.prototype = { }；

var =新的a（）；
b.constructor = a.constructor；

console.log（a.constructor =一个）； / /假
console.log（a.constructor）； / /函数对象（）{ } } {本地代码
console.log（种类）； / /函数对象（）{ } } {本地代码

console.log（a.constructor = b.constructor）； / /假
console.log（b.constructor）； / /函数（）{ } } {本地代码

console.log（一个是一个）； / /假
console.log（B是A）； / /真的
2，实例也被称为一个关系运算符，它可以被用来确定是否一个构造函数的原型属性的另一个原型链检测对象。
新字符串（Hello）；
console.log（STR是字符串）； / /真的
console.log（String实例功能）； / /真的
console.log（STR instanceof功能）； / /假
为什么第三输出返回false原文地址：一个问题是关于在Javaｓｃｒｉｐｔ
一点表达式
console.log（str.__proto__ =字符串。原型）； / /真的
console.log（STR是字符串）； / /真的

双点表达式
console.log（字符串。__proto__ = function.prototype / /真实）；
console.log（String实例功能）； / /真的

三点表达式
console.log（str.__proto__ = string.prototype / /真实）；
console.log（str.__proto__。__proto__ =字符串。原型。__proto__ / /真实）；
console.log（str.__proto__。__proto__ = object.prototype / /真实）；
console.log（str.__proto__。__proto__。__proto__ = null / /真实）；
console.log（str实例对象）； / /真的
console.log（STR instanceof功能）； / /假
看一个复杂的用法
console.log（对象实例对象）； / /真的
console.log（函数是函数）； / /真的
console.log（数是数）； / /假
console.log（字符串是字符串）； / /假

console.log（函数实例对象）； / /真的

console.log（foo instanceof功能）； / /真的
console.log（foo instanceof Foo）； / /假
为什么，这就是为什么要理解下面的意思

1。如何定义语言规范中的操作符

2、Javaｓｃｒｉｐｔ原型继承机制

对象实例对象
为了便于表达式的表达，首先给出了左右表达式的表达式。
objectl =对象，objectr =对象；
console.log（ObjectL instanceof ObjectR）； / /真的
按规范逐步演绎
console.log（objectl。__proto__ =函数原型）； / /真的
console.log（objectl。__proto__。__proto__ =对象。原型）； / /真的
函数是函数

功能：功能、functionR =功能；
console.log（FunctionL instanceof FunctionR）； / /真的
console.log（功能。__proto__ =函数原型）； / /真的

instanceof Foo Foo

函数（富）{ }
新富（）；
傻瓜= foo，傻瓜= foo；
console.log（傻瓜是傻瓜）； / /假
console.log（傻瓜。__proto__ =函数原型）； / /真的
console.log（傻瓜。__proto__。__proto__ =对象。原型）； / /真的
console.log（傻瓜。__proto__。__proto__。__proto__ = null）； / /真的

instanceof在道场的继承机制的应用

在Javaｓｃｒｉｐｔ中，没有多重继承这一概念，就像java。但使用时向道场声明一个类，它允许从多个类继承
Dojo.declare（AOO
Dojo.declare（嘘
Dojo.declare（Foo，{ Aoo，嘘}，{ }）；

新富（）；
console.log（foo instanceof AOO）； / /真的
console.log（foo instanceof BOO）； / /假

console.log（foo.isinstanceof（AOO））； / /真的
console.log（foo.isinstanceof（BOO） / /真实）；
实例和多个全局对象（多帧或多个窗口之间的相互作用）

在浏览器中，我们的脚本可能需要多个窗口之间的相互作用。多窗口多的全球环境，和全球不同的环境有不同的全局对象，具有不同的内置类型的构造函数。这可能会导致一些问题。例如，instanceof窗口的表达。帧{ 0 }，{ }数组将返回false，因为Array.prototype！= =窗口。帧{ 0 }。Array.prototype，所以你必须使用array.isarray（myobj时）或Object.prototype.toString.call（myobj时）={对象数组} 判断myobj时是一个数组。
以下的眉来眼去铬45.0.2454.101 M测试版代码 / /
数字
console.log（37是数字）； / /假
console.log（3.14是数字）； / /假。
console.log（math.ln2实例数）； / /假
console.log（无限实例数）； / /假
console.log（南是数）； / /假而楠是非数字的缩写
console.log（编号（1）实例数）； / /假不使用！

字符串
console.log（是字符串）； / /假
console.log（BLA是字符串）； / /假
（console.log（1）中的字符串（falseconsole。日志）； / /回报肯定是一个字符串
console.log（String（abc）； / /假是字符串）不使用！

/ /布尔运算
console.log（真是布尔）； / /假
console.log（假是布尔）； / /假
console.log（布尔（真）是布尔）； / /假不使用这样的！

符号
console.log（符号）是（符号）； / /假
console.log（符号（foo）； / /假是符号）
console.log（symbol.iterator是符号）； / /假

未定义
VaR blabla；
/ / console.log（不确定是不确定的）； / /捕获的referenceerror：未定义未定义
/ / console.log（当初是不确定的）； / /捕获的referenceerror：未定义未定义
console.log（未定义的实例对象）； / /假
console.log（blabla实例对象）； / /假

对object.prototype.tostring.call或array.isarray / /对象的方法可以区分对象从基本类型数组的使用
console.log（{ 1 }：实例对象）； / /真的
console.log（{ 1, 2, 4 }实例对象）； / /真的
console.log（ / ^ { } { } a-za-z 5美元/实例对象）； / /真的
console.log（{姓名：'wenzi，年龄：25 }实例对象）； / /真的
console.log（空对象）； / /假

以下容易混淆，不要使用！
console.log（新的布尔（真）实例对象）； / /真的
console.log（新号码（1）实例对象）； / /真的
console.log（新的日期（）实例对象）； / /真的
console.log（新的字符串（ABC）是对象）； / /真的
console.log（新的错误（）实例对象）； / /真的

函数
console.log（function（函数 / /是真的）{ }）；
console.log（math.sin instanceof功能）； / /真的
注意：未定义的和空的是检测到的对象类型，因为js中没有全局类型的未定义和null，数字、字符串和布尔型无法检测到它的类型。

三、构造函数

当使用instanceof检测变量的类型，我们没有发现的类数，'String'，和布尔值。因此，我们需要换一种方式来解决这个问题

object.prototype.constructor返回一个函数的引用指向的对象的原型创作。需要注意的是，该属性的值是函数本身重要，没有一个包含该函数的名称，原来的值（如1，真的，或试验），此属性只读对象都继承自它的原型构造函数属性

构造函数最初是原型对象上的一个属性，指向构造函数，但是我们可以根据实例对象找到属性的顺序。如果实例对象上没有实例属性或方法，我们将在原型链中查找它。因此，实例对象也可以使用构造函数属性。
功能人（）{

}
Var Tom =新人（）；

console.log（tom.constructor =人）； / /真的
但是请注意，可以修改构造函数属性，从而导致不正确的结果。
功能人（）{

}
函数学生（）{

}
student.prototype =新的人（）；
新学生（）；
console.log（约翰。构造函数= =学生）； / /假
console.log（约翰。构造函数= =人）； / /真的
更改此对象的构造函数属性的值。
函数类型（）{ }；

var类型= {
新的阵列，
{ }，
新的布尔，
正确，保持不变
新的日期，
新的错误，
新功能，
函数（）{ }，
数学,
新的号码，
1 保持不变
新的对象，
{ }，
新的正则表达式，
（/），
新的字符串，
测试保持不变
}；

对于（var i = 0；i < types.length；i++）{
类型{；
{我} = {类型类型{我}，{我}实例构造函数，类类型，类型的ToString（）{ } }；
}；

console.log（types.join（；
除了未定义的和空的，其他类型的变量可以使用构造函数来确定类型。

四。通用object.prototype.tostring.call

使用toString（）方法来检测对象类型
函数类型（）{ }；

VaR方法= object.prototype.tostring；
console.log（tostring.call（新日期）={ }对象的日期； / /真实）
console.log（tostring.call（字符串）= = ={ }对象的字符串）； / /真的
console.log（tostring.call（新功能）= = ={ }目标函数）； / /真的
console.log（tostring.call（型）= = ={ }目标函数）； / /真的
console.log（tostring.call（'str = = =）{对象的字符串}）； / /真的
console.log（tostring.call（数学）={ }对象的数学； / /真实）
console.log（tostring.call（真正的）= = ={ }布尔对象）； / /真的
console.log（tostring.call（ / ^ { } { } a-za-z 5美元/）= = ={ }对象regexp）； / /真的
console.log（tostring.call（{姓名：'wenzi，年龄：25 }）= = ={对象}）； / /真的
console.log（tostring.call（{ 1, 2, 3，4 }）= = ={ }对象数组）； / /真的
/ /由于Javaｓｃｒｉｐｔ 1.8.5
console.log（tostring.call（定义）={ }对象不明确； / /真实）
console.log（tostring.call（null）{零} =对象； / /真实）
判断函数Javaｓｃｒｉｐｔ中的数据类型是多少

五、jQuery实现：1.8.2

在jQuery中，提供了一个$类型的接口来查看代码。
var m = object.prototype.tostring / / 501线

e；{；}； / 512

功能：功能（一）{ / / 645线
返回p.type（一）=功能
}，
ISArray：array.isarray函数（）{ | |
返回p.type（一）=阵
}
，
IsWindow：功能（一）{
返回=空= = a.window！
}，
ISNUMERIC：功能（一）{
返回！IsNaN（parseFloat（一））（一）有限
}，
类型：函数（a）{
返回一个为空字符串（一）：（一）m.call E { } | |对象
}，
isplainobject：功能（一）{
如果（一p.type（一）| |！！= =对象| | | | a.nodetype p.iswindow（一））
返回！1；
{试
如果（a.constructor！n.call（一、构造函数）！n.call（a.constructor.prototype，isprototypeof ））
返回！一
catch（c）{ }
返回！一
}
VaR D；
为（d中）
；
返回a b | | n.call（A，D）
}，
isemptyobject：功能（一）{
VaR B；
对于（b中）
返回！1；
返回！零
}，
可以看出，jQuery实现object.prototype.tostring.call