可见, 使用typeof操作符和constucor属性检测对象类型返回值是存在差异的.

typeof

typeof会返回一个变量的基本类型,只有以下几种:

string、number、boolean、undefined、object、function

例:

alert(typeof(“abc”));//string

alert(typeof(1));//number

alert(typeof(true));//boolean

alert(typeof(m));//undefined

alert(typeof(null));//object

alert(typeof([]));//object

var arr=[“a”,”b”,”c”];

alert(typeof(arr));//object

var person = {firstName:”John”, lastName:”Doe”, age:50,
eyeColor:”blue”};

alert(typeof(person));//object

function a(){

console.log(“haha”);

}

alert(typeof(a));//function

上述例子无法用来区分null、对象、数组的变量类型,因为它们都会返回object,于是可以用下面两种方式

p2.showMsg();// ‘neuxs : 18’

复制代码 代码如下:

constructor 

constructor属性返回所有 JavaScript 变量的构造函数。

object.constructor

“John”.constructor                // 返回函数 String()  { [native
code] }

(3.14).constructor                // 返回函数 Number()  { [native
code] }

false.constructor                  // 返回函数 Boolean() { [native
code] }

[1,2,3,4].constructor              // 返回函数 Array()  { [native
code] }

{name:’John’, age:34}.constructor  // 返回函数 Object()  { [native
code] }

new Date().constructor            // 返回函数 Date()    { [native
code] }

function () {}.constructor        // 返回函数 Function(){ [native
code] }

this.name = name;

运行$node type.js得

javascript的基本数据类型:

p1.showMsg();// ‘neuxs : 18’

object:   function Object() { [native code]欧博国际平台, }
object:   function Array() { [native code] }
function: function Function() { [native code] }
string:   function String() { [native code] }
number:   function Number() { [native code] }
boolean:  function Boolean() { [native code] }
object:   function Object() { [native code] }
object:   function Person() { [native code] }

string、number、boolean、undefined、null、数组、对象

}

复制代码 代码如下:

判断一个变量的数据类型的方法:

throw new TypeError(callback + ‘ is not a function’);

有一点需要注意的是,
不同的浏览器对typeof操作符检测正则表达式会有所不同,IE和Firefox会返回’object’.

instanceof

instanceof运算符用来判断一个构造函数的prototype属性所指向的对象是否存在另外一个要检测对象的原型链上

obj instanceof Object;//true 实例obj在不在Object构造函数中

1.instanceof的普通的用法,obj instanceof Object
检测Object.prototype是否存在于参数obj的原型链上

function Person(){};

var p =new Person();

console.log(p instanceof Person);//true

2.继承中判断实例是否属于它的父类

function Person(){};

function Student(){};

var p =new Person();

Student.prototype=p;//继承原型

var s=new Student();

console.log(s instanceof Student);//true

console.log(s instanceof Person);//true

使用 delete 操作符删除了 p1.name,之前它保存的 “noa”
值屏蔽了同名的原型属性。把它删除以后,就恢复了对原型中 name 属性的连接。

好了,今天内容就先到这里了,小伙伴们如有疑问,就在下方留言吧。

执行构造函数中的代码(为这个新对象添加属性和方法),

function Person(name, age) {
 this.name = name;
 this.age = age;
}
var d = {an: ‘object’};
var a = [‘apple’, ‘banana’];
var f = function() {};
var s = ‘David’;
var n = 33;
var b = true;
var o = new Object();
var person = new Person(‘Mark’, 22);
console.log(typeof(d) + ‘: ‘ + d.constructor);
console.log(typeof(a) + ‘: ‘ + a.constructor);
console.log(typeof(f) + ‘: ‘ + f.constructor);
console.log(typeof(s) + ‘: ‘ + s.constructor);
console.log(typeof(n) + ‘: ‘ + n.constructor);
console.log(typeof(b) + ‘: ‘ + b.constructor);
console.log(typeof(o) + ‘: ‘ + o.constructor);
console.log(typeof(person) + ‘: ‘ + person.constructor);

name:’noa’,

您可能感兴趣的文章:

  • 全面解析JavaScript中“&&”和“||”操作符(总结篇)
  • 浅谈javascript中new操作符的原理
  • JavaScript中的操作符类型转换示例总结
  • JavaScript中的各种操作符使用总结
  • 总结JavaScript中布尔操作符||与&&的使用技巧
  • js中的内部属性与delete操作符介绍
  • JavaScript中诡异的delete操作符
  • javascript操作符”!~”详解
  • Javascript基础教程之比较操作符
  • JS之相等操作符详解

Person.prototype 重新设置为一个新对象。实例 p.constructor 属性不再指向
Person 了,而是指向 Object 构造函数。

*#type.js

function Person(){}

如果变量是数组, typeof操作符返回object, constructor属性返回Array;
如果变量是构造函数对象, typeof操作符返回object,
constructor属性返回该构造函数
每个变量都有其construcor属性, 这个属性不单单提供了这个是否对象,
还提供了这个对象是什么类型的对象. 总之,
constructor属性保存了一个指向对象的构造函数,
无论它是自定义的还是原生类型的对象.

console.log(this.name + ‘:’ + this.age);

o.name = name;

constructor是每一个实例对象都拥有的属性,而这个属性也相当于是一个指针,它指向于创建当前对象的对象。

p.showMsg();// ‘nexus : 18’

例子中新建了一个对象o,其中o对象有属性name和方法showMsg。

Person.prototype = {

p.sayHi();  // ‘hi’

返回新对象。

console.log(p1.friends === p2.friends);// false

console.log(this.name + ‘:’ + this.age);

this.friends = [‘a’, ‘b’];

Person.prototype.showMsg = function(){

if (this == null) {

console.log(p.showMsg());// ‘nexus : 18’

// 当作构造函数使用,新建一个对象p

console.log(p1.name);// ‘nexus’,来自原型

}

console.log(this.name + ‘:’ + this.age);

}

Person.prototype.name = ‘nexus’;

p1.friends.push(‘c’);

console.log(p.age);// 18

创建两个完成同样任务的 showMsg
方法没有必要,这个时候就需要使用prototype。

console.log(o instanceof Function);// false

if (!Array.prototype.map) {

console.log(this.name + ‘:’ + this.age);

this.name = name;

// 当 k < len 时,执行循环

throw new TypeError(‘Array.prototype.map called on null or undefined’);

console.log(p instanceof Person);      // true

Person.prototype.age = 18;

创建一个新对象,

将构造函数的作用域赋给新对象(因此 this 就指向了这个新对象),

console.log(‘hi’);

我们同样可以给原生对象添加方法,这里展示一下如何实现一个Array.prototype.map函数的原型方法。

// 在另一个对象的作用域中调用

this.showMsg = function(){

}

var o = {

Person.prototype.name = ‘nexus’;

console.log(o.name);// ‘nexus’

Person.prototype.name = ‘nexus’;

if (k in O) {

return o;

构造函数用于定义实例属性,而原型用于定义方法和共享的属性。

o.showMsg()就是运行o的showMsg函数,其中调用showMsg函数的宿主是o,所以此时的this是o,this.name也就是’nexus’,打印’my
name is nexus’。

Person.prototype.showMsg = function(){

console.log(p.name);// ‘nexus’

A[k] = mappedValue;

name:’nexus’, // 定义一个属性

window.showMsg();// ‘nexus : 18’

console.log(p instanceof Person);      // true

}

console.log(this.name + ‘:’ + this.age);

};

}

delete p1.name;

要创建 Person 的新实例,必须使用 new 操作符。

console.log(typeof c);// ‘boolean’

prototype 原型

function Person(){}

Person.prototype.age = 18;

};

name : ‘nexus’,

Person.prototype = {

从代码中看出 delete 操作符只能删除对象的实例name属性,无法删除原型的
name 属性。

通过 p.name
没有发生改变可以得出结论:调用构造函数时会为实例添加一个指向最初原型的
Prototype
指针,而把原型修改为另外一个对象就等于切断了构造函数与最初原型之间的联系。

console.log(p1.friends);// [‘a’,’b’,’c’]

console.log(p.age);// 18

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

// 返回新数组A

Person.prototype.name = ‘nexus’;

};

console.log(this.name + ‘:’ + this.age);

name : ‘nexus’,

var p = new Person();

var o = new Object();

}

}

while (k < len) {

Author

发表评论

电子邮件地址不会被公开。 必填项已用*标注