මට ජාවාස්ක්‍රිප්ට් අරාවක් ඇත, dataArrayඑය මට නව අරාවකට තල්ලු කිරීමට අවශ්‍යය newArray. මම කැමති නෑ හැර newArray[0]විය dataArray. සියලු අයිතම නව අරාව තුළට තල්ලු කිරීමට මට අවශ්‍යය:

var newArray = [];

newArray.pushValues(dataArray1);
newArray.pushValues(dataArray2);
// ...

හෝ ඊටත් වඩා හොඳ:

var newArray = new Array (
   dataArray1.values(),
   dataArray2.values(),
   // ... where values() (or something equivalent) would push the individual values into the array, rather than the array itself
);

දැන් නව අරාවෙහි තනි දත්ත අරා වල සියලු අගයන් අඩංගු වේ. අයිතම එකින් එක එකතු කරමින් මට pushValuesඑක් එක් පුද්ගලයාට වඩා නැවත කියවීමට අවශ්‍ය නැති නිසා කෙටිමං කිහිපයක් dataArrayතිබේද?

කොන්ක්‍රීට් ශ්‍රිතය භාවිතා කරන්න , එසේ:

var arrayA = [1, 2];
var arrayB = [3, 4];
var newArray = arrayA.concat(arrayB);

newArrayකැමැත්තෙහි වටිනාකම [1, 2, 3, 4]( arrayAසහ arrayBනොවෙනස්ව පවතී; concatප්‍රති .ලය සඳහා නව අරාවක් නිර්මාණය කර ආපසු ලබා දෙයි).

ඔබගේ පෙලගැස්මක් විශාල නොවේ සපයන (පහත වරනයක් බලන්න), ඔබ භාවිතා කළ හැකිය push()ඔබ වටිනාකම් එකතු කිරීමට කැමති සඳහා අරා ක්රමය. push()බහු පරාමිතීන් ගත හැකි apply()බැවින් ශ්‍රිත පරාමිතීන් ලැයිස්තුවක් ලෙස තල්ලු කළ යුතු අගයන් පෙළ පසු කිරීමට ඔබට එහි ක්‍රමය භාවිතා කළ හැකිය . concat()නව අරාවක් නිර්මාණය කරනවාට වඩා තැනින් තැනට මූලද්‍රව්‍ය එකතු කිරීම භාවිතා කිරීමේ වාසිය මෙයයි .

කෙසේ වෙතත්, විශාල අරා සඳහා (සාමාජිකයන් 100,000 ක් හෝ ඊට වැඩි ගණනක), මෙම උපක්‍රමය අසාර්ථක විය හැකි බව පෙනේ. එවැනි අරා සඳහා, ලූපයක් භාවිතා කිරීම වඩා හොඳ ප්‍රවේශයකි. වැඩි විස්තර සඳහා https://stackoverflow.com/a/17368101/96100 බලන්න.

var newArray = [];
newArray.push.apply(newArray, dataArray1);
newArray.push.apply(newArray, dataArray2);

මෙය ශ්‍රිතයක් බවට සාමාන්‍යකරණය කිරීමට ඔබට අවශ්‍ය විය හැකිය:

function pushArray(arr, arr2) {
    arr.push.apply(arr, arr2);
}

... හෝ එය Arrayමූලාකෘතියට එක් කරන්න :

Array.prototype.pushArray = function(arr) {
    this.push.apply(this, arr);
};

var newArray = [];
newArray.pushArray(dataArray1);
newArray.pushArray(dataArray2);

... හෝ මුල් අනුකරණය push()බව භාවිතයෙන් බහු පරාමිතීන් ඉඩ දීම මගින් ක්රමය concat()මෙන් push(), බහු පරාමිතියන් අවකාශ ලබා දෙයි:

Array.prototype.pushArray = function() {
    this.push.apply(this, this.concat.apply([], arguments));
};

var newArray = [];
newArray.pushArray(dataArray1, dataArray2);

IE <= 8 ඇතුළුව විශාල අරා සහ සියලුම ප්‍රධාන බ්‍රව්සර් සඳහා සුදුසු අවසාන උදාහරණයේ ලූප් පාදක අනුවාදය මෙන්න.

Array.prototype.pushArray = function() {
    var toPush = this.concat.apply([], arguments);
    for (var i = 0, len = toPush.length; i < len; ++i) {
        this.push(toPush[i]);
    }
};

මම තවත් "අනාගත-ඔප්පු" පිළිතුරක් එක් කරමි

ECMAScript 6 හි, ඔබට පැතිරෙන සින්ටැක්ස් භාවිතා කළ හැකිය :

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

console.log(arr1)

සියලුම ප්‍රධාන බ්‍රව්සර්වල පැතිරුණු සින්ටැක්ස් තවමත් ඇතුළත් කර නොමැත. වත්මන් අනුකූලතාව සඳහා, මෙම (අඛණ්ඩව යාවත්කාලීන කරන ලද) අනුකූලතා වගුව බලන්න .

කෙසේ වෙතත්, ඔබට බාබෙල්.ජේ සමඟ පැතිරෙන සින්ටැක්ස් භාවිතා කළ හැකිය .

සංස්කරණය කරන්න:

කාර්ය සාධනය පිළිබඳ වැඩි විස්තර සඳහා ජැක් ගිෆින්ගේ පිළිතුර පහත බලන්න. පැතිරුම් ක්‍රියාකරුට වඩා කොන්කට් තවමත් හොඳ සහ වේගවත් බව පෙනේ.

එම්ඩීඑන් වෙතින් අලංකාර ක්‍රමයක් සොයා ගත්තේය

var vegetables = ['parsnip', 'potato'];
var moreVegs = ['celery', 'beetroot'];

// Merge the second array into the first one
// Equivalent to vegetables.push('celery', 'beetroot');
Array.prototype.push.apply(vegetables, moreVegs);

console.log(vegetables); // ['parsnip', 'potato', 'celery', 'beetroot']

නැතහොත් ඔබට spread operatorES6 හි විශේෂාංගය භාවිතා කළ හැකිය :

let fruits = [ 'apple', 'banana'];
const moreFruits = [ 'orange', 'plum' ];

fruits.push(...moreFruits); // ["apple", "banana", "orange", "plum"]

var a=new Array('a','b','c');
var b=new Array('d','e','f');
var d=new Array('x','y','z');
var c=a.concat(b,d)

එය ඔබේ ගැටලුව විසඳනවාද?

පහත දැක්වෙන්නේ මට සරල බව පෙනේ:

var newArray = dataArray1.slice();
newArray.push.apply(newArray, dataArray2);

"තල්ලු කිරීම" විචල්‍ය තර්ක ගණනක් ගන්නා බැවින්, ඔබට වෙනත් අරාවක සියලුම අංග තල්ලු කිරීමට ශ්‍රිතයේ applyක්‍රමය භාවිතා කළ හැකිය push. එහි පළමු තර්කය ("නව අරා" මෙහි) "මෙය" ලෙසත්, අරාවෙහි මූලද්‍රව්‍යයන් ඉතිරි තර්ක ලෙසත් තල්ලු කිරීම සඳහා ඇමතුමක් සාදයි.

මෙම sliceපළමු ප්රකාශයේ පළමු මාලාවක් පිටපතක් ලැබෙන, එසේ ඔබ එය වෙනස් කරන්නේ නැහැ.

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

newArray.push(...dataArray2)

පහත ශ්‍රිතයට අරා වල දිග පිළිබඳ ගැටළුවක් නොමැති අතර සියලු යෝජිත විසඳුම් වලට වඩා හොඳින් ක්‍රියා කරයි:

function pushArray(list, other) {
    var len = other.length;
    var start = list.length;
    list.length = start + len;
    for (var i = 0; i < len; i++ , start++) {
        list[start] = other[i];
    }
}

අවාසනාවකට මෙන්, jspref මගේ ඉදිරිපත් කිරීම් පිළිගැනීම ප්‍රතික්ෂේප කරයි, එබැවින් මෙන්න ඒවා benchmark.js භාවිතා කරන ප්‍රති results ල වේ

        Name            |   ops/sec   |  ± %  | runs sampled
for loop and push       |      177506 |  0.92 | 63
Push Apply              |      234280 |  0.77 | 66
spread operator         |      259725 |  0.40 | 67
set length and for loop |      284223 |  0.41 | 66

කොහෙද

ලූප් සහ තල්ලු සඳහා:

    for (var i = 0, l = source.length; i < l; i++) {
        target.push(source[i]);
    }

තල්ලු කරන්න අයදුම් කරන්න:

target.push.apply(target, source);

පැතිරීමේ ක්‍රියාකරු:

    target.push(...source);

අවසාන වශයෙන් 'සෙට් දිග සහ ලූපය' යනු ඉහත ශ්‍රිතයයි

𝗥𝗲𝘀𝗲𝗮𝗿𝗰𝗵 𝗔𝗻𝗱 𝗕𝗲𝗻𝗰𝗵𝗺𝗮𝗿𝗸𝘀 𝗣𝗼𝘄𝗲𝗿𝗳𝘂𝗹𝗹𝘆 𝗦𝗵𝗼𝘄 𝗧𝗵𝗮𝘁 𝗖𝗼𝗻𝗰𝗮𝘁 𝗜𝘀 𝗧𝗵𝗲 𝗕𝗲𝘀𝘁 (මුල් ප්‍රශ්නය සඳහා)

කරුණු සඳහා, jsperf හි කාර්ය සාධන පරීක්ෂණයක් සහ කොන්සෝලයේ සමහර දේවල් පරීක්ෂා කිරීම සිදු කරනු ලැබේ. පර්යේෂණ සඳහා, irt.org වෙබ් අඩවිය භාවිතා කරයි. පහත දැක්වෙන්නේ මෙම සියලු ප්‍රභවයන්ගේ එකතුවක් සහ පතුලේ උදාහරණ ශ්‍රිතයකි.

╔═══════════════╦══════╦═════════════════╦════════ ═══════╦═════════╦══════════╗
║ ක්‍රමය onConcat║slice & push.apply ║ push.apply x2 ║ ForLoop ║Sread
╠═══════════════╬══════╬═════════════════╬════════ ═══════╬═════════╬══════════╣
MOps / Sec ║179 ║104 ║ 76 81 ║28
╠═══════════════╬══════╬═════════════════╬════════ ═══════╬═════════╬══════════╣
Ar විරල අරා ║ ඔව්! පෙති කපන ලද නැත ║ සමහර විට 2   ║no ║
║ විරල ලෙස තබා ඇත ║ ║ආරේ (1 වන ආර්ග්) ║ ║ ║
╠═══════════════╬══════╬═════════════════╬════════ ═══════╬═════════╬══════════╣
║ සහාය ║MSIE 4║MSIE 5.5 ║ MSIE 5.5 ║ MSIE 4 dEdge 12
║ ( මූලාශ්රය ) ║NNav 4║NNav 4,06 ║ NNav 4,06 ║ NNav 3 ║ MSIE  NNav ║
╠═══════════════╬══════╬═════════════════╬════════ ═══════╬═════════╬══════════╣
R අරා-වැනි ක්‍රියා - තල්ලු කළ පමණින් ඔව්! ඔව්! If තිබේ නම්
රාශියද ║ ║array (2 වන arg) ║ ║ ║iterator ║like 1   ║
╚═══════════════╩══════╩═════════════════╩════════ ═══════╩═════════╩══════════╝
1 අරාව වැනි වස්තුවට Symbol.iterator දේපලක් නොමැති නම්, උත්සාහ කරන්න
  පැතිරීමට එය ව්‍යතිරේකයක් විසි කරයි.
2 කේතය මත රඳා පවතී. පහත දැක්වෙන උදාහරණ කේතය "ඔව්" හිඟකම ආරක්ෂා කරයි.

function mergeCopyTogether(inputOne, inputTwo){
   var oneLen = inputOne.length, twoLen = inputTwo.length;
   var newArr = [], newLen = newArr.length = oneLen + twoLen;
   for (var i=0, tmp=inputOne[0]; i !== oneLen; ++i) {
        tmp = inputOne[i];
        if (tmp !== undefined || inputOne.hasOwnProperty(i)) newArr[i] = tmp;
    }
    for (var two=0; i !== newLen; ++i, ++two) {
        tmp = inputTwo[two];
        if (tmp !== undefined || inputTwo.hasOwnProperty(two)) newArr[i] = tmp;
    }
    return newArr;
}

ඉහත දැක්වෙන පරිදි, කොන්කට් සෑම විටම පාහේ කාර්ය සාධනය සහ අමතර අරා වල විරල බව රඳවා ගැනීමේ හැකියාව යන දෙකටම යා හැකි මාර්ගය යැයි මම තර්ක කරමි. පසුව, අරාව-කැමති සඳහා (DOMNodeLists වැනි document.body.children), for for loop භාවිතා කිරීම නිර්දේශ කරමි, මන්ද එය 2 වන වඩාත් කාර්ය සාධනය සහ විරල අරා රඳවා ඇති එකම ක්‍රමයයි. පහත දැක්වෙන්නේ, ව්‍යාකූලතා ඉවත් කිරීම සඳහා විරල අරා සහ අරා-කැමති දේවලින් අපි ඉක්මණින් යන්නෙමු.

𝗧𝗵𝗲

මුලදී, සමහර අය සිතන්නේ මෙය නළාවක් බවත් බ්‍රව්සර් වෙළෙන්දෝ අවසානයේදී Array.prototype.push ප්‍රශස්තිකරණය කර Array.prototype.concat පරාජය කිරීමට තරම් වේගවත් වනු ඇති බවත්ය. වැරදි! Array.prototype.concat සෑම විටම වේගවත් වනු ඇත (ප්‍රතිපත්තිමය වශයෙන් අවම වශයෙන්) එය දත්ත වලට වඩා සරල පිටපතක් වන නිසා. බිටු 32 අරාව ක්‍රියාත්මක කිරීම කෙබඳු විය හැකිද යන්න පිළිබඳ සරල කළ හැකි ඒත්තු ගැන්වීමේ දෘශ්‍ය රූප සටහනක් පහත දැක්වේ (කරුණාකර සැබෑ ක්‍රියාත්මක කිරීම් වඩාත් සංකීර්ණ බව සලකන්න)

බයිට් ║ දත්ත මෙහි
═════╬═══════════
0x00 ║ int nonNumericPropertiesLength = 0x00000000
0x01 ib ibid
0x02 ib ibid
0x03 ib ibid
0x00 ║ int දිග = 0x00000001
0x01 ib ibid
0x02 ib ibid
0x03 ib ibid
0x00 ║ int valueIndex = 0x00000000
0x01 ib ibid
0x02 ib ibid
0x03 ib ibid
0x00 ║ int valueType = JS_PRIMITIVE_NUMBER
0x01 ib ibid
0x02 ib ibid
0x03 ib ibid
0x00 ║ uintptr_t valuePointer = 0x38d9eb60 (හෝ එය මතකයේ තිබියදීත්)
0x01 ib ibid
0x02 ib ibid
0x03 ib ibid

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

ඒ ගැන සිතීමට විකල්ප ක්‍රමයක් මෙයයි. ප්‍රභව අරාව යනු එකට එකතු කර ඇති විශාල කඩදාසි තොගයකි. ප්‍රභව අරාව දෙක තවත් විශාල කඩදාසි තොගයකි. එය ඔබට වේගවත් වේවිද?

1. ගබඩාවට ගොස්, එක් එක් ප්‍රභව අරාවෙහි පිටපතක් සඳහා අවශ්‍ය කඩදාසි මිලදී ගන්න. ඉන්පසු එක් එක් ප්‍රභව අරා කඩදාසි කැබලි පිටපත් යන්ත්‍රයක් හරහා දමා එහි ප්‍රති copy ල පිටපත් දෙක එකට තබන්න.
2. ගබඩාවට යන්න, පළමු ප්‍රභව අරාවේ තනි පිටපතක් සඳහා ප්‍රමාණවත් කඩදාසි මිලදී ගන්න. ඉන්පසු, හිස් කඩදාසි විරල ස්ථාන පිරවීම සහතික කරමින්, මූලාශ්‍ර අරා අතින් අතින් පිටපත් කරන්න. ඉන්පසු, නැවත ගබඩාවට ගොස්, දෙවන ප්‍රභව අරාව සඳහා ප්‍රමාණවත් කඩදාසි මිලදී ගන්න. ඉන්පසු, දෙවන ප්‍රභව අරාව හරහා ගොස් පිටපතෙහි හිස් හිඩැස් නොමැති බව සහතික කර එය පිටපත් කරන්න. ඉන්පසු, පිටපත් කරන ලද සියලුම කඩදාසි එකට එකතු කරන්න.

ඉහත ප්‍රතිසමයේදී, # 1 විකල්පය Array.prototype.concat නියෝජනය කරන අතර # 2 Array.prototype.push.apply නියෝජනය කරයි. J න අරා නොව විරල අරා වලට වඩා ක්‍රම පරීක්ෂා කරන විට පමණක් වෙනස් වන සමාන JSperf සමඟ අපි මෙය පරීක්ෂා කරමු. කෙනෙකුට එය මෙතැනින් සොයාගත හැකිය .

එමනිසා, මෙම විශේෂිත භාවිත නඩුවේ කාර්ය සාධනයේ අනාගතය පවතින්නේ Array.prototype.push හි නොව Array.prototype.concat හි බව මගේ නඩුව විවේක ගනිමි.

𝗖𝗹𝗮𝗿𝗶𝗳𝗶𝗰𝗮𝘁𝗶𝗼𝗻𝘀

𝗦𝗽𝗮𝗿𝗲

අරාවෙහි සමහර සාමාජිකයන් අතුරුදහන් වූ විට. උදාහරණයක් වශයෙන්:

// This is just as an example. In actual code, 
// do not mix different types like this.
var mySparseArray = [];
mySparseArray[0] = "foo";
mySparseArray[10] = undefined;
mySparseArray[11] = {};
mySparseArray[12] =  10;
mySparseArray[17] = "bar";
console.log("Length:   ", mySparseArray.length);
console.log("0 in it:  ", 0 in mySparseArray);
console.log("arr[0]:   ", mySparseArray[0]);
console.log("10 in it: ", 10 in mySparseArray);
console.log("arr[10]   ", mySparseArray[10]);
console.log("20 in it: ", 20 in mySparseArray);
console.log("arr[20]:  ", mySparseArray[20]);

විකල්පයක් ලෙස, අමතර අරා පහසුවෙන් ආරම්භ කිරීමට ජාවාස්ක්‍රිප්ට් ඔබට ඉඩ දෙයි.

var mySparseArray = ["foo",,,,,,,,,,undefined,{},10,,,,,"bar"];

𝗔𝗿𝗿𝗮𝘆-

අරාව වැනි වස්තුවක් යනු අවම වශයෙන් lengthදේපලක් ඇති නමුත් එය ආරම්භ කර new Arrayහෝ නොතිබූ වස්තුවකි []; උදාහරණයක් ලෙස, පහත දැක්වෙන වස්තූන් අරාව වැනි වර්ගීකරණය කර ඇත.

{0: "foo", 1: "bar", දිග: 2}

document.body.children

නව Uint8Array (3)

• මෙය අරා-සමාන ය, මන්ද එය (n) (ටයිප් කළ) අරාවක් වුවද, එය අරාවකට බල කිරීම ඉදිකිරීම්කරු වෙනස් කරයි.

(ශ්‍රිතය () {ආපසු තර්ක}) ()

පෙත්තක් වැනි අරා වලට අරාව-කැමැත්ත බල කරන ක්‍රමයක් භාවිතා කරමින් සිදුවන්නේ කුමක්ද යන්න නිරීක්ෂණය කරන්න.

var slice = Array.prototype.slice;
// For arrays:
console.log(slice.call(["not an array-like, rather a real array"]));
// For array-likes:
console.log(slice.call({0: "foo", 1: "bar", length:2}));
console.log(slice.call(document.body.children));
console.log(slice.call(new Uint8Array(3)));
console.log(slice.call( function(){return arguments}() ));

• සටහන: ක්‍රියාකාරීත්වය නිසා ශ්‍රිත තර්ක මත පෙත්තක් කැඳවීම නරක පුරුද්දකි.

කරන්නේ බව ක්රමය භාවිතා සිදු වන දෙය නිරීක්ෂණය නොවන concat වැනි පෙලගැස්මක් බවට බිය වද්දන මාලාවක්-කැමතියි.

var empty = [];
// For arrays:
console.log(empty.concat(["not an array-like, rather a real array"]));
// For array-likes:
console.log(empty.concat({0: "foo", 1: "bar", length:2}));
console.log(empty.concat(document.body.children));
console.log(empty.concat(new Uint8Array(3)));
console.log(empty.concat( function(){return arguments}() ));

ජාවාස්ක්‍රිප්ට් ඊඑස් 6 සමඟ, ඔබට ... ක්‍රියාකරු පැතිරීමේ ක්‍රියාකරුවෙකු ලෙස භාවිතා කළ හැකි අතර එය අත්‍යවශ්‍යයෙන්ම අරාව අගයන් බවට පරිවර්තනය කරයි. එවිට ඔබට මේ වගේ දෙයක් කළ හැකිය:

const myArray = [1,2,3,4,5];
const moreData = [6,7,8,9,10];

const newArray = [
  ...myArray,
  ...moreData,
];

වාක්‍ය ඛණ්ඩය සංක්ෂිප්ත වුවත්, මෙය අභ්‍යන්තරව ක්‍රියා කරන්නේ කෙසේද සහ විශාල අරා වල ක්‍රියාකාරීත්වයේ ඇඟවුම් මොනවාදැයි මම නොදනිමි.

මෙන්න ES6 මාර්ගය

var newArray = [];
let dataArray1 = [1,2,3,4]
let dataArray2 = [5,6,7,8]
newArray = [...dataArray1, ...dataArray2]
console.log(newArray)

ඉහත ක්‍රමවේදය බොහෝ අවස්ථාවන් සඳහා යෑමට හොඳ වන අතර එය concatඅරා වල අයිතම ලක්ෂ ගණනක් ඇති බැවින් කරුණාකර සලකා බලන්න .

    let dataArray1 = [1,2,3,4]
    let dataArray2 = [5,6,7,8]
    let newArray = dataArray1.concat(dataArray2);
    console.log(newArray)

Array.prototype.push.apply ගැන කතා කරන පිළිතුරු ගණනාවක් තිබේ. මෙන්න පැහැදිලි උදාහරණයක්:

var dataArray1 = [1, 2];
var dataArray2 = [3, 4, 5];
var newArray = [ ];
Array.prototype.push.apply(newArray, dataArray1); // newArray = [1, 2]
Array.prototype.push.apply(newArray, dataArray2); // newArray = [1, 2, 3, 4, 5]
console.log(JSON.stringify(newArray)); // Outputs: [1, 2, 3, 4, 5]

ඔබට ES6 සින්ටැක්ස් තිබේ නම්:

var dataArray1 = [1, 2];
var dataArray2 = [3, 4, 5];
var newArray = [ ];
newArray.push(...dataArray1); // newArray = [1, 2]
newArray.push(...dataArray2); // newArray = [1, 2, 3, 4, 5]
console.log(JSON.stringify(newArray)); // Outputs: [1, 2, 3, 4, 5]

ඔබට මුල් අරාව වෙනස් කිරීමට අවශ්‍ය නම්, ඔබට පැතිරීමට හා තල්ලු කිරීමට හැකිය:

var source = [1, 2, 3];
var range = [5, 6, 7];
var length = source.push(...range);

console.log(source); // [ 1, 2, 3, 5, 6, 7 ]
console.log(length); // 6

එකම වර්ගයේ අයිතම පමණක් sourceඅරාව තුළට යන බවට ඔබට සහතික වීමට අවශ්‍ය නම් (උදාහරණයක් ලෙස අංක සහ නූල් මිශ්‍ර නොකිරීම), ඉන්පසු ටයිප්ස්ක්‍රිප්ට් භාවිතා කරන්න.

/**
 * Adds the items of the specified range array to the end of the source array.
 * Use this function to make sure only items of the same type go in the source array.
 */
function addRange<T>(source: T[], range: T[]) {
    source.push(...range);
}

අපට a සහ b යන අරා දෙකක් ඇත. මෙහි කළ කේතය අරාව යනු අගය අරාවකට තල්ලු කරනු ලැබේ b.

let a = [2, 4, 6, 8, 9, 15]

function transform(a) {
    let b = ['4', '16', '64']
    a.forEach(function(e) {
        b.push(e.toString());
    });
    return b;
}

transform(a)

[ '4', '16', '64', '2', '4', '6', '8', '9', '15' ]

මේක උත්සාහ කරන්න:

var arrayA = [1, 2];
var arrayB = [3, 4];
var newArray = arrayB.reduce((pre, cur) => [...pre, ...cur], arrayA);
console.log(newArray)

තල්ලු () ශ්‍රිතය වෙනුවට IE සඳහා කොන්ක්‍රීට් ශ්‍රිතය භාවිතා කරන්න. උදාහරණයක්,

var a=a.concat(a,new Array('amin'));

Тhis යනු ක්‍රියාකාරී කේතයක් වන අතර එය හොඳින් ක්‍රියාත්මක වේ:

var els = document.getElementsByTagName('input'), i;
var invnum = new Array();
var k = els.length;
for(i = 0; i < k; i++){invnum.push(new Array(els[i].id,els[i].value))}