المصفوفات هي واحدة من هياكل البيانات الأساسية في جافا سكريبت. باستخدام المصفوفة، يمكنك تخزين قيم متعددة في متغير واحد. توفر JavaScript العديد من الأساليب المضمنة للتعامل مع المصفوفات، مما يجعلها متعددة الاستخدامات بشكل لا يصدق. في هذا المنشور، سنستكشف جميع أساليب المصفوفة المضمنة وكيفية استخدامها بفعالية في مشاريع JavaScript الخاصة بك.

الطرق الأساسية

لكل ()

تسمح لك طريقة forEach() بالتكرار على مصفوفة وتنفيذ دالة مقدمة مرة واحدة لكل عنصر في المصفوفة. إنها طريقة بسيطة للتكرار عبر المصفوفة.

const array = [1, 2, 3, 4, 5];

array.forEach((element) => {
  console.log(element);
});

رسم خريطة()

تقوم طريقة الخريطة () بإنشاء مصفوفة جديدة مليئة بنتائج استدعاء دالة مقدمة على كل عنصر في المصفوفة. يتم استخدامه عادةً لتحويل البيانات.

const array = [1, 2, 3, 4, 5];

const doubled = array.map((element) => element * 2);

console.log(doubled); // [2, 4, 6, 8, 10]

فلتر()

تقوم طريقة التصفية () بإنشاء مصفوفة جديدة تحتوي على جميع العناصر التي تجتاز الاختبار الذي تنفذه الوظيفة المقدمة. يكون ذلك مفيدًا عندما تحتاج إلى تصفية عناصر معينة من مصفوفة بناءً على شرط ما.

const array = [1, 2, 3, 4, 5];

const evenNumbers = array.filter((element) => element % 2 === 0);

console.log(evenNumbers); // [2, 4]

يقلل()

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

const array = [1, 2, 3, 4, 5];

const sum = array.reduce((accumulator, currentValue) => accumulator   currentValue, 0);

console.log(sum); // 15

يجد()

تقوم طريقة find () بإرجاع قيمة العنصر الأول في المصفوفة التي تلبي وظيفة الاختبار المتوفرة. ويتوقف بعد العثور على المباراة الأولى.

const array = [1, 2, 3, 4, 5];

const found = array.find((element) => element > 3);

console.log(found); // 4

العثور على الفهرس ()

تقوم طريقة findIndex () بإرجاع فهرس العنصر الأول في المصفوفة الذي يلبي وظيفة الاختبار المتوفرة. إذا لم يفي أي عنصر بوظيفة الاختبار، فسيتم إرجاع -1.

const array = [1, 2, 3, 4, 5];

const index = array.findIndex((element) => element > 3);

console.log(index); // 3

نوع()

تقوم طريقة الترتيب () بفرز عناصر المصفوفة في مكانها وإرجاع المصفوفة التي تم فرزها. تُستخدم بشكل شائع لفرز السلاسل والأرقام، ولكنها قد تتطلب دالة مقارنة لفرز الأرقام بشكل صحيح.

const array = [5, 3, 8, 1, 2];

const sortedArray = array.sort((a, b) => a - b);

console.log(sortedArray); // [1, 2, 3, 5, 8]

يعكس()

تعمل الطريقة العكسية () على عكس عناصر المصفوفة الموجودة في مكانها. يصبح عنصر المصفوفة الأول هو العنصر الأخير، والأخير يصبح الأول.

const array = [1, 2, 3, 4, 5];

const reversedArray = array.reverse();

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

كونكات ()

يتم استخدام طريقة concat () لدمج صفيفين أو أكثر. تقوم بإرجاع مصفوفة جديدة، مع ترك المصفوفات الأصلية دون تغيير.

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

const concatenatedArray = array1.concat(array2);

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

شريحة()

يُرجع أسلوب الشريحة () نسخة سطحية من جزء من المصفوفة إلى كائن مصفوفة جديد محدد من البداية إلى النهاية (النهاية غير مضمنة).

const array = [1, 2, 3, 4, 5];

const slicedArray = array.slice(1, 4);

console.log(slicedArray); // [2, 3, 4]

لصق()

تقوم طريقة splice () بتغيير محتويات المصفوفة عن طريق إزالة العناصر أو استبدالها أو إضافتها.

const array = [1, 2, 3, 4, 5];

array.splice(2, 1, 6, 7);

console.log(array); // [1, 2, 6, 7, 4, 5]

يدفع()

تضيف طريقة الدفع () عنصرًا واحدًا أو أكثر إلى نهاية المصفوفة وترجع الطول الجديد للمصفوفة.

const array = [1, 2, 3];

array.push(4, 5);

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

البوب ​​()

تزيل طريقة pop() العنصر الأخير من المصفوفة وتعيد هذا العنصر.

const array = [1, 2, 3, 4, 5];

const lastElement = array.pop();

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

يحول()

يزيل الأسلوب Shift () العنصر الأول من المصفوفة ويعيد هذا العنصر.

const array = [1, 2, 3, 4, 5];

const firstElement = array.shift();

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

إلغاء النقل ()

يضيف الأسلوب unshift() عنصرًا واحدًا أو أكثر إلى بداية المصفوفة ويعيد الطول الجديد للمصفوفة.

const array = [2, 3, 4, 5];

array.unshift(1);

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

ينضم()

تقوم طريقة join () بإنشاء وإرجاع سلسلة جديدة عن طريق تسلسل كافة العناصر في مصفوفة، مفصولة بفواصل أو سلسلة فاصلة محددة.

const array = [1, 2, 3, 4, 5];

const joinedString = array.join('-');

console.log(joinedString); // "1-2-3-4-5"

طرق إضافية

كل()

تختبر الطريقة every() ما إذا كانت جميع العناصر في المصفوفة تجتاز وظيفة الاختبار المتوفرة.

const array = [2, 4, 6, 8];

const allEven = array.every((element) => element % 2 === 0);

console.log(allEven); // true

بعض()

تختبر الطريقة some() ما إذا كان عنصر واحد على الأقل في المصفوفة يجتاز وظيفة الاختبار المتوفرة.

const array = [1, 2, 3, 4, 5];

const hasEven = array.some((element) => element % 2 === 0);

console.log(hasEven); // true

مستوي()

تنشئ الطريقة المسطحة () مصفوفة جديدة تحتوي على جميع عناصر المصفوفة الفرعية متسلسلة فيها بشكل متكرر حتى العمق المحدد.

const array = [1, [2, [3, [4]]]];

const flattenedArray = array.flat(2);

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

خريطة مسطحة ()

تقوم طريقة flatMap () أولاً بتعيين كل عنصر باستخدام وظيفة التعيين، ثم تقوم بتسوية النتيجة في مصفوفة جديدة. إنها مزيج من الخريطة () والمسطحة ().

const array = [1, 2, 3, 4];

const flattened = array.flatMap((num) => [num, num * 2]);

console.log(flattened); // [1, 2, 2, 4, 3, 6, 4, 8]

يملأ()

يملأ أسلوب fill () جميع عناصر المصفوفة بقيمة ثابتة من فهرس البداية إلى فهرس النهاية.

const array = [1, 2, 3, 4, 5];

array.fill(0, 2, 4);

console.log(array); // [1, 2, 0, 0, 5]

نسخة داخل ()

تقوم طريقة CopyWithin () بنسخ جزء من المصفوفة إلى موقع آخر في نفس المصفوفة دون تعديل طولها.

const array = [1, 2, 3, 4, 5];

array.copyWithin(0, 3, 5);

console.log(array); // [4, 5, 3, 4, 5]

يشمل ()

تقوم الطريقة include() بالتحقق مما إذا كان المصفوفة تحتوي على قيمة معينة.

const array = [1, 2, 3, 4, 5];

const hasThree =

 array.includes(3);

console.log(hasThree); // true

إلى سلسلة ()

يقوم الأسلوب toString () بتحويل المصفوفة إلى سلسلة مفصولة بفواصل.

const array = [1, 2, 3, 4, 5];

const arrayString = array.toString();

console.log(arrayString); // "1,2,3,4,5"

فهرس ()

يُرجع أسلوب IndexOf() الفهرس الأول الذي يمكن العثور على عنصر معين فيه في المصفوفة، أو -1 إذا لم يكن موجودًا.

const array = [1, 2, 3, 4, 5];

const index = array.indexOf(3);

console.log(index); // 2

آخر مؤشر ()

يُرجع الأسلوب lastIndexOf() الفهرس الأخير الذي يمكن العثور على عنصر معين فيه في المصفوفة، أو -1 إذا لم يكن موجودًا.

const array = [1, 2, 3, 4, 3, 5];

const lastIndex = array.lastIndexOf(3);

console.log(lastIndex); // 4

من()

ينشئ الأسلوب Array.from() نسخة مصفوفة جديدة من كائن يشبه المصفوفة أو كائن قابل للتكرار.

const array = Array.from('hello');

console.log(array); // ['h', 'e', 'l', 'l', 'o']

isArray()

تتحقق طريقة Array.isArray() مما إذا كانت القيمة التي تم تمريرها هي مصفوفة.

const array = [1, 2, 3, 4, 5];
const notArray = { a: 1, b: 2 };

console.log(Array.isArray(array)); // true
console.log(Array.isArray(notArray)); // false

ل()

ينشئ الأسلوب Array.of() نسخة مصفوفة جديدة بعدد متغير من العناصر.

const array1 = Array.of(1, 2, 3);
const array2 = Array.of('a', 'b', 'c');

console.log(array1); // [1, 2, 3]
console.log(array2); // ['a', 'b', 'c']

خاتمة

تأتي صفائف JavaScript مع مجموعة واسعة من الأساليب المضمنة التي تسمح بمعالجة البيانات بشكل فعال. إن فهم هذه الأساليب سيجعلك أكثر كفاءة في كتابة تعليمات برمجية نظيفة وموجزة. خذ بعض الوقت لتجربة هذه الأساليب ومعرفة كيف يمكنها تحسين التعليمات البرمجية الخاصة بك.
نُشر في الأصل: دليل أساليب مصفوفة جافا سكريبت