Function.prototype.extends=function(ParentClass) {
this.prototype = new ParentClass();
this.prototype.constructor = this;
}

然后:

function Person() {
this.name = "anonym"
this.skills = ["abc"];
}
Person.prototype.profile = function() {
return this.skills.length // 1
};


function Student() {} //well extends fom Person Class
Student.extends(Person)


var s1 = new Student();
s1.skills.push("")
s1.profile() // 2

2017年1月更新:

请忽略我2015年的回答，因为从 ES6(Ecmasctipt6)开始，Javascript 现在支持 extends关键字

- ES6:

class Person {
constructor() {
this.name = "anonym"
this.skills = ["abc"];
}


profile() {
return this.skills.length // 1
}


}


Person.MAX_SKILLS = 10;
class Student extends Person {




} //well extends from Person Class


//-----------------
var s1 = new Student();
s1.skills.push("")
s1.profile() // 2

- ES7:

class Person {
static MAX_SKILLS = 10;
name = "anonym"
skills = ["abc"];


profile() {
return this.skills.length // 1
}


}
class Student extends Person {




} //well extends from Person Class


//-----------------
var s1 = new Student();
s1.skills.push("")
s1.profile() // 2

在大多数项目中，都有一些对象扩展的实现: 下划线、 jquery、 loash: 延伸。

还有纯粹的 javascript 实现，这是 ECMAscript 6: 对象. 分配的一部分: Https://developer.mozilla.org/en-us/docs/web/javascript/reference/global_objects/object/assign

Mozilla“宣布”从 ECMAScript 6.0扩展的对象:

Https://developer.mozilla.org/en-us/docs/web/javascript/reference/classes/extends

注意: 这是一个实验技术，ECMAScript 6(Harmony)提案的一部分。

class Square extends Polygon {
constructor(length) {
// Here, it calls the parent class' constructor with lengths
// provided for the Polygon's width and height
super(length, length);
// Note: In derived classes, super() must be called before you
// can use 'this'. Leaving this out will cause a reference error.
this.name = 'Square';
}


get area() {
return this.height * this.width;
}


set area(value) {
this.area = value;     }
}

这项技术可以在 Gecko (Google Chrome/Firefox)-03/2015夜间版本中获得。

在 ES6 中，可以使用类似于

var mergedObj = { ...Obj1, ...Obj2 };

注意 Object.sign ()触发器 setter，而传播语法则不是。

更多信息见链接，MDN 扩展语法

老答案:

在 ES6 中，有用于复制属性值的 Object.assign。如果不想修改目标对象(传递的第一个参数) ，请使用 {}作为第一个参数。

var mergedObj = Object.assign({}, Obj1, Obj2);

有关详细信息，请参阅链接，MDN-Object.sign ()

如果您需要的是一个 ES5填充料，链接也提供它。 :)

你可以简单地使用:

Object.prototype.extend = function(object) {
// loop through object
for (var i in object) {
// check if the extended object has that property
if (object.hasOwnProperty(i)) {
// mow check if the child is also and object so we go through it recursively
if (typeof this[i] == "object" && this.hasOwnProperty(i) && this[i] != null) {
this[i].extend(object[i]);
} else {
this[i] = object[i];
}
}
}
return this;
};

更新: 我检查了 this[i] != null，因为 null是一个对象

然后像这样使用它:

var options = {
foo: 'bar',
baz: 'dar'
}


var defaults = {
foo: false,
baz: 'car',
nat: 0
}


defaults.extend(options);

这样做的结果是:

// defaults will now be
{
foo: 'bar',
baz: 'dar',
nat: 0
}

请加上拒绝投票的理由

• 不需要使用任何外部库来扩展

• 在 JavaScript 中，所有内容都是一个对象(除了三个 基本数据类型，甚至它们也自动包装为 此外，所有对象都是可变的。

JavaScript 中的类人员

function Person(name, age) {
this.name = name;
this.age = age;
}
Person.prototype = {
getName: function() {
return this.name;
},
getAge: function() {
return this.age;
}
}


/* Instantiate the class. */
var alice = new Person('Alice', 93);
var bill = new Person('Bill', 30);

修改特定的 instance/object 。

alice.displayGreeting = function()
{
alert(this.getGreeting());
}

修改类

Person.prototype.getGreeting = function()
{
return 'Hi ' + this.getName() + '!';
};

或者简单地说: 扩展 JSON 和 OBJECT 都是相同的

var k = {
name : 'jack',
age : 30
}


k.gender = 'male'; /*object or json k got extended with new property gender*/

多亏了 Ross Harmes 和 Dustin Diaz

这将使扩展属性创建一个带有对象参数原型的新 Object，而无需更改传递的对象。

function extend(object) {
if (object === null)
throw TypeError;
if (typeof object !== "object" && typeof object !== "function")
throw TypeError;
if (Object.create)
return Object.create(object);
function f() {}
;
f.prototype = p;
return new f();
}

但是，如果希望在不修改 Object 参数的情况下扩展 Object，则可以将 extendProperty 添加到对象中。

var Person{
//some code
extend: extendProperty
}


//Enforce type checking an Error report as you wish
function extendProperty(object) {
if ((object !== null && (typeof object === "object" || typeof object === "function"))){
for (var prop in object) {
if (object.hasOwnProperty(prop))
this[prop] = object[prop];
}
}else{
throw TypeError; //Not an object
}
}

摘要:

Javascript 使用一种称为 原型遗传的机制。在查找对象上的属性时使用原型继承。当我们在 javascript 中扩展属性时，我们是从一个实际的对象继承这些属性。它的工作方式如下:

1. 当请求一个对象属性时，(例如 myObj.foo或 myObj['foo']) JS 引擎将首先在对象本身上查找该属性
2. 当在对象本身上找不到这个属性时，它将 爬上原型链查看原型对象。如果这个属性在这里也没有找到，它将继续攀爬原型链，直到找到这个属性。如果找不到该属性，它将引发一个引用错误。

当我们想要从 javascript 中的对象扩展时，我们可以简单地在原型链中链接这个对象。有许多方法来实现这一点，我将描述2个常用的方法。

例子:

1. Object.create()

Object.create()是一个函数，它接受一个对象作为参数并创建一个新对象。作为参数传递的对象将是新创建对象的原型。例如:

// prototype of the dog
const dogPrototype = {
woof: function () { console.log('woof'); }
}


// create 2 dog objects, pass prototype as an argument
const fluffy = Object.create(dogPrototype);
const notFluffy = Object.create(dogPrototype);


// both newly created object inherit the woof
// function from the dogPrototype
fluffy.woof();
notFluffy.woof();

2. 显式设置原型属性

当使用构造函数创建对象时，我们可以将 add 属性设置为其原型对象属性。使用 new关键字创建的构造函数对象的原型设置为构造函数的原型。例如:

// Constructor function object
function Dog (name) {
name = this.name;
}


// Functions are just objects
// All functions have a prototype property
// When a function is used as a constructor (with the new keyword)
// The newly created object will have the consturctor function's
// prototype as its prototype property
Dog.prototype.woof = function () {
console.log('woof');
}


// create a new dog instance
const fluffy = new Dog('fluffyGoodBoyyyyy');
// fluffy inherits the woof method
fluffy.woof();


// can check the prototype in the following manner
console.log(Object.getPrototypeOf(fluffy));

人们还在为简单和最好的方法而奋斗，你可以用 Spread Syntax来扩展对象。

var person1 = {
name: "Blank",
age: 22
};


var person2 = {
name: "Robo",
age: 4,
height: '6 feet'
};
// spread syntax
let newObj = { ...person1, ...person2 };
console.log(newObj.height);

注意: 记住，属性最右边的将具有优先级。在这个例子中，person2位于右侧，因此 newObj的名称为 机器人。

虽然这项工作是不是100% 正确的

// Parent
var Parent = function (name) {
this.name = name;
this.test = function () {
console.log("parent test");
}
this.testOverride = function () {
console.log("parent testOverride");
}
}
// define a function extend
Parent.prototype.extend = function () {
// parent properties to override or add
var override = arguments[0];
return function () {
Parent.apply(this, arguments);
// add and override properties
Object.keys(override).forEach(el =>{
this[el] = override[el];
})
}
}
// create a Child from the Parent and override
// the function "testOverride" and keep "test" unchanged
var Child = Parent.prototype.extend({
y: 10,
testOverride: function () {
console.log("child testOverride");
}
});
// Create an object of type Parent
var p = new Parent("Parent");
// Create an object of type Child
var c = new Child("Child");
console.log(p.name);
// Parent
console.log(c.name);
// Child
p.test();
//parent test
p.testOverride();
//parent testOverride
c.test();
//parent test
c.testOverride();
//child testOverride

简单易读的解决方案是使用扩展运算符

...

例如:

const obj1 = {a: "a"} const obj2 = {b: "b"} const result = {...obj1, ..obj2,} console.log("result", result) // must be {a: "a", b: "b"}