6333557442705696719

先看typeof

<!doctype html>

<html lang="en">

    <head>

        <meta charset="UTF-8" />

        <script type="text/javascript" src="" ></script>

        <title>Document</title>

        <style type="text/css">

        </style>

        <script type="text/javascript">

            var a;

            console.log("1:" + typeof a);

            var b = null;

            console.log("2:" + typeof b);

            var c = undefined;

            console.log("3:" + typeof c);

            var d = new Object;

            console.log("4:" + typeof d);

            var e = function() {};

            console.log("5:" + typeof e);

            var f = {};

            console.log("6:" + typeof f);

            var g = '';

            console.log("7:" + typeof g);

            var h = [];

            console.log("8:" + typeof h);

            var i = true;

            console.log("9:" + typeof i);

            var j = 123;

            console.log("10:" + typeof j);

            var k = NaN;

            console.log("11:" + typeof k);

            var l = /^[-+]?\d+$/;

            console.log("12:" + typeof l);

        </script>

    </head>

    <body>

    </body>

</html>

按照上面的打印结果,总结出下面要注意的几点

typeof (引用类型) 除了函数, 都是 'object',比如 typeof /123/
typeof null 为'object'
typeof undefined 为 'undefined',通常, 如果使用两等号, null == undefined 为真.
转换为数字的常见用法 "10"-0或+"10", 如果没有转换成功,返回NaN,由于NaN 的一个特性: NaN != NaN,故判断转换成功与否的常见做法: (这也是我参见 jQuery的源码发现的,jQuery源码读100遍都不为过)
```
  ("10x" - 0) == ("10x" - 0);

  // 结果为假!   
```

再看看constructor 和 instanceof

instanceof 用于判断一个变量是否某个对象的实例,或用于判断一个变量是否某个对象的实例；

constructor 用于判断一个变量的原型，constructor 属性返回对创建此对象的数组函数的引用。

Javascript中对象的prototype属性的解释是:返回对象类型原型的引用。

<!DOCTYPE html>

<html>

    <head>

        <meta charset="utf-8" />

        <title></title>

        <script type="text/javascript">

            console.log("----------------Number---------------");

            var A = 123;

            console.log(A instanceof Number); //false

            console.log(A.constructor == Number); //true

            console.log(A.constructor);

            console.log("----------------String---------------");

            var B = "javascript";

            console.log(B instanceof String); //false

            console.log(B.constructor == String); //true

            console.log(B.constructor);

            console.log("----------------Boolean---------------");

            var C = true;

            console.log(C instanceof Boolean); //false

            console.log(C.constructor == Boolean); //true

            console.log(C.constructor);

            console.log("----------------null---------------");

            var D = null;

            console.log(D instanceof Object); //false

            //console.log(D.constructor == null); //报错

            //console.log(D.constructor); //报错

            console.log("----------------undefined---------------");

            var E = undefined;

            //console.log(E instanceof undefined); // //报错

            //console.log(E.constructor == undefined); //报错

            //console.log(E.constructor); //报错

            console.log("----------------function---------------");

            var F = function() {};

            console.log(F instanceof Function);

            console.log(F.constructor == Function);

            console.log(F.constructor);

            console.log("----------------new function---------------");

            function SB() {};

            var G = new SB();

            console.log(G instanceof SB);

            console.log(G.constructor == SB);

            console.log(G.constructor);

            console.log("----------------new Object---------------");

            var H = new Object;

            console.log(H instanceof Object);

            console.log(H.constructor == Object);

            console.log(H.constructor);

            console.log("-----------------Array--------------");

            var I = [];

            console.log(I instanceof Array);

            console.log(I.constructor == Array);

            console.log(I.constructor);

            console.log("-----------------JSON--------------");

            var J = {

                "sb": "javascript",

                "node": "very SB"

            };

            console.log(J instanceof Object);

            console.log(J.constructor == Object);

            console.log(J.constructor);

        </script>

    </head>

    <body>

    </body>

</html>

再看看{}.toString.call(obj)

 <!doctype html>

<html lang="en">

	<head>

		<meta charset="UTF-8" />

		<title>Document</title>

		<script type="text/javascript">

			console.log({}.toString.call(1));

			console.log({}.toString.call("11"));

			console.log({}.toString.call(/123/));

			console.log({}.toString.call({}));

			console.log({}.toString.call(function() {}));

			console.log({}.toString.call([]));

			console.log({}.toString.call(true));

			console.log({}.toString.call(new Date()));

			console.log({}.toString.call(new Error()));

			console.log({}.toString.call(null));

			console.log({}.toString.call(undefined));

			console.log(String(null));

			console.log(String(undefined));

		</script>

	</head>

	<body>

	</body>

</html>

使用jQuery中的方法$.type()

现在看看jQuery是怎么做的

// 先申明一个对象,目的是用来做映射

var class2type = {};

// 申明一个core_toString() 的方法,得到最原始的toString() 方法,因为在很多对象中,toStrintg() 已经被重写

var core_toString() = class2type.toString;

// 这里为 toStrintg() 后的结果和类型名做一个映射,申明一个core_toString() 后的结果,而值就是类型名

jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {

    class2type[ "[object " + name + "]" ] = name.toLowerCase();

});

<!doctype html>

<html lang="en">

	<head>

		<meta charset="UTF-8" />

		<script type="text/javascript" src="" ></script>

		<title>Document</title>

		<script type="text/javascript">

			console.log($.type(1));

			console.log($.type("11"));

			console.log($.type(/123/));

			console.log($.type({}));

			console.log($.type(function() {}));

			console.log($.type([]));

			console.log($.type(true));

			console.log($.type(new Date()));

			console.log($.type(new Error()));

			console.log($.type(null));

			console.log($.type(undefined));

			console.log(String(null));

			console.log(String(undefined));

		</script>

	</head>

	<body>

	</body>

</html>

上面的打印结果与

class2type[ "[object " + name + "]" ] = name.toLowerCase();

不谋而合!

这是jQuery.type 的核心方法

type: function( obj ) {

    if ( obj == null ) {

        return String( obj );

    }

    // Support: Safari <= 5.1 (functionish RegExp)

    return typeof obj === "object" || typeof obj === "function" ?

        class2type[ core_toString.call(obj) ] || "object" :

        typeof obj;

},

注意,为什么把 null 或者 undefined 单独讨论呢,因为在一些版本浏览器中
console.log(core_toString.call(null));

console.log(core_toString.call(undefined));
这是会报错的!

如果是对象类型,另:由于在一些低版本的浏览器中,typeof /123/ 会返回的是 "function" 而不是 "object",所以这里要判断是否是函数,要明白这里的 typeof obj === function 不是为了函数讨论的,因为函数本身就可以通过typeof 来得到类型.

 typeof obj === "object" || typeof obj === "function" ?

        class2type[ core_toString.call(obj) ]

就直接返回class2type 中键值对的结果,,如果不是,那么一定就是基本类型, 通过 typeof 就可以啦.

class2type[ core_toString.call(obj) ] || "object" :

// 这是防止一些未知情况的,如果未取到,就返回object

但是 jQuery.type 有一个很大的缺陷

这是一个自定义类型

function Person(){

   this.name = 'pawn';

}

var p = Person.toString();

// 注意,这里会打印 [object Object],通过上面的方法,无法得到精确的自定义类型
这也是它的一个大缺陷了!

下面,我们通过构造函数的方式来获取精确类型

通过构造函数来获取类型

在理解这个方法之前,需要理解两个点

prorotype 原型属性

我们知道,任何对象或者函数都直接或者间接的继承自Object 或者 Function，（其实最终Function 是继承自 Object 的，这属于原型链的知识了，见下图）。那么，任何一个对象都具有原型对象 __proto__ (这个对象只在chrome 和 firefox 暴露，但是在其他浏览器中也是存在的)，这个原型对象就是这个对象的构造函数的原型属性(这里可能有点绕,直接上图).

由于任何函数都具有原型属性prototype,并且这个原型属性具有一个默认属性 constructor,它是这个函数的引用,看下面的代码

  function Person(){

      this.name = 'pawn';

  }

  console.log(Person.prototype.constructor === Person);   //true

发现,这两个东西其实一个东西

但是,在某些情况下,需要这么写

  function Person(){

      this.name = 'pawn';

  }

  Person.protype = {

      XX: ... ,

      xx: ... ,

      ...

  }

这么做,就会覆盖原本的 protype 方法,那么construcor 就不存在了,这是,必须要显示的申明这个对象

  Person.protype = {

      construction: Person,

      XX: ... ,

      xx: ... ,

      ...

  }

在jQuery的中,就是这么做的,

  jQuery.fn = jQuery.prototype = {

    constructor: jQuery,

    init: function( selector, context, rootjQuery ) {

        var match, elem;

关于 jQuery对象封装的方式也是非常值得研究

注意,这里已经不是熟悉 [object Object],而是已经重写了.

也就是,如果调用一个函数的toString() 方法.那么就会打印这个函数的函数体.

如何通过构造函数来获得变量的类型?

判断是否是基本类型

   var getType = function(obj){

       if(obj == null){

          return String(obj);

       }

       if(typeof obj === 'object' || typeof obj === 'fucntion'){

           ...

       }else{

           // 如果不是引用类型,那么就是基本类型

           return typeof obj

       }

   }

如果是对象或者函数类型

   function Person(){

       this.name = 'pawn';

   }

   var p = new Person();

   console.log(p.constructor);   //返回function Person(){...}

现在要做的事 : 如何将Person 提取出来呢?
毋庸置疑,字符串切割那一套肯定可以办到,但是太 low 啦!
这里,我使用正则将Person提取出来

   var regex = /function\s(.+?)\(/

   function Person(){

    this.name = 'pawn';

   }

   var p = new Person();

   var c = p.constructor

   var regex = /function\s(.+?)\(/;

   console.log('|' + regex.exec(c)[1] + '|');

其实,除了上面的正则,每个函数还有一个name属性,返回函数名,但是ie8 是不支持的.

因此上面的代码可以写为:

var getType = function(obj){

    if(obj == null){

        return String(obj);

    }

    if(typeof obj === 'object' || typeof obj === 'function'){

        var constructor = obj.constructor;

        if(constructor && constructor.name){

            return constructor.name;

        }

        var regex = /function\s(.+?)\(/;

        return regex.exec(c)[1];

    }else{

        // 如果不是引用类型,那么就是基本;类型

        return typeof obj;

    }

};

但是上面的代码太丑啦,将其简化

简化

var getType = function(obj){

    if(obj == null){

        return String(obj);

    }

    if(typeof obj === 'object' || typeof obj === 'function'){

        return obj.constructor && obj.constructor.name.toLowerCase() ||

          /function\s(.+?)\(/.exec(obj.constructor)[1].toLowerCase();

    }else{

        // 如果不是引用类型,那么就是基本类型

        return typeof obj;

    }

};

还是比较麻烦,继续简化

var getType = function(obj){

    if(obj == null){

       return String(obj);

    }

    return typeof obj === 'object' || typeof obj === 'function' ?

      obj.constructor && obj.constructor.name && obj.constructor.name.toLowerCase() ||

          /function\s(.+?)\(/.exec(obj.constructor)[1].toLowerCase():

      typeof obj;

};

好了,已经全部弄完了,写个代码测试一下:

function Person(){

    this.name = 'pawn';

}

var p = new Person();

console.log(getType(p));

console.log(getType(1));

console.log(getType("a"));

console.log(getType(false));

console.log(getType(/123/));

console.log(getType({}));

console.log(getType(function(){}));

console.log(getType(new Date()));

console.log(getType(new Error()));

console.log(getType( null));

console.log(getType( undefined));

1.有时会看到Object.prototype.toString.call()

2.toString()是一个怎样的方法,他定义在哪里呢？

3.call.apply.bind可以吗？

4.为神马要去call呢？用 Object.prototype.toString.call(obj) 而不用 obj.toString() 呢？

<!DOCTYPE html>

<html>

    <head>

        <meta charset="UTF-8">

        <title></title>

        <script type="text/javascript">

            function A(){

                this.say=function(){

                    console.log("我是1");

                }

            }

            function B(){

                this.say=function(){

                    console.log("我是2");

                }

            }

            var a=new A();

            var b=new B();

            a.say.call(b);    //我是1

        </script>

    </head>

    <body>

    </body>

</html>

<!DOCTYPE html>

<html>

    <head>

        <meta charset="UTF-8">

        <title></title>

        <script type="text/javascript">

            function A(){

                this.name='SB';

                this.say=function(){

                    console.log("我是1");

                }

            }

            function B(){

                A.call(this);   //B继承A，重写say方法

                this.say=function(){

                    console.log("我是2");

                }

            }

            var a=new A();

            var b=new B();

            console.log(b.name);  //SB

            b.say();         //我是2

            a.say.call(b);    //我是1

        </script>

    </head>

    <body>

    </body>

</html>

就是怕你重写了toString,所以才要用object 最原始的他toString,所以才去call。

5.Object.prototype.toString方法的原理是什么？

参考链接：http://www.jb51.net/article/79941.htm

在JavaScript中,想要判断某个对象值属于哪种内置类型,最靠谱的做法就是通过Object.prototype.toString方法.

12var arr = [];console.log(Object.prototype.toString.call(arr)) //"[object Array]"

本文要讲的就是,toString方法是如何做到这一点的,原理是什么.

ECMAScript 3

在ES3中,Object.prototype.toString方法的规范如下:

115.2.4.2 Object.prototype.toString()

在toString方法被调用时,会执行下面的操作步骤:

1. 获取this对象的[[Class]]属性的值.

2. 计算出三个字符串"[object ", 第一步的操作结果Result(1), 以及 "]"连接后的新字符串.

3. 返回第二步的操作结果Result(2).

[[Class]]是一个内部属性,所有的对象(原生对象和宿主对象)都拥有该属性.在规范中,[[Class]]是这么定义的

[[Class]]一个字符串值,表明了该对象的类型.

然后给了一段解释:

所有内置对象的[[Class]]属性的值是由本规范定义的.所有宿主对象的[[Class]]属性的值可以是任意值,甚至可以是内置对象使用过的[[Class]]属性的值.[[Class]]属性的值可以用来判断一个原生对象属于哪种内置类型.需要注意的是,除了通过Object.prototype.toString方法之外,本规范没有提供任何其他方式来让程序访问该属性的值(查看 15.2.4.2).

也就是说,把Object.prototype.toString方法返回的字符串,去掉前面固定的"[object "和后面固定的"]",就是内部属性[[class]]的值,也就达到了判断对象类型的目的.jQuery中的工具方法$.type(),就是干这个的.

在ES3中,规范文档并没有总结出[[class]]内部属性一共有几种,不过我们可以自己统计一下,原生对象的[[class]]内部属性的值一共有10种.分别是:"Array", "Boolean", "Date", "Error", "Function", "Math", "Number", "Object", "RegExp", "String".

ECMAScript 5

在ES5.1中,除了规范写的更详细一些以外,Object.prototype.toString方法和[[class]]内部属性的定义上也有一些变化,Object.prototype.toString方法的规范如下:

15.2.4.2 Object.prototype.toString ( )

在toString方法被调用时,会执行下面的操作步骤:

如果this的值为undefined,则返回"[object Undefined]".

如果this的值为null,则返回"[object Null]".

让O成为调用ToObject(this)的结果.

让class成为O的内部属性[[Class]]的值.

返回三个字符串"[object ", class, 以及 "]"连接后的新字符串.

可以看出,比ES3多了1,2,3步.第1,2步属于新规则,比较特殊,因为"Undefined"和"Null"并不属于[[class]]属性的值,需要注意的是,这里和严格模式无关(大部分函数在严格模式下,this的值才会保持undefined或null,非严格模式下会自动成为全局对象).第3步并不算是新规则,因为在ES3的引擎中,也都会在这一步将三种原始值类型转换成对应的包装对象,只是规范中没写出来.ES5中,[[Class]]属性的解释更加详细:

所有内置对象的[[Class]]属性的值是由本规范定义的.所有宿主对象的[[Class]]属性的值可以是除了"Arguments", "Array", "Boolean", "Date", "Error", "Function", "JSON", "Math", "Number", "Object", "RegExp", "String"之外的的任何字符串.[[Class]]内部属性是引擎内部用来判断一个对象属于哪种类型的值的.需要注意的是,除了通过Object.prototype.toString方法之外,本规范没有提供任何其他方式来让程序访问该属性的值(查看 15.2.4.2).

和ES3对比一下,第一个差别就是[[class]]内部属性的值多了两种,成了12种,一种是arguments对象的[[class]]成了"Arguments",而不是以前的"Object",还有就是多个了全局对象JSON,它的[[class]]值为"JSON".第二个差别就是,宿主对象的[[class]]内部属性的值,不能和这12种值冲突,不过在支持ES3的浏览器中,貌似也没有发现哪些宿主对象故意使用那10个值.

ECMAScript 6

ES6目前还只是工作草案,但能够肯定的是,[[class]]内部属性没有了,取而代之的是另外一个内部属性[[NativeBrand]].[[NativeBrand]]属性是这么定义的:

内部属性属性值描述
[[NativeBrand]]枚举NativeBrand的一个成员.该属性的值对应一个标志值(tag value),可以用来区分原生对象的类型.

[[NativeBrand]]属性的解释:

[[NativeBrand]]内部属性用来识别某个原生对象是否为符合本规范的某一种特定类型的对象.[[NativeBrand]]内部属性的值为下面这些枚举类型的值中的一个:NativeFunction, NativeArray, StringWrapper, BooleanWrapper, NumberWrapper, NativeMath, NativeDate, NativeRegExp, NativeError, NativeJSON, NativeArguments, NativePrivateName.[[NativeBrand]]内部属性仅用来区分区分特定类型的ECMAScript原生对象.只有在表10中明确指出的对象类型才有[[NativeBrand]]内部属性.

表10 — [[NativeBrand]]内部属性的值

属性值对应类型
NativeFunctionFunction objects
NativeArrayArray objects
StringWrapperString objects
BooleanWrapperBoolean objects
NumberWrapperNumber objects
NativeMathThe Math object
NativeDateDate objects
NativeRegExpRegExp objects
NativeErrorError objects
NativeJSONThe JSON object
NativeArgumentsArguments objects
NativePrivateNamePrivate Name objects

可见,和[[class]]不同的是,并不是每个对象都拥有[[NativeBrand]].同时,Object.prototype.toString方法的规范也改成了下面这样:

15.2.4.2 Object.prototype.toString ( )

在toString方法被调用时,会执行下面的操作步骤:

如果this的值为undefined,则返回"[object Undefined]".

如果this的值为null,则返回"[object Null]".

让O成为调用ToObject(this)的结果.

如果O有[[NativeBrand]]内部属性,让tag成为表29中对应的值.

否则

让hasTag成为调用O的[[HasProperty]]内部方法后的结果,参数为@@toStringTag.

如果hasTag为false,则让tag为"Object".

否则,

让tag成为调用O的[[Get]]内部方法后的结果,参数为@@toStringTag.

如果tag是一个abrupt completion,则让tag成为NormalCompletion("???").

让tag成为tag.[[value]].

如果Type(tag)不是字符串,则让tag成为"???".

如果tag的值为"Arguments", "Array", "Boolean", "Date", "Error", "Function", "JSON", "Math", "Number", "Object", "RegExp",或

者"String"中的任一个,则让tag成为字符串"~"和tag当前的值连接后的结果.

返回三个字符串"[object ", tag, and "]"连接后的新字符串.

表29 — [[NativeBrand]] 标志值

[[NativeBrand]]值标志值
NativeFunction"Function"
NativeArray"Array"
StringWrapper"String"
BooleanWrapper"Boolean"
NumberWrapper"Number"
NativeMath"Math"
NativeDate"Date"
NativeRegExp"RegExp"
NativeError"Error"
NativeJSON"JSON"
NativeArguments"Arguments"

可以看到,在规范上有了很大的变化,不过对于普通用户来说,貌似感觉不到.

也许你发现了,ES6里的新类型Map,Set等,都没有在表29中.它们在执行toString方法的时候返回的是什么?

console.log(Object.prototype.toString.call(Map())) //"[object Map]"

console.log(Object.prototype.toString.call(Set())) //"[object Set]"

其中的字符串"Map"是怎么来的呢:

15.14.5.13 Map.prototype.@@toStringTag

@@toStringTag 属性的初始值为字符串"Map".

由于ES6的规范还在制定中,各种相关规定都有可能改变,所以如果想了解更多细节.看看下面这两个链接,现在只需要知道的是:[[class]]没了,使用了更复杂的机制.

以上所述是小编给大家分享的JavaScript中Object.prototype.toString方法的原理，希望对大家有所帮助！

附加：

关于JS中原型链中的prototype与_proto_的个人理解与详细总结

一直认为原型链太过复杂，尤其看过某图后被绕晕了一整子，今天清理硬盘空间（渣电脑），偶然又看到这图，勾起了点回忆，于是索性复习一下原型链相关的内容，表达能力欠缺逻辑混乱别见怪（为了防止新人__（此处指我）__被在此绕晕，图片就放在末尾了。）

以下三点需要谨记

1.每个对象都具有一个名为__proto__的属性；

2.每个构造函数（构造函数标准为大写开头，如Function()，Object()等等JS中自带的构造函数，以及自己创建的）都具有一个名为prototype的方法（注意：既然是方法，那么就是一个对象（JS中函数同样是对象），所以prototype同样带有__proto__属性）；

3.每个对象的__proto__属性指向自身构造函数的prototype；

思路扩展如下

 1             function Fun(){

 2             }

 3 //            我创造了一个函数Fn

 4 //            这个函数由Function生成（Function作为构造函数）

 5             var fn=new Fun()

 6 //            我创建了一个函数fn

 7 //            这个函数由Fn生成（Fn作为构造函数)

 8

 9

10             console.log(fn.__proto__===Fun.prototype)    //true

11 //            fn的__proto__指向其构造函数Fun的prototype

12             console.log(Fun.__proto__===Function.prototype)        //true

13 //            Fun的__proto__指向其构造函数Function的prototype

14             console.log(Function.__proto__===Function.prototype)    //true

15 //            Function的__proto__指向其构造函数Function的prototype

16 //            构造函数自身是一个函数，他是被自身构造的

17             console.log(Function.prototype.__proto__===Object.prototype)    //true

18 //            Function.prototype的__proto__指向其构造函数Object的prototype

19 //            Function.prototype是一个对象,同样是一个方法,方法是函数,所以它必须有自己的构造函数也就是Object

20             console.log(Fun.prototype.__proto__===Object.prototype)         //true

21 //             与上条相同

22 //             此处可以知道一点,所有构造函数的的prototype方法的__都指向__Object.prototype(除了....Object.prototype自身)

23             console.log(Object.__proto__===Function.prototype)        //true

24 //            Object作为一个构造函数(是一个函数对象!!函数对象!!),所以他的__proto__指向Function.prototype

25             console.log(Object.prototype.__proto__===null)        //true

26 //            Object.prototype作为一切的源头,他的__proto__是null

27

28 //            下面是一个新的,额外的例子

29

30             var obj={}

31 //            创建了一个obj

32             console.log(obj.__proto__===Object.prototype)        //true

33 //            obj作为一个直接以字面量创建的对象，所以obj__proto__直接指向了Object.prototype，而不需要经过Function了！！

34

35 //            下面是根据原型链延伸的内容

36 //            还有一个上文并未提到的constructor,  constructor在原型链中,是作为对象prototypr的一个属性存在的,它指向构造函数（由于主要讲原型链，这个就没在意、）；

37

38             console.log(obj.__proto__.__proto__===null)        //true

39             console.log(obj.__proto__.constructor===Object)        //true

40             console.log(obj.__proto__.constructor.__proto__===Function.prototype)        //true

41             console.log(obj.__proto__.constructor.__proto__.__proto__===Object.prototype)    //true

42             console.log(obj.__proto__.constructor.__proto__.__proto__.__proto__===null)        //true

43             console.log(obj.__proto__.constructor.__proto__.__proto__.constructor.__proto__===Function.prototype)    //true

44

45

46 //            以上，有兴趣的可以一一验证　　F12搞起.

为了方便记忆可以得出如下结论（如有错误欢迎斧正.....）

prototype是构造函数独有的属性；

对象的__prototype__属性通常与其构造函数的prototype属性相互对应；

所有构造函数的的prototype方法的__都指向__Object.prototype(除了....Object.prototype自身)；

需要注意的指向是

Function的__proto__指向其构造函数Function的prototype；

Object作为一个构造函数(是一个函数对象!!函数对象!!),所以他的__proto__指向Function.prototype；

Function.prototype的__proto__指向其构造函数Object的prototype；

Object.prototype的__prototype__指向null（尽头）；

在文章结构顺便附送上俩个与原型链相关的方法....欢迎使用

hasOwnProperty判断一个对象是否有名称的属性或对象，此方法无法检查该对象的原型链中是否具有该属性，该属性必须是对象本身的一个成员。

如果该属性或者方法是该对象自身定义的而不是器原型链中定义的则返回true;否则返回false;

格式如下：

object.hasOwnProperty(proName); 　　
括号内必须要加引号，并且直接写入属性名

isPrototypeOf是用来判断指定对象object1是否存在于另一个对象object2的原型链中，是则返回true，否则返回false。

格式如下：

object1.isPrototypeOf(object2);

object1是一个对象的实例；

object2是另一个将要检查其原型链的对象。

原型链可以用来在同一个对象类型的不同实例之间共享功能。

如果 object2 的原型链中包含object1，那么 isPrototypeOf 方法返回 true。

如果 object2 不是一个对象或者 object1 没有出现在 object2 中的原型链中，isPrototypeOf 方法将返回 false。

某图在这里　　ps：本文是总结，加个人理解.....图是好久前留存在电脑的....忘了是在哪看到的...

JS类型判断typeof PK {}.toString.call(obj)的更多相关文章

js类型判断：typeof与instanceof
typeof用以获取一个变量或者表达式的类型,typeof一般只能返回如下几个结果: number,boolean,string,function(函数),object(NULL,数组,对象),und ...
数据类型的判断 --Object.prototype.toString.call(obj)精准检测对象类型
数据类型的判断 typeof typeof返回一个表示数据类型的字符串,返回结果包括:number.boolean.string.symbol.object.undefined.function等7种 ...
类型和原生函数及类型转换（二：终结js类型判断）
typeof instanceof isArray() Object.prototype.toString.call() DOM对象与DOM集合对象的类型判断一.typeof typeof是一个一元 ...
看jquery3.3.1学js类型判断的技巧
需要预习:call , typeof, js数据类型 1. isFunction中typeof的不靠谱源码: var isFunction = function isFunction( obj ) ...
JS类型判断&原型链
JS类型检测主要有四种 1.typeof Obj 2.L instanceof R 3.Object.prototype.toString.call/apply(); 4.Obj.constructo ...
JavaScript 类型判断 —— typeof 以及 instanceof 中的陷阱
JavaScript中基本类型包含Undefined.Null.Boolean.Number.String以及Object引用类型.基本类型可以通过typeof来进行检测,对象类型可以通过instan ...
js类型判断-丰富加好用
一, 自己有时候写一些东西,要做类型判断,还有测试的时候,对于原生的和jQuery中的类型判断,实在不敢恭维,所以就写了一个好用的类型判断,一般情况都够用的. function test(type) ...
js类型判断及鸭式辨型
目录 instanceof constructor 构造函数名字鸭式辨型三种检测对象的类方式: instanceof.constructor .构造函数名字用法如下: 1)instanceof ...
JavaScript的三种类型检测typeof , instanceof , toString比较
1.typeof typeof是js的一个操作符,在类型检测中,几乎没有任何用处. typeof 返回一个表达式的数据类型的字符串,返回结果为javascript中的基本数据类型,包括:number. ...

随机推荐

JS中类型检测方式
在js中的类型检测目前我所知道的是三种方式,分别有它们的应用场景: 1.typeof:主要用于检测基本类型. typeof undefined;//=> undefined typeof 'a' ...
memcached结合php以及memcache共享session
//安装php的memcache扩展一.使用php自带的pecl安装程序 [root@localhost src]# /usr/local/php/bin/pecl install memcache ...
cpu占用高 20180108
1.top 中的mysql占用高,在mysql中开启慢查询,用tail -f 监控慢查询日志,发现是有表的索引不合理: 2.top 中的php_fpm的进程数高,修改了一下php_fpm的配置文件p ...
Redis -- 过期时间和缓存例子
1.设置 key的生存时间,过期自动删除 exprire key seconds 设置过期时间秒数 ttl key 查询剩余时间如果设置了过期时间.对key进行 set 操作,会清除 ...
leetcode 之Remove Nth Node From End of List（19）
这题比较简单,方法有很多.其中一种比较有意思的做法是设置两个指针,一个先走n步,然后再一起走.一个到了末尾,另一个也就确定了要删除元素的位置. ListNode *removeNthFromEnd(L ...
linux命令（4）：vmstat命令
CPU监控如下: vmstat 2 10 //表示每隔2秒运行10次内存监控如下: vmstat –s 监控进程及CPU.内存状态如下: top
[译]怎样用HTML5 Canvas制作一个简单的游戏
这是我翻译自LostDecadeGames主页的一篇文章,原文地址:How To Make A Simple HTML5 Canvas Game. 下面是正文: 自从我制作了一些HTML5游戏(例如C ...
微信小程序实战篇-图片的预览、二维码的识别
开篇今天,做的小程序项目要求,个人中心的客服图片在用户长按时可以识别其二维码,各种翻阅查找,采坑很多,浪费了很多时间,在这里记录下需要注意的点,以及对小程序官方提供的API做一个正确和清晰的认知,希 ...
【转载】JAVA多线程和并发基础面试问答
转载自这里. 多线程和并发问题是Java技术面试中面试官比较喜欢问的问题之一.在这里,从面试的角度列出了大部分重要的问题,但是你仍然应该牢固的掌握Java多线程基础知识来对应日后碰到的问题.(校对注: ...
Apache配置基于端口号的虚拟主机 Apache virtual host configuration is based on the port
有可能只有一个ip出口,但却有多个项目,那么就需要基于端口号架设虚拟主机. Step 1: 检查是否开启 httpd-vhosts.conf apache/conf/httpd.conf文件 # Vi ...

JS类型判断typeof PK {}.toString.call(obj)

参考链接：https://www.talkingcoder.com/article/6333557442705696719

先看typeof

再看看constructor 和 instanceof

再看看{}.toString.call(obj)

使用jQuery中的方法$.type()

但是 jQuery.type 有一个很大的缺陷

通过构造函数来获取类型

1.有时会看到Object.prototype.toString.call()

2.toString()是一个怎样的方法,他定义在哪里呢？

3.call.apply.bind可以吗？

4.为神马要去call呢？用 Object.prototype.toString.call(obj) 而不用 obj.toString() 呢？

就是怕你重写了toString,所以才要用object 最原始的他toString,所以才去call。

5.Object.prototype.toString方法的原理是什么？

关于JS中原型链中的prototype与_proto_的个人理解与详细总结

JS类型判断typeof PK {}.toString.call(obj)的更多相关文章

随机推荐

热门专题