javascript webcoachbd জাভাস্ক্রিপ্ট একটি বস্তু গভীর ক্লোন সবচেয়ে কার্যকর উপায় কি?




জাভাস্ক্রিপ্ট লুপ (24)

এখানে কনোয়েরপ এর উত্তরের একটি সংস্করণ রয়েছে যা নির্মাতাটির প্যারামিটারগুলির প্রয়োজন থাকলেও এটি কাজ করে:

//If Object.create isn't already defined, we just do the simple shim,
//without the second argument, since that's all we need here
var object_create = Object.create;
if (typeof object_create !== 'function') {
    object_create = function(o) {
        function F() {}
        F.prototype = o;
        return new F();
    };
}

function deepCopy(obj) {
    if(obj == null || typeof(obj) !== 'object'){
        return obj;
    }
    //make sure the returned object has the same prototype as the original
    var ret = object_create(obj.constructor.prototype);
    for(var key in obj){
        ret[key] = deepCopy(obj[key]);
    }
    return ret;
}

এই ফাংশন আমার simpleoo লাইব্রেরি পাওয়া যায় ।

সম্পাদনা:

এখানে আরও শক্তিশালী সংস্করণ (জাস্টিন ম্যাকক্যান্ডলে ধন্যবাদ যা এখন সাইক্লিক রেফারেন্সগুলিকে সমর্থন করে):

/**
 * Deep copy an object (make copies of all its object properties, sub-properties, etc.)
 * An improved version of http://keithdevens.com/weblog/archive/2007/Jun/07/javascript.clone
 * that doesn't break if the constructor has required parameters
 * 
 * It also borrows some code from http://stackoverflow.com/a/11621004/560114
 */ 
function deepCopy(src, /* INTERNAL */ _visited, _copiesVisited) {
    if(src === null || typeof(src) !== 'object'){
        return src;
    }

    //Honor native/custom clone methods
    if(typeof src.clone == 'function'){
        return src.clone(true);
    }

    //Special cases:
    //Date
    if(src instanceof Date){
        return new Date(src.getTime());
    }
    //RegExp
    if(src instanceof RegExp){
        return new RegExp(src);
    }
    //DOM Element
    if(src.nodeType && typeof src.cloneNode == 'function'){
        return src.cloneNode(true);
    }

    // Initialize the visited objects arrays if needed.
    // This is used to detect cyclic references.
    if (_visited === undefined){
        _visited = [];
        _copiesVisited = [];
    }

    // Check if this object has already been visited
    var i, len = _visited.length;
    for (i = 0; i < len; i++) {
        // If so, get the copy we already made
        if (src === _visited[i]) {
            return _copiesVisited[i];
        }
    }

    //Array
    if (Object.prototype.toString.call(src) == '[object Array]') {
        //[].slice() by itself would soft clone
        var ret = src.slice();

        //add it to the visited array
        _visited.push(src);
        _copiesVisited.push(ret);

        var i = ret.length;
        while (i--) {
            ret[i] = deepCopy(ret[i], _visited, _copiesVisited);
        }
        return ret;
    }

    //If we've reached here, we have a regular object

    //make sure the returned object has the same prototype as the original
    var proto = (Object.getPrototypeOf ? Object.getPrototypeOf(src): src.__proto__);
    if (!proto) {
        proto = src.constructor.prototype; //this line would probably only be reached by very old browsers 
    }
    var dest = object_create(proto);

    //add this object to the visited array
    _visited.push(src);
    _copiesVisited.push(dest);

    for (var key in src) {
        //Note: this does NOT preserve ES5 property attributes like 'writable', 'enumerable', etc.
        //For an example of how this could be modified to do so, see the singleMixin() function
        dest[key] = deepCopy(src[key], _visited, _copiesVisited);
    }
    return dest;
}

//If Object.create isn't already defined, we just do the simple shim,
//without the second argument, since that's all we need here
var object_create = Object.create;
if (typeof object_create !== 'function') {
    object_create = function(o) {
        function F() {}
        F.prototype = o;
        return new F();
    };
}

একটি জাভাস্ক্রিপ্ট বস্তু ক্লোন করার সবচেয়ে কার্যকর উপায় কি? আমি obj = eval(uneval(o)); দেখেছি obj = eval(uneval(o)); ব্যবহার করা হচ্ছে, কিন্তু এটি অ-মানক এবং শুধুমাত্র ফায়ারফক্স দ্বারা সমর্থিত

আমি obj = JSON.parse(JSON.stringify(o)); মত জিনিস সম্পন্ন করেছি obj = JSON.parse(JSON.stringify(o)); কিন্তু দক্ষতা প্রশ্ন।

আমি বিভিন্ন ত্রুটি সঙ্গে recursive অনুলিপি ফাংশন দেখা করেছি।
আমি কোন ক্যাননিক সমাধান বিদ্যমান বিস্মিত।


দ্রষ্টব্য: এটি অন্য প্রশ্নের উত্তর, এই প্রশ্নের সঠিক প্রতিক্রিয়া নয়। আপনি যদি দ্রুত বস্তু ক্লোনিং করতে চান তবে দয়া করে এই প্রশ্নের উত্তরে Corban এর পরামর্শ অনুসরণ করুন।

আমি জাভাস্ক্রিপ্টে ক্লোন .clone() পদ্ধতিটি কেবল ক্লোন DOM উপাদানের ক্লোন করতে চাই। জাভাস্ক্রিপ্ট বস্তু ক্লোন করার জন্য, আপনি করবেন:

// Shallow copy
var newObject = jQuery.extend({}, oldObject);

// Deep copy
var newObject = jQuery.extend(true, {}, oldObject);

আরো তথ্য jQuery ডকুমেন্টেশন পাওয়া যাবে।

আমিও মনে রাখতে চাই যে গভীর প্রতিলিপি আসলে উপরে দেখানো তুলনায় অনেক বেশি স্মার্ট - এটি অনেক ফাঁদ এড়াতে সক্ষম (উদাহরণস্বরূপ, DOM উপাদানটি প্রসারিত করার চেষ্টা করে)। এটি jQuery কোর এবং দুর্দান্ত প্রভাবগুলিতে প্লাগইনগুলিতে ঘন ঘন ব্যবহৃত হয়।


অনুমান করা যে আপনার কেবলমাত্র ভেরিয়েবল আছে এবং আপনার বস্তুর কোনও ফাংশন নেই, আপনি এটি ব্যবহার করতে পারেন:

var newObject = JSON.parse(JSON.stringify(oldObject));

জাভাস্ক্রিপ্ট মধ্যে গভীর অনুলিপি বস্তু (আমি ভাল এবং সবচেয়ে সহজ মনে)

1. JSON.parse ব্যবহার করে (JSON.stringify (অবজেক্ট));

var obj = { 
  a: 1,
  b: { 
    c: 2
  }
}
var newObj = JSON.parse(JSON.stringify(obj));
obj.b.c = 20;
console.log(obj); // { a: 1, b: { c: 20 } }
console.log(newObj); // { a: 1, b: { c: 2 } } 

2. তৈরি পদ্ধতি ব্যবহার

function cloneObject(obj) {
    var clone = {};
    for(var i in obj) {
        if(obj[i] != null &&  typeof(obj[i])=="object")
            clone[i] = cloneObject(obj[i]);
        else
            clone[i] = obj[i];
    }
    return clone;
}

var obj = { 
  a: 1,
  b: { 
    c: 2
  }
}
var newObj = cloneObject(obj);
obj.b.c = 20;

console.log(obj); // { a: 1, b: { c: 20 } }
console.log(newObj); // { a: 1, b: { c: 2 } } 

3. লো-ড্যাশের _ ক্লোন ব্যবহার করে লিংক lodash

var obj = { 
  a: 1,
  b: { 
    c: 2
  }
}

var newObj = _.cloneDeep(obj);
obj.b.c = 20;
console.log(obj); // { a: 1, b: { c: 20 } }
console.log(newObj); // { a: 1, b: { c: 2 } } 

4. Object.assign () পদ্ধতি ব্যবহার করে

var obj = { 
  a: 1,
  b: 2
}

var newObj = _.clone(obj);
obj.b = 20;
console.log(obj); // { a: 1, b: 20 }
console.log(newObj); // { a: 1, b: 2 }  

কিন্তু যখন ভুল

var obj = { 
  a: 1,
  b: { 
    c: 2
  }
}

var newObj = Object.assign({}, obj);
obj.b.c = 20;
console.log(obj); // { a: 1, b: { c: 20 } }
console.log(newObj); // { a: 1, b: { c: 20 } } --> WRONG
// Note: Properties on the prototype chain and non-enumerable properties cannot be copied.

5.Using Underscore.js _.clone লিংক Underscore.js

var obj = { 
  a: 1,
  b: 2
}

var newObj = _.clone(obj);
obj.b = 20;
console.log(obj); // { a: 1, b: 20 }
console.log(newObj); // { a: 1, b: 2 }  

কিন্তু যখন ভুল

var obj = { 
  a: 1,
  b: { 
    c: 2
  }
}

var newObj = _.cloneDeep(obj);
obj.b.c = 20;
console.log(obj); // { a: 1, b: { c: 20 } }
console.log(newObj); // { a: 1, b: { c: 20 } } --> WRONG
// (Create a shallow-copied clone of the provided plain object. Any nested objects or arrays will be copied by reference, not duplicated.)

রেফারেন্স medium.com

JSBEN.CH পারফরমেন্স বেঞ্চমার্কিং খেলার মাঠ 1 ~ 3 http://jsben.ch/KVQLd


আপনার উদ্দেশ্যটি "প্লেইন পুরানো জাভাস্ক্রিপ্ট অবজেক্ট" ক্লোন করা হোক না কেন তার উপরে দুটি ভাল উত্তর আছে।

আসুন আমরা অনুমান করি যে আপনার অভিপ্রায় উৎস উত্সে কোনও প্রোটোটাইপ রেফারেন্স সহ সম্পূর্ণ ক্লোন তৈরি করতে হয়। আপনি যদি সম্পূর্ণ ক্লোনটিতে আগ্রহী না হন তবে আপনি অন্যান্য কিছু উত্তরগুলিতে (ক্রকফোর্ডের প্যাটার্ন) প্রদত্ত অবজেক্ট। ক্লোন () রুটিনগুলি ব্যবহার করতে পারেন।

প্লেইন পুরানো জাভাস্ক্রিপ্ট বস্তুর জন্য, আধুনিক রানটাইমগুলিতে একটি বস্তুর ক্লোন করার চেষ্টা এবং সত্যিকারের ভাল উপায়টি বেশ সহজ:

var clone = JSON.parse(JSON.stringify(obj));

উল্লেখ্য যে উত্স বস্তু একটি বিশুদ্ধ JSON বস্তু হতে হবে। এর মানে হল, তার সমস্ত নেস্টেড বৈশিষ্ট্যগুলি স্কলার (বুলিয়ান, স্ট্রিং, অ্যারে, অবজেক্ট ইত্যাদি) হতে হবে। RegExp বা তারিখ মত কোন ফাংশন বা বিশেষ বস্তু ক্লোন করা হবে না।

এটা কি দক্ষ? হ্যাঁ হ্যা। আমরা ক্লোনিং পদ্ধতির সব ধরণের চেষ্টা করেছি এবং এটি সর্বোত্তম কাজ করে। আমি নিশ্চিত যে কিছু নিজা একটি দ্রুত পদ্ধতি পরিত্যাগ করতে পারে। কিন্তু আমি সন্দেহ করি আমরা সীমিত লাভ সম্পর্কে কথা বলছি।

এই পদ্ধতির সহজ এবং বাস্তবায়ন সহজ। এটি একটি সুবিধার্থে ফাংশন মধ্যে মোড়ানো এবং যদি সত্যিই আপনি কিছু লাভ ঝাঁকনি প্রয়োজন, পরবর্তী সময়ে যান।

এখন, অ-প্লেইন জাভাস্ক্রিপ্ট বস্তুর জন্য, সত্যিই একটি সহজ উত্তর নেই। আসলে, জাভাস্ক্রিপ্ট ফাংশন এবং অভ্যন্তরীণ অবজেক্টের গতিশীল প্রকৃতির কারণে এটি হতে পারে না। ডিপ cloning ভিতরে ফাংশন সঙ্গে একটি JSON কাঠামো প্রয়োজন আপনি যারা ফাংশন এবং তাদের ভিতরের প্রসঙ্গ পুনরূদ্ধার প্রয়োজন। এবং জাভাস্ক্রিপ্ট কেবল যে একটি মানানসই উপায় আছে না।

এটি করার সঠিক উপায়, আবার, একটি সুবিধাজনক পদ্ধতির মাধ্যমে আপনি ঘোষণা করেন এবং আপনার কোডের মধ্যে পুনঃব্যবহার করেন। সুবিধার পদ্ধতিটি আপনার নিজস্ব বস্তুর কিছু বোঝার সাথে সম্পন্ন করা যেতে পারে যাতে আপনি নতুন বস্তুর মধ্যে গ্রাফটিকে যথাযথভাবে পুনঃস্থাপন করতে পারেন তা নিশ্চিত করতে পারেন।

আমরা আমাদের নিজের লেখা, কিন্তু আমি দেখেছি সেরা সাধারণ পদ্ধতি এখানে আচ্ছাদিত:

http://davidwalsh.name/javascript-clone

এই সঠিক ধারণা। লেখক (ডেভিড ওয়ালশ) জেনারেলাইজড ফাংশন ক্লোনিং মন্তব্য করেছে। আপনার ব্যবহার ক্ষেত্রে নির্ভর করে এমন কিছু আপনি করতে পারেন।

মূল ধারণাটি হল আপনাকে প্রতি-ধরণের ভিত্তিতে আপনার ফাংশনের তাত্ক্ষণিক হ্যান্ডেল (বা প্রোটোটাইপ ক্লাসগুলি যেমন কথা বলতে হবে) হ্যান্ডেল করতে হবে। এখানে, তিনি RegExp এবং তারিখের জন্য কয়েকটি উদাহরণ সরবরাহ করেছেন।

শুধু এই কোড সংক্ষিপ্ত নয়, কিন্তু এটি খুব পাঠযোগ্য। এটা প্রসারিত প্রশংসনীয় সহজ।

এই দক্ষ? হ্যাঁ হ্যা। লক্ষ্যটি সত্যিকারের গভীর-অনুলিপি তৈরির ক্লোন তৈরি করার পরে, আপনাকে উৎস উত্স গ্রাফের সদস্যদের হাঁটাতে হবে। এই পদ্ধতির সাথে, আপনি ঠিক কোন সন্তানের সদস্যদের চিকিত্সা করতে এবং কীভাবে স্বনির্ধারিত প্রকারগুলি পরিচালনা করতে পারেন তা পরিবর্তন করতে পারেন।

তাই আপনি সেখানে যান। দুই পন্থা। উভয় আমার দৃশ্যে দক্ষ।


শুধু কারণ আমি AngularJS উল্লিখিত ছিল না এবং চিন্তা যে মানুষ জানতে চাইতে পারে ...

angular.copy এছাড়াও গভীর অনুলিপি বস্তু এবং অ্যারের একটি পদ্ধতি উপলব্ধ করা হয়।


শেল কপি এক-মাছ ধরার নৌকা ( ECMAScript 5 ম সংস্করণ ):

var origin = { foo : {} };
var copy = Object.keys(origin).reduce(function(c,k){c[k]=origin[k];return c;},{});

console.log(origin, copy);
console.log(origin == copy); // false
console.log(origin.foo == copy.foo); // true

এবং অগভীর এক-মাছ ধরার নৌকা ( ECMAScript 6 ষ্ঠ সংস্করণ , 2015):

var origin = { foo : {} };
var copy = Object.assign({}, origin);

console.log(origin, copy);
console.log(origin == copy); // false
console.log(origin.foo == copy.foo); // true

এখানে একটি বিস্তৃত ক্লোন () পদ্ধতি যা কোনও জাভাস্ক্রিপ্ট বস্তু ক্লোন করতে পারে। এটি প্রায় সব ক্ষেত্রে পরিচালনা করে:

function clone(src, deep) {

    var toString = Object.prototype.toString;
    if (!src && typeof src != "object") {
        // Any non-object (Boolean, String, Number), null, undefined, NaN
        return src;
    }

    // Honor native/custom clone methods
    if (src.clone && toString.call(src.clone) == "[object Function]") {
        return src.clone(deep);
    }

    // DOM elements
    if (src.nodeType && toString.call(src.cloneNode) == "[object Function]") {
        return src.cloneNode(deep);
    }

    // Date
    if (toString.call(src) == "[object Date]") {
        return new Date(src.getTime());
    }

    // RegExp
    if (toString.call(src) == "[object RegExp]") {
        return new RegExp(src);
    }

    // Function
    if (toString.call(src) == "[object Function]") {

        //Wrap in another method to make sure == is not true;
        //Note: Huge performance issue due to closures, comment this :)
        return (function(){
            src.apply(this, arguments);
        });
    }

    var ret, index;
    //Array
    if (toString.call(src) == "[object Array]") {
        //[].slice(0) would soft clone
        ret = src.slice();
        if (deep) {
            index = ret.length;
            while (index--) {
                ret[index] = clone(ret[index], true);
            }
        }
    }
    //Object
    else {
        ret = src.constructor ? new src.constructor() : {};
        for (var prop in src) {
            ret[prop] = deep
                ? clone(src[prop], true)
                : src[prop];
        }
    }
    return ret;
};

AngularJS

আচ্ছা আপনি যদি কৌণিক ব্যবহার করেন তবে আপনিও এটি করতে পারেন

var newObject = angular.copy(oldObject);

কর্মক্ষমতা দ্বারা গভীর কপি: সেরা থেকে সবচেয়ে খারাপ স্থান

  • পুনর্নির্মাণ "=" (স্ট্রিং অ্যারে, সংখ্যা অ্যারে - শুধুমাত্র)
  • স্লাইস (স্ট্রিং অ্যারে, সংখ্যা অ্যারে - শুধুমাত্র)
  • Concatenation (স্ট্রিং অ্যারে, সংখ্যা অ্যারে - শুধুমাত্র)
  • কাস্টম ফাংশন: জন্য লুপ বা recursive কপি
  • jQuery এর $ .extend
  • JSON.parse (স্ট্রিং অ্যারে, সংখ্যা অ্যারে, বস্তু অ্যারে - শুধুমাত্র)
  • Underscore.js এর _clone (স্ট্রিং অ্যারে, সংখ্যা অ্যারে - শুধুমাত্র)
  • লো-দাশের _ ক্লোনড ডিপ

গভীর স্ট্রিং বা সংখ্যার একটি অ্যারে অনুলিপি করুন (এক স্তর - কোন রেফারেন্স পয়েন্টার):

যখন একটি অ্যারে সংখ্যা এবং স্ট্রিং থাকে - .slice (), .concat (), .splice (), অ্যাসাইনমেন্ট অপারেটর "=", এবং Underscore.js এর ক্লোন ফাংশন। অ্যারে এর উপাদান একটি গভীর কপি করা হবে।

যেখানে reassignment দ্রুততম কর্মক্ষমতা আছে:

var arr1 = ['a', 'b', 'c'];
var arr2 = arr1;
arr1 = ['a', 'b', 'c'];

এবং .slice () কে .concat (), http://jsperf.com/duplicate-array-slice-vs-concat/3 চেয়ে ভাল কর্মক্ষমতা রয়েছে।

var arr1 = ['a', 'b', 'c'];  // Becomes arr1 = ['a', 'b', 'c']
var arr2a = arr1.slice(0);   // Becomes arr2a = ['a', 'b', 'c'] - deep copy
var arr2b = arr1.concat();   // Becomes arr2b = ['a', 'b', 'c'] - deep copy

গভীর বস্তুগুলির অ্যারের অনুলিপি অনুলিপি করুন (দুই বা ততোধিক স্তরের - রেফারেন্স পয়েন্টার):

var arr1 = [{object:'a'}, {object:'b'}];

একটি কাস্টম ফাংশন লিখুন ($ .extend () বা JSON.parse তুলনায় দ্রুত কর্মক্ষমতা আছে:

function copy(o) {
   var out, v, key;
   out = Array.isArray(o) ? [] : {};
   for (key in o) {
       v = o[key];
       out[key] = (typeof v === "object" && v !== null) ? copy(v) : v;
   }
   return out;
}

copy(arr1);

তৃতীয় পক্ষের ইউটিলিটি ফাংশন ব্যবহার করুন:

$.extend(true, [], arr1); // Jquery Extend
JSON.parse(arr1);
_.cloneDeep(arr1); // Lo-dash

যেখানে jQuery এর $ .extend ভাল কর্মক্ষমতা আছে:


এটি সাধারণত সবচেয়ে দক্ষ সমাধান নয়, তবে এটি আমার যা দরকার তা করে। নীচের সহজ পরীক্ষা ক্ষেত্রে ...

function clone(obj, clones) {
    // Makes a deep copy of 'obj'. Handles cyclic structures by
    // tracking cloned obj's in the 'clones' parameter. Functions 
    // are included, but not cloned. Functions members are cloned.
    var new_obj,
        already_cloned,
        t = typeof obj,
        i = 0,
        l,
        pair; 

    clones = clones || [];

    if (obj === null) {
        return obj;
    }

    if (t === "object" || t === "function") {

        // check to see if we've already cloned obj
        for (i = 0, l = clones.length; i < l; i++) {
            pair = clones[i];
            if (pair[0] === obj) {
                already_cloned = pair[1];
                break;
            }
        }

        if (already_cloned) {
            return already_cloned; 
        } else {
            if (t === "object") { // create new object
                new_obj = new obj.constructor();
            } else { // Just use functions as is
                new_obj = obj;
            }

            clones.push([obj, new_obj]); // keep track of objects we've cloned

            for (key in obj) { // clone object members
                if (obj.hasOwnProperty(key)) {
                    new_obj[key] = clone(obj[key], clones);
                }
            }
        }
    }
    return new_obj || obj;
}

সাইক্লিক অ্যারে পরীক্ষা ...

a = []
a.push("b", "c", a)
aa = clone(a)
aa === a //=> false
aa[2] === a //=> false
aa[2] === a[2] //=> false
aa[2] === aa //=> true

ফাংশন পরীক্ষা...

f = new Function
f.a = a
ff = clone(f)
ff === f //=> true
ff.a === a //=> false

কোড এক লাইন একটি বস্তু ক্লোন (গভীর ক্লোন নয়) দক্ষ উপায়

একটি Object.assign পদ্ধতি ECMAScript 2015 (ES6) মানদন্ডের অংশ এবং আপনার যা দরকার তা ঠিক করে।

var clone = Object.assign({}, obj);

Object.assign () পদ্ধতিটি এক বা একাধিক উত্স বস্তু থেকে লক্ষ্যবস্তু বস্তুর সমস্ত সংখ্যাসূচক নিজের বৈশিষ্ট্যগুলির মানগুলি অনুলিপি করার জন্য ব্যবহৃত হয়।

Object.assign

পুরানো ব্রাউজার সমর্থন করার জন্য পলিফিল :

if (!Object.assign) {
  Object.defineProperty(Object, 'assign', {
    enumerable: false,
    configurable: true,
    writable: true,
    value: function(target) {
      'use strict';
      if (target === undefined || target === null) {
        throw new TypeError('Cannot convert first argument to object');
      }

      var to = Object(target);
      for (var i = 1; i < arguments.length; i++) {
        var nextSource = arguments[i];
        if (nextSource === undefined || nextSource === null) {
          continue;
        }
        nextSource = Object(nextSource);

        var keysArray = Object.keys(nextSource);
        for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex++) {
          var nextKey = keysArray[nextIndex];
          var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
          if (desc !== undefined && desc.enumerable) {
            to[nextKey] = nextSource[nextKey];
          }
        }
      }
      return to;
    }
  });
}

একটি লাইব্রেরি আছে ("ক্লোন" বলা হয়) , যা এটি বেশ ভাল করে। এটা আমি জানি যে নির্বিচারে বস্তুর সবচেয়ে সম্পূর্ণ recursive ক্লোনিং / অনুলিপি উপলব্ধ করা হয়। এটি সার্কুলার রেফারেন্সগুলিকে সমর্থন করে, যা অন্যান্য উত্তরগুলির দ্বারা আচ্ছাদিত নয়।

আপনি খুব npm এটি খুঁজে পেতে পারেন। এটি ব্রাউজারের পাশাপাশি নোড।

এটি ব্যবহার করার জন্য এখানে একটি উদাহরণ দেওয়া হয়েছে:

সঙ্গে এটি ইনস্টল করুন

npm install clone

বা Ender সঙ্গে প্যাকেজ।

ender build clone [...]

আপনি নিজেও সোর্স কোডটি ডাউনলোড করতে পারেন।

তারপর আপনি এটি আপনার সোর্স কোড ব্যবহার করতে পারেন।

var clone = require('clone');

var a = { foo: { bar: 'baz' } };  // inital value of a
var b = clone(a);                 // clone a -> b
a.foo.bar = 'foo';                // change a

console.log(a);                   // { foo: { bar: 'foo' } }
console.log(b);                   // { foo: { bar: 'baz' } }

(দাবিত্যাগ: আমি লাইব্রেরি লেখক।)


যদি কোনো বিল্টিন না থাকে তবে আপনি চেষ্টা করতে পারেন:

function clone(obj) {
    if (obj === null || typeof (obj) !== 'object' || 'isActiveClone' in obj)
        return obj;

    if (obj instanceof Date)
        var temp = new obj.constructor(); //or new Date(obj);
    else
        var temp = obj.constructor();

    for (var key in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, key)) {
            obj['isActiveClone'] = null;
            temp[key] = clone(obj[key]);
            delete obj['isActiveClone'];
        }
    }
    return temp;
}

অ্যারের মতো বস্তুর জন্য এখনও কোন আদর্শ গভীর ক্লোন অপারেটর বলে মনে হচ্ছে না। নীচের কোডটি বর্ণিত হিসাবে, জন রেসিগ এর jQuery ক্লোনার অ্যারে নয় এমন অণুগুলিতে অ সংখ্যাসূচক বৈশিষ্ট্যগুলির অ্যারে সক্রিয় করে এবং রেজিডাইটের JSON ক্লোনারটি অ সংখ্যাসূচক বৈশিষ্ট্যগুলি ড্রপ করে। নিম্নলিখিত পরীক্ষা একাধিক ব্রাউজারে এই পয়েন্ট illustrated:

function jQueryClone(obj) {
   return jQuery.extend(true, {}, obj)
}

function JSONClone(obj) {
   return JSON.parse(JSON.stringify(obj))
}

var arrayLikeObj = [[1, "a", "b"], [2, "b", "a"]];
arrayLikeObj.names = ["m", "n", "o"];
var JSONCopy = JSONClone(arrayLikeObj);
var jQueryCopy = jQueryClone(arrayLikeObj);

alert("Is arrayLikeObj an array instance?" + (arrayLikeObj instanceof Array) +
      "\nIs the jQueryClone an array instance? " + (jQueryCopy instanceof Array) +
      "\nWhat are the arrayLikeObj names? " + arrayLikeObj.names +
      "\nAnd what are the JSONClone names? " + JSONCopy.names)

লোডশের একটি সুন্দর lodash.com/docs#cloneDeep পদ্ধতি রয়েছে:

var objects = [{ 'a': 1 }, { 'b': 2 }];

var deep = _.cloneDeep(objects);
console.log(deep[0] === objects[0]);
// => false

কোড:

// extends 'from' object with members from 'to'. If 'to' is null, a deep clone of 'from' is returned
function extend(from, to)
{
    if (from == null || typeof from != "object") return from;
    if (from.constructor != Object && from.constructor != Array) return from;
    if (from.constructor == Date || from.constructor == RegExp || from.constructor == Function ||
        from.constructor == String || from.constructor == Number || from.constructor == Boolean)
        return new from.constructor(from);

    to = to || new from.constructor();

    for (var name in from)
    {
        to[name] = typeof to[name] == "undefined" ? extend(from[name], null) : to[name];
    }

    return to;
}

টেস্ট:

var obj =
{
    date: new Date(),
    func: function(q) { return 1 + q; },
    num: 123,
    text: "asdasd",
    array: [1, "asd"],
    regex: new RegExp(/aaa/i),
    subobj:
    {
        num: 234,
        text: "asdsaD"
    }
}

var clone = extend(obj);

function clone(obj)
 { var clone = {};
   clone.prototype = obj.prototype;
   for (property in obj) clone[property] = obj[property];
   return clone;
 }

var clone = function() {
    var newObj = (this instanceof Array) ? [] : {};
    for (var i in this) {
        if (this[i] && typeof this[i] == "object") {
            newObj[i] = this[i].clone();
        }
        else
        {
            newObj[i] = this[i];
        }
    }
    return newObj;
}; 

Object.defineProperty( Object.prototype, "clone", {value: clone, enumerable: false});

আমি জানি এটি একটি পুরাতন পোস্ট, তবে আমি মনে করি এটি পরবর্তী ব্যক্তির সাথে কিছুটা সাহায্যের কারণ হতে পারে।

যতক্ষণ আপনি কোনও বস্তু বরাদ্দ করেন না ততক্ষণ এটি মেমরিতে কোন উল্লেখ রাখে না। তাই আপনি অন্য বস্তুর মধ্যে ভাগ করতে চান এমন একটি বস্তু তৈরি করতে আপনাকে এমন একটি কারখানা তৈরি করতে হবে:

var a = function(){
    return {
        father:'zacharias'
    };
},
b = a(),
c = a();
c.father = 'johndoe';
alert(b.father);

একটি অবজেক্ট Cloning সবসময়ই Cloning একটি উদ্বেগের বিষয় ছিল, কিন্তু এটি এসএস 6 এর আগেই ছিল, আমি নীচের জাভাস্ক্রিপ্টে একটি বস্তুর অনুলিপি করার বিভিন্ন উপায়ে তালিকাবদ্ধ করেছি, কল্পনা করুন আপনার নীচের অবজেক্ট আছে এবং এর একটি গভীর অনুলিপি চাই:

var obj = {a:1, b:2, c:3, d:4};

মূল পরিবর্তন ছাড়া এই বস্তুর অনুলিপি করার কয়েকটি উপায় রয়েছে:

1) ES5 +, আপনার জন্য কপি করার জন্য একটি সহজ ফাংশন ব্যবহার করে:

function deepCopyObj(obj) {
    if (null == obj || "object" != typeof obj) return obj;
    if (obj instanceof Date) {
        var copy = new Date();
        copy.setTime(obj.getTime());
        return copy;
    }
    if (obj instanceof Array) {
        var copy = [];
        for (var i = 0, len = obj.length; i < len; i++) {
            copy[i] = cloneSO(obj[i]);
        }
        return copy;
    }
    if (obj instanceof Object) {
        var copy = {};
        for (var attr in obj) {
            if (obj.hasOwnProperty(attr)) copy[attr] = cloneSO(obj[attr]);
        }
        return copy;
    }
    throw new Error("Unable to copy obj this object.");
}

2) ES5 +, JSON.parse এবং JSON.stringify ব্যবহার করে।

var  deepCopyObj = JSON.parse(JSON.stringify(obj));

3) AngularJs:

var  deepCopyObj = angular.copy(obj);

4) jQuery:

var deepCopyObj = jQuery.extend(true, {}, obj);

5) আন্ডারস্কোর জেএস ও লোডশ:

var deepCopyObj = _.cloneDeep(obj); //latest version UndescoreJs makes shallow copy

এই সাহায্য আশা করি ...


ক্রোকফোর্ড এই ফাংশনটি ব্যবহার করে (এবং আমি পছন্দ করি) প্রস্তাব করে:

function object(o) {
    function F() {}
    F.prototype = o;
    return new F();
}

var newObject = object(oldObject);

এটা terse, প্রত্যাশিত হিসাবে কাজ করে এবং আপনি একটি লাইব্রেরি প্রয়োজন হয় না।

সম্পাদনা করুন:

এটি একটি পলিফিল Object.create, তাই আপনি এটি ব্যবহার করতে পারেন।

var newObject = Object.create(oldObject);

দ্রষ্টব্য: যদি আপনি এটির কিছু ব্যবহার করেন, তবে কিছু পুনরাবৃত্তি নিয়ে আপনার সমস্যা হতে পারে hasOwnProperty। কারণ, createউত্তরাধিকারী যারা নতুন খালি বস্তু তৈরি করুন oldObject। কিন্তু এটি এখনও ক্লোনিং বস্তু জন্য দরকারী এবং ব্যবহারিক।

উদাহরণস্বরূপ যদি oldObject.a = 5;

newObject.a; // is 5

কিন্তু:

oldObject.hasOwnProperty(a); // is true
newObject.hasOwnProperty(a); // is false

আমি যা ব্যবহার করছি তা হল:

function cloneObject(obj) {
    var clone = {};
    for(var i in obj) {
        if(typeof(obj[i])=="object" && obj[i] != null)
            clone[i] = cloneObject(obj[i]);
        else
            clone[i] = obj[i];
    }
    return clone;
}

যারা JSON.parse(JSON.stringify(obj))সংস্করণটি ব্যবহার করতে চান তাদের জন্য , কিন্তু তারিখ বস্তুগুলি হারানো ছাড়া, আপনি স্ট্রিংগুলিকে তারিখে রূপান্তর করতে পদ্ধতিটির দ্বিতীয় যুক্তিটিparse ব্যবহার করতে পারেন :

function clone(obj) {
  var regExp = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
  return JSON.parse(JSON.stringify(x), function(k, v) {
    if (typeof v === 'string' && regExp.test(v))
      return new Date(v);
    return v;
  });
}






clone