• constructor&object 的联系与对比


    constructor&object 的联系与区别

    构造函数与对象

    构造函数是类中的特殊成员函数,用于为对象分配内存。它可用于为数据成员提供值。创建对象时将调用构造函数。它与类具有相同的名称。构造函数不返回任何值。

    构造函数是生成对象的模板,一个构造函数可以生成多个对象,每个对象都有相同的结构。 构造函数的缺点就是,每当你实例化两个对象时,需要调用两次构造函数的某一个方法,这带来的坏处就是占用内存,而且没必要。
    其次,为了解决构造函数的属性和方法无法被对象实例所共享的问题,我们可以把需要共享的属性和方法放在原型(prototype)对象上。原型对象上的所有属性和方法,都会被对象实例所共享。对于构造函数来说,prototype是作为构造函数的属性;对于对象实例来说,prototype是对象实例的原型对象。所以prototype即是属性,又是对象。
    然后,除了undefined和null之外,每一个数据类型都可以看成一个对象,每一个对象都有它的原型。所有一切对象的原型顶端,都是Object.prototype,即Object构造函数的prototype属性指向的那个对象。当然,Object.prototype对象也有自己的原型对象,那就是没有任何属性和方法的null对象,而null对象没有自己的原型。
    原型链的特点有:
    a:读取对象的某个属性时,JavaScript引擎先寻找对象本身的属性,如果找不到,就到它的原型去找,如果还是找不到,就到原型的原型去找。如果直到最顶层的Object.prototype还是找不到,则返回undefined。
    b:如果对象自身和它的原型,都定义了一个同名属性,那么优先读取对象自身的属性,这叫做“覆盖”(overiding)。
    c:一级级向上在原型链寻找某个属性,对性能是有影响的。所寻找的属性在越上层的原型对象,对性能的影响越大。如果寻找某个不存在的属性,将会遍历整个原型链。
    再次,constructor属性是原型对象上的一个属性,可以被所有实例对象所共享。要注意的是,prototype是构造函数的属性,而constructor则是构造函数的prototype属性所指向的那个对象,也就是原型对象的属性。由于constructor属性是一种原型对象和构造函数的关系,所以在修改原型对象的时候,一定要注意constructor的指向问题。
    最后,instanceof运算符返回一个布尔值,用于判断对象是否为某个构造函数的实例。

      任何函数都是构造函数,如果通过new就可以得到一个对象。通过函数不同的上下文调用分下面几种:
    (1). 当在一个函数调用之前有new关键字,则上下文为新建的对象;
    //任何函数可以new 创建一个对象
    (2). 当一个函数使用call或者apply调用时,给定的第一个参数即为上下文;
    //构造方法中可以写成员方法。然后通过对象来调用
    (3). 否则,如果一个函数作为一个对象的属性(obj.func)或者obj['func'])来调用时,它就把该对象作为上下文来运行;
    //上边new fun2()没意义,直接 fun2()调用,这里在全局上下文运行
    (4)如果与上述几条都不符的话,则函数将在全局上下文中运行。

    Constructor:是用于创建和初始化类中创建的一种特殊方法。constructor属性返回对创建此对象的数组函数的引用。 

     语法

    object.constructor

    constructor([arguments])

     { ... }

    派生类构造函数:

    Constructor(.....args){

    Super(...args);

    }

     

    在一个类中只能有一个名为 “constructor” 的特殊方法。 一个类中出现多次构造函数 (constructor)方法将会抛出一个 SyntaxError 错误。

    在一个构造方法中可以使用super关键字来调用一个父类的构造方法。

    如果没有显式指定构造方法,则会添加默认的 constructor 方法。

    如果不指定一个构造函数(constructor)方法, 则使用一个默认的构造函数(constructor)。

    <script type="text/javascript">

    var test=new Array();

    if (test.constructor==Array)

    {

    document.write("This is an Array");

    }

    if (test.constructor==Boolean)

    {

    document.write("This is a Boolean");

    }

    if (test.constructor==Date)

    {

    document.write("This is a Date");

    }

    if (test.constructor==String)

    {

    document.write("This is a String");

    }

    </script>

    输出:

    This is an Array

    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 } });

  • 相关阅读:
    美团面试准备
    SSM实战项目——Java高并发秒杀API
    接口和抽象类有什么区别
    Java中static、final、static final的区别
    多线程面试题
    idea新建maven项目没有src目录
    聊聊MyBatis缓存机制
    Java 8系列之重新认识HashMap
    数据库SQL实战练习
    牛客网刷题(一)
  • 原文地址:https://www.cnblogs.com/yyqxlcx/p/9930334.html
Copyright © 2020-2023  润新知