ජාවාස්ක්‍රිප්ට් හි අරාව ආරම්භයේ දී නව අරා අංග එකතු කරන්නේ කෙසේද?

අරාව ආරම්භයේ දී මූලද්‍රව්‍ය එකතු කිරීමට හෝ සූදානම් කිරීමට මට අවශ්‍යතාවයක් ඇත.

උදාහරණයක් ලෙස, මගේ අරාව පහතින් පෙනේ නම්:

[23, 45, 12, 67]

මගේ AJAX ඇමතුමෙන් ලැබෙන ප්‍රතිචාරය නම් 34, යාවත්කාලීන කළ අරාව පහත දැක්වෙන ආකාරයට වීමට මට අවශ්‍යය:

[34, 23, 45, 12, 67]

දැනට මම මේ ආකාරයට එය කිරීමට සැලසුම් කරමි:

var newArray = [];
newArray.push(response);

for (var i = 0; i < theArray.length; i++) {
    newArray.push(theArray[i]);
}

theArray = newArray;
delete newArray;

මෙය කිරීමට වඩා හොඳ ක්‍රමයක් තිබේද? ජාවාස්ක්‍රිප්ට් හි මෙය තුළ කිසියම් ක්‍රියාකාරීත්වයක් තිබේද?

මගේ ක්‍රමයේ සංකීර්ණතාවය වන අතර O(n)වඩා හොඳ ක්‍රියාත්මක කිරීම් දැකීම ඇත්තෙන්ම සිත්ගන්නා සුළු වනු ඇත.

භාවිතා කරන්න unshift. එය හරියට pushඅවසානය වෙනුවට අරාවෙහි ආරම්භයට මූලද්‍රව්‍ය එකතු කිරීම හැර.

• unshift/ push- අරාවක ආරම්භයට / අවසානයට මූලද්‍රව්‍යයක් එක් කරන්න
• shift/ pop - අරාවෙහි පළමු / අවසාන අංගය ඉවත් කර ආපසු එවන්න

සරල රූප සටහනක් ...

   unshift -> array <- push
   shift   <- array -> pop

සහ සටහන:

          add  remove  start  end
   push    X                   X
    pop           X            X
unshift    X             X
  shift           X      X

මෙම පරීක්ෂා කරන්න MDN Array ප්රලේඛනය . අරාවකින් මූලද්‍රව්‍ය තල්ලු කිරීමේ / පොප් කිරීමේ හැකියාව ඇති සෑම භාෂාවකටම පාහේ මූලද්‍රව්‍ය ඉවත් කිරීමට / මාරු කිරීමට (සමහර විට push_front/ pop_front) ලෙස හැඳින්වීමේ හැකියාව ඇත , ඔබට මේවා කිසි විටෙකත් ක්‍රියාත්මක කිරීමට අවශ්‍ය නොවිය යුතුය.

අදහස් දැක්වීමේදී පෙන්වා දී ඇති පරිදි, ඔබේ මුල් අරාව විකෘති කිරීමෙන් වළක්වා ගැනීමට ඔබට අවශ්‍ය නම්, ඔබට භාවිතා කළ හැකිය concat, එය අරා දෙකක් හෝ වැඩි ගණනක් එකට සම්බන්ධ කරයි. පවතින මූලද්‍රව්‍යයක ඉදිරිපස හෝ පසුපසට තනි මූලද්‍රව්‍යයක් ක්‍රියාකාරීව තල්ලු කිරීමට ඔබට මෙය භාවිතා කළ හැකිය; එසේ කිරීමට, ඔබ නව මූලද්‍රව්‍යය තනි මූලද්‍රව්‍ය අරාවක් බවට පත් කළ යුතුය:

const array = [ 3, 2, 1 ]

const newFirstElement = 4

const newArray = [newFirstElement].concat(array) // [ 4, 3, 2, 1 ]

concatඅයිතම එකතු කිරීමට ද හැකිය. සඳහා වන තර්ක concatඕනෑම වර්ගයක විය හැකිය; ඒවා දැනටමත් අරාවක් නොමැති නම් ඒවා තනි මූලද්‍රව්‍ය අරාවකින් ඔතා ඇත:

const array = [ 3, 2, 1 ]

const newLastElement  = 0

// Both of these lines are equivalent:
const newArray1 = array.concat(newLastElement)   // [ 3, 2, 1, 0 ]
const newArray2 = array.concat([newLastElement]) // [ 3, 2, 1, 0 ]

ES6 සමඟ, පැතිරීමේ ක්‍රියාකරු භාවිතා කරන්න ...:

ඩෙමෝ

var arr = [23, 45, 12, 67];
arr = [34, ...arr]; // RESULT : [34,23, 45, 12, 67]

console.log(arr)

එය කළ හැකි තවත් ක්‍රමයක් concat

var arr = [1, 2, 3, 4, 5, 6, 7];
console.log([0].concat(arr));

අතර වෙනස concatහා unshiftබවයි concatනව මාලාවක් පැමිණේ. ඔවුන් අතර කාර්ය සාධනය මෙහි සොයාගත හැකිය .

function fn_unshift() {
  arr.unshift(0);
  return arr;
}

function fn_concat_init() {
  return [0].concat(arr)
}

පරීක්ෂණ ප්‍රති .ලය මෙන්න

ඉක්මන් වංචා පත්‍රිකාව:

C හි වැඩසටහන්කරණය ගැන හුරු නැති අයට අවම වශයෙන් shift / unshift සහ push / pop යන වචන ටිකක් ව්‍යාකූල විය හැකිය.

ඔබ භාෂාව ගැන හුරු නැතිනම්, විකල්ප වචනවල ඉක්මන් පරිවර්තනයක් මෙහි ඇත, එය මතක තබා ගැනීම පහසු විය හැකිය:

* array_unshift()  -  (aka Prepend ;; InsertBefore ;; InsertAtBegin )     
* array_shift()    -  (aka UnPrepend ;; RemoveBefore  ;; RemoveFromBegin )

* array_push()     -  (aka Append ;; InsertAfter   ;; InsertAtEnd )     
* array_pop()      -  (aka UnAppend ;; RemoveAfter   ;; RemoveFromEnd ) 

ඔබට අරාවක් තිබේ: var arr = [23, 45, 12, 67];

ආරම්භයට අයිතමයක් එක් කිරීමට, ඔබට භාවිතා කිරීමට අවශ්‍ය වන්නේ splice:

var arr = [23, 45, 12, 67];
arr.splice(0, 0, 34)
console.log(arr);

විකෘති නොමැතිව

ඇත්ත වශයෙන්ම, සියලු unshift/ pushසහ shift/ pop විකෘති සම්භවය අරාව.

මෙම unshift/ pushආරම්භ / කෙළවරක සිට පැවති අරාවට අයිතමය එකතු shift/ popරැසක් ආරම්භයේ / අවසානයේ සිට අයිතමය ඉවත් කරන්න.

නමුත් විකෘතියකින් තොරව අරාවකට අයිතම එකතු කිරීමට ක්‍රම කිහිපයක් තිබේ. ප්‍රති code ලය පහත දැක්වෙන කේතයේ අරාව භාවිතයේ අවසානයට එක් කිරීමට නව අරාවකි:

const originArray = ['one', 'two', 'three'];
const newItem = 4;

const newArray = originArray.concat(newItem); // ES5
const newArray2 = [...originArray, newItem]; // ES6+

මුල් අරාව ආරම්භ කිරීම සඳහා එකතු කිරීම සඳහා පහත කේතය භාවිතා කරන්න:

const originArray = ['one', 'two', 'three'];
const newItem = 0;

const newArray = (originArray.slice().reverse().concat(newItem)).reverse(); // ES5
const newArray2 = [newItem, ...originArray]; // ES6+

ඉහත ක්‍රමය සමඟ, ඔබ විකෘතියකින් තොරව අරාවක ආරම්භයට / අවසානයට එකතු කරයි.

ES6 විනාශ කිරීම භාවිතා කිරීම: (මුල් අරාවෙන් විකෘති වීම වළක්වා ගැනීම)

const newArr = [item, ...oldArr]

අරාව ආරම්භයේදීම ඔබට මූලද්‍රව්‍යයක් අඛණ්ඩව ඇතුළත් කිරීමට අවශ්‍ය නම් , සෑම විටම ඇමතීම වෙනුවට pushඇමතුමකින් පසුව ප්‍රකාශ භාවිතා කිරීම වේගවත් වේ .reverseunshift

මිණුම් සලකුණු පරීක්ෂණය: http://jsben.ch/kLIYf

spliceඅපි භාවිතා කිරීමේදී මූලද්‍රව්‍යයක් අරාවකට ඇතුළත් කරමු:

arrName.splice( 0, 0, 'newName1' );

ඔබේ අරාව ආරම්භයේ දී අරාවෙහි ඇති මූලද්‍රව්‍ය තල්ලු කිරීමට ඔබට අවශ්‍ය නම් <func>.apply(<this>, <Array of args>):

const arr = [1, 2];
arr.unshift.apply(arr, [3, 4]);
console.log(arr); // [3, 4, 1, 2]