www.2527.com_澳门新葡8455手机版_新京葡娱乐场网址_
做最好的网站

Javascript原型和原型链,对象的应用Web前端

2019-08-30 11:55 来源:未知

javascript 原型、原型链、对象复制等规律和演示分析(下)

原型
原型是 JavaScript 面向对象天性中珍视的概念,也是豪门太熟练的概念。因为在绝非常多
数的面向对象语言中,对象是凭借类的(举个例子 Java 和 C ) ,对象是类实例化的结果。而在
JavaScript 语言中,未有类的概念
① ,对象由对象实例化。打个借使来讲,基于类的言语中类
就像五个模具,对象由那几个模具浇注产生,而依赖原型的言语中,原型就类似是一件艺术品
的原件,我们经过一台 百分百 正确的机器把这么些原件复制出比较多份。
前方小节的事例中都从未关联原型,仅仅通过构造函数和 new 语句生成类,让我们看
看怎么使用原型和构造函数共同转换对象。
function Person() {}
Person.prototype.name = ‘BYVoid’;
Person.prototype.showName = function() {
console.log(this.name);
};
var person = new Person();
person.showName();
上边这段代码应用了原型并不是构造函数开首化对象。 那样做与直接在构造函数内定义
品质有何分歧呢?
*构造函数钦点义的性质持续方式与原型不相同, 子对象须求显式调用父对象手艺承接构
造函数钦定义的质量。
构造函数钦点义的别的性质, 包蕴函数在内都会被重新创建, 同一个构造函数发生的
七个目的不分享实例。
**
构造函数内定义的函数有运转时闭包的支出, 因为构造函数内的一部分变量对里面定义
的函数来讲也是可知的。
下边这段代码可以申明以上难点:
function Foo() {
var innerVar = ‘hello’;
this.prop1 = ‘BYVoid’;
this.func1 = function() {
innerVar = ”;
};
}
Foo.prototype.prop2 = ‘Carbo’;
Foo.prototype.func2 = function() {
console.log(this.prop2);
};
var foo1 = new Foo();
var foo2 = new Foo();
console.log(foo1.func1 == foo2.func1); // 输出 false
console.log(foo1.func2 == foo2.func2); // 输出 true
就算,并不是说在构造函数内创设属性糟糕,而是两个各有合乎的限制。那么大家
怎样时候利用原型,哪天利用构造函数钦赐义来成立属性呢?
*除非必需用构造函数闭包,不然尽量用原型定义成员函数,因为这么能够减掉支出。
用尽了全力在构造函数钦点义一般成员, 尤其是指标或数组, 因为用原型定义的成员是八个
实例共享的。**
接下去,大家介绍一下JavaScript中的原型链机制。
原型链
JavaScript 中有三个例外的对象: Object 与 Function ,它们皆以构造函数,用于生
成靶子。 Object.prototype 是具备指标的祖先, Function.prototype 是全部函数的原
型,包罗构造函数。笔者把 JavaScript 中的对象分为三类,
一类是客户创建的目的,
一类是构造函数对象,
一类是原型对象。
顾客制造的目的,即一般意义上用 new 语句显式构造的靶子。
构造函数对象指的是平时的构造函数,即经过 new 调用调换普通对象的函数。
原型对象特指构造函数 prototype 属性指向的对象。
那三类对象中各类都有七个 proto 属性,它指向该目的的原型,从任何对象沿着它初叶遍历都得以追溯到 Object.prototype 。
构造函数对象有 prototype 属性,指向叁个原型对象,通过该构造函数创制对象时,被成立对象的 proto 属性将会指向构造函数的 prototype 属性。
原型对象有 constructor属性,指向它对应的构造函数。让我们透过上面那几个事例来明白原型:

function Foo() {}
Object.prototype.name = ‘My Object’;
Foo.prototype.name = ‘Bar’;
var obj = new Object();
var foo = new Foo();
console.log(obj.name); // 输出 My Object
console.log(foo.name); // 输出 Bar
console.log(foo.proto.name); // 输出 Bar
console.log(foo.proto.proto.name); // 输出 My Object
console.log(foo.proto.constructor.prototype.name); // 输出 Bar

大家定义了叁个叫做 Foo () 的构造函数,生成了目的 foo 。同时我们还各自给 Object和 Foo 生成原型对象。
下图解析了它们中间千头万绪的涉嫌。

Web前端 1

对象的复制
JavaScript 和 Java 同样都未有像C语言中一样的指针,全部目的类型的变量都是指向对
象的援引,八个变量之间赋值传递一个指标并不会对这么些指标开展复制,而只是传递引用。
某个时候我们需求总体地复制一个对象,那该怎么办吧? Java 语言中有 clone 方法能够实
现对象复制,但 JavaScript 中并未如此的函数。因而大家要求手动达成如此七个函数,三个
简轻易单的做法是复制对象的保有属性:< 喎?" target="_blank" class="keylink">vcD4NCjxwPk9iamVjdC5wcm90b3R5cGUuY2xvbmUgPSBmdW5jdGlvbigpIHs8YnIgLz4NCnZhciBuZXdPYmogPSB7fTs8YnIgLz4NCmZvciAodmFyIGkgaW4gdGhpcykgezxiciAvPg0KbmV3T2JqW2ldID0gdGhpc1tpXTs8YnIgLz4NCn08YnIgLz4NCnJldHVybiBuZXdPYmo7PGJyIC8 DQp9PGJyIC8 DQp2YXIgb2JqID0gezxiciAvPg0KbmFtZTogJmxzcXVvO2J5dm9pZCZyc3F1bzssPGJyIC8 DQpsaWtlczogWyZsc3F1bztub2RlJnJzcXVvO108YnIgLz4NCn07PGJyIC8 DQp2YXIgbmV3T2JqID0gb2JqLmNsb25lKCk7PGJyIC8 DQpvYmoubGlrZXMucHVzaCgmbHNxdW87cHl0aG9uJnJzcXVvOyk7PGJyIC8 DQpjb25zb2xlLmxvZyhvYmoubGlrZXMpOyAvLyDK5LP2IFsgJmxzcXVvO25vZGUmcnNxdW87LCAmbHNxdW87cHl0aG9uJnJzcXVvOyBdPGJyIC8 DQpjb25zb2xlLmxvZyhuZXdPYmoubGlrZXMpOyAvLyDK5LP2IFsgJmxzcXVvO25vZGUmcnNxdW87LCAmbHNxdW87cHl0aG9uJnJzcXVvOyBdPC9wPg0KPHA yc/D5rXEtPrC68rH0ru49rbUz/PHs7 9sbSjqHNoYWxsb3cgY29weaOptcTKtc/Wo6y8tNa7uLTWxrv5sb7A4NDNtcTK9NDUo6y2 DxiciAvPg0KubLP7bbUz/PA4NDNtcTK9NDUoaMgx7O/vbG0tcTOysziysc8c3Ryb25nPsG9uPa21M/zubLP7bbUz/PA4NDNtcTK9NDUPC9zdHJvbmc o6wgwP3I58nPwP3W0CBsaWtlcyDK9DxiciAvPg0K0NTWuM/ytcTKx82s0ru49sr91 mhozxiciAvPg0KyrXP1tK7uPbN6sirtcS4tNbGo6y78snuv72xtKOoZGVlcCBjb3B5o6myorK7ysfSu7z yN3S17XEysKjrNLyzqqz/cHLu/mxvsr9vt08YnIgLz4NCsDg0M2jrLu509C24NbWsrvNrLXEttTP86OsttTP88Tasr 7udPQuLTU07XEveG5uaOs0vK0y9Do0qrTw7Xduem1xLe9yr3AtMq1z9ajujwvcD4NCjxwPk9iamVjdC5wcm90b3R5cGUuY2xvbmUgPSBmdW5jdGlvbigpIHs8YnIgLz4NCnZhciBuZXdPYmogPSB7fTs8YnIgLz4NCmZvciAodmFyIGkgaW4gdGhpcykgezxiciAvPg0KaWYgKHR5cGVvZih0aGlzW2ldKSA9PSAmbHNxdW87b2JqZWN0JnJzcXVvOyA="| typeof(this[i]) == ‘function’) {
newObj[i] = this[i].clone();
} else {
newObj[i] = this[i];
}
}
return newObj;
};
Array.prototype.clone = function() {
var newArray = [];
for (var i = 0; i < this.length; i ) {
if (typeof(this[i]) == ‘object’ || typeof(this[i]) == ‘function’) {
newArray[i] = this[i].clone();
} else {
newArray[i] = this[i];
}
}
return newArray;

};
Function.prototype.clone = function() {
var that = this;
var newFunc = function() {
return that.apply(this, arguments);
};
for (var i in this) {
newFunc[i] = this[i];
}
return newFunc;
};
var obj = {
name: ‘byvoid’,
likes: [‘node’],
display: function() {
console.log(this.name);
},
};
var newObj = obj.clone();
newObj.likes.push(‘python’);
console.log(obj.likes); // 输出 [ ‘node’ ]
console.log(newObj.likes); // 输出 [ ‘node’, ‘python’ ]
console.log(newObj.display == obj.display); // 输出 false

下面那些达成看起来很圆满,它不仅仅递归地复制了指标复杂的组织,还完毕了函数的深
拷贝。这么些办法在大大多情景下都很好用,但有一种景况它却无力回天,举例上面包车型客车代码:
var obj1 = {
ref: null
};
var obj2 = {
ref: obj1
};
obj1.ref = obj2;
这段代码的逻辑极其轻便,就是多个相互引用的对象。当我们试图动用深拷贝来复制
obj1 和 obj第22中学的任何一个时,难点就应际而生了。因为深拷贝的做法是境遇对象就举办递归
复制,那么结果只好Infiniti循环下去。对于这种场馆,轻松的递归已经黔驴技穷缓慢解决,必需统一策画一
套**图论算法, 剖判对象之间的依赖关系, 创立一个拓扑结构图, 然后各自依次复制每个终端,
并再度营造它们中间的重视性关系**。

原型、原型链、对象复制等规律和示范分析(下) 原型 原型是 JavaScript 面向对象个性中重大的概念,也是豪门太熟习的定义。因为...

一、构造函数

function Foo(name, age) {

    this.name = name;

    this.age = age;

    this.class = 'class-1';

    //return this;    //私下认可有这一行

}

var foo = new Foo('zhangsan', 20);    //创制四个结构函数Foo的目的

介绍

二、构造函数——增加

语法糖

var a = {};    //var a = new Object();

var a = [];    //var a = new Array();

function Foo(){……}    //var Foo = new Function(……);

使用instanceof判断四个函数是还是不是是八个变量的构造函数

if (arr instanceof Array) {}

在javascript中, 数据类型首要分为原始类型和引用类型三种。而整个援用类型都来自于Object的正片。全体引用类型的原型链都能够追溯到 Object

三、5条原型法规

1、全数的援用类型(对象、数组、函数),都具备对象性格,就可以自由增添属性(除了“null”以外)

var obj = {};

obj.a = 100;

var arr = [];

arr.a = 100;

function fn() {}

fn.a = 100;

2、全体的援用类型(对象、数组、函数),都有三个__proto__(隐式原型)属性,属性值是三个普通对象

console.log(obj.__proto__);

console.log(arr.__proto__);

console.log(fn.__proto__);

3、全体的函数,都有一个prototype(显式原型)属性,属性值是贰个日常对象

console.log(fn.prototype);

4、全体的援用类型(对象、数组、函数),__proto__属性值指向它的构造函数的prototype属性值

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

5、当试图拿走八个指标的某些属性时,假设这么些目的变量本人并未有那一个性格,那么会去它的__proto__(即它的构造函数的prototype)中寻找

function Foo(name) {

    this.name;

}

Foo.prototype.alertName = function () {

    alert(this.name);

};

var foo = new Foo('zhangsan');

foo.printName = function (){

    console.log(this.name);

};

foo.printName();    //'zhangsan'

foo.alertName();    //'zhangsan'

this恒久指向实例自身

遍历对象自己的品质

高端浏览器已经在for...in中屏蔽了来自原型的属性,但最佳或然采用hasOwnProperty推断一下,保障程序的健壮性

var item;

for (item in f) {

    if (f.hasOwnProperty(item)) {

        console.log(item);

    }

}

Object 构造函数属性

四、原型链

去foo.__proto__.__proto__...中查找

Web前端 2

对象的__proto__品质即其构造函数的prototype属性引用

foo.__proto__ === Foo.prototype    //true

Foo.prototype.__proto__ === Object.prototype    //true

JavaScript 内置的一对构造函数有 Object, Function, Number, String, Boolean, Array, RegExp 等等, 它们首要有八个共有的属性。

五、原型链类instanceof

foo instanceof Foo的论断原理是:

foo的__proto__属性和Foo的prototype属性是不是是同三个援用

foo instanceof Foo的判别逻辑是:

foo的__proto__一层一层发展,能或不可能对应到Foo.prototype,再试着判定foo instance Object

foo instanceof Foo    //true

foo instanceof Object    //true

只要要咬定叁个指标是不是是一个构造函数生成的实例,使用constructor更稳重

foo.__proto__.constructor === Foo    //true

foo.__proto__.constructor === Object    //false

 

六、new贰个对象的经过

1、创立多个新指标,它一而再自Foo.prototype

2、试行函数,传入相应的参数,同不日常候上下文(this)被内定为那几个新实例

    在不传递任何参数的意况下,new Foo等同于new Foo()

3、假若构造函数再次回到了三个对象,那么这一个指标会顶替全部new出来的结果

    如果构造函数没有回去对像,那么new出来的结果为步骤1创办的目的

var new2 = function (func) {

    var o = Object.create(func.prototype);    //成立二个新指标

    var k = func.call();    //实行函数

    if (typeof k === 'object') {    //决断构造函数是或不是重返了三个目标

        return k;

    } else {

        return o;

    }

}

  • length 构造函数参数个数

  • prototype 构造函数原型对象

 

Object原型链

  • Object.getPrototypeOf

  • Object.isPrototypeOf

  • Object.hasOwnProperty

一体援引对象的原型都出自 Object.prototype

测验各样数据类型的援用意况

 

var a = {},

    b = [],

    c = function () {},

    d = Function,

    e = String;

[a, b, c, d, e].forEach(function (val) {

    // all return true

    console.log(val instanceof Object);

});

各类引用类型对象, 都满含二个原型属性__proto__, 它承担调节目的的原型属性和办法的查询利用

 

创办无Object.prototype的原型链对象

// method 1

var obj1 = Object.create(null);

 

// method 2

var obj2 = {};

Object.setPrototypeOf(obj2, null);

 

// method 3

var obj3 = {};

obj3.__proto__ = null;

 

[obj1, obj2, obj3].forEach(function (item) {

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

});

__proto__ 与 prototype

__proto__ 隐式原型, prototype 呈现原型. 

实例对象通过隐式原型__proto__ 相配找到相应的函数和属性. 而prototype是每一个构造函数都设有的多个属性。当中prototype 包括constructor属性

 

var o = {};

'__proto__' in o; // return true, 表达 字面量对象存在叁个隐式属性

 

// 钦命隐式属性

function Foo () {}

o.__proto__ = Foo.prototype;

 

o instanceof Foo; // return true

o instanceof Object; // return true

 

设置隐敝原型属性

var o = {};

'__proto__' in o;

 

function Foo () {}

function Bar () {}

Bar.prototype = new Foo();

Bar.prototype.constructor = Bar;

 

// 方法一, 直接设置 __proto__值

o.__proto__ = Foo.prototype;

console.log(o instanceof Foo); // return true;

 

// 方法二, 使用 setPrototypeOf

Object.setPrototypeOf(o, Bar.prototype); // 设置新原型

console.log(o instanceof Bar); // return true;

 

// 获取对象隐式属性

Object.getPrototypeOf(o) === Bar.prototype; // return true

 

// 检查原型 是不是存在于对象属性的链中

Bar.prototype.isPrototypeOf(o); // true

Foo.prototype.isPrototypeOf(o); // true

Object.prototype.isPrototypeOf(o); // true

 

获得对象的实例属性

  • Object.keys

  • Object.getOwnPropertyNames

// return []

Object.keys(Object.prototype)

 

// return ["constructor", "__defineGetter__", "__defineSetter__", "hasOwnProperty", "__lookupGetter__", "__lookupSetter__", "isPrototypeOf", "propertyIsEnumerable", "toString", "valueOf", "__proto__", "toLocaleString"]

Object.getOwnPropertyNames(Object.prototype)

Object.keys 重返多少个对象的实例可枚举属性, 假设使用了Object.defineProperty更换了指标的某部属性, 则不能够透过Object.keys再次回到属性进行遍历属性, 也心余力绌运用 for-in循环。

 

var obj = {

    foo: function () {}

};

 

// return ['foo']

Object.keys(obj);

 

Object.defineProperty(obj, 'foo', {

   enumerable: false

});

 

// return []

Object.keys(obj);

 

// empty loop

for (var name in obj) {

  console.log(name);

}

 

// return false

obj.hasOwnProperty('foo');

Object.getOwnPropertyNames() 再次回到自身实例属性名称, 无视enumerable: false

 

var obj = {

    foo: function () {},

    bar: 'hello world'

};

 

Object.defineProperty(obj, 'foo', {

    // foo 已被定义, 所以要求出示设置 false

    enumerable: false

});

 

Object.defineProperty(obj, 'foo2', {

    value: function () {},

    // foo2 未被定义, 暗许enumerable为false

    enumerable: true

});

 

// 'bar', 'foo2'

Object.keys(obj);

 

// 'foo', 'bar', 'foo2'

Object.getOwnPropertyNames(obj);

 

'foo' in obj // return true

in 操作符, 检查属性是不是在能够拿走, 无视属性

 

目的定义属性

  • Object.defineProperty

  • Object.getOwnPropertyDescriptor

质量描述相似是由enumrable, value, get, set, configurable, writeable, value 组成, 个中 get, set 与 value 为互斥关系

 

概念二个对象的陈说

var obj = Object.create(null);

 

Object.defineProperty(obj, 'foo', {

    value: 'foo',

    configurable: false,

    writeable: false,

    enumerable: false

});

 

obj.foo = 'change foo';

console.log(obj.foo); // still foo

 

Object.defineProperty(obj, 'foo', {

    writeable: true,

    configurable: true

});

 

obj.foo = 'change foo 2';

console.log(obj.foo); // still foo

'foo' in obj; // return true

  • 借使被定义了configureable: false, 那么继续再度defineProperty时不会收效。

  • writeable: false 的情状下, 不能修改属性的 value 值

 

特性描述中的 value 与 get, set

var obj = Object.create(null);

 

// throw Error 

// Uncaught TypeError: Invalid property descriptor. 

// Cannot both specify accessors and a value or writable attribute

Object.defineProperty(obj, 'foo', {

    value: 'foo',

    set: function (val) {

        // this 指向 obj

        this._foo = val;

    },

    get: function () {

        return this._foo;

    }

});

因为 value 与 get, set 为互斥关系, 所以无法同期实行定义。

 

writeable 与 get, set

var obj = Object.create(null);

 

Object.defineProperty(obj, 'foo', {

    // 失效

    writeable: false,

    set: function (val) {

        // this 指向 obj

        this._foo = val;

    },

    get: function () {

        return this._foo;

    }

});

 

obj.foo = 'abc'; // set()

obj._foo === obj.foo  // return true

console.log(obj.foo); // return 'abc'

'foo' in obj // return true

writeable 失效, 不大概对品质做另外限制

 

重复定义对象的性质

var obj = Object.create(null);

 

Object.defineProperty(obj, 'foo', {

    configurable: false,

    value: 'foo'

});

 

// Uncaught TypeError: Cannot redefine property: foo

Object.defineProperty(obj, 'foo', {

    value: 'foo2'

});

假如定义了configurable: false今后, 不允许再度定义 descriptor

 

获得对象的性质描述

var obj = Object.create(null);

 

Object.defineProperty(obj, 'foo', {

    configurable: true,

    value: 'foo'

});

var descriptor = Object.getOwnPropertyDescriptor(obj, 'foo');

 

console.log(descrptor); // {value: "foo", writable: false, enumerable: false, configurable: false}

 

// {foo: {value: "foo", writable: false, enumerable: false, configurable: false}}

Object.getOwnPropertyDescriptors(obj);

 

对象拷贝

浅拷贝

  • Object.assign

将候选的对象里的可枚举属性进行引用赋值, 协理七个候选的靶子传递

 

var o = {

  foo: 'foo',

  bar: 'bar'

};

 

Object.defineProperty(o, 'foo', {

  enumerable: false

});

 

var obj = Object.assign(Object.create(null), o, {

  o: o

});

 

/*

obj = {

  bar: 'bar',

  o: {

    'foo': 'foo',

    'bar': 'bar'

  }

}

*/

obj.o === o; // return true;

出于Object.assign 处于浅拷贝的涉嫌, 所以再次回到的key 都为简便的引用情势.

 

纵深拷贝

接纳 对象种类化格局copy数据格式

 

// 该措施只可以拷Becky本数据类型

var obj = {a: 1, b: 2, c: function () { console.log('hello world');}, d: {e: 3, f: 4}};

 

JSON.parse(JSON.stringify(obj));

电动完毕深度拷贝

 

function deepClone (obj) {

  var newObj;

  var isPlainObject = function (o) {

    return Object.prototype.toString.call(o) === '[object Object]';

  };

  var isArray = function (o) {

    return Object.prototype.toString.call(o) === '[object Array]';

  };

  if (isArray(obj)) {

    newObj = [];

    for (var i = 0, len = obj.length; i < len; i ) {

      newObj.push(deepClone(obj[i]));

    }

  } else if (isPlainObject(obj)) {

    newObj = {};

    for (var key in obj) {

      newObj[key] = deepClone(obj[key]);

    }

  } else {

    newObj = obj;

  }

  return newObj;

}

 

var o = {a: 1, b: [{c: 2, d: 3}]};

var o2 = deepClone(o);

o.b[0] !== o2.b[0]; // return true

深度拷贝对象函数, 内置的靶子和数组都被全体的正片出来。

 

巡回引用拷贝难点

 

 

var o = {a: 1, b: 2};

 

// 循环援用难点

o.foo = o;

 

// Uncaught TypeError: Converting circular structure to JSON

JSON.stringify(o);

 

// Uncaught RangeError: Maximum call stack size exceeded

deepClone(o);

 

// 将循环援引的key设置为不可胜计型

Object.defineProperty(o, 'foo', {enumerable: false});

// OK {"a":1,"b":2}

JSON.stringify(o);

防止再一次循环援用的深度clone

 

function deepClone (obj) {

 

  var objStack = [];

 

  var isPlainObject = function (o) {

    return Object.prototype.toString.call(o) === '[object Object]';

  };

 

  var isArray = function (o) {

    return Object.prototype.toString.call(o) === '[object Array]';

  };

  

  var isError = function (o) {

    return o instanceof Error;

  };

 

  function _deepClone (obj) {

    var newObj, cloneObj;

    if (isArray(obj) || isPlainObject(obj)) {

      // 对象重复援引

      if (objStack.indexOf(obj) === -1) {

        objStack.push(obj);

      } else {

        return new Error('parameter Error. it is exits loop reference');

      }

    }

    if (isArray(obj)) {

      newObj = [];

      for (var i = 0, len = obj.length; i < len; i ) {

        cloneObj = _deepClone(obj[i]);

        if (!isError(cloneObj)) {

          newObj.push(cloneObj);

        }

      }

    } else if (isPlainObject(obj)) {

      newObj = {};

      for (var key in obj) {

        cloneObj = _deepClone(obj[key]);

        if (!isError(cloneObj)) {

          newObj[key] = cloneObj;

        }

      }

    } else {

      newObj = obj;

    }

    return newObj;

  }

  return _deepClone(obj);

}

 

Object.create 创制对象实例

一般创制对象有三种艺术

 

  • 字面量形式 var o = {};

  • 构造函数方式 var o = new Object();

  • Object.create();

Object.create 与 字面量创设的区分

 

Object.create 能够钦赐创制的靶子的隐式原型链 __proto__, 也得以创立空原型链的的指标

 

var prototype = {

  foo: 'foo',

  name: 'prototoype'

};

var o = Object.create(prototype);

var o2 = Object.create(null);

o.__proto__ === prototype; // true

 

'__protot__' in o2; // false

Object.create 与构造函数的界别

 

Object.create 直接实行开辟对象空间, 绑定隐式原型链属性。而构造函数成立对象除了上边的操作以外, 还也许会运转构造函数。

 

选拔 Object.create 与构造函数, 达成持续对象关联

 

// Shape - superclass

function Shape() {

  this.x = 0;

  this.y = 0;

}

 

// superclass method

Shape.prototype.move = function(x, y) {

  this.x = x;

  this.y = y;

  console.info('Shape moved.');

};

 

// Rectangle - subclass

function Rectangle() {

  Shape.call(this); // call super constructor.

}

 

// subclass extends superclass

Rectangle.prototype = Object.create(Shape.prototype);

Rectangle.prototype.constructor = Rectangle;

 

var rect = new Rectangle();

 

console.log('Is rect an instance of Rectangle?',

  rect instanceof Rectangle); // true

console.log('Is rect an instance of Shape?',

  rect instanceof Shape); // true

rect.move(1, 1); // Outputs, 'Shape moved.'

转自:

推荐↓↓↓ 

Web前端 3

 

 

web前端开采销路好新闻,每一天 10:24 播报

TAG标签:
版权声明:本文由澳门新葡8455手机版发布于Web前端,转载请注明出处:Javascript原型和原型链,对象的应用Web前端