原生javascript实现extend

var obj1 = {'a': 'obj2','b':'2'};

var obj2 = {name: 'obj3'};

function extend() {

var length = arguments.length;

var target = arguments[0] || {};

if (typeof target!="object" && typeof target != "function") {

target = {};

}

if (length == 1) {

target = this;

i--;

}

for (var i = 1; i < length; i++) {

var source = arguments[i];

for (var key in source) {

// 使用for in会遍历数组所有的可枚举属性，包括原型。

if (Object.prototype.hasOwnProperty.call(source, key)) {

target[key] = source[key];

}

}

}

return target;

}

console.log(extend(obj1,obj2));

extend 要实现的是给任意对象扩展

分析一下

在extend()函数中没有写死参数，是为了更好的扩展性，永远也不知道需要扩展的对象有几个。

而是通过arguments来获取传进来的参数。

arguments对象不是一个 Array 。它类似于Array，但除了length属性和索引元素之外没有任何Array属性。

// 可以转换为数组 ES2015

const args = Array.from(arguments);

console.log(typeof arguments); // 'object'

target

target是传进来的第一个参数，也就是需要扩展的对象。

var target = arguments[0] || {}; // 如果没有传参，则设为一个空对象

// 进行这一步判断是为了保证代码的可执行性，如果传进来的是个数字、布尔值，则设为一个空对象

if (typeof target!="object" && typeof target != "function") {

target = {};

}

循环遍历赋值

for (var i = 1; i < length; i++) {

var source = arguments[i];

for (var key in source) {

// 使用for in会遍历数组所有的可枚举属性，包括原型。

if (Object.prototype.hasOwnProperty.call(source, key)) {

target[key] = source[key];

}

}

}

这一步就是将扩展源里的属性、方法循环遍历赋值到扩展项中。

如果扩展项和扩展源中有相同的属性、方法，后面的会覆盖前面的。 这个思想也是插件开发中，实现用户配置覆盖默认设置的实现思想。

hasOwnProperty

为什么需要使用hasOwnProperty，这跟for in有密切关系。

使用for in会遍历所有的可枚举属性，包括原型。

所以需要判断一下，是否是对象自身的属性，而不是继承于原型的。

那为什么不直接使用source.hasOwnProperty(source[key])呢？

JavaScript 并没有保护 hasOwnProperty 属性名，因此某个对象是有可能存在使用这个属性名的属性，使用外部的 hasOwnProperty 获得正确的结果是需要的：

var foo = {

hasOwnProperty: function() {

return false;

},

bar: 'Here be dragons'

};

foo.hasOwnProperty('bar'); // 始终返回 false

// 如果担心这种情况，可以直接使用原型链上真正的 hasOwnProperty 方法

({}).hasOwnProperty.call(foo, 'bar'); // true

// 也可以使用 Object 原型上的 hasOwnProperty 属性

Object.prototype.hasOwnProperty.call(foo, 'bar'); // true

call apply

上面用到的call和apply，就在这里记录一下。

1.每个函数都包含两个非继承而来的方法：call()方法和apply()方法。

2.相同点：这两个方法的作用是一样的。

都是在特定的作用域中调用函数，等于设置函数体内this对象的值，以扩充函数赖以运行的作用域。

一般来说，this总是指向调用某个方法的对象，但是使用call()和apply()方法时，就会改变this的指向。

3.不同点：接收参数的方式不同。

- apply()方法 接收两个参数，一个是函数运行的作用域（this），另一个是参数数组。

语法：apply([thisObj [,argArray] ]);，调用一个对象的一个方法，2另一个对象替换当前对象。

说明：如果argArray不是一个有效数组或不是arguments对象，那么将导致一个TypeError，如果没有提供argArray和thisObj任何一个参数，那么Global对象将用作thisObj。

- call()方法 第一个参数和apply()方法的一样，但是传递给函数的参数必须列举出来。

语法：call([thisObject[,arg1 [,arg2 [,…,argn]]]]);，应用某一对象的一个方法，用另一个对象替换当前对象。

说明： call方法可以用来代替另一个对象调用一个方法，call方法可以将一个函数的对象上下文从初始的上下文改变为thisObj指定的新对象，如果没有提供thisObj参数，那么Global对象被用于thisObj。

// call

window.name = 'FinGet';

document.name = 'FinGet1';

var boy = {name: 'FinGet2' };

function showName(){

console.log(this.name);

}

showName.call();         //FinGet (默认传递参数)  this 是指向window

showName.call(window);   //FinGet

showName.call(document); //FinGet1

showName.call(this);     //FinGet

showName.call(boy);       //FinGet2

var Pet = {

words : 'hello',

speak : function (say) {

console.log(say + ''+ this.words)

}

}

Pet.speak('Speak'); // 结果：Speakhello

var Dog = {

words:'Wang'

}

//将this的指向改变成了Dog

Pet.speak.call(Dog, 'Speak'); //结果： SpeakWang

可以将上面代码中的call换成apply，也是可以执行的。

Object.assign

Object.assign(target, …sources)

- target 目标对象

- sources 源对象

如果目标对象中的属性具有相同的键，则属性将被源中的属性覆盖。后来的源的属性将类似地覆盖早先的属性。

注意，Object.assign 会跳过那些值为 null 或 undefined 的源对象。

var obj1 = {a:'1',b:'2'};

var obj2 = {c:'3',d:'4'};

Object.assign(obj1,obj2); // Object {a: "1", b: "2", c: "3", d: "4"}

obj1 也改变

Object {a: "1", b: "2", c: "3", d: "4"}

obj2

Object {c: "3", d: "4"}