javascript - كيفية إلحاق شيء إلى صفيف؟




arrays append (25)

كيف يمكنني إلحاق كائن (مثل سلسلة أو رقم) بصفيف في JavaScript؟


Answers

يمكنك فعل ذلك باستخدام ميزة 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' ]

إلحاق عنصر واحد

لإلحاق عنصر واحد إلى صفيف ، استخدم الأسلوب push() يوفره كائن الصفيف:

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

push() يتغير المصفوفة الأصلية.

لإنشاء صفيف جديد بدلاً من ذلك ، استخدم الأسلوب firstArray.concat(secondArray) Array:

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)

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

إلحاق عناصر متعددة

لإلحاق عنصر متعدد بصفيف ، يمكنك استخدام push() عن طريق الاتصال به مع وسائط متعددة:

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

يمكنك أيضًا استخدام طريقة firstArray.concat(secondArray) التي رأيتها من قبل ، وتمرير قائمة بالعناصر المفصولة بفاصلة:

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)

تذكر أنه كما هو موضح سابقًا ، لا تؤدي هذه الطريقة إلى تحوير الصفيف الأصلي ، ولكنها تُرجع صفيفًا جديدًا.

نشرت أصلا في https://flaviocopes.com/how-to-append-item-to-array/


أعتقد أنه من الجدير بالذكر أنه يمكن استدعاء الدفع بحجج متعددة ، سيتم إلحاقها بالصفيف بالترتيب. فمثلا:

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

ونتيجة لذلك ، يمكنك استخدام push.apply لإلحاق مصفوفة بمجموعة أخرى مثل:

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

يحتوي ES10 المشروح على مزيد من المعلومات حول push والتطبيق بالضبط.

تحديث 2016: مع spread ، لن تحتاج بعد الآن إلى apply ، مثل:

arr.push(...['fourth', 'fifth']);
console.log(arr) // ['first', 'second', 'third', 'fourth', 'fifth']

الآن ، يمكنك الاستفادة من بنية ES6 وفعل ما يلي:

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

الحفاظ على المجموعة الأصلية غير قابل للتغيير.


يمكنك استخدام طريقة الدفع.

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() يعمل بشكل جيد. إذا كنت تريد إلحاق مصفوفة أخرى ، فاستخدم concat() :

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

var ar3 = ar1.concat(ar2);

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

سوف يبصقون:

"1,2,3"
"4,5,6"
"1,2,3,4,5,6"

لا يؤثر concat على ar2 و ar2 ما لم يتم تعيينهم ، على سبيل المثال:

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

سوف يعرض:

"1,2,3,4,5,6"

الكثير من المعلومات العظيمة here


إذا كنت تريد دمج صفيفتين بدون التكرار ، فيمكنك تجربة الرمز أدناه

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]


إذا كنت تريد إلحاق قيمة واحدة في مصفوفة ، فما عليك سوى استخدام طريقة الدفع. ستضيف عنصرًا جديدًا في نهاية الصفيف.

ولكن إذا كنت تنوي إضافة عناصر متعددة ، فقم بتخزين العناصر في صفيف جديد وقم بتنسيق الصفيف الثاني مع المصفوفة الأولى ... إما بالطريقة التي تريدها.

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);

push() يضيف عنصر جديد إلى نهاية صفيف.
يزيل pop() عنصرًا من نهاية الصفيف.

إلحاق كائن (مثل سلسلة أو رقم) إلى استخدام صفيف -
array.push(toAppend);



يمكنك استخدام push apply الوظيفة لإلحاق صفيفين.

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

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

ستقوم بإلحاق array2 إلى array1 . يحتوي الآن array1 على [11, 32, 75, 99, 67, 34] . هذا الرمز أبسط بكثير من كتابة الحلقات لنسخ كل العناصر في الصفيف.


إذا كان arr صفيفًا ، وكانت val هي القيمة التي ترغب في إضافتها:

arr.push(val);

على سبيل المثال

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

سوف يسجل:

['a', 'b', 'c', 'd']

ليس لدينا وظيفة إلحاق لـ Array في javascript ، لكن لدينا دفع و unshift ، تخيل أن لديك الصفيف أدناه:

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

ونحب إضافة قيمة إلى هذا المصفوفة ، يمكننا القيام به ، arr.push (6) وسيضيف 6 إلى نهاية الصفيف:

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

يمكننا أيضًا استخدام unshift ، انظر كيف يمكننا تطبيق ذلك:

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

وهي وظائف رئيسية لإضافة أو إلحاق قيم جديدة إلى المصفوفات.


هناك طريقتان لإلحاق صفيف في JavaScript:

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) يمكنك استخدام خاصية array .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"]

جافا سكريبت مع معيار 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 المدعوم من قبل Chrome و FF و IE Edge ، يمكنك استخدام عامل spread النشر:

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

array2.push(...array1);

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

سيحل عامل array2.push(...array1); محل array2.push(...array1); مع array2.push(3, 4, 5); عندما يفكر المتصفح في المنطق.

نقطة إضافية

إذا كنت ترغب في إنشاء متغير آخر لتخزين كافة العناصر من كلا الصفيف ، فيمكنك القيام بذلك:

ES5 var combinedArray = array1.concat(array2);

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

عامل الانتشار ( ... ) هو توزيع جميع العناصر من مجموعة.


إذا كنت تستخدم ES6 ، فيمكنك استخدام عامل التوسيع للقيام بذلك.

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

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

arr.push(...arr2);

إذا كنت تريد إلحاق صفيفين -

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

عندها يمكنك استخدام:

var c = a.concat(b);

وإذا كنت تريد إضافة سجل g إلى مجموعة ( var a=[] ) ، فيمكنك استخدام:

a.push('g');

دع خاصية طول الصفيف تقوم بالعمل:

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

myarray.length تقوم بإرجاع عدد السلاسل في الصفيف. JS يستند إلى الصفر لذا فإن مفتاح العنصر التالي من المصفوفة سيكون الطول الحالي للمصفوفة. EX:

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

أنت .push () التي قيمة. مثال: array.push (قيمة)؛


إلحاق عنصر مفرد

//Append at first
arrName.push('newName1');

//Append at last
arrName.unshift('newName1');

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


//Append at index 3
arrName[3] = 'newName1';

إلحاق عنصر متعدد

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

إلحاق مجموعة

//join two or more array
arrName.concat(newAry1, newAry2);
//newAry1,newAry2: Two different array which is to be append to the existing array

مع مشغّل توزيع ES6 الجديد ، يصبح الانضمام إلى صفيفين باستخدام push أسهل:

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

هذا يضيف محتويات arr2 على نهاية arr .

Babel REPL مثال


إلحاق العناصر على صفيف

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]);
}

يمكنك استخدام push () إذا كنت ترغب في إضافة قيم مثل arr.push("Test1", "Test2");

إذا كان لديك صفيف يمكنك استخدام concat () مثل Array1.concat(Array2)

إذا كان لديك عنصر واحد فقط لتضيفه ، فيمكنك أيضًا تجربة طول menthod على سبيل المثال array[aray.length] = 'test';


أظهرت بعض المقاييس السريعة (كل اختبار = 500 ألف من العناصر الملحقة والنتائج هي متوسطات التشغيل المتعدد) ما يلي:

Firefox 3.6 (نظام التشغيل Mac):

  • المصفوفات الصغيرة: arr[arr.length] = b أسرع (300ms vs. 800ms)
  • صفائف كبيرة: arr.push(b) أسرع (500ms مقابل 900 مللي ثانية)

Safari 5.0 (نظام التشغيل Mac):

  • صفائف صغيرة: arr[arr.length] = b أسرع (90ms vs. 115ms)
  • صفائف كبيرة: arr[arr.length] = b أسرع (160ms vs. 185ms)

Google Chrome 6.0 (نظام التشغيل Mac):

  • صفائف صغيرة: لا يوجد فرق كبير (والكروم سريع! فقط ~ 38ms !!)
  • صفائف كبيرة: لا يوجد فرق كبير (160ms)

أنا أحب arr.push() بشكل أفضل ، ولكن أعتقد أنني سأكون أفضل حالًا مع إصدار arr[arr.length] ، على الأقل في سرعة الخام. أنا أحب أن أرى نتائج تشغيل IE على الرغم من.

الحلقات القياسية الخاصة بي:

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;
    }
}

عادة لا يتبع جافا سكريبت قواعد صارمة وبالتالي زيادة فرص الأخطاء. بعد استخدام "use strict"، يجب أن يتبع شفرة جافا سكريبت مجموعة صارمة من القواعد كما هو الحال في لغات البرمجة الأخرى مثل استخدام المصطلحات ، والإعلان قبل التهيئة وما إلى ذلك.

إذا "use strict"تم استخدامه ، فيجب كتابة الشفرة باتباع مجموعة من القواعد الصارمة ، وبالتالي تقليل فرص الأخطاء والغموض.





javascript arrays append