ජාවාස්ක්‍රිප්ට් හි අරාවකට මම වස්තුවක් (නූලක් හෝ අංකයක් වැනි) එකතු කරන්නේ කෙසේද?

Array.prototype.pushඅරාවකට අගයන් එකතු කිරීමට ක්‍රමය භාවිතා කරන්න :

// initialize array
var arr = [
  "Hi",
  "Hello",
  "Bonjour"
];

// append new value to the array
arr.push("Hola");

console.log(arr);

push()එක් ඇමතුමකින් අරාවකට එක් අගයකට වඩා එකතු කිරීමට ඔබට ශ්‍රිතය භාවිතා කළ හැකිය :

// initialize array
var arr = ["Hi", "Hello", "Bonjour", "Hola"];

// append multiple values to the array
arr.push("Salut", "Hey");

// display all values
for (var i = 0; i < arr.length; i++) {
  console.log(arr[i]);
}

යාවත්කාලීන කරන්න

ඔබට එක් අරාවක අයිතම තවත් අරාවකට එක් කිරීමට අවශ්‍ය නම්, ඔබට මෙය භාවිතා කළ හැකිය firstArray.concat(secondArray):

var arr = [
  "apple",
  "banana",
  "cherry"
];

arr = arr.concat([
  "dragonfruit",
  "elderberry",
  "fig"
]);

console.log(arr);

යාවත්කාලීන කරන්න

පළමු දර්ශකයට අදහස් කරන අරාවක ආරම්භයට කිසියම් අගයක් එකතු කිරීමට ඔබට අවශ්‍ය නම් මෙම පිළිතුරට එකතු කිරීමක් නම් ඔබට Array.prototype.unshiftමෙම කාර්යය සඳහා භාවිතා කළ හැකිය .

var arr = [1, 2, 3];
arr.unshift(0);
console.log(arr);

එකවර මෙන් බහු අගයන් එකතු කිරීමට ද එය සහාය pushවේ.

ඔබ එක් විචල්‍යයක් පමණක් එකතු කරන්නේ නම්, push()එය හොඳින් ක්‍රියාත්මක වේ. ඔබට වෙනත් අරාවක් එකතු කිරීමට අවශ්‍ය නම්, භාවිතා කරන්න concat():

var ar1 = [1, 2, 3];
var ar2 = [4, 5, 6];

var ar3 = ar1.concat(ar2);

alert(ar1);
alert(ar2);
alert(ar3);

කොන්ක්‍රීට් බලපාන්නේ නැති ar1අතර ar2නැවත පවරා නොගන්නේ නම්, උදාහරණයක් ලෙස:

var ar1 = [1, 2, 3];
var ar2 = [4, 5, 6];

ar1 = ar1.concat(ar2);
alert(ar1);

මෙහි විශාල තොරතුරු රාශියක් .

සමහර ඉක්මන් මිණුම් සලකුණු (එක් එක් පරීක්ෂණය = 500k එකතු කළ අංග සහ ප්‍රති results ල බහු ලකුණු වල සාමාන්‍ය වේ) පහත දැක්වේ:

ෆයර්ෆොක්ස් 3.6 (මැක්):

• කුඩා අරා: arr[arr.length] = bවේගවත් (300ms හා 800ms)
• විශාල අරා: arr.push(b)වේගවත් වේ (500ms එදිරිව 900ms)

සෆාරි 5.0 (මැක්):

• කුඩා අරා: arr[arr.length] = bවේගවත් (90ms හා 115ms)
• විශාල අරා: arr[arr.length] = bවේගවත් වේ (මීටර් 160 හා එදිරිව 185m)

ගූගල් ක්‍රෝම් 6.0 (මැක්):

• කුඩා අරා: සැලකිය යුතු වෙනසක් නොමැත (සහ ක්‍රෝම් වේගවත්ය! ඩොලර් 38 ක් පමණි !!)
• විශාල අරා: සැලකිය යුතු වෙනසක් නැත (මීටර් 160)

මම arr.push()වාක්‍ය ඛණ්ඩයට වඩා කැමතියි, නමුත් මම හිතන්නේ arr[arr.length]අනුවාදය සමඟ වඩා හොඳ වනු ඇත , අවම වශයෙන් අමු වේගයෙන්. IE ධාවනයක ප්‍රති results ල දැකීමට මා කැමතිය.

මගේ මිණුම් සලකුණු ලූප:

function arrpush_small() {
    var arr1 = [];
    for (a = 0; a < 100; a++)
    {
        arr1 = [];
        for (i = 0; i < 5000; i++)
        {
            arr1.push('elem' + i);
        }
    }
}

function arrlen_small() {
    var arr2 = [];
    for (b = 0; b < 100; b++)
    {
        arr2 = [];
        for (j = 0; j < 5000; j++)
        {
            arr2[arr2.length] = 'elem' + j;
        }
    }
}


function arrpush_large() {
    var arr1 = [];
    for (i = 0; i < 500000; i++)
    {
        arr1.push('elem' + i);
    }
}

function arrlen_large() {
    var arr2 = [];
    for (j = 0; j < 500000; j++)
    {
        arr2[arr2.length] = 'elem' + j;
    }
}

තල්ලුව බහුවිධ තර්ක සමඟ කැඳවිය හැකි බව සඳහන් කිරීම වටී යැයි මම සිතමි. උදාහරණයක් වශයෙන්:

var arr = ['first'];
arr.push('second', 'third');
console.log(arr);

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

var arr = ['first'];
arr.push('second', 'third');
arr.push.apply(arr, ['forth', 'fifth']);
console.log(arr);

තල්ලු කිරීම සහ යෙදීම යනු කුමක්ද යන්න පිළිබඳ වැඩි විස්තරයක් ඇනෝටේටඩ් ඊඑස් 5 සතුව ඇත .

2016 යාවත්කාලීන කිරීම: පැතිරීමත් සමඟ ඔබට එය තවදුරටත් අවශ්‍ය applyනොවේ, වැනි:

var arr = ['first'];
arr.push('second', 'third');

arr.push(...['fourth', 'fifth']);
console.log(arr) ;

ඔබට භාවිතා කළ හැකි pushහා applyපෙලගැස්මක් දෙකක් එකතු කිරීමට ශ්රිතය.

var array1 = [11, 32, 75];
var array2 = [99, 67, 34];

Array.prototype.push.apply(array1, array2);
console.log(array1);

එය එකතු array2වේ array1. දැන් array1අඩංගු වේ [11, 32, 75, 99, 67, 34]. මෙම කේතය forඅරාවෙහි ඇති සෑම අයිතමයක්ම පිටපත් කිරීම සඳහා ලූප ලිවීමට වඩා සරල ය .

නව ES6 පැතිරුම් ක්‍රියාකරු සමඟ, අරා දෙකක් සම්බන්ධ කිරීම pushවඩාත් පහසු වේ:

var arr = [1, 2, 3, 4, 5];
var arr2 = [6, 7, 8, 9, 10];
arr.push(...arr2);
console.log(arr);

මෙමඟින් අන්තර්ගතය arr2අවසානයට එකතු වේ arr.

බාබෙල් REPL උදාහරණය

නම් arrමාලාවක් වන අතර, valඑය භාවිතා කරන එක් කිරීමට කැමති වටිනාකම වේ:

arr.push(val);

උදා

var arr = ['a', 'b', 'c'];
arr.push('d');
console.log(arr);

භාවිතා කරන්න concat:

a = [1, 2, 3];
b = [3, 4, 5];
a = a.concat(b);
console.log(a);

බොහෝ බ්‍රව්සර්වල සහය දක්වන ECMAScript 5 ප්‍රමිතිය සහිත ජාවාස්ක්‍රිප්ට් , ඔබට apply()එකතු array1කිරීමට භාවිතා කළ හැකිය array2.

var array1 = [3, 4, 5];
var array2 = [1, 2];

Array.prototype.push.apply(array2, array1);

console.log(array2); // [1, 2, 3, 4, 5]

ක්‍රෝම් සහ එෆ්එෆ් සහ අයිඊ එජ් විසින් සහාය දක්වන ECMAScript 6 ප්‍රමිතිය සහිත ජාවාස්ක්‍රිප්ට් , ඔබට spreadක්‍රියාකරු භාවිතා කළ හැකිය :

"use strict";
let array1 = [3, 4, 5];
let array2 = [1, 2];

array2.push(...array1);

console.log(array2); // [1, 2, 3, 4, 5]

මෙම spreadක්රියාකරු වෙනුවට array2.push(...array1);සමග array2.push(3, 4, 5);බ්රව්සරය තර්කනය කල්පනා කරන විට.

පාරිතෝෂික ලක්ෂ්‍යය

අරාව දෙකෙන්ම සියලුම අයිතම ගබඩා කිරීම සඳහා වෙනත් විචල්‍යයක් නිර්මාණය කිරීමට ඔබ කැමති නම් , ඔබට මෙය කළ හැකිය:

ES5 var combinedArray = array1.concat(array2);

ES6 const combinedArray = [...array1, ...array2]

පැතිරුම් ක්‍රියාකරු ( ...) යනු එකතුවකින් සියලුම අයිතම ව්‍යාප්ත කිරීමයි.

ඔබට අරා දෙකක් එකතු කිරීමට අවශ්‍ය නම් -

var a = ['a', 'b'];
var b = ['c', 'd'];

එවිට ඔබට භාවිතා කළ හැකිය:

var c = a.concat(b);

ඔබට gඅරාව ( var a=[]) වෙත වාර්තාවක් එක් කිරීමට අවශ්‍ය නම් ඔබට මෙය භාවිතා කළ හැකිය:

a.push('g');

මෙම push()ක්‍රමය අරාවෙහි අවසානයට නව අයිතම එකතු කරන අතර නව දිග ලබා දෙයි. උදාහරණයක්:

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.push("Kiwi");

// The result of fruits will be:
Banana, Orange, Apple, Mango, Kiwi

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

මෙම unshift()ක්‍රමය අරාවෙහි ආරම්භයට නව අයිතම එකතු කරන අතර නව දිග ලබා දෙයි. උදාහරණයක්:

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.unshift("Lemon", "Pineapple");

// The result of fruits will be:
Lemon, Pineapple, Banana, Orange, Apple, Mango

අවසාන වශයෙන්, concat()අරා දෙකකට හෝ වැඩි ගණනකට සම්බන්ධ වීමට මෙම ක්‍රමය භාවිතා කරයි. උදාහරණයක්:

var fruits = ["Banana", "Orange"];
var moreFruits = ["Apple", "Mango", "Lemon"];
var allFruits = fruits.concat(moreFruits);

// The values of the children array will be:
Banana, Orange, Apple, Mango, Lemon

ජාවාස්ක්‍රිප්ට් හි අරාවක් එකතු කිරීමට ක්‍රම කිහිපයක් තිබේ:

1) මෙම push()ක්‍රමය අරාවෙහි අවසානයට මූලද්‍රව්‍ය එකක් හෝ කිහිපයක් එකතු කර අරාවෙහි නව දිග ලබා දෙයි.

var a = [1, 2, 3];
a.push(4, 5);
console.log(a);

ප්‍රතිදානය:

[1, 2, 3, 4, 5]

2) මෙම unshift()ක්‍රමය අරාවෙහි ආරම්භයට මූලද්‍රව්‍ය එකක් හෝ කිහිපයක් එකතු කර අරාවේ නව දිග ලබා දෙයි:

var a = [1, 2, 3];
a.unshift(4, 5);
console.log(a); 

ප්‍රතිදානය:

[4, 5, 1, 2, 3]

3)concat() අරා දෙකක් හෝ වැඩි ගණනක් ඒකාබද්ධ කිරීම සඳහා ක්‍රමය භාවිතා කරයි. මෙම ක්‍රමය පවතින අරා වෙනස් නොකරයි , ඒ වෙනුවට නව අරාවක් ලබා දෙයි.

var arr1 = ["a", "b", "c"];
var arr2 = ["d", "e", "f"];
var arr3 = arr1.concat(arr2);
console.log(arr3);

ප්‍රතිදානය:

[ "a", "b", "c", "d", "e", "f" ]

4) අරාවේ .lengthඅවසානයට මූලද්‍රව්‍යයක් එක් කිරීමට ඔබට අරාවෙහි දේපල භාවිතා කළ හැකිය :

var ar = ['one', 'two', 'three'];
ar[ar.length] = 'four';
console.log( ar ); 

ප්‍රතිදානය:

 ["one", "two", "three", "four"]

5) මෙම splice()ක්රමය දැනට පවතින කොටස් ඉවත් කිරීම සහ / හෝ නව අංග එකතු කිරීම මඟින් මාලාවක් අන්තර්ගතය වෙනස්:

var myFish = ["angel", "clown", "mandarin", "surgeon"];
myFish.splice(4, 0, "nemo");
//array.splice(start, deleteCount, item1, item2, ...)
console.log(myFish);

ප්‍රතිදානය:

["angel", "clown", "mandarin", "surgeon","nemo"]

6) නව දර්ශකයක් නියම කිරීමෙන් සහ අගයක් පැවරීමෙන් ඔබට අරාවකට නව අංගයක් එක් කළ හැකිය:

var ar = ['one', 'two', 'three'];
ar[3] = 'four'; // add new element to ar
console.log(ar);

ප්‍රතිදානය:

["one", "two","three","four"]

දැන්, ඔබට ES6 සින්ටැක්ස් වලින් ප්‍රයෝජන ගත හැකි අතර එසේ කරන්න:

let array = [1, 2];
console.log([...array, 3]);

මුල් අරාව වෙනස් කළ නොහැකි ලෙස තබා ගැනීම.

ඉහළම දර්ශකය ඔබ දන්නේ නම් (විචල්ය "i" හි ගබඩා කර ඇති) වැනි දේ කළ හැකිය

myArray[i + 1] = someValue;

කෙසේ වෙතත් ඔබ නොදන්නේ නම් ඔබට භාවිතා කළ හැකිය

myArray.push(someValue);

වෙනත් පිළිතුරු යෝජනා කර ඇති පරිදි හෝ ඔබට භාවිතා කළ හැකිය

myArray[myArray.length] = someValue; 

අරාව බිංදුව මත පදනම් වන බව සලකන්න. දිග වැඩිම දර්ශකය සහ ප්ලස් එක ලබා දෙයි.

ඔබ පිළිවෙලට එකතු කළ යුතු නැති බවත්, ඇත්ත වශයෙන්ම ඔබට අගයන් මඟ හැරිය හැකි බවත් සලකන්න

myArray[myArray.length + 1000] = someValue;

කුමන අවස්ථාවක දී අගයන් නිර්වචනය නොකළ අගයක් ඇත.

එම අවස්ථාවේ දී අගයක් සත්‍ය වශයෙන්ම පවතින බව තහවුරු කර ගැනීම සඳහා ජාවාස්ක්‍රිප්ට් හරහා ලූප් කිරීමේදී එය හොඳ පුරුද්දකි.

මෙය පහත සඳහන් දේවලින් කළ හැකිය:

if(myArray[i] === "undefined"){ continue; }

ඔබට අරාවෙහි කිසිදු ශුන්‍යයක් නොමැති බව ඔබට විශ්වාස නම් ඔබට කළ හැක්කේ:

if(!myArray[i]){ continue; }

ඇත්ත වශයෙන්ම මෙම අවස්ථාවෙහිදී ඔබ myArray [i] යන කොන්දේසිය ලෙස භාවිතා නොකරන බවට වග බලා ගන්න (අන්තර්ජාලය හරහා සමහර අය යෝජනා කරන පරිදි අවසානය මත පදනම්ව මා විශාල වූ විගස ඉහළම දර්ශකය එය නිර්වචනය නොකෙරේ. අසත්ය)

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

//Append to the end
arrName.push('newName1');

//Prepend to the start
arrName.unshift('newName1');

//Insert at index 1
arrName.splice(1, 0,'newName1');
//1: index number, 0: number of element to remove, newName1: new element


// Replace index 3 (of exists), add new element otherwise.
arrName[3] = 'newName1';

බහු මූලද්රව්ය එකතු කරන්න

//Insert from index number 1
arrName.splice(1, 0,'newElemenet1', 'newElemenet2', 'newElemenet3');
//1: index number from where insert starts, 
//0: number of element to remove, 
//newElemenet1,2,3: new elements

අරාව එකතු කරන්න

//join two or more arrays
arrName.concat(newAry1, newAry2);
//newAry1,newAry2: Two different arrays which are to be combined (concatenated) to an existing array

concat(), ඇත්ත වශයෙන්ම, ද්විමාන අරා සමඟද භාවිතා කළ හැකිය. ලූපයක් අවශ්‍ය නොවේ.

var a = [[1, 2], [3, 4]];

var b = [["a", "b"], ["c", "d"]];

b = b.concat (අ);

ඇඟවීම් (ආ [2] [1]); // ප්‍රති result ලය 2

අරාව දිග දේපල වැඩ කිරීමට ඉඩ දෙන්න:

myarray[myarray.length] = 'new element value added to the end of the array';

myarray.length අරාවෙහි ඇති නූල් ගණන නැවත ලබා දෙයි. JS ශුන්‍ය පදනම් වේ, එබැවින් අරාවෙහි ඊළඟ මූලද්‍රව්‍ය යතුර අරාවේ වත්මන් දිග වේ. උදා:

var myarray = [0, 1, 2, 3],
    myarrayLength = myarray.length; //myarrayLength is set to 4

මූලද්‍රව්‍යයක් විනාශකාරී නොවන එකතු කිරීම සඳහා ස්නිපටයක් එක් කිරීමට අවශ්‍යය.

var newArr = oldArr.concat([newEl]);

අරාවකට අගයක් එකතු කරන්න

සිට Array.prototype.push රැසක් අවසන් කිරීමට ඇති මූලදව්ය එකක් ෙහෝ වැඩි කරයි සහ අරාව නව දිග නැවත , සමහර විට අපි ඒ වගේ දෙයක් කරන්න පුළුවන් නිසා පමණක් නව යාවත්කාලීන මාලාවක් ලබා ගැනීමට අවශ්ය:

const arr = [1, 2, 3];
const val = 4;

arr.concat([val]); // [1, 2, 3, 4]

හෝ:

[...arr, val] // [1, 2, 3, 4]

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

var arr = [
    "apple",
    "banana",
    "cherry"
];

var arr2 = [
    "dragonfruit",
    "elderberry",
    "fig"
];

arr.push(...arr2);

නව javascript Es 6 විශේෂාංගය භාවිතයෙන් ඔබට එය කළ හැකිය:

// initialize array

var arr = [
    "Hi",
    "Hello",
    "Bangladesh"
];

// append new value to the array

arr= [...arr , "Feni"];

// or you can put a variable value

var testValue = "Cool";

arr = [...arr , testValue ];

console.log(arr); 

// final output  [ 'Hi', 'Hello', 'Bangladesh', 'Feni', 'Cool' ]

අනුපිටපතක් නොමැතිව අරා 2 ක් ඒකාබද්ධ කිරීමට ඔබට අවශ්‍ය නම් ඔබට පහත කේතය උත්සාහ කළ හැකිය

array_merge = function (arr1, arr2) {
  return arr1.concat(arr2.filter(function(item){
    return arr1.indexOf(item) < 0;
  }))
}

භාවිතය:

array1 = ['1', '2', '3']
array2 = ['2', '3', '4', '5']
combined_array = array_merge(array1, array2)

ප්‍රතිදානය: [1,2,3,4,5]

තනි අයිතමයක් එකතු කරන්න

තනි අයිතමයක් අරාවකට එකතු කිරීමට, අරාව push()වස්තුව මඟින් සපයන ක්‍රමය භාවිතා කරන්න :

const fruits = ['banana', 'pear', 'apple']
fruits.push('mango')
console.log(fruits)

push() මුල් අරාව විකෘති කරයි.

ඒ වෙනුවට නව අරාවක් සෑදීමට, අරාව concat()ක්‍රමය භාවිතා කරන්න:

const fruits = ['banana', 'pear', 'apple']
const allfruits = fruits.concat('mango')
console.log(allfruits)

සිටින බව දැනුම් concat()ඇත්තටම අරාව සඳහා අයිතමය එකතු කරන්නේ නැහැ, නමුත් ඔබට තවත් විචල්ය අනුයුක්ත, හෝ මුල් අරා (එය ප්රකාශ කිරීමට නැවත පැවරීම සිදු කළ හැකි නව මාලාවක් නිර්මාණය letඔබ නැවත පැවරීම සිදු නො හැකි, const):

const fruits = ['banana', 'pear', 'apple']
const allfruits = fruits.concat('mango')
console.log(allfruits)

let fruits = ['banana', 'pear', 'apple']
fruits = fruits.concat('mango')

බහු අයිතම එකතු කරන්න

අරාවකට බහු අයිතමයක් එකතු කිරීම සඳහා, ඔබට push()එය බහු තර්ක සමඟ ඇමතීමෙන් භාවිතා කළ හැකිය :

const fruits = ['banana', 'pear', 'apple']
fruits.push('mango', 'melon', 'avocado')
console.log(fruits)

concat()කොමා මඟින් වෙන් කරන ලද අයිතම ලැයිස්තුවක් පසුකරමින් ඔබට පෙර දුටු ක්‍රමය භාවිතා කළ හැකිය :

const fruits = ['banana', 'pear', 'apple']
const allfruits = fruits.concat('mango', 'melon', 'avocado')
console.log(allfruits)

හෝ අරාව:

const fruits = ['banana', 'pear', 'apple']
const allfruits = fruits.concat(['mango', 'melon', 'avocado'])
console.log(allfruits)

කලින් විස්තර කර ඇති පරිදි මෙම ක්‍රමය මුල් අරාව විකෘති නොකරන නමුත් එය නව අරාවක් ලබා දෙන බව මතක තබා ගන්න.

මුලින් පළ කරන ලද්දේ

ඔබ .පුෂ් () එම අගය. උදාහරණය: array.push (අගය);

ඔබට තනි අගයක් අරාවකට එකතු කිරීමට අවශ්‍ය නම්, තල්ලු කිරීමේ ක්‍රමය භාවිතා කරන්න. එය අරාව අවසානයේ නව අංගයක් එකතු කරනු ඇත.

නමුත් ඔබ බහු මූලද්‍රව්‍ය එකතු කිරීමට අදහස් කරන්නේ නම් මූලද්‍රව්‍ය නව අරාවකට ගබඩා කර දෙවන අරාව පළමු අරාව සමඟ සංයුක්ත කරන්න ... එක්කෝ ඔබ කැමති ආකාරයට.

arr=['a','b','c'];
arr.push('d');
//now print the array in console.log and it will contain 'a','b','c','d' as elements.
console.log(array);

අපට ජාවාස්ක්‍රිප්ට් හි අරාව සඳහා උපග්‍රන්ථ ශ්‍රිතයක් නොමැත, නමුත් අපට තල්ලු සහ වෙනස් නොකෙරේ , ඔබට පහත අරාව ඇති බව සිතන්න:

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

තවද අපි මෙම අරාව සඳහා අගයක් එකතු කිරීමට කැමතියි, අපට කළ හැකිය, arr.push (6) සහ එය අරාවෙහි අවසානයට 6 ක් එකතු කරයි:

arr.push(6); // return [1, 2, 3, 4, 5, 6];

එසේම අපට shhift භාවිතා කළ හැකිය, අපට මෙය අදාළ කර ගත හැකි ආකාරය දෙස බලන්න:

arr.unshift(0); //return [0, 1, 2, 3, 4, 5];

අරා වලට නව අගයන් එකතු කිරීම හෝ එකතු කිරීම ප්‍රධාන කාර්යයන් වේ.

ඔබට තල්ලු කිරීමේ ක්‍රමය භාවිතා කළ හැකිය.

Array.prototype.append = function(destArray){
     destArray = destArray || [];
     this.push.call(this,...destArray);
     return this;
}
var arr = [1,2,5,67];
var arr1 = [7,4,7,8];
console.log(arr.append(arr1));// [7, 4, 7, 8, 1, 4, 5, 67, 7]
console.log(arr.append("Hola"))//[1, 2, 5, 67, 7, 4, 7, 8, "H", "o", "l", "a"]

push() අරාවක අවසානයට නව අංගයක් එක් කරයි.
pop()අරාව අවසානයේ සිට මූලද්‍රව්‍යයක් ඉවත් කරයි.

අරාව භාවිතා කිරීම සඳහා වස්තුවක් (නූලක් හෝ අංකයක් වැනි) එකතු කිරීමට -
array.push(toAppend);

අරාව මත අයිතම එකතු කිරීම

let fruits =["orange","banana","apple","lemon"]; /*array declaration*/

fruits.push("avacado"); /* Adding an element to the array*/

/*displaying elements of the array*/

for(var i=0; i < fruits.length; i++){
  console.log(fruits[i]);
}

ඔබට අගයන් එකතු කිරීමට අවශ්‍ය නම් ඔබට තල්ලු () භාවිතා කළ හැකිය arr.push("Test1", "Test2");

ඔබට අරාව තිබේ නම් ඔබට කොන්කට් () උදා Array1.concat(Array2)

එක් කිරීමට ඔබට ඇත්තේ එක් අංගයක් නම් ඔබට දිග මෙන්තෝඩ් උත්සාහ කළ හැකිය array[aray.length] = 'test';