නව අරාවක් නිර්මාණය නොකර, දැනට පවතින ජාවාස්ක්‍රිප්ට් අරාව වෙනත් අරාවක් සමඟ දිගු කරන්නේ කෙසේද

දැනට පවතින ජාවාස්ක්‍රිප්ට් අරාව වෙනත් අරාවකින් විස්තාරණය කිරීමට ක්‍රමයක් ඇති බවක් නොපෙනේ, එනම් පයිතන්ගේ extendක්‍රමය අනුකරණය කිරීම .

මට පහත දෑ සාක්ෂාත් කර ගැනීමට අවශ්‍යයි:

>>> a = [1, 2]
[1, 2]
>>> b = [3, 4, 5]
[3, 4, 5]
>>> SOMETHING HERE
>>> a
[1, 2, 3, 4, 5]

a.concat(b)ක්‍රමයක් ඇති බව මම දනිමි , නමුත් එය පළමු ක්‍රමය සරල කිරීම වෙනුවට නව අරාවක් නිර්මාණය කරයි. aවඩා සැලකිය යුතු තරම් විශාල වූ විට b(එනම් පිටපත් නොකරන a) කාර්යක්ෂමව ක්‍රියා කරන ඇල්ගොරිතමයකට මම කැමතියි .

_{සටහන: මෙය අනුපිටපතක් නොවේ අරාවකට යමක් එකතු කරන්නේ කෙසේද? - මෙහි පරමාර්ථය වන්නේ එක් අරාවක සම්පූර්ණ අන්තර්ගතය අනෙකට එකතු කිරීම සහ එය “තැනින් තැන” කිරීම, එනම් විස්තාරිත අරාවෙහි සියලුම අංග පිටපත් නොකර.}

මෙම .pushක්රමය බහු තර්ක කළ හැක. දෙවන අරාවේ සියලුම අංග තර්ක ලෙස සම්මත කිරීමට ඔබට පැතිරුම් ක්‍රියාකරු භාවිතා කළ හැකිය .push:

>>> a.push(...b)

ඔබගේ බ්‍රව්සරය ECMAScript 6 සඳහා සහය නොදක්වන්නේ නම්, .applyඒ වෙනුවට ඔබට භාවිතා කළ හැකිය :

>>> a.push.apply(a, b)

නැතහොත්, එය වඩාත් පැහැදිලි යැයි ඔබ සිතන්නේ නම්:

>>> Array.prototype.push.apply(a,b)

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

_{යාවත්කාලීන 2018 : වඩා හොඳ පිළිතුරක් මගේ නවතම එකකි : a.push(...b). මෙම ප්‍රශ්නයට කිසි විටෙකත් පිළිතුරු නොදුන් බැවින් මෙය තවදුරටත් ඉහළට ඔසවා තබන්න එපා, නමුත් එය ගූගල් හි පළමු වරට පහර දුන් 2015 කඩුල්ලක් විය :)}

"ජාවාස්ක්‍රිප්ට් අරා විස්තාරණය" සඳහා සරලව සෙවූ සහ මෙහි පැමිණි අය සඳහා, ඔබට ඉතා හොඳින් භාවිතා කළ හැකිය Array.concat.

var a = [1, 2, 3];
a = a.concat([5, 4, 3]);

නූල් ආරම්භකයාට අවශ්‍ය නැති නිසා කොන්කට් විසින් නව අරාවෙහි පිටපතක් ලබා දෙනු ඇත. නමුත් ඔබ ගණන් නොගත හැකිය (නිසැකවම බොහෝ ආකාරයේ භාවිතයන් සඳහා මෙය හොඳ වනු ඇත).

පැතිරීමේ ක්‍රියාකරුගේ ස්වරූපයෙන් මේ සඳහා හොඳ ECMAScript 6 සීනි ද තිබේ:

const a = [1, 2, 3];
const b = [...a, 5, 4, 3];

(එය පිටපත් කරයි.)

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

තරමක් තද පුඩුවක් මත පදනම් වූ ක්‍රියාත්මක කිරීම:

Array.prototype.extend = function (other_array) {
    /* You should include a test to check whether other_array really is an array */
    other_array.forEach(function(v) {this.push(v)}, this);
}

එවිට ඔබට පහත සඳහන් දෑ කළ හැකිය:

var a = [1,2,3];
var b = [5,4,3];
a.extend(b);

.applyඅප එකතු කරන අරාව විශාල වන විට DzinX හි පිළිතුර (push.apply භාවිතා කිරීම) සහ වෙනත් පදනම් වූ ක්‍රම අසාර්ථක වේ (පරීක්ෂණවලින් පෙනී යන්නේ මට විශාල> ක්‍රෝම් හි ඇතුළත් කිරීම් 150,000 ක් සහ ෆයර්ෆොක්ස් හි ඇතුළත් කිරීම් 500,000 ක් පමණ වන බවයි). මෙම jsperf හි මෙම දෝෂය සිදුවන බව ඔබට දැක ගත හැකිය .

දෝෂයක් ඇති වන්නේ දෙවන තර්කය ලෙස 'Function.prototype.apply' විශාල අරාවකින් කැඳවූ විට ඇමතුම් තොගයේ ප්‍රමාණය ඉක්මවා ඇති බැවිනි. ( Function.prototype.apply භාවිතා කරමින් ඇමතුම් තොගයේ ප්‍රමාණය ඉක්මවා යාමේ අන්තරායන් පිළිබඳ සටහනක් MDN සතුව ඇත - "අදාළ කර ගොඩනංවන ලද කාර්යයන්" යන මාතෘකාව බලන්න.)

මෙම පිටුවේ ඇති වෙනත් පිළිතුරු සමඟ වේගවත් සංසන්දනයක් සඳහා, මෙම jsperf බලන්න ( ස්තූතියි). ලූප් මත පදනම් වූ ක්‍රියාත්මක කිරීම භාවිතා කිරීමේ වේගය හා සමාන වේ Array.push.apply, නමුත් වඩා ටිකක් මන්දගාමී වේ Array.slice.apply.

සිත්ගන්නා කරුණ නම්, ඔබ එකතු කරන අරාව විරල නම්, forEachඉහත පදනම් කරගත් ක්‍රමයට විරලතාවයෙන් ප්‍රයෝජන ගත හැකි අතර ඒවා ඉක්මවා යා හැක.apply පදනම් වූ ක්‍රමවේදයන් ; ඔබට මෙය පරීක්ෂා කර බැලීමට අවශ්‍ය නම් මෙම jsperf බලන්න.

මාර්ගය වන විට, සෑම ක්‍රියාවලියක් සඳහාම තවදුරටත් කෙටි කිරීමට (මා මෙන්!) පෙළඹෙන්න එපා:

Array.prototype.extend = function (array) {
    array.forEach(this.push, this);
}

මෙය කුණු කසළ ප්‍රති results ල ලබා දෙන නිසා! මන්ද? මන්ද Array.prototype.forEachඑය හඳුන්වන ශ්‍රිතයට තර්ක තුනක් සපයයි - ඒවා නම්: (element_value, element_index, source_array). forEachඔබ "forEach (this.push, this)" භාවිතා කරන්නේ නම් මේ සෑම ක්‍රියාවක් සඳහාම ඔබේ පළමු අරාව වෙතට තල්ලු කරනු ලැබේ !

මේ දිනවල වඩාත්ම අලංකාර බව මට හැඟේ:

arr1.push(...arr2);

මෙම පැතිරීම ක්රියාකරු මත MDN ලිපිය ES2015 (ES6) මෙම ලස්සන සීනි මාර්ගය සඳහන්:

වඩා හොඳ තල්ලුවක්

උදාහරණය: තල්ලු කිරීම බොහෝ විට භාවිතා කරනුයේ පවතින අරාවක අවසානයට අරාව තල්ලු කිරීමට ය. ES5 හි මෙය බොහෝ විට සිදු කරනුයේ:

var arr1 = [0, 1, 2];
var arr2 = [3, 4, 5];
// Append all items from arr2 onto arr1
Array.prototype.push.apply(arr1, arr2);

පැතිරීම සමඟ ES6 හි මෙය සිදු වන්නේ:

var arr1 = [0, 1, 2];
var arr2 = [3, 4, 5];
arr1.push(...arr2);

arr2Jcdude ගේ පිළිතුරට අනුව ඇමතුම් තොගය පිරී ඉතිරී යන හෙයින් එය විශාල විය නොහැකි බව සලකන්න (අයිතම 100,000 ක් පමණ තබා ගන්න).

apply()අපි එය භාවිතා කරන්නේ ඇයිද යන්න තේරුම් ගැනීමට උදව් කිරීමට පළමුව ජාවාස්ක්‍රිප්ට් හි වචන කිහිපයක් :

මෙම apply()ක්‍රමය මඟින් ලබා දී ඇති thisඅගය සහිත ශ්‍රිතයක් සහ අරාව ලෙස ලබා දී ඇති තර්ක කැඳවයි .

අරාව වෙත එකතු කිරීම සඳහා අයිතම ලැයිස්තුවක් පුෂ් අපේක්ෂා කරයි . apply()කෙසේ වෙතත්, මෙම ක්‍රමය මඟින් ශ්‍රිත ඇමතුම සඳහා අපේක්ෂිත තර්ක අරාව ලෙස ගනී. pushබිල්ඩින් push()ක්‍රමවේදය සමඟ එක් අරාවක මූලද්‍රව්‍ය තවත් අරාවකට පහසුවෙන් ගෙනයාමට මෙය අපට ඉඩ දෙයි .

ඔබට මෙම අරා ඇති බව සිතන්න:

var a = [1, 2, 3, 4];
var b = [5, 6, 7];

සරලව මෙය කරන්න:

Array.prototype.push.apply(a, b);

ප්රති result ලය වනු ඇත්තේ:

a = [1, 2, 3, 4, 5, 6, 7];

පැතිරීමේ ක්‍රියාකරු (" ...") භාවිතා කරමින් ES6 හි එකම දේ කළ හැකිය :

a.push(...b); //a = [1, 2, 3, 4, 5, 6, 7]; 

කෙටි හා වඩා හොඳ නමුත් මේ මොහොතේ සියලුම බ්‍රව්සර්වල පූර්ණ සහය නොදක්වයි.

ක්‍රියාවලියේ හිස් කිරීම , අරාව සිට සියල්ල දක්වා ගෙනයාමට ඔබට අවශ්‍ය නම් , ඔබට මෙය කළ හැකිය:bab

while(b.length) {
  a.push(b.shift());
} 

ප්‍රති result ලය පහත පරිදි වේ:

a = [1, 2, 3, 4, 5, 6, 7];
b = [];

ඔබට jQuery භාවිතා කිරීමට අවශ්‍ය නම් $ .merge () ඇත

උදාහරණයක්:

a = [1, 2];
b = [3, 4, 5];
$.merge(a,b);

ප්‍රති ult ලය: a = [1, 2, 3, 4, 5]

a.push.apply(a, b)ඉහත විස්තර කර ඇති ක්‍රමයට මම කැමතියි , ඔබට අවශ්‍ය නම් ඔබට සැමවිටම මේ ආකාරයට පුස්තකාල ශ්‍රිතයක් නිර්මාණය කළ හැකිය:

Array.prototype.append = function(array)
{
    this.push.apply(this, array)
}

එය මේ ආකාරයට භාවිතා කරන්න

a = [1,2]
b = [3,4]

a.append(b)

එය භාවිතයෙන් එය කළ හැකිය splice():

b.unshift(b.length)
b.unshift(a.length)
Array.prototype.splice.apply(a,b) 
b.shift() // Restore b
b.shift() // 

නමුත් අවලස්සන වුවත් එය වේගවත් නොවේ push.apply, අවම වශයෙන් ෆයර්ෆොක්ස් 3.0 හි නොවේ.

මෙම විසඳුම මා වෙනුවෙන් ක්‍රියා කරයි (ECMAScript 6 හි පැතිරීමේ ක්‍රියාකරු භාවිතා කරමින්):

let array = ['my', 'solution', 'works'];
let newArray = [];
let newArray2 = [];
newArray.push(...array); // Adding to same array
newArray2.push([...array]); // Adding as child/leaf/sub-array
console.log(newArray);
console.log(newArray2);

මා පහත දැක්වෙන පරිදි ඔබට දිගු කිරීම සඳහා පොලිෆිල් එකක් සෑදිය හැකිය. එය අරාවට එකතු කරනු ඇත; ඔබට වෙනත් ක්‍රම දාමයක් ලබා ගත හැකි වන පරිදි ස්ථානගත වී නැවත පැමිණෙන්න.

if (Array.prototype.extend === undefined) {
  Array.prototype.extend = function(other) {
    this.push.apply(this, arguments.length > 1 ? arguments : other);
    return this;
  };
}

function print() {
  document.body.innerHTML += [].map.call(arguments, function(item) {
    return typeof item === 'object' ? JSON.stringify(item) : item;
  }).join(' ') + '\n';
}
document.body.innerHTML = '';

var a = [1, 2, 3];
var b = [4, 5, 6];

print('Concat');
print('(1)', a.concat(b));
print('(2)', a.concat(b));
print('(3)', a.concat(4, 5, 6));

print('\nExtend');
print('(1)', a.extend(b));
print('(2)', a.extend(b));
print('(3)', a.extend(4, 5, 6));

body {
  font-family: monospace;
  white-space: pre;
}

පිළිතුරු ඒකාබද්ධ කරමින් ...

Array.prototype.extend = function(array) {
    if (array.length < 150000) {
        this.push.apply(this, array)
    } else {
        for (var i = 0, len = array.length; i < len; ++i) {
            this.push(array[i]);
        };
    }  
}

අරා දෙකකට වඩා ඒකාබද්ධ කිරීම සඳහා තවත් විසඳුමක්

var a = [1, 2],
    b = [3, 4, 5],
    c = [6, 7];

// Merge the contents of multiple arrays together into the first array
var mergeArrays = function() {
 var i, len = arguments.length;
 if (len > 1) {
  for (i = 1; i < len; i++) {
    arguments[0].push.apply(arguments[0], arguments[i]);
  }
 }
};

ඉන්පසු අමතන්න:

mergeArrays(a, b, c);
console.log(a)

ප්‍රතිදානය වනුයේ: Array [1, 2, 3, 4, 5, 6, 7]

පිළිතුර ඉතා සරල ය.

>>> a = [1, 2]
[1, 2]
>>> b = [3, 4, 5]
[3, 4, 5]
>>> SOMETHING HERE
(The following code will combine the two arrays.)

a = a.concat(b);

>>> a
[1, 2, 3, 4, 5]

කොන්කට් ජාවාස්ක්‍රිප්ට් නූල් සම්මුතියට බෙහෙවින් සමාන ය. එමඟින් ඔබ විසින් ශ්‍රිතය හඳුන්වන අරාව අවසානයේ කොන්ක්‍රීට් ශ්‍රිතයට දැමූ පරාමිතියේ එකතුවක් ලබා දෙනු ඇත. ක x රත්වය නම්, ඔබ ආපසු ලබා දුන් අගය විචල්‍යයකට පැවරිය යුතු අතර එය නැති වී යයි. උදාහරණයක් ලෙස

a.concat(b);  <--- This does absolutely nothing since it is just returning the combined arrays, but it doesn't do anything with it.

> 150,000 වාර්තා Array.extendවෙනුවට භාවිතා කරන්න Array.push.

if (!Array.prototype.extend) {
  Array.prototype.extend = function(arr) {
    if (!Array.isArray(arr)) {
      return this;
    }

    for (let record of arr) {
      this.push(record);
    }

    return this;
  };
}

push()ක්‍රමයේ ආධාරයෙන් අරාව වෙත නව අංග එකතු කිරීමෙන් ඔබට එය කළ හැකිය .

let colors = ["Red", "Blue", "Orange"];
console.log('Array before push: ' + colors);
// append new value to the array
colors.push("Green");
console.log('Array after push : ' + colors);

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

let colors = ["Red", "Blue", "Orange"];
console.log('Array before unshift: ' + colors);
// append new value to the array
colors.unshift("Black", "Green");
console.log('Array after unshift : ' + colors);

වෙනත් ක්‍රම ද තිබේ. ඔබට ඒවා මෙතැනින් පරීක්ෂා කළ හැකිය .

ඉතා සරලයි, එය ගැටළුවක් නම්, පැතිරීමේ ක්‍රියාකරුවන් ගණන් නොගනී.

b.map(x => a.push(x));

මේ පිළිබඳව සමහර කාර්ය සාධන පරීක්ෂණ පැවැත්වීමෙන් පසු, එය ඉතා මන්දගාමී ය, නමුත් නව අරාවක් නිර්මාණය නොකිරීම පිළිබඳ ප්‍රශ්නයට පිළිතුරු සපයයි. කොන්කට් සැලකිය යුතු වේගයකින් යුක්ත වන අතර, jQuery පවා $.merge()එය අනුමත කරයි.

https://jsperf.com/merge-arrays19b/1