عرض مصدر JavaScript/Array

<noinclude>{{DISPLAYTITLE:الكائن <code>Array</code> في JavaScript}}</noinclude>
الكائن <code>Array</code> يُستخدَم في إنشاء المصفوفات، والتي هي قوائم شبيهة بالكائنات.

=== إنشاء مصفوفة ===
<syntaxhighlight lang="javascript">
var fruits = ['Apple', 'Banana'];

console.log(fruits.length);
// 2
</syntaxhighlight>

=== الوصول إلى عنصر من عناصر المصفوفة ===
<syntaxhighlight lang="javascript">
var first = fruits[0];
// Apple

var last = fruits[fruits.length - 1];
// Banana

</syntaxhighlight>

=== المرور على عناصر المصفوفة بحلقة تكرار ===
<syntaxhighlight lang="javascript">
fruits.forEach(function(item, index, array) {
  console.log(item, index);
});
// Apple 0
// Banana 1

</syntaxhighlight>

=== إضافة عنصر في نهاية المصفوفة ===
<syntaxhighlight lang="javascript">
var newLength = fruits.push('Orange');
// ["Apple", "Banana", "Orange"]

</syntaxhighlight>

=== إزالة عنصر من نهاية المصفوفة ===
<syntaxhighlight lang="javascript">
var last = fruits.pop(); // إزالة Orange (من النهاية)
// ["Apple", "Banana"];

</syntaxhighlight>

=== إزالة عنصر من بداية المصفوفة ===
<syntaxhighlight lang="javascript">
var first = fruits.shift(); // إزالة Apple (من البداية)
// ["Banana"];

</syntaxhighlight>

=== إضافة عنصر في بداية المصفوفة ===
<syntaxhighlight lang="javascript">
var newLength = fruits.unshift('Strawberry');
// ["Strawberry", "Banana"];

</syntaxhighlight>

=== العثور على فهرس أحد عناصر المصفوفة ===
<syntaxhighlight lang="javascript">
fruits.push('Mango');
// ["Strawberry", "Banana", "Mango"]

var pos = fruits.indexOf('Banana');
// 1

</syntaxhighlight>

=== حذف عنصر في فهرس معيّن ===
<syntaxhighlight lang="javascript">
var removedItem = fruits.splice(pos, 1);
// ["Strawberry", "Mango"]

</syntaxhighlight>

=== إزالة عناصر بعدد معيّن بدءًا من فهرسٍ مُحدَّد ===
<syntaxhighlight lang="javascript">
var vegetables = ['Cabbage', 'Turnip', 'Radish', 'Carrot'];
console.log(vegetables); 
// ["Cabbage", "Turnip", "Radish", "Carrot"]

var pos = 1, n = 2;

var removedItems = vegetables.splice(pos, n); 

console.log(vegetables); 
// ["Cabbage", "Carrot"] (ستُغيّر المصفوفة الأصلية)

console.log(removedItems); 
// ["Turnip", "Radish"]

</syntaxhighlight>

=== نسخ مصفوفة ===
<syntaxhighlight lang="javascript">
var shallowCopy = fruits.slice();
// ["Strawberry", "Mango"]

</syntaxhighlight>

==البنية العامة==
<syntaxhighlight lang="javascript">
[element0, element1, ..., elementN]
new Array(element0, element1[, ...[, elementN]])
new Array(arrayLength)

</syntaxhighlight>

=== <code>element''N''</code> ===
تهيئة مصفوفة فيها العناصر التي قد مُرِّرَت إليها، إلا إذا مررنا وسيطًا وحيدًا إلى الدالة البانية <code>Array</code> وكان هذا الوسيط رقمًا (انظر المعامل <code>arrayLength</code> أدناه). لاحظ أنَّ الحالة الخاصة السابقة تُطبَّق على المصفوفات المُنشَأة عبر الدالة البانية <code>Array</code>، وليس على المصفوفات المُنشَأة بالشكل المختصر.

=== <code>arrayLength</code> ===
إذا مررنا وسيطًا وحيدًا إلى الدالة البانية <code>Array</code> وكان هذا الوسيط عددًا صحيحًا موجبًا من 0 إلى ‎2<sup>32</sup>-1، فستُعاد مصفوفةٌ مع ضبط قيمة الخاصية <code>length</code> فيها إلى هذا العدد (وهذا يُشير إلى مصفوفة لها خانات فارغة بعدد <code>arrayLength</code>، ولن تكون هذه الخانات مرتبطةً مع القيمة <code>[[JavaScript/undefined|undefined]]</code>). إذا كان الوسيط أيّ عدد ليس من المجال السابق، فسيرمى الاستثناء <code>[[JavaScript/RangeError|RangeError]]</code>.

== الوصف ==
المصفوفات هي كائنات شبيهة بالقوائم (list-like) التي يملك كائن prototype فيها دوالًا تُستخدَم لإجراء عمليات التحويل والتعديل على المصفوفات. لاحظ أنَّ طول المصفوفات أو نوع العناصر ليسا ثابتين. 

لا يمكن استخدام السلاسل النصية كفهارس للعناصر في المصفوفات (كما في [[wikipedia:Associative_array|المصفوفات الترابطية]])، وإنما يجب استخدام الأعداد الصحيحة فقط، ومحاولة ضبط أو الوصول إلى الفهارس غير العددية باستخدام [[JavaScript/Property Accessors#طريقة الأقواس|طريقة الأقواس]] (أو [[JavaScript/Property Accessors#طريقة النقط|طريقة النقط]]) لن يؤدي إلى ضبط أو الحصول على أحد عناصر المصفوفة، لكنه سيضبط أو يصل إلى خاصية مرتبطة بتلك المصفوفة؛ لاحظ أنَّ خاصيات المصفوفة وعناصرها هما أمران منفصلان عن بعضهما تمامًا، ولا يمكن استخدام دوال تعديل المصفوفات على الخاصيات التابعة لها. 

=== الوصول إلى عناصر المصفوفة ===
يبدأ عدّ العناصر في JavaScript من الفهرس 0، أي أنَّ أوّل عنصر في المصفوفة له الفهرس 0، وفهرس آخر عنصر هو قيمة الخاصية <code>[[JavaScript/Array/length|length]]</code> مطروحًا منها 1؛ لاحظ أنَّ استخدام فهارس غير صالحة سيؤدي إلى إعادة القيمة <code>[[JavaScript/undefined|undefined]]</code>.<syntaxhighlight lang="javascript">
var arr = ['this is the first element', 'this is the second element', 'this is the last element'];
console.log(arr[0]);              // 'this is the first element'
console.log(arr[1]);              // 'this is the second element'
console.log(arr[arr.length - 1]); // 'this is the last element'

</syntaxhighlight>يجدر بالذكر أنَّ عناصر المصفوفة هي خاصياتٌ تابعةٌ لها أيضًا (أي أنَّها مثل الخاصية <code>toString</code>)، لكن إذا حاولنا الوصول إلى عناصر المصفوفة بالطريقة الآتية فسيُسبِّب برمي الاستثناء <code>[[JavaScript/SyntaxError|SyntaxError]]</code>، وذلك لأنَّ اسم الخاصية غير صالح:<syntaxhighlight lang="javascript">
console.log(arr.0); // SyntaxError

</syntaxhighlight>سببُ ذلك الخطأ ليس تابعًا للمصفوفات، وإنما لا يمكن أن الإشارة إلى الخاصيات التي تبدأ برقم باستخدام [[JavaScript/Property Accessors#طريقة النقط|طريقة النقط]]، ويجب حينئذٍ استخدام [[JavaScript/Property Accessors#طريقة الأقواس|طريقة الأقواس]]. على سبيل المثال، إذا كان لدينا كائنٌ له خاصيةٌ اسمها <code>3d</code> فلن نتمكن من الإشارة إليها إلا عبر [[JavaScript/Property Accessors#طريقة الأقواس|طريقة الأقواس]].<syntaxhighlight lang="javascript">
var years = [1950, 1960, 1970, 1980, 1990, 2000, 2010];
console.log(years.0);   // SyntaxError
console.log(years[0]);  // تعمل دون مشاكل

</syntaxhighlight><syntaxhighlight lang="javascript">
renderer.3d.setTexture(model, 'character.png');     // SyntaxError
renderer['3d'].setTexture(model, 'character.png');  // تعمل دون مشاكل

</syntaxhighlight>لاحظ أنَّ اسم الخاصية <code>3d</code> قد وضعناه بين علامتي اقتباس <code>'3d'</code>، ومن الممكن وضع علامات اقتباس لفهارس عناصر المصفوفات (مثلًا: ‎<code>years['2']</code>‎‎ بدلًا من <code>years[2]‎</code>) لكن ذلك ليس ضروريًا. إذ إنَّ القيمة 2 في <code>years[2]‎</code> ستحوّل إلى سلسلة نصية من محرِّك JavaScript باستخدام <code>toString</code>، ولهذا السبب ستجد أنَّ الفهرسين <code>'2'</code> و <code>'02'</code> يشيران إلى خانتين مختلفتين في كائن <code>years</code>، وستكون نتيجة السطر البرمجي الآتي هي <code>true</code>:<syntaxhighlight lang="javascript">
console.log(years['2'] != years['02']);

</syntaxhighlight>

=== العلاقة بين <code>[[JavaScript/Array/length|length]]</code> والخاصيات الرقمية ===
ترتبط الخاصية <code>[[JavaScript/Array/length|length]]</code> التابعة للمصفوفات مع قيم الخاصيات الرقمية (فهارس العناصر)؛ وعدد من الدوال المُضمَّنة في الكائن <code>Array</code> (مثلًا: <code>[[JavaScript/Array/join|join]]</code> و <code>[[JavaScript/Array/slice|slice]]</code> و <code>[[JavaScript/Array/indexOf|indexOf]]</code> ...إلخ.) تأخذ قيمة الخاصية <code>[[JavaScript/Array/length|length]]</code> التابعة للمصفوفة عند استدعائها بالحسبان؛ أما الدوال الأخرى (مثل <code>[[JavaScript/Array/push|push]]</code> و <code>[[JavaScript/Array/splice|splice]]</code>) ستؤدي إلى تحديثات على قيمة <code>[[JavaScript/Array/length|length]]</code>.<syntaxhighlight lang="javascript">
var fruits = [];
fruits.push('banana', 'apple', 'peach');

console.log(fruits.length); // 3

</syntaxhighlight>عند إضافة عنصر إلى مصفوفة وله فهرسٌ سليمٌ لكنه خارج حدود المصفوفة، فسيُحدِّث محرِّك JavaScript قيمة الخاصية <code>[[JavaScript/Array/length|length]]</code> بما يناسب:<syntaxhighlight lang="javascript">
fruits[5] = 'mango';
console.log(fruits[5]); // 'mango'
console.log(Object.keys(fruits));  // ['0', '1', '2', '5']
console.log(fruits.length); // 6

</syntaxhighlight>أما زيادة قيمة الخاصية <code>[[JavaScript/Array/length|length]]</code> يدويًا فلن تؤثر على شيء إلا على قيمة الخاصية نفسها:<syntaxhighlight lang="javascript">
fruits.length = 10;
console.log(Object.keys(fruits)); // ['0', '1', '2', '5']
console.log(fruits.length); // 10

</syntaxhighlight>لكن إنقاص قيمة الخاصية <code>[[JavaScript/Array/length|length]]</code> سيؤدي إلى حذف العناصر:<syntaxhighlight lang="javascript">
fruits.length = 2;
console.log(Object.keys(fruits)); // ['0', '1']
console.log(fruits.length); // 2

</syntaxhighlight>هذا السلوك مشروحٌ بالتفصيل في صفحة الخاصية <code>[[JavaScript/Array/length|Array.length]]</code>.

=== إنشاء مصفوفة عند مطابقة نمط في سلسلة نصية ===
إنَّ نتيجة المطابقة التي تحدث بين التعابير النمطية والسلاسل النصية ستؤدي إلى إنشاء مصفوفات، وهذه المصفوفة لها خاصيات وعناصر التي يمكن استخدامها للحصول على معلومات عن المطابقة؛ ستُعاد مثل هذه المصفوفة من الدوال <code>[[JavaScript/RegExp/exec|RegExp.exec]]</code> و <code>[[JavaScript/String/match|String.match]]</code> و <code>[[JavaScript/String/replace|String.replace]]</code>. ألقِ نظرةً على المثال الآتي (الذي يُطابِق الحرف d المتبوع بحرف b واحد أو أكثر والمتبوع بحرف d واحد، لاحظ كيفية استخدام الراية <code>i</code> لتجاهل حالة الأحرف) ثم أمعن النظر في الجدول الذي يليه:<syntaxhighlight lang="javascript">
var myRe = /d(b+)(d)/i;
var myArray = myRe.exec('cdbBdbsbz');
</syntaxhighlight>الجدول الآتي يوضِّح خاصيات وعناصر المصفوفة المعادة من المثال السابق:
{| class="wikitable"
!الخاصية/العنصر
!الوصف
!مثال
|-
|<code>input</code>
|خاصية للقراءة فقط تُشير إلى السلسلة النصية الأصلية التي جرت عملية المُطابَقة عليها.
|<code>cdbBdbsbz</code>
|-
|<code>index</code>
|خاصية للقراءة فقط تحتوي على فهرس بداية السلسلة النصية المُطابَقة.
|<code>1</code>
|-
|<code>[0]</code>
|عنصر للقراءة فقط الذي يُشير إلى السلسلة النصية الفرعية التي جرت مطابقتها.
|<code>dbBd</code>
|-
|<code>‎[1], ...[n]‎</code>
|عناصر للقراءة فقط تحتوي على السلاسل النصية الفرعية التي جرت مطابقتها من الأنماط الفرعية الموجودة بين قوسين.
|<code>‎‎[1]: bB</code>

<code>‎[2]: d‎</code>
|}

== الخاصيات التابعة للدالة البانية <code>Array</code> ==

=== <code>Array.length</code> ===
قيمة الخاصية <code>length</code> التابعة للدالة البانية <code>Array</code> هي 1.

=== <code>[[JavaScript/Array/prototype|Array.prototype]]</code> ===
تسمح هذه الخاصية بإضافة خاصيات متاحة لجميع الكائنات التي نوعها هو <code>Array</code>.

== الدوال التابعة للدالة البانية <code>Array</code> ==

=== <code>[[JavaScript/Array/from|Array.from()‎]]</code> ===
إنشاء مصفوفة جديدة من كائن شبيه بالمصفوفات.

=== <code>[[JavaScript/Array/isArray|Array.isArray()‎]]</code> ===
إعادة <code>true</code> إذا كانت المتغير مصفوفةً، و <code>false</code> فيما عدا ذلك.

=== <code>[[JavaScript/Array/of|Array.of()‎]]</code> ===
إنشاء مصفوفة جددة من عدد متغير من الوسائط، بغض النظر عن نوع تلك الوسائط.

== الكائن prototype ==
النسخ المُنشَأة من الدالة البانية <code>Array</code> ترث الدوال والخاصيات من كائن <code>Array.prototype</code>؛ وكما في جميع الدوال البانية، يمكنك إجراء تغييرات إلى كائن <code>prototype</code> في الدالة البانية لكي تنعكس تلك التعديلات إلى جميع نسخ الكائن <code>Array</code>.

=== الخاصيات ===

==== <code>Array.prototype.constructor</code> ====
تُحديد الدالة التي ستُنشِئ كائن prototype التابع للكائن <code>Array</code>؛ راجع صفحة الخاصية <code>[[JavaScript/Object/constructor|Object.prototype.constructor]]</code> لمزيدٍ من التفاصيل.

==== <code>[[JavaScript/Array/length|Array.prototype.length]]</code> ====
إعادة عدد العناصر الموجودة في المصفوفة. 

=== دوال التحويل ===
هذه الدوال تُعدِّل المصفوفة نفسها.

==== <code>[[JavaScript/Array/copyWithin|Array.prototype.copyWithin()‎]]</code> ====
نسخ سلسلة من عناصر المصفوفة إلى مكانٍ آخر داخلها.

==== <code>[[JavaScript/Array/fill|Array.prototype.fill()‎]]</code> ====
ملء جميع عناصر المصفوفة من فهرس البداية حتى فهرس النهاية بقيمة ثابتة.

==== <code>[[JavaScript/Array/pop|Array.prototype.pop()‎]]</code> ====
إزالة آخر عنصر من المصفوفة وإعادة ذلك العنصر.

==== <code>[[JavaScript/Array/push|Array.prototype.push()‎]]</code> ====
إضافة عنصر أو أكثر إلى نهاية المصفوفة، وإعادة طول المصفوفة الجديدة.

==== <code>[[JavaScript/Array/reverse|Array.prototype.reverse()‎]]</code> ====
عكس ترتيب عناصر المصفوفة، أي أنَّ أوّل عنصر سيصبح الأخير وآخر عنصر سيصبح الأوّل.

==== <code>[[JavaScript/Array/shift|Array.prototype.shift()‎]]</code> ====
إزالة أوّل عنصر من المصفوفة وإعادة ذلك العنصر.

==== <code>[[JavaScript/Array/sort|Array.prototype.sort()‎]]</code> ====
ترتيب عناصر المصفوفة وإعادة المصفوفة الناتجة.

==== <code>[[JavaScript/Array/splice|Array.prototype.splice()‎]]</code> ====
إضافة أو إزالة عناصر من مصفوفة.

==== <code>[[JavaScript/Array/unshift|Array.prototype.unshift()‎]]</code> ====
إضافة عنصر أو أكثر في بداية المصفوفة، وإعادة طول المصفوفة الجديدة.

=== دوال الوصول ===
هذه الدوال لا تُعدِّل المصفوفة، وستُعيد مصفوفةً جديدةً.

==== <code>[[JavaScript/Array/concat|Array.prototype.concat()‎]]</code> ====
إعادة مصفوفة جديدة تتألف من جمع المصفوفة الحالية مع مصفوفات أو قيم أخرى.

==== <code>[[JavaScript/Array/includes|Array.prototype.includes()‎]]</code> ====
تحديد إذا كانت المصفوفة تحتوي على عنصر معيّن، وتُعيد <code>true</code> أو <code>false</code>.

==== <code>[[JavaScript/Array/indexOf|Array.prototype.indexOf()‎]]</code> ====
إعادة أوّل فهرس للعنصر الموجود في الدالة والذي يساوي القيمة المُحدَّدة، أو القيمة -1 إن لم يُعثَر على مُطابَقة.

==== <code>[[JavaScript/Array/join|Array.prototype.join()‎]]</code> ====
جمع جميع عناصر المصفوفة في سلسلة نصية.

==== <code>[[JavaScript/Array/lastIndexOf|Array.prototype.lastIndexOf()‎]]</code> ====
إعادة آخر فهرس للعنصر الموجود في الدالة والذي يساوي القيمة المُحدَّدة، أو القيمة -1 إن لم يُعثَر على مُطابَقة.

==== <code>[[JavaScript/Array/slice|Array.prototype.slice()‎]]</code> ====
استخراج قسم من المصفوفة وإعادة مصفوفة جديدة.

==== <code>[[JavaScript/Array/toString|Array.prototype.toString()‎]]</code> ====
إعادة سلسلة نصية تُمثِّل المصفوفة وعناصرها، وهي إعادة تعريف للدالة <code>[[JavaScript/Object/toString|Object.prototype.toString]]</code>.

=== دوال المرور على عناصر المصفوفة ===

==== <code>[[JavaScript/Array/entries|Array.prototype.entries()‎]]</code> ====
إعادة كائن <code>Array Iterator</code> الذي يحتوي على أزواج «المفتاح/القيمة» لكل فهرس في المصفوفة.

==== <code>[[JavaScript/Array/every|Array.prototype.every()‎]]</code> ====
إعادة <code>true</code> إذا كانت جميع عناصر المصفوفة تحقق الشرط الموجود في دالة الاختبار.

==== <code>[[JavaScript/Array/filter|Array.prototype.filter()‎]]</code> ====
إنشاء مصفوفة جديدة مع جميع عناصر هذه المصفوفة التي تجعل دالة الاختبار تُعيد <code>true</code>.

==== <code>[[JavaScript/Array/find|Array.prototype.find()‎]]</code> ====
إعادة القيمة التي عُثِرَ عليها في المصفوفة، وذلك إذا كان أحد عناصر المصفوفة يحقق دالة الاختبار المُعطاة، أو ستُعاد القيمة <code>[[JavaScript/undefined|undefined]]</code> فيما عدا ذلك.

==== <code>[[JavaScript/Array/findIndex|Array.prototype.findIndex()‎]]</code> ====
إعادة الفهرس التي عُثِرَ عليه في المصفوفة، وذلك إذا كان أحد عناصر المصفوفة يحقق دالة الاختبار المُعطاة، أو ستُعاد القيمة <code>-1</code> فيما عدا ذلك.

==== <code>[[JavaScript/Array/forEach|Array.prototype.forEach()‎]]</code> ====
استدعاء دالة لكل عنصر موجود في المصفوفة.

==== <code>[[JavaScript/Array/keys|Array.prototype.keys()‎]]</code> ====
إعادة كائن <code>Array Iterator</code> الذي يحتوي على كل فهرس في المصفوفة.

==== <code>[[JavaScript/Array/map|Array.prototype.map()‎]]</code> ====
إنشاء مصفوفة جديدة اعتمادًا على نتائج استدعاء دالة مُعيّنة على كل عنصر من عناصر المصفوفة.

==== <code>[[JavaScript/Array/reduce|Array.prototype.reduce()‎]]</code> ====
تطبيق دالة لاختزال جميع قيم المصفوفة (بدءًا من اليسار إلى اليمين) إلى قيمة واحدة.

==== <code>[[JavaScript/Array/reduceRight|Array.prototype.reduceRight()‎]]</code> ====
تطبيق دالة لاختزال جميع قيم المصفوفة (بدءًا من اليمين إلى اليسار) إلى قيمة واحدة.

==== <code>[[JavaScript/Array/some|Array.prototype.some()‎]]</code> ====
إعادة <code>true</code> إذا كان هنالك عنصرٌ واحدٌ من عناصر المصفوفة يُحقِّق دالة الاختبار المعطية.

==== <code>[[JavaScript/Array/values|Array.prototype.values()‎]]</code> ====
إعادة كائن <code>Array Iterator</code> الذي يحتوي على كل قيمة في المصفوفة.

== أمثلة ==

=== إنشاء مصفوفة ===
المثال الآتي يُنشِئ مصفوفةً باسم <code>msgArray</code> طولها (<code>[[JavaScript/Array/length|length]]</code>) هو 0، ثم يُسنِد قيمًا إلى <code>msgArray[0]‎</code> و <code>msgArray[99]‎</code>، مما يُغيّر طول المصفوفة إلى 100:<syntaxhighlight lang="javascript">
var msgArray = [];
msgArray[0] = 'Hello';
msgArray[99] = 'world';

if (msgArray.length === 100) {
  console.log('The length is 100.');
}

</syntaxhighlight>

=== إنشاء مصفوفة ثنائية الأبعاد ===
المثال الآتي يُنشِئ رقعة شطرنج باستخدام مصفوفة ثنائية الأبعاد تتألف من سلاسل نصية، وأوّل حركة في الرقعة تمت بنسخ 'p' من (6,4) إلى (4,4):<syntaxhighlight lang="javascript">
var board = [ 
  ['R','N','B','Q','K','B','N','R'],
  ['P','P','P','P','P','P','P','P'],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  [' ',' ',' ',' ',' ',' ',' ',' '],
  ['p','p','p','p','p','p','p','p'],
  ['r','n','b','q','k','b','n','r'] ];

console.log(board.join('\n') + '\n\n');

// تحريك البيدق أمام الملك خطوتين
board[4][4] = board[6][4];
board[6][4] = ' ';
console.log(board.join('\n'));

</syntaxhighlight>هذه مخرجات المثال السابق:<syntaxhighlight lang="javascript">
R,N,B,Q,K,B,N,R
P,P,P,P,P,P,P,P
 , , , , , , , 
 , , , , , , , 
 , , , , , , , 
 , , , , , , , 
p,p,p,p,p,p,p,p
r,n,b,q,k,b,n,r

R,N,B,Q,K,B,N,R
P,P,P,P,P,P,P,P
 , , , , , , , 
 , , , , , , , 
 , , , ,p, , , 
 , , , , , , , 
p,p,p,p, ,p,p,p
r,n,b,q,k,b,n,r

</syntaxhighlight>

=== استخدام مصفوفة لإنشاء جدول من القيم ===
<syntaxhighlight lang="javascript">
values = [];
for (var x = 0; x < 10; x++){
 values.push([
  2 ** x,
  2 * x ** 2
 ])
};
console.table(values)

</syntaxhighlight>الناتج:<syntaxhighlight lang="javascript">
0	1	0
1	2	2
2	4	8
3	8	18
4	16	32
5	32	50
6	64	72
7	128	98
8	256	128
9	512	162

</syntaxhighlight>

== دعم المتصفحات ==
{| class="wikitable"
!الميزة
!|Chrome
!Firefox
!Internet Explorer
!Opera
!Safari
|-
! الدعم الأساسي
|نعم
|نعم
|نعم
|نعم
|نعم
|}
انظر إلى صفحة كل خاصية ودالة تابعة للكائن <code>Array</code> لتفاصيل عن دعم المتصفحات لها.

== مصادر ومواصفات ==
* مسودة المعيار [https://tc39.github.io/ecma262/#sec-string-objects ECMAScript Latest Draft]. أضاف هذا المعيار الدالة <code>[[JavaScript/Array/includes|includes]]</code>.
* معيار [https://www.ecma-international.org/ecma-262/6.0/#sec-string-objects ECMAScript 2015 (6th Edition)]‎. أضاف هذا المعيار الدوال <code>[[JavaScript/Array/from|from]]</code> و <code>[[JavaScript/Array/of|of]]</code> و <code>[[JavaScript/Array/find|find]]</code> و <code>[[JavaScript/Array/findIndex|findIndex]]</code> و <code>[[JavaScript/Array/fill|fill]]</code> و <code>[[JavaScript/Array/copyWithin|copyWithin]]</code>.
* معيار [https://www.ecma-international.org/ecma-262/5.1/#sec-15.4 ECMAScript 5.1]. أضاف هذا المعيار الدوال <code>[[JavaScript/Array/isArray|isArray]]</code> و <code>[[JavaScript/Array/indexOf|indexOf]]</code> و <code>[[JavaScript/Array/lastIndexOf|lastIndexOf]]</code> و <code>[[JavaScript/Array/every|every]]</code> و <code>[[JavaScript/Array/some|some]]</code> و <code>[[JavaScript/Array/forEach|forEach]]</code> و <code>[[JavaScript/Array/map|map]]</code> و <code>[[JavaScript/Array/filter|filter]]</code> و <code>[[JavaScript/Array/reduce|reduce]]</code> و <code>[[JavaScript/Array/reduceRight|reduceRight]]</code>.
* معيار [http://www.ecma-international.org/publications/files/ECMA-ST-ARCH/ECMA-262,%201st%20edition,%20June%201997.pdf ECMAScript 1st Edition] . 
[[تصنيف:JavaScript|{{SUBPAGENAME}}]]
[[تصنيف:JavaScript Global Objects|{{SUBPAGENAME}}]]
[[تصنيف:JavaScript Array|{{SUBPAGENAME}}]]