JavaScript復制（合并）對象

vslam 發布于2019-08-21 16:58 / 2248人閱讀

摘要：實現合并對象的方法有很多種，比如也是用寫的，謝謝系列等，至于區別自己看文檔，文檔地址打造的一個不可變數據結構庫的方法其中，為原生方法，但是存在以下兩個在具體應用場景上的缺點瀏覽器兼容性問題只能進行淺合并關于淺合并深合并，碼友之述備矣，這里就

javascript實現合并對象的方法有很多種，比如：

1、Object.assign

2、jQuery.extend（jQuery也是用javascript寫的，謝謝）

3、lodash系列（lodash.merge、lodash.assign等，至于區別自己看文檔，文檔地址：https://lodash.com/docs）

4、Immutable.js（fackbook打造的一個不可變數據結構JS庫）的 merge 方法

其中，Object.assign為javascript原生方法，但是存在以下兩個在具體應用場景上的缺點：

1、瀏覽器兼容性問題

2、只能進行淺合并（關于淺合并深合并，碼友之述備矣，這里就不贅言，戳：https://juejin.im/entry/58df4...）

PS: 之所以說具體應用場景的缺點，是因為假如項目是在高版本瀏覽器運行，并且只要對數據結構進行淺合并，那就不存在上述兩個問題

而為了實現合并對象，特意引入上述的 jQuery、lodash、immutable這些庫，就有點夸張了（項目本身需要用到這些庫，那當我什么也沒說）

好了，進入正題，下面是我自己實現的一個可配置的合并多個對象的方法

function EXT(options) {
    return new EXT.prototype.init(options);
}

EXT.fn = EXT.prototype = {
    type: function(o) {
        return Object.prototype.toString.call(o).slice(8, -1).toLowerCase();
    },
    typeMap: {
        object: function() {
            return {};
        },
        array: function() {
            return [];
        }
    },
    // 默認配置項
    defaults: {
        // 是否深合并
        isDeep: true,
        // 是否遍歷合并源對象原型鏈上的屬性
        includePrototype: true,
        // 用于對每個合并項進行自定義修正
        forEach: function(target, name, sourceItem) {
            target[name] = sourceItem;
            return target;
        }
    },
    // 將配置項合并到默認配置項
    init: function(options) {
        for (let name in options) {
            this.defaults[name] = options[name];
        }
        return this;
    },
    merge: function() {
        let self = this,
            _default = self.defaults,
            i = 1,
            length = arguments.length,
            target = arguments[0] || {},
            source,
            targetItem,
            sourceItem,
            tiType,
            siType,
            clone,
            name;

        for (; i < length; i++) {
            // 判斷源對象是否為空
            if ((source = arguments[i]) != null) {
                for (name in source) {
                    const hasPro = source.hasOwnProperty(name);
                    // 是否遍歷源對象的原型鏈
                    if (hasPro || _default.includePrototype) {
                        targetItem = target[name];
                        sourceItem = source[name];
                        tiType = self.type(targetItem);
                        siType = self.type(sourceItem);

                        // 防止出現回環
                        if (target === sourceItem) {
                            continue;
                        }

                        // 如果復制的是對象或者數組
                        if (_default.isDeep && sourceItem != null && self.typeMap[siType]) {
                            clone = targetItem != null && tiType === siType ? targetItem : self.typeMap[siType]();
                            // 遞歸
                            target[name] = self.merge(clone, sourceItem);
                        } else {
                            clone = hasPro ? target : target.__proto__;
                            // 處理每一個合并項
                            clone = _default.forEach.call(self, clone, name, sourceItem);
                        }
                    }
                }
            }
        }
        return target;
    }
};
EXT.fn.init.prototype = EXT.fn;

擼個demo先，先定義兩份數據

function Foo() {
    this.a = 1;
}

function Bar() {
    this.c = 3;
}

Foo.prototype.b = 2;
Bar.prototype.d = 4;

let data = {
    info: {
        name: "Leslie",
        age: 26,
        scores: [60, 66, 70, 80]
    }
};
let data2 = {
    info: {
        name: "Leslie",
        age: 32,
        scores: [99, 66, 70, {
            name: "john",
            age: 18
        },
        new Foo()]
    }
};

1、普通合并

let target = EXT().merge(data1, data2);

結果為：

2、自定義配置進行合并

isDeep：選擇是否進行深合并，設置為 false 則只進行淺合并，默認為 true

let target = EXT({ isDeep: false }).merge(data1, data2);

includePrototype：選擇是否要遍歷對象的原型鏈，默認為 true

let target = EXT({ includePrototype: false }).merge(data1, data2);

forEach：對每個合并項進行自定義處理

let target = EXT({
    forEach: function(target, name, sourceItem) {
        target[name] = sourceItem + ’hello， 自定義每個合并項‘;
        return target;
    }
}).merge(data1, data2);

好了，這就是這個方法的全部，還不知道怎么用的小伙伴可以私信我.

GPU云服務器云服務器合并對象 php對象屬性合并 json對象數組合并 asp復制對象

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/88963.html

[譯] 為什么原型繼承很重要

摘要：使用構造函數的原型繼承相比使用原型的原型繼承更加復雜，我們先看看使用原型的原型繼承上面的代碼很容易理解。相反的，使用構造函數的原型繼承像下面這樣當然，構造函數的方式更簡單。五天之前我寫了一個關于ES6標準中Class的文章。在里面我介紹了如何用現有的Javascript來模擬類并且介紹了ES6中類的用法，其實它只是一個語法糖。感謝Om Shakar以及Javascript Room中...

xiao7cn 2019-08-21 10:27 評論0 收藏0
（JavaScript）合并數組的方法

摘要：添加元素到數組合并兩個數組錯誤方法應該用方法，將被的數組當成參數數組。會改變數組，返回最新屬性，占用內存較少。一、Array.prototype.concat() concat方法將創建一個新的數組，然后將調用它的對象（this指向的對象）中的元素以及所有參數中的數組類型的參數中的元素以及非數組類型的參數本身按照順序放入這個新數組,并返回該數組。concat方法并不修改調用它的對象...

econi 2019-08-19 18:22 評論0 收藏0
JavaScript深入理解對象方法——Object.assign()

摘要：它將返回目標對象。該方法使用源對象的和目標對象的，所以它會調用相關和。注意，會跳過那些值為或的源對象。合并對象注意目標對象自身也會改變。注意，只有字符串的包裝對象才可能有自身可枚舉屬性。，第三個源對象更是不會被拷貝到的。 Object.assign() Object.assign()方法用于將所有可枚舉屬性的值從一個或多個源對象復制到目標對象。它將返回目標對象。語法 Object.a...

sunnyxd 2019-08-21 17:06 評論0 收藏0
JavaScript專題之從零實現jQuery的extend

摘要：不過的實現中，多了很多細節上的判斷，比如第一個參數是否是布爾值，是否是一個對象，不傳參數時的默認值等。 JavaScritp 專題系列第七篇，講解如何從零實現一個 jQuery 的 extend 函數前言 jQuery 的 extend 是 jQuery 中應用非常多的一個函數，今天我們一邊看 jQuery 的 extend 的特性，一邊實現一個 extend! extend 基本用...

wangtdgoodluck 2019-08-20 17:59 評論0 收藏0
JavaScript深拷貝、淺拷貝

摘要：深拷貝淺拷貝淺拷貝淺拷貝只是復制了內存地址，如果原地址中的對象改變了，淺拷貝出來的對象也會相應改變。也就是深拷貝之后，不管這個對象原來的構造函數是什么，在深拷貝之后都會變成。 JavaScript深拷貝、淺拷貝淺拷貝：淺拷貝只是復制了內存地址，如果原地址中的對象改變了，淺拷貝出來的對象也會相應改變。深拷貝：開辟了一塊新的內存存放地址和地址指向的對象，原地址的任何對象改變了，深拷...

Scorpion 2019-08-23 14:57 評論0 收藏0