constructor 与 object

对象的constructor属性引用了该对象的构造函数.对于 Object 对象，该指针指向原始的 Object() 函数.如下

var obj = {};
obj.constructor    //ƒ Object() { [native code] }
obj.constructor == Object    //true

var arr = [];
arr.constructor    //ƒ Array() { [native code] }
arr.constructor == Array    //true

function Fun(){
    console.log('function');
}
var fun = new Fun();    //实例化
fun.constructor    //ƒ Fun(){console.log('function')}    【打印出来的引用是Fun函数，说明fun的引用是Fun函数】
Fun.constructor    //ƒ Function() { [native code] }      【打印出来的引用是Funcion函数，说明Fun的引用是Function函数】
fun.constructor == Fun    //true    【再次证明fun的constructor属性引用了fun对象的构造函数】
fun.constructor == Fun.constructor    //false
--------------------- 
 

constructor常用于判断未知对象的类型,如下:

function isArray (val){
    var isTrue = typeof val == 'object' && val.constructor == Array;
    return isTrue?true:false;
}
var arr = isArray([1,2,3,4,5]);
console.log(arr);    //true
1
--------------------- 
作者：汪洋啊 
来源：CSDN 
原文：https://blog.csdn.net/wyangonly/article/details/79089881 
版权声明：本文为博主原创文章，转载请附上博文链接！

原文：https://blog.csdn.net/wyangonly/article/details/79089881 

Object:object是js自带的函数对象,可以有属性和方法。

在定义以后，不能在使用new创建对象实例，可以复制给其他变量，多个变量同时引用一个对象，或者克隆对象。具有多态性，无法继承，除非用复制的方式来实现

（1）Object.assign()

可以用作对象的复制

var obj = { a: 1 };

var copy = Object.assign({}, obj);

console.log(copy); // { a: 1 }

可以用作对象的合并 

var o1 = { a: 1 };

var o2 = { b: 2 };

var o3 = { c: 3 };

var obj = Object.assign(o1, o2, o3);

console.log(obj); // { a: 1, b: 2, c: 3 }

console.log(o1);  // { a: 1, b: 2, c: 3 }, 注意目标对象自身也会改变。

（2）Object.is() 

Object.is('haorooms', 'haorooms');     // true

Object.is(window, window);   // true

Object.is('foo', 'bar');     // false

Object.is([], []);           // false

var test = { a: 1 };

Object.is(test, test);       // true

Object.is(null, null);       // true

// 特例

Object.is(0, -0);            // false

Object.is(-0, -0);           // true

Object.is(NaN, 0/0);         // true

（3）Object.keys()

这个方法会返回一个由给定对象的自身可枚举属性组成的数组，数组中属性名的排列顺序和使用 for...in 循环遍历该对象时返回的顺序一致 （两者的主要区别是 一个 for-in 循环还会枚举其原型链上的属性）。

/* 类数组对象 */

var obj = { 0 : "a", 1 : "b", 2 : "c"};

alert(Object.keys(obj));

// 弹出"0,1,2"

/* 具有随机键排序的数组类对象 */

var an_obj = { 100: 'a', 2: 'b', 7: 'c' };

console.log(Object.keys(an_obj));

// console: ['2', '7', '100']

（4）Object.create() 

Object.create(proto, [ propertiesObject ])

第二个参数是可选的，主要用于指定我们创建的对象的一些属性，

例：ar o;

o = Object.create(Object.prototype, {

  // foo会成为所创建对象的数据属性

  foo: { writable:true, configurable:true, value: "hello" },

  // bar会成为所创建对象的访问器属性

  bar: {

    configurable: false,

    get: function() { return 10 },

    set: function(value) { console.log("Setting `o.bar` to", value) }

}})

 

// 创建一个以另一个空对象为原型,且拥有一个属性p的对象

o = Object.create({}, { p: { value: 42 } })

// 省略了的属性特性默认为false,所以属性p是不可写,不可枚举,不可配置的:

o.p = 24

o.p

//42

o.q = 12

for (var prop in o) {

   console.log(prop)

}

//"q"

delete o.p

//false

//创建一个可写的,可枚举的,可配置的属性p

o2 = Object.create({}, { p: { value: 42, writable: true, enumerable: true, configurable: true } });