ජාවාස්ක්‍රිප්ට් හි අරාව වෙනත් අරාවකට පිටපත් කිරීමේදී:

var arr1 = ['a','b','c'];
var arr2 = arr1;
arr2.push('d');  //Now, arr1 = ['a','b','c','d']

එය නව ස්වාධීන අරාවකට වඩා arr2එකම අරාවකට යොමු වන බව මම තේරුම් ගතිමි arr1. ස්වාධීන අරා දෙකක් ලබා ගැනීම සඳහා අරාව පිටපත් කරන්නේ කෙසේද?

මෙය භාවිතා කරන්න:

var newArray = oldArray.slice();

මූලික වශයෙන්, slice()මෙහෙයුම අරාව ක්ලෝන කර නව අරාවකට යොමු කරයි.

මෙයද සටහන් කරන්න:

යොමු කිරීම්, නූල් සහ සංඛ්‍යා සඳහා (සහ සත්‍ය වස්තුව නොවේ), slice()වස්තු යොමු කිරීම් නව අරාව තුළට පිටපත් කරයි. මුල් සහ නව අරාව යන දෙකම එකම වස්තුවකට යොමු වේ. යොමු කරන ලද වස්තුවක් වෙනස් වුවහොත්, වෙනස්කම් නව සහ මුල් අරා දෙකටම පෙනේ.

නූල් සහ සංඛ්‍යා වැනි ප්‍රාථමිකයන් වෙනස් කළ නොහැකි බැවින් නූල් හෝ අංකයට වෙනස් කළ නොහැක.

ජාවාස්ක්‍රිප්ට් හි, ගැඹුරු පිටපත් කිරීමේ ක්‍රමෝපායන් අරාවෙහි ඇති මූලද්‍රව්‍ය මත රඳා පවතී. අපි එතැනින් පටන් ගනිමු.

මූලද්රව්ය වර්ග තුනක්

මූලද්රව්ය විය හැකිය: වචනාර්ථමය අගයන්, වචනාර්ථ ව්යුහයන් හෝ මූලාකෘති.

// Literal values (type1)
const booleanLiteral = true;
const numberLiteral = 1;
const stringLiteral = 'true';

// Literal structures (type2)
const arrayLiteral = [];
const objectLiteral = {};

// Prototypes (type3)
const booleanPrototype = new Bool(true);
const numberPrototype = new Number(1);
const stringPrototype = new String('true');
const arrayPrototype = new Array();
const objectPrototype = new Object(); // or `new function () {}`

මෙම මූලද්‍රව්‍ය වලින් අපට අරා වර්ග තුනක් නිර්මාණය කළ හැකිය.

// 1) Array of literal-values (boolean, number, string) 
const type1 = [true, 1, "true"];

// 2) Array of literal-structures (array, object)
const type2 = [[], {}];

// 3) Array of prototype-objects (function)
const type3 = [function () {}, function () {}];

ගැඹුරු පිටපත් කිරීමේ ක්‍රම අරා වර්ග තුන මත රඳා පවතී

අරාවෙහි ඇති මූලද්‍රව්‍ය වර්ග මත පදනම්ව, ගැඹුරු පිටපත් කිරීම සඳහා අපට විවිධ උපක්‍රම භාවිතා කළ හැකිය.

• ප්රායෝගික-අගයන් (type1) ගණනාවක් සම්බන්ධයෙන්
  මෙම [...myArray], myArray.splice(0), myArray.slice(), හා myArray.concat()ශිල්ප ක්රම ප්රායෝගික අගයන් (වීජ, අංකය, සහ සංගීත) පමණක් ගැඹුරු පිටපතක් අයාත කිරීම සඳහා භාවිතා කල හැක; එහිදී පැතිරීමේ ක්‍රියාකරුට [...myArray]හොඳම ක්‍රියාකාරිත්වය ඇත ( https://measurethat.net/Benchmarks/Show/4281/0/spread-array-performance-vs-slice-splice-concat ).

• වචනාර්ථ-අගයන් (වර්ගය 1) සහ වචනාර්ථ-ව්‍යුහයන් (වර්ගය 2)
  මෙම JSON.parse(JSON.stringify(myArray))තාක්ෂණය ගැඹුරු පිටපතක් සත්ය අගයන් (වීජ, අංකය, නූල්) සහ සා ව්යුහයන් (අරාව, වස්තුව), භාවිතා කළ හැකි නමුත් වස්තූන් ආකෘති නොවේ.

• සියලුම අරා (type1, type2, type3) සියලු අරා වර්ග ගැඹුරින් පිටපත් කිරීමට
  jQuery $.extend(myArray)තාක්ෂණය භාවිතා කළ හැකිය. අන්ඩර්ස්කෝර් සහ ලෝ-ඩෑෂ් වැනි පුස්තකාල jQuery සඳහා සමාන ගැඹුරු පිටපත් කිරීමේ කාර්යයන් ලබා දෙන $.extend()නමුත් අඩු කාර්ය සාධනයක් ඇත. වඩා පුදුමයට කරුණක් නම්, http://jsperf.com/js-deep-copy/15 තාක්‍ෂණයට $.extend()වඩා ඉහළ කාර්ය සාධනයක් ඇත . තෙවන පාර්ශවීය පුස්තකාලවලින් (jQuery වැනි) y ත් වන සංවර්ධකයින් සඳහා, ඔබට පහත අභිරුචි ශ්‍රිතය භාවිතා කළ හැකිය; එය performance .extend ට වඩා ඉහළ කාර්ය සාධනයක් ඇති අතර සියලු අරා ගැඹුරු පිටපත් කරයි.JSON.parse(JSON.stringify(myArray))
  

function copy(aObject) {
  if (!aObject) {
    return aObject;
  }

  let v;
  let bObject = Array.isArray(aObject) ? [] : {};
  for (const k in aObject) {
    v = aObject[k];
    bObject[k] = (typeof v === "object") ? copy(v) : v;
  }

  return bObject;
}

ඉතින් ප්‍රශ්නයට පිළිතුරු දීමට ...

ප්‍රශ්නය

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

Arr2 යනු නව ස්වාධීන අරාවකට වඩා arr1 හා සමාන අරාවකට යොමු වන බව මම තේරුම් ගතිමි. ස්වාධීන අරා දෙකක් ලබා ගැනීම සඳහා අරාව පිටපත් කරන්නේ කෙසේද?

පිළිතුර

නිසා arr1ප්රායෝගික අගයන් (වීජ, අංකය, හෝ string) රාශියද, ඔබ ඉහත සාකච්ඡා ඕනෑම ගැඹුරු පිටපතක් තාක්ෂණය, පැතිරීම ක්රියාකරු එහිදී භාවිතා කළ හැකි ...ඉහළම කාර්ය සාධන ඇත.

// Highest performance for deep copying literal values
arr2 = [...arr1];

// Any of these techniques will deep copy literal values as well,
//   but with lower performance.
arr2 = arr1.slice();
arr2 = arr1.splice(0);
arr2 = arr1.concat();
arr2 = JSON.parse(JSON.stringify(arr1));
arr2 = $.extend(true, [], arr1); // jQuery.js needed
arr2 = _.extend(arr1); // Underscore.js needed
arr2 = _.cloneDeep(arr1); // Lo-dash.js needed
arr2 = copy(arr1); // Custom-function needed - as provided above

...අරා පිටපත් කිරීම සඳහා ඔබට අරාව පැතිරීම භාවිතා කළ හැකිය .

const itemsCopy = [...items];

එසේම දැනට පවතින කොටසෙහි කොටසක් සමඟ නව අරාවක් නිර්මාණය කිරීමට අවශ්‍ය නම්:

var parts = ['shoulders', 'knees'];
var lyrics = ['head', ...parts, 'and', 'toes'];

සියලුම ප්‍රධාන බ්‍රව්සර්වල අරා පැතිරීම දැන් සහය දක්වයි නමුත් ඔබට පැරණි සහය අවශ්‍ය නම් යතුරු ලියනය හෝ බාබල් භාවිතා කර ES5 වෙත සම්පාදනය කරන්න.

පැතිරීම පිළිබඳ වැඩි විස්තර

JQuery අවශ්‍ය නැත ... වැඩ කරන උදාහරණය

var arr2 = arr1.slice()

මෙය අරාව ආරම්භක ස්ථානයේ 0සිට අරාව අවසානය දක්වා පිටපත් කරයි .

එය ප්‍රාථමික වර්ග (නූල්, අංකය, ආදිය) සඳහා අපේක්ෂිත පරිදි ක්‍රියාත්මක වන බව සටහන් කර ගැනීම වැදගත් වන අතර විමර්ශන වර්ග සඳහා අපේක්ෂිත හැසිරීම පැහැදිලි කිරීමට ද ...

ඔබ සතුව විමර්ශන වර්ග රාශියක් තිබේ නම්, වර්ගය ගැන කියන්න Object. අරාව පිටපත් කරනු ඇත, නමුත් අරා දෙකෙහිම එකම සඳහනක් අඩංගු වේ Object. එබැවින් මෙම අවස්ථාවෙහිදී අරාව සැබවින්ම පිටපත් කර තිබුණද, අරාව යොමු කිරීම මගින් පිටපත් කර ඇති බවක් පෙනේ .

විකල්පයක් sliceනම් concat, එය ක්‍රම 2 කින් භාවිතා කළ හැකිය. අපේක්ෂිත හැසිරීම ඉතා පැහැදිලි බැවින් මේවායින් පළමුවැන්න වඩාත් කියවිය හැකිය:

var array2 = [].concat(array1);

දෙවන ක්‍රමය:

var array2 = array1.concat();

කොහෙන් (අදහස් දැක්වීමේදී) පෙන්වා දුන්නේ මෙම දෙවන ක්‍රමය වඩා හොඳ කාර්ය සාධනයක් ඇති බවයි.

මෙය ක්‍රියාත්මක වන ආකාරය නම්, මෙම concatක්‍රමය මඟින් වස්තුවෙහි මූලද්‍රව්‍යයන්ගෙන් සමන්විත නව අරාවක් නිර්මාණය වන අතර එය හැඳින්වෙන ඕනෑම අරා වල මූලද්‍රව්‍යයන් තර්ක ලෙස ඉදිරිපත් කරයි. එබැවින් කිසිදු තර්කයක් සම්මත නොවූ විට, එය හුදෙක් අරාව පිටපත් කරයි.

ලී පෙන්ක්මන් ද අදහස් දැක්වීමේදී පෙන්වා දෙන්නේ අවස්ථාවක් තිබේ array1නම් undefinedඔබට හිස් අරා එකක් පහත පරිදි ආපසු ලබා දිය හැකි බවයි:

var array2 = [].concat(array1 || []);

හෝ, දෙවන ක්රමය සඳහා:

var array2 = (array1 || []).concat();

ඔබට මෙයද කළ හැකි බව සලකන්න slice: var array2 = (array1 || []).slice();.

බොහෝ ප්‍රවේශයන් අත්හදා බැලීමෙන් පසු මම එය කළේ මෙයයි:

var newArray = JSON.parse(JSON.stringify(orgArray));

මෙය පළමු පිටපතට සම්බන්ධ නොවන නව ගැඹුරු පිටපතක් නිර්මාණය කරයි (නොගැඹුරු පිටපතක් නොවේ).

එසේම මෙය පැහැදිලිවම සිදුවීම් සහ ක්‍රියාකාරකම් ක්ලෝන නොකරනු ඇත, නමුත් ඔබට එය එක පේළියකින් කළ හැකි හොඳ දෙය වන අතර එය ඕනෑම ආකාරයක වස්තුවක් සඳහා භාවිතා කළ හැකිය (අරා, නූල්, අංක, වස්තු ...)

අංක හෝ නූල් වැනි සරල දත්ත වර්ග සමඟ වැඩ කිරීමේදී සඳහන් කළ සමහර ක්‍රම හොඳින් ක්‍රියාත්මක වේ, නමුත් අරාවෙහි වෙනත් වස්තු අඩංගු වූ විට මෙම ක්‍රම අසාර්ථක වේ. අපි ඕනෑම වස්තුවක් එක් අරාවකින් තවත් පෙළකට යැවීමට උත්සාහ කරන විට එය සම්මත වන්නේ වස්තුව නොව යොමු කිරීමක් වශයෙනි.

ඔබගේ ජාවාස්ක්‍රිප්ට් ගොනුවේ පහත කේතය එක් කරන්න:

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

සරලව භාවිතා කරන්න

var arr1 = ['val_1','val_2','val_3'];
var arr2 = arr1.clone()

එය ක්‍රියාත්මක වනු ඇත.

ES2015 සිට,

var arr2 = [...arr1];

මම පෞද්ගලිකව සිතන්නේ Array.from වඩාත් කියවිය හැකි විසඳුමක් බවයි. මාර්ගය වන විට, එහි බ්‍රව්සර් සහාය ගැන පරිස්සම් වන්න.

//clone
let x = [1,2,3];
let y = Array.from(x);

//deep clone
let clone = arr => Array.from(arr,item => Array.isArray(item) ? clone(item) : item);
let x = [1,[],[[]]];
let y = clone(x);

වැදගත්!

මෙහි බොහෝ පිළිතුරු විශේෂිත අවස්ථා සඳහා ක්‍රියා කරයි .

ගැඹුරු / කැදැලි වස්තූන් සහ මුක්කු භාවිතය ( ES6 ) ගැන ඔබ තැකීමක් නොකරන්නේ නම් :

let clonedArray = [...array]

නමුත් ඔබට ගැඹුරු ක්ලෝන කිරීමට අවශ්‍ය නම් ඒ වෙනුවට මෙය භාවිතා කරන්න:

let cloneArray = JSON.parse(JSON.stringify(array))

ලොඩාෂ් භාවිතා කරන්නන් සඳහා:

let clonedArray = _.clone(array) ප්‍රලේඛනය

සහ

let clonedArray = _.cloneDeep(array) ප්‍රලේඛනය

ඔබ ECMAScript 6 හි පරිසරයක සිටී නම් , පැතිරීමේ ක්‍රියාකරු භාවිතා කර ඔබට එය මේ ආකාරයෙන් කළ හැකිය:

var arr1 = ['a','b','c'];
var arr2 = [...arr1]; //copy arr1
arr2.push('d');

console.log(arr1)
console.log(arr2)

<script src="http://www.wzvang.com/snippet/ignore_this_file.js"></script>

Array.slice () හි විසඳුමට එකතු කිරීම ; ඔබ සතුව බහුමානීය අරාව උප අරා තිබේ නම් යොමු කිරීම් මගින් පිටපත් කරනු ඇති බව මතක තබා ගන්න. ඔබට කළ හැක්කේ එක් එක් උප අරාව තනි තනිව ලූප සහ කැපීමයි

var arr = [[1,1,1],[2,2,2],[3,3,3]];
var arr2 = arr.slice();

arr2[0][1] = 55;
console.log(arr2[0][1]);
console.log(arr[0][1]);

function arrCpy(arrSrc, arrDis){
 for(elm in arrSrc){
  arrDis.push(arrSrc[elm].slice());
}
}

var arr3=[];
arrCpy(arr,arr3);

arr3[1][1] = 77;

console.log(arr3[1][1]);
console.log(arr[1][1]);

එකම දේ වස්තු පෙළට යයි, ඒවා යොමු කිරීම මගින් පිටපත් කරනු ලැබේ, ඔබ ඒවා අතින් පිටපත් කළ යුතුය

ප්‍රාථමික අගයන් සැමවිටම එහි අගය අනුව ගමන් කරයි (පිටපත් කර ඇත). කෙසේ වෙතත් සංයුක්ත අගයන් යොමු කිරීම මඟින් සම්මත වේ.

ඉතින් අපි කොහොමද මේ අර පිටපත් කරන්නේ?

let arr = [1,2,3,4,5];

ES6 හි අරාව පිටපත් කරන්න

let arrCopy = [...arr]; 

ES5 හි n අරාව පිටපත් කරන්න

let arrCopy = arr.slice(); 
let arrCopy = [].concat(arr);

`ArCopy = arr` අගය අනුව නොයන්නේ ඇයි?

වස්තුව / අරාව වැනි සංයුක්ත අගයන් මත එක් විචල්‍යයක් තවත් විචල්‍යයකට ගමන් කිරීම එකිනෙකට වෙනස් ලෙස හැසිරේ. කොපෑන්ඩ් අගයන් මත asign operator භාවිතා කරමින් අපි වස්තුවක් වෙත යොමු කරමු. අර්‍ග මූලද්‍රව්‍ය ඉවත් කිරීමේදී / එකතු කිරීමේදී අරා දෙකේම අගය වෙනස් වන්නේ මේ නිසාය.

ව්‍යතිරේක:

arrCopy[1] = 'adding new value this way will unreference';

ඔබ විචල්‍යයට නව අගයක් ලබා දුන් විට, ඔබ යොමු කිරීමම වෙනස් කරන අතර එය මුල් වස්තුව / අරාවට බලපාන්නේ නැත.

වැඩිදුර කියවන්න

ජාවාස්ක්‍රිප්ට් අරා සහ වස්තු වලින් අප දන්නා පරිදි , නමුත් මුල් අරාව පසුව වෙනස් නොකර අරාව පිටපත් කළ හැකි ක්‍රම මොනවාද?

එය කළ හැකි ක්‍රම කිහිපයක් මෙන්න:

ඔබේ කේතය තුළ මෙම අරාව අප සතුව ඇතැයි සිතන්න:

var arr = [1, 2, 3, 4, 5];

1) ශ්‍රිතයක අරාව හරහා විවර වී නව අරා එකක් නැවත එවන්න,

 function newArr(arr) {
      var i=0, res = [];
      while(i<arr.length){
       res.push(arr[i]);
        i++;
       }
   return res;
 }

2) පෙති ක්‍රමය භාවිතා කිරීම, පෙත්ත යනු අරාවෙහි කොටසක් කැපීම සඳහා වන අතර, එය මුල් පිටපතට අත නොතබා ඔබේ අරාවෙහි යම් කොටසක් කපා දමනු ඇත, පෙත්තෙහි, අරාවෙහි ආරම්භය සහ අවසානය සඳහන් නොකරන්නේ නම්, එය මුළු පෙත්තම කපයි අරාව සහ මූලික වශයෙන් අරාවෙහි සම්පූර්ණ පිටපතක් සාදන්න, එවිට අපට පහසුවෙන් කිව හැකිය:

var arr2 = arr.slice(); // make a copy of the original array

3) එසේම සම්බන්ධතා ක්‍රමය, මෙය අරාව දෙකක් ඒකාබද්ධ කිරීම සඳහා වේ, නමුත් අපට අරා වලින් එකක් පමණක් නියම කළ හැකි අතර පසුව මෙය මූලික වශයෙන් නව සම්බන්ධිත අරාවෙහි අගයන්හි පිටපතක් සාදයි:

var arr2 = arr.concat();

4) එසේම දැඩි හා විග්‍රහ කිරීමේ ක්‍රමය නිර්දේශ නොකරයි, නමුත් අරාව සහ වස්තු පිටපත් කිරීමට පහසු ක්‍රමයක් විය හැකිය:

var arr2 = JSON.parse(JSON.stringify(arr));

5) Array.from ක්‍රමයට, මෙය පුළුල් ලෙස සහාය නොදක්වයි, භාවිතයට පෙර විවිධ බ්‍රව්සර්වල සහාය පරීක්ෂා කරන්න:

const arr2 = Array.from(arr);

6) ECMA6 මාර්ගය, පූර්ණ සහය නොදක්වයි, නමුත් ඔබට පාරදෘශ්‍ය කිරීමට අවශ්‍ය නම් බාබෙල්ජේ ඔබට උදව් කළ හැකිය:

const arr2 = [...arr];

let a = [1,2,3];

අරාවෙහි පිටපතක් සෑදීම සඳහා දැන් ඔබට පහත සඳහන් ඕනෑම දෙයක් කළ හැකිය.

let b = Array.from(a); 

හෝ

let b = [...a];

හෝ

let b = new Array(...a); 

හෝ

let b = a.slice(); 

හෝ

let b = a.map(e => e);

දැන්, මම a වෙනස් කළහොත්,

a.push(5); 

එවිට a යනු [1,2,3,5] නමුත් වෙනස් සඳහනක් ඇති බැවින් b තවමත් [1,2,3] වේ.

නමුත් මම හිතන්නේ, Array.from ට ඉහළින් ඇති සියලුම ක්‍රම වඩා හොඳ වන අතර ප්‍රධාන වශයෙන් අරාව පිටපත් කිරීම සඳහා සාදා ඇත.

මම පෞද්ගලිකව මේ ආකාරයට කැමතියි:

JSON.parse(JSON.stringify( originalObject ));

මගේ විශේෂිත අවස්ථාවෙහිදී, අරාව නොවෙනස්ව පවතින බව සහතික කිරීමට මට අවශ්‍ය විය, එබැවින් මෙය මට වැඩ කළේය:

// Empty array
arr1.length = 0;
// Add items from source array to target array
for (var i = 0; i < arr2.length; i++) {
    arr1.push(arr2[i]);
}

බහුමානීය අරාව / වස්තුවෙහි පිටපතක් සාදන්න:

function deepCopy(obj) {
   if (Object.prototype.toString.call(obj) === '[object Array]') {
      var out = [], i = 0, len = obj.length;
      for ( ; i < len; i++ ) {
         out[i] = arguments.callee(obj[i]);
      }
      return out;
   }
   if (typeof obj === 'object') {
      var out = {}, i;
      for ( i in obj ) {
         out[i] = arguments.callee(obj[i]);
      }
      return out;
   }
   return obj;
}

මෙම කාර්යය සඳහා ජේම්ස් පැඩොල්සිට ස්තූතියි.

මුලාශ්‍රය: මෙන්න

ඩෑන්, විසිතුරු උපක්‍රම භාවිතා කිරීමට අවශ්‍ය නැත. ඔබ කළ යුත්තේ මෙය කිරීමෙන් arr1 හි පිටපතක් සෑදීම පමණි.

var arr2 = new Array(arr1);

දැන් arr1සහ arr2වෙනස් අරාව විචල්‍යයන් දෙකක් වෙනම කොටස්වල ගබඩා කර ඇත. මෙය jsfiddle හි පරීක්ෂා කරන්න .

අපට පැවරුම් ක්‍රියාකරු භාවිතා කර අරාව පිටපත් කිරීමට අවශ්‍ය වූ විට ( =) එය පිටපතක් සාදන්නේ නැත, එය හුදෙක් අරාව වෙත දර්ශකය / යොමු කිරීම පිටපත් කරයි. උදාහරණයක් වශයෙන්:

const oldArr = [1,2,3];

const newArr = oldArr;  // now oldArr points to the same place in memory 

console.log(oldArr === newArr);  // Points to the same place in memory thus is true

const copy = [1,2,3];

console.log(copy === newArr);  // Doesn't point to the same place in memory and thus is false

බොහෝ විට අපි දත්ත පරිවර්තනය කරන විට අපගේ ආරම්භක දත්ත ව්‍යුහය (උදා: අරාව) නොවෙනස්ව තබා ගැනීමට අපට අවශ්‍යය. අපි මෙය කරන්නේ අපගේ අරාවෙහි නිශ්චිත පිටපතක් සෑදීමෙනි, එවිට මෙය පරිවර්තනය කළ හැකි අතර ආරම්භක එක නොවෙනස්ව පවතී.

අරාව පිටපත් කිරීමේ ක්‍රම:

const oldArr = [1,2,3];

// Uses the spread operator to spread out old values into the new array literal
const newArr1 = [...oldArr];

// Slice with no arguments returns the newly copied Array
const newArr2 = oldArr.slice();

// Map applies the callback to every element in the array and returns a new array
const newArr3 = oldArr.map((el) => el);

// Concat is used to merge arrays and returns a new array. Concat with no args copies an array
const newArr4 = oldArr.concat();

// Object.assign can be used to transfer all the properties into a new array literal
const newArr5 = Object.assign([], oldArr);

// Creating via the Array constructor using the new keyword
const newArr6 = new Array(...oldArr);

// For loop
function clone(base) {
	const newArray = [];
    for(let i= 0; i < base.length; i++) {
	    newArray[i] = base[i];
	}
	return newArray;
}

const newArr7 = clone(oldArr);

console.log(newArr1, newArr2, newArr3, newArr4, newArr5, newArr6, newArr7);

අරා හෝ වස්තූන් කූඩු කර ඇති විට ප්‍රවේශම් වන්න!:

අරා කූඩු කළ විට අගයන් යොමු කිරීමෙන් පිටපත් කරනු ලැබේ. මෙය ගැටළු වලට තුඩු දිය හැකි ආකාරය පිළිබඳ උදාහරණයක් මෙන්න:

let arr1 = [1,2,[1,2,3]]

let arr2 = [...arr1];

arr2[2][0] = 5;  // we change arr2

console.log(arr1);  // arr1 is also changed because the array inside arr1 was copied by reference

එබැවින් ඔබට පිටපත් කිරීමට අවශ්‍ය ඔබේ අරාව තුළ වස්තු හෝ අරා ඇති විට මෙම ක්‍රම භාවිතා නොකරන්න. එනම් ප්‍රාථමිකයන්ගේ අරා මත පමණක් මෙම ක්‍රම භාවිතා කරන්න.

ඔබ ජාවාස්ක්රිප්ට් අරා භාවිතා deepclone අවශ්ය නම් කළ JSON.parseසමඟ එක්ව JSON.stringifyමේ වගේ,:

let arr1 = [1,2,[1,2,3]]

let arr2 = JSON.parse(JSON.stringify(arr1)) ;

arr2[2][0] = 5;

console.log(arr1);  // now I'm not modified because I'm a deep clone

පිටපත් කිරීමේ කාර්ය සාධනය:

එබැවින් ප්‍රශස්ත කාර්ය සාධනය සඳහා අප තෝරා ගන්නේ කුමන එකද? වඩාත්ම වාචික ක්‍රමය වන ලූපයට forඉහළම ක්‍රියාකාරීත්වය ඇති බව පෙනේ. පාවිච්චි කරන්නforසැබවින්ම CPU තීව්‍ර පිටපත් කිරීම සඳහා ලූපය (විශාල / බොහෝ අරා).

ඉන්පසු .slice()ක්‍රමවේදය ද හොඳ කාර්ය සාධනයක් ඇති අතර එය වාචික හා ක්‍රමලේඛකයාට ක්‍රියාත්මක කිරීමට පහසු වේ. .slice()ඔබේ එදිනෙදා අරා පිටපත් කිරීම සඳහා භාවිතා කිරීමට මම යෝජනා කරමි . භාවිතා කිරීමෙන් වළකින්නJSON.parse(JSON.stringify(arr))ගැඹුරු ක්ලෝනයක් අවශ්‍ය නොවන්නේ නම් සහ කාර්ය සාධනය ගැටළුවක් නම් (බොහෝ දේ) .

ප්‍රභව කාර්ය සාධන පරීක්ෂණය

ඔබේ අරාවෙහි int, char, හෝ string වැනි ප්‍රාථමික දත්ත වර්ගයේ අංග තිබේ නම් .slice () හෝ .map () හෝ පැතිරුම් ක්‍රියාකරු (වැනි මුල් අරාවේ පිටපතක් ආපසු ලබා දෙන ක්‍රම වලින් එකක් ඔබට භාවිතා කළ හැකිය. ES6 ට ස්තූතියි).

new_array = old_array.slice()

හෝ

new_array = old_array.map((elem) => elem)

හෝ

const new_array = new Array(...old_array);

නමුත් ඔබේ අරාවෙහි වස්තූන් (හෝ අරා) හෝ ඊට වැඩි කැදැලි වස්තු වැනි සංකීර්ණ මූලද්‍රව්‍ය තිබේ නම්, එවිට ඔබ සියලු මූලද්‍රව්‍යවල පිටපතක් ඉහළ මට්ටමේ සිට අවසාන මට්ටම දක්වා අභ්‍යන්තරයේ වෙනත් සඳහනක් බවට පත් කරන බවට වග බලා ගත යුතුය. වස්තූන් භාවිතා කරනු ඇති අතර එයින් අදහස් කරන්නේ නව_ආරේ හි වස්තු_අවස්ථාවන්හි අගයන් වෙනස් කිරීම තවමත් පැරණි_ආරයට බලපානු ඇති බවයි. එක් එක් මට්ටමින් පිටපත් කිරීමේ ක්‍රමය ඔබට ඩීප් කෝපි එකක් ලෙස හැඳින්විය හැකිය පැරණි_ආරේ එකක් හැඳින්විය හැකිය.

ගැඹුරු පිටපත් කිරීම සඳහා, දත්ත වර්ගය අනුව එක් එක් මට්ටමින් ප්‍රාථමික දත්ත වර්ග සඳහා ඉහත සඳහන් ක්‍රම භාවිතා කළ හැකිය, නැතහොත් වැඩි වැඩ කොටසක් නොකර ගැඹුරු පිටපතක් සෑදීම සඳහා ඔබට මෙම මිල අධික ක්‍රමය (පහත සඳහන්) භාවිතා කළ හැකිය .

var new_array = JSON.parse(JSON.stringify(old_array));

ඔබේ අවශ්‍යතා අනුව ඔබට භාවිතා කළ හැකි වෙනත් ක්‍රම රාශියක් ඇත. මම සඳහන් කර ඇත්තේ ඒවායින් එකක් පමණක් වටිනාකමින් අනෙකට පිටපත් කිරීමට උත්සාහ කළ විට කුමක් සිදුවේද යන්න පිළිබඳ සාමාන්‍ය අදහසක් ලබා දීම සඳහා පමණි .

ඔබට වස්තුවක හෝ අරාවක නව පිටපතක් සෑදීමට අවශ්‍ය නම්, ඔබ වස්තුවේ ගුණාංග හෝ අරාවේ මූලද්‍රව්‍යයන් පැහැදිලිව පිටපත් කළ යුතුය, උදාහරණයක් ලෙස:

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

for (var i=0; i < arr1.length; i++) {
   arr2[i] = arr1[i];
}

වෙනස් කළ නොහැකි ප්‍රාථමික අගයන් සහ විකෘති වස්තු යොමු කිරීම් පිළිබඳව ඔබට ගූගල් හි වැඩි විස්තර සෙවිය හැකිය.

JQuery ගැඹුරු පිටපතක් භාවිතා කිරීම පහත පරිදි කළ හැකිය:

var arr2 = $.extend(true, [], arr1);

අරාව පිටපත් කිරීමට ඔබට ES6 පැතිරුම් ක්‍රියාකරු භාවිතා කළ හැකිය

var arr=[2,3,4,5];
var copyArr=[...arr];

පිටපත් කිරීමට තවත් ක්‍රම කිහිපයක් මෙන්න:

const array = [1,2,3,4];

const arrayCopy1 = Object.values(array);
const arrayCopy2 = Object.assign([], array);
const arrayCopy3 = array.map(i => i);
const arrayCopy4 = Array.of(...array );

ඔබට වඩාත් පහසු වන පැතිරුණු ඔපර්ටර් සමඟ ES6 භාවිතා කළ හැකිය.

arr2 = [...arr1];

සීමාවන් තිබේ..චෙක් ඩොක්ස් පැතිරෙන සින්ටැක්ස් @ මොසිල්ලා

ඉක්මන් උදාහරණ:

1. අරාවෙහි ඇති මූලද්‍රව්‍ය ප්‍රාථමික වර්ග නම් (නූල්, අංකය, ආදිය)

var arr1 = ['a','b','c'];
// arr1 and arr2 are independent and primitive elements are stored in 
// different places in the memory
var arr2 = arr1.slice(); 
arr2.push('d');
console.log(arr1); // [ 'a', 'b', 'c' ]
console.log(arr2); // [ 'a', 'b', 'c', 'd' ]

2. අරාවෙහි ඇති මූලද්‍රව්‍ය වස්තු සාහිත්‍ය නම්, තවත් අරාව ({}, [])

var arr1 = [{ x: 'a', y: 'b'}, [1, 2], [3, 4]];
// arr1 and arr2 are independent and reference's/addresses are stored in different
// places in the memory. But those reference's/addresses points to some common place
// in the memory.
var arr2 = arr1.slice(); 
arr2.pop();      // OK - don't affect arr1 bcos only the address in the arr2 is
                 // deleted not the data pointed by that address
arr2[0].x = 'z'; // not OK - affect arr1 bcos changes made in the common area 
                 // pointed by the addresses in both arr1 and arr2
arr2[1][0] = 9;	 // not OK - same above reason

console.log(arr1); // [ { x: 'z', y: 'b' }, [ 9, 2 ], [ 3, 4 ] ]
console.log(arr2); // [ { x: 'z', y: 'b' }, [ 9, 2 ] ]

3. 2 සඳහා විසඳුම : මූලද්‍රව්‍යය අනුව ගැඹුරු පිටපත

var arr1 = [{ x: 'a', y: 'b'}, [1, 2], [3, 4]];
arr2 = JSON.parse(JSON.stringify(arr1));
arr2.pop();	  // OK - don't affect arr1
arr2[0].x = 'z';  // OK - don't affect arr1
arr2[1][0] = 9;	  // OK - don't affect arr1

console.log(arr1); // [ { x: 'a', y: 'b' }, [ 1, 2 ], [ 3, 4 ] ]
console.log(arr2); // [ { x: 'z', y: 'b' }, [ 9, 2 ] ]

මෙන්න ප්‍රභේදයක්:

var arr1=['a', 'b', 'c'];
var arr2=eval(arr1.toSource());
arr2.push('d');
console.log('arr1: '+arr1+'\narr2: '+arr2);
/*
 *  arr1: a,b,c
 *  arr2: a,b,c,d
 */

අළුතින් හඳුන්වා දී ඇත Array.from, නමුත් අවාසනාවකට මෙන්, මෙම ලිවීමේ කාලය වන විට එයට සහය දක්වන්නේ මෑත කාලීන ෆයර්ෆොක්ස් අනුවාදයන් සඳහා පමණි (32 සහ ඊට වැඩි). එය සරලව පහත පරිදි භාවිතා කළ හැකිය:

var arr1 = [1, 2, 3];
console.log(Array.from(arr1)); // Logs: [1, 2, 3]

යොමුව: මෙන්න

හෝ Array.prototype.mapඅනන්‍යතා ශ්‍රිතයක් සමඟ භාවිතා කළ හැකිය:

function identity(param)
{
    return param;
}

var arr1 = [1, 2, 3],
    clone = arr1.map(identity);

යොමුව: මෙන්න

වස්තු අඩංගු ES6 අරාව සඳහා

cloneArray(arr) {
    return arr.map(x => ({ ...x }));
}