عرض مصدر JavaScript/Bitwise Operators

<noinclude>{{DISPLAYTITLE:المعاملات الثنائية في JavaScript}}</noinclude>
المعاملات الثنائية (bitwise operators) تُعامِل القيم كأنها سلسلة تتألف من 32 بت (أصفار وواحدات) بدلًا من الأرقام <code>[[JavaScript/Number|Number]]</code> في النظام العشري (decimal) أو الست عشري (hexadecimal) أو الثماني (octal)؛ فمثلًا يُمثَّل العدد 9 في نظام العد الثنائي بالمحارف 1001؛ وتجري معاملات البتات في JavaScript العمليات على التمثيل الثنائي للأعداد، لكنها تعيد قيمًا عدديةً عاديةً قياسيةً في JavaScript.

الجدول الآتي يُلخِّص معاملات البتات في JavaScript:
{| class="wikitable"
!المعامل
!الاستخدام
!الوصف
|-
|AND
|<code>a & b</code>
|يُعيد 1 مكان كل بت له القيمة 1 في كلا القيمتين.
|-
|OR
|<code><nowiki>a | b</nowiki></code>
|يُعيد 1 مكان كل بت له القيمة 1 في إحدى القيمتين أو كلتيهما.
|-
|XOR
|<code>a ^ b</code>
|يُعيد 1 مكان كل بت له القيمة 1 في إحدى القيمتين فقط دونًا عن الأخرى.
|-
|NOT
|<code>‎~ a</code>
|يعكس قيمة البتات.
|-
|الإزاحة نحو اليسار
|<code>a << b</code>
|يزيح بتات القيمة <code>a</code> بمقدار <code>b</code> إلى اليسار، وسنحصل على أصفار في اليمين.
|-
|معامل الإزاحة إلى اليمين مع الحفاظ على الإشارة
|<code>a >> b</code>
|يزيح بتات القيمة <code>a</code> بمقدار <code>b</code> إلى اليمين.
|-
|معامل الإزاحة إلى اليمين دون الحفاظ على الإشارة
|<code>a >>> b</code>
|يزيح بتات القيمة <code>a</code> بمقدار <code>b</code> إلى اليمين، وسيؤدي إلى إضافة أصفار على الطرف الأيسر.
|}

== الأعداد الصحيحة بطول 32 بت مع إشارة ==
جميع القيم التي تُجرى عليها عمليات عبر معاملات البتات ستحوّل إلى أعداد صحيحة بطول 32 بت لها إشارة (بصيغة المتمم الثنائي [[wikipedia:Two's_complement|two's complement format]]). صيغة المتمم الثنائي تعني أنَّ العدد السالب المقابل للعدد الحالي (أي 5 و ‎-5) هو ناتج قلب جميع البتات في العدد + 1، فمثلًا هذا هو تمثيل العدد <code>314</code> في النظام الثنائي:<syntaxhighlight lang="javascript">
00000000000000000000000100111010

</syntaxhighlight>وما يلي هو ناتج <code>‎~314</code> أي المتمم الأحادي ([[wikipedia:Ones'_complement|ones' complement]]) للعدد  ‎<code>-314</code>:<syntaxhighlight lang="javascript">
11111111111111111111111011000101
</syntaxhighlight>وفي النهاية هذا هو العدد ‎<code>-314</code>، أي المتمم الثنائي للعدد ‎<code>314</code>:<syntaxhighlight lang="javascript">
11111111111111111111111011000110

</syntaxhighlight>المتمم الثنائي يضمن أنَّ البت الموجود على اليسار هو 0 إذا كان العدد موجبًا و 1 إذا كان العدد سالبًا، ولهذا السبب يسمى هذا البت بالمصطلح «بت الإشارة» (sign bit).

العدد <code>0</code> في النظام العشري هو سلسلة من الأصفار في النظام الثنائي:<syntaxhighlight lang="javascript">
0 (base 10) = 00000000000000000000000000000000 (base 2)

</syntaxhighlight>أما العدد <code>‎-1</code> في النظام العشري هو سلسلة من الواحدات في النظام الثنائي:<syntaxhighlight lang="javascript">
-1 (base 10) = 11111111111111111111111111111111 (base 2)

</syntaxhighlight>والعدد <code>‎-2147483648</code> في النظام العشري (تمثيله في نظام العد الست عشري هو <code>‎-0x80000000</code>) هو سلسلة من الأصفار باستثناء أوّل بت (على اليسار) فهو 1:<syntaxhighlight lang="javascript">
-2147483648 (base 10) = 10000000000000000000000000000000 (base 2)

</syntaxhighlight>أما العدد <code>2147483647</code> في النظام العشري (تمثيله في نظام العد الست عشري هو <code>0x7fffffff</code>) هو سلسلة من الواحدات باستثناء أوّل بت (على اليسار):<syntaxhighlight lang="javascript">
2147483647 (base 10) = 01111111111111111111111111111111 (base 2)

</syntaxhighlight>لاحظ أنَّ العددين <code>‎-2147483648</code> و <code>2147483647</code> هما أدنى وأقصى عدد صحيح يمكن تمثيله مع إشارة في 32 بت.

== المعاملات الثنائية ==
تعمل معاملات البتات كما يلي:
* ستحوّل القيم إلى أعداد صحيحة بطول 32 بت تتألف من الأصفار والواحدات، والأعداد الأطول من 32 بت سيُقتَطَع جزءٌ منها، فالعدد الآتي أطول من 32 بت، لاحظ كيف سيحوّل إلى 32 بت:
<syntaxhighlight lang="javascript">
Before: 11100110111110100000000000000110000000000001
After:              10100000000000000110000000000001

</syntaxhighlight>
* كل بت في القيمة الأولى سيرتبط بمقابله في القيمة الثانية، أي أنَّ أوّل بت في القيمة الأولى سيرتبط بأوّل بت في القيمة الثانية، وهلمّ جرًا للبقية.
* بعد تطبيق المعامل على كل زوج من البتات، فستعاد القيمة النهائية.

=== المعامل AND (<code>&</code>) ===
إجراء عملية AND على كل زوج من البتات، فالتعبير <code>a</code> AND <code>b</code> يعطي <code>1</code> إذا كان زوج البتات المعني في <code>a</code> و <code>b</code> هو <code>1</code>. هذا جدول يوضِّح ناتج عملية AND على مختلف القيم:
{| class="wikitable"
!a
!b
!a AND b
|-
|<code>0</code>
|<code>0</code>
|<code>0</code>
|-
|<code>0</code>
|<code>1</code>
|<code>0</code>
|-
|<code>1</code>
|<code>0</code>
|<code>0</code>
|-
|<code>1</code>
|<code>1</code>
|<code>1</code>
|}
مثال عن استخدام المعامل AND على العددين <code>9</code> و <code>14</code>، وسيكون الناتج هو <code>8</code>:<syntaxhighlight lang="javascript">
.    9 (base 10) = 00000000000000000000000000001001 (base 2)
    14 (base 10) = 00000000000000000000000000001110 (base 2)
                   --------------------------------
14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10)

</syntaxhighlight>لاحظ أنَّ إجراء العملية AND على العدد <code>x</code> مع العدد <code>0</code> سينتج <code>0</code>، وإجراء العملية AND على العدد <code>x</code> مع العدد <code>-1</code> سينتج <code>x</code>.

=== المعامل OR (<code>|</code>) ===
إجراء عملية OR على كل زوج من البتات، فالتعبير <code>a</code> OR <code>b</code> يعطي <code>1</code> إذا كان زوج البتات المعني في <code>a</code> أو <code>b</code> هو <code>1</code>. هذا جدول يوضِّح ناتج عملية OR على مختلف القيم:
{| class="wikitable"
!a
!b
!a OR b
|-
|<code>0</code>
|<code>0</code>
|<code>0</code>
|-
|<code>0</code>
|<code>1</code>
|<code>1</code>
|-
|<code>1</code>
|<code>0</code>
|<code>1</code>
|-
|<code>1</code>
|<code>1</code>
|<code>1</code>
|}
مثال عن استخدام المعامل OR على العددين <code>9</code> و <code>14</code>، وسيكون الناتج هو <code>15</code>:<syntaxhighlight lang="javascript">
.    9 (base 10) = 00000000000000000000000000001001 (base 2)
    14 (base 10) = 00000000000000000000000000001110 (base 2)
                   --------------------------------
14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10)

</syntaxhighlight>لاحظ أنَّ إجراء العملية OR على العدد <code>x</code> مع العدد <code>0</code> سينتج <code>x</code>، وإجراء العملية OR على العدد <code>x</code> مع العدد <code>-1</code> سينتج <code>-1</code>.

=== المعامل XOR (<code>^</code>) ===
إجراء عملية XOR على كل زوج من البتات، فالتعبير <code>a</code> XOR <code>b</code> يعطي <code>1</code> إذا كان زوج البتات المعني في <code>a</code> أو <code>b</code> مختلفًا عن بعضه. هذا جدول يوضِّح ناتج عملية XOR على مختلف القيم:
{| class="wikitable"
!a
!b
!a XOR b
|-
|<code>0</code>
|<code>0</code>
|<code>0</code>
|-
|<code>0</code>
|<code>1</code>
|<code>1</code>
|-
|<code>1</code>
|<code>0</code>
|<code>1</code>
|-
|<code>1</code>
|<code>1</code>
|<code>0</code>
|}
مثال عن استخدام المعامل XOR على العددين <code>9</code> و <code>14</code>، وسيكون الناتج هو <code>7</code>:<syntaxhighlight lang="javascript">
.    9 (base 10) = 00000000000000000000000000001001 (base 2)
    14 (base 10) = 00000000000000000000000000001110 (base 2)
                   --------------------------------
14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10)

</syntaxhighlight>لاحظ أنَّ إجراء العملية XOR على العدد <code>x</code> مع العدد <code>0</code> سينتج <code>x</code>، وإجراء العملية XOR على العدد <code>x</code> مع العدد <code>-1</code> سينتج <code>‎~x</code>.

=== المعامل NOT (<code>~</code>) ===
يجري المعامل NOT عمليته على كل بت، فالتعبير <code>NOT a</code> سيؤدي إلى قلب القيمة <code>a</code> (أي إعادة المتمم الأحادي). هذا جدول يوضِّح ناتج عملية NOT:
{| class="wikitable"
!a
!NOT a
|-
|<code>0</code>
|<code>1</code>
|-
|<code>1</code>
|<code>0</code>
|}
مثال عن استخدام المعامل NOT على العدد <code>9</code>، وسيكون الناتج هو <code>-10</code>:<syntaxhighlight lang="javascript">
 9 (base 10) = 00000000000000000000000000001001 (base 2)
               --------------------------------
~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10)

</syntaxhighlight>لاحظ أنَّ إجراء العملية NOT على العدد <code>x</code> سينتج <code>‎‎‎-‎(x+1)</code>‎. فمثلًا التعبير <code>‎~-5</code> سينتج <code>4</code>.

مثال عن استخدام المعامل NOT مع الدالة <code>[[JavaScript/String/indexOf|indexOf()]]</code>‎:<syntaxhighlight lang="javascript">
var str = 'rawr';
var searchFor = 'a';

// هذه طريقة بديلة لكتابة العبارة الشرطية
// if (-1*str.indexOf('a') <= 0)
if (~str.indexOf(searchFor)) {
  // ما نبحث عنه موجودٌ في السلسلة النصية
} else {
  // ما نبحث عنه ليس موجودًا في السلسلة النصية
}

// هذه هي القيمة المُعادة من التعبير
// (~str.indexOf(searchFor))

// r == -1
// a == -2
// w == -3

</syntaxhighlight>

== معاملات الإزاحة الثنائية ==
تأخذ معاملات الإزاحة الثنائية (bitwise shift operators) قيمتين: القيمة الأولى هي القيمة التي ستُزاح البتات فيها، والقيمة الثانية تُمثِّل مقدار إزاحة بتات القيمة الأولى؛ اتجاه عملية الإزاحة يختلف حسب المعامل المُستخدَم.

=== معامل الإزاحة إلى اليسار (<code>>></code>) ===
هذا المعامل يؤدي إلى إزاحة بتات القيمة الأولى وفق العدد المحدد باتجاه اليسار، والبتات الزائدة التي تُزاح إلى اليسار ستُهمَل، وستُضاف أصفار من الجهة اليمنى.

المثال الآتي يُطبِّق معامل الإزاحة إلى اليسار على العدد <code>9</code>، إذ سنزيح بتاته بمقدار <code>2</code>، وستنتج عندنا القيمة <code>36</code>:<syntaxhighlight lang="javascript">
.    9 (base 10): 00000000000000000000000000001001 (base 2)
                  --------------------------------
9 << 2 (base 10): 00000000000000000000000000100100 (base 2) = 36 (base 10)

</syntaxhighlight>لاحظ أنَّ إزاحة إي قيمة (<code>x</code>) إلى اليسار بمقدار <code>y</code> سينتج <code>x * 2^y</code>.

=== معامل الإزاحة إلى اليمين مع الحفاظ على الإشارة (<code><<</code>) ===
معامل الإزاحة إلى اليمين مع الحفاظ على الإشارة (sign-propagating right shift) يؤدي إلى إزاحة بتات القيمة الأولى وفق العدد المحدد باتجاه اليمين، والبتات الزائدة التي تُزاح إلى اليمين ستُهمَل، وستُنسَخ قيمة البت الموجود على أقصى اليسار، وبالتالي لن تتغير إشارة العدد (بت الإشارة).

المثال الآتي يُطبِّق معامل الإزاحة إلى اليمين مع الحفاظ على الإشارة على العدد <code>9</code>، إذ سنزيح بتاته بمقدار <code>2</code>، وستنتج عندنا القيمة <code>2</code>:<syntaxhighlight lang="javascript">
.    9 (base 10): 00000000000000000000000000001001 (base 2)
                  --------------------------------
9 >> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)

</syntaxhighlight>وبشكلٍ مشابه، التعبير ‎<code>-9 >> 2</code> سينتج <code>‎-3</code>، وذلك لأنَّ هذا المعامل يحافظ على الإشارة:<syntaxhighlight lang="javascript">
.    -9 (base 10): 11111111111111111111111111110111 (base 2)
                   --------------------------------
-9 >> 2 (base 10): 11111111111111111111111111111101 (base 2) = -3 (base 10)

</syntaxhighlight>

=== معامل الإزاحة إلى اليمين دون الحفاظ على الإشارة (<code><<<</code>) ===
معامل الإزاحة إلى اليمين دون الحفاظ على الإشارة (zero-fill right shift) يؤدي إلى إزاحة بتات القيمة الأولى وفق العدد المحدد باتجاه اليمين، والبتات الزائدة التي تُزاح إلى اليمين ستُهمَل، وستصبح قيمة بت الإشارة 0، ولهذا ستكون نتيجة هذا العملية عددًا موجبًا دومًا.

لاحظ أنَّ تطبيق المعامل <code><<<</code> على الأعداد الموجبة ينُتِج نفس نتيجة تطبيق المعامل <code><<</code>، فمثلًا ناتج العملية <code>‎9 >>> 2</code> هو <code>2</code>، وسنحصل على النتيجة نفسها إن طبقنا العملية ‎<code>9 >> 2</code>:<syntaxhighlight lang="javascript">
.     9 (base 10): 00000000000000000000000000001001 (base 2)
                   --------------------------------
9 >>> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)

</syntaxhighlight>لكن الوضع مختلف بالنسبة إلى الأرقام السالبة، فمثلًا العملية <code>‎-9 >>> 2</code> ستُنتِج <code>1073741821</code>، وهذا يختلف كثيرًا عن العملية <code>‎-9 >> 2</code> (التي تُنتِج ‎<code>-3</code>):

== أمثلة ==

=== الرايات وأقنعة البتات ===
تُستخدَم المعاملات الثنائية عادةً لإنشاء أو تعديل أو قراءة سلسلة من الرايات (flags)، والتي تُشبه المتغيرات الثنائية (binary variables)، ويمكن أن تُستخدَم المتغيرات العادية بدل استخدام سلسلة من الرايات، لكن الرايات الثنائية تستهلك ذاكرةً أقل بكثير (أقل بمقدار 32 ضعف).

لنفترض أنَّ لدينا أربع رايات:
* الراية A: لدينا مشكلة مع النمل (ant)!
* الراية B: نملك خفاشًا (bat)!
* الراية C: لدينا قطة (cat)!
* الراية D: لدينا بطة (duck)!
تُمثَّل هذه الرايات بسلسلة من البتات DCBA، وعندما «تُضبَط» الراية فستملك القيمة 1، وعندما «تُحذَف» الراية فستملك القيمة 0؛ ولنفرض مثلًا أنَّ المتغير flags له القيمة الثنائية 0101:<syntaxhighlight lang="javascript">
var flags = 5;   // binary 0101

</syntaxhighlight>هذه القيمة تُشير إلى أنَّ:
* الراية A مضبوطة (لدينا مشكلة من النمل).
* الراية B غير مضبوطة (لا نملك خفاشًا).
* الراية C مضبوطة (لدينا قطة).
* الراية D غير مضبوطة (لا نملك بطةً).
ولمّا كانت المعاملات الثنائية تُجري عملياتها على أعداد بطول 32 بت، فإنَّ القيمة 0101 تُخزَّن فعليًا بالشكل 00000000000000000000000000000101، لكن الأصفار الموجودة على اليسار غير مهمة إذ لا تحتوي على معلومات لها معنى.

قناع البتات (bitmask) هو سلسلة من البتات التي يمكنها تعديل أو قراءة الرايات، ويُعرَّف عادةً قناعٌ «أوليٌّ» (primitive) لكل راية:<syntaxhighlight lang="javascript">
var FLAG_A = 1; // 0001
var FLAG_B = 2; // 0010
var FLAG_C = 4; // 0100
var FLAG_D = 8; // 1000

</syntaxhighlight>يمكن إنشاء أقنعة جديدة باستخدام المعاملات الثنائية على الأقنعة الأوليّة، فمثلًا القناع 1001 يمكن إنشاؤه باستخدام العملية OR على القيم <code>FLAG_A</code> و <code>FLAG_B</code> و <code>FLAG_D</code>:<syntaxhighlight lang="javascript">
var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 => 1011

</syntaxhighlight>يمكن استخراج قيمة الرايات باستخدام العملية AND عليها مع قيمة القناع، لاحظ أنَّ أقنعة البتات ستَحجب (mask) الرايات غير المهمة، فلو كانت قيمة القناع 0100 فيمكننا أن نعرف إذا كانت الراية C مضبوطة عبر:<syntaxhighlight lang="javascript">
// إذا كنّا نملك قطةً
if (flags & FLAG_C) { // 0101 & 0100 => 0100 => true
   // ...
}

</syntaxhighlight>القناع الثنائي الذي ضُبِطَت فيه أكثر من راية سيعمل عمل «إما/أو»، فالمثالان الآتيان متكافئان:<syntaxhighlight lang="javascript">
// إذا كنا نملك خفاشًا أو كنا نملك قطةً
// (0101 & 0010) || (0101 & 0100) => 0000 || 0100 => true
if ((flags & FLAG_B) || (flags & FLAG_C)) {
   // ...
}
</syntaxhighlight>والمثال:<syntaxhighlight lang="javascript">
// إذا كنا نملك خفاشًا أو قطةً
var mask = FLAG_B | FLAG_C; // 0010 | 0100 => 0110
if (flags & mask) { // 0101 & 0110 => 0100 => true
   // ...
}
</syntaxhighlight>يمكن ضبط الرايات عبر إجراء عملية OR عليها مع القناع الثنائي، فإن لم يكن البت الموافق للراية مضبوطًا فسيُضبَط عبر العملية OR. فمثلًا القناع 1100 يمكن أن يُستخدَم لضبط الرايتين C و D:<syntaxhighlight lang="javascript">
// نملك قطةً وبطةً
var mask = FLAG_C | FLAG_D; // 0100 | 1000 => 1100
flags |= mask;   // 0101 | 1100 => 1101

</syntaxhighlight>يمكن إلغاء ضبط الرايات بتنفيذ العملية AND عليها مع القناع الثنائي، إذ سيؤدي كل بت له القيمة 0 إلى إلغاء ضبط الراية المرتبطة به. يمكن إنشاء القناع عبر تنفيذ العملية NOT على أقنعة الرايات الأوليّة، فمثلًا يمكن استخدام القناع 1010 لإلغاء ضبط الرايتين A و C:<syntaxhighlight lang="javascript">
// ليس لدينا مشكلة مع النمل ولا نملك قطةً
var mask = ~(FLAG_A | FLAG_C); // ~0101 => 1010
flags &= mask;   // 1101 & 1010 => 1000

</syntaxhighlight>يمكن إنشاء القناع باستخدام التعبير ‎<code>~FLAG_A & ~FLAG_C</code> (ويسمى ذلك بقانون دي مورغان [[[wikipedia:De_Morgan's_laws|De Morgan's law]]]):<syntaxhighlight lang="javascript">
// ليس لدينا مشكلة مع النمل ولا نملك قطةً
var mask = ~FLAG_A & ~FLAG_C;
flags &= mask;   // 1101 & 1010 => 1000

</syntaxhighlight>يمكن تفعيل/تعطيل الرايات بتنفيذ العملية XOR عليها مع القناع الثنائي، إذ سيؤدي وجود البت في القيمة إلى تفعيل أو تعطيل الراية المرتبطة به، فمثلًا القناع 0110 يمكن أن يستخدم لتفعيل/تعطيل الرايتين B و C:<syntaxhighlight lang="javascript">
// إذا لم يكن لدينا خفاش فأصبح لدينا واحدٌ الآن 
// وإذا كان لدينا خفاش فلم يعد موجودًا الآن
// وينطبق المثل على القطط
var mask = FLAG_B | FLAG_C;
flags = flags ^ mask;   // 1100 ^ 0110 => 1010

</syntaxhighlight>لاحظ أنَّ بإمكاننا قلب الرايات باستخدام معامل NOT:<syntaxhighlight lang="javascript">
flags = ~flags;    // ~1010 => 0101

</syntaxhighlight>

=== تحويل بين السلاسل النصية والأرقام الثنائية ===
لتحويل سلسلة نصية <code>[[JavaScript/String|String]]</code> تُمثِّل عددًا ثنائيًا إلى عددٍ عشري <code>[[JavaScript/Number|Number]]</code>:<syntaxhighlight lang="javascript">
var sBinString = '1011';
var nMyNumber = parseInt(sBinString, 2);
alert(nMyNumber); // 11, i.e. 1011

</syntaxhighlight>أما لتحويل عدد عشري <code>[[JavaScript/Number|Number]]</code> إلى سلسلة نصية <code>[[JavaScript/String|String]]</code> ثنائية:<syntaxhighlight lang="javascript">
var nMyNumber = 11;
var sBinString = nMyNumber.toString(2);
alert(sBinString); // 1011, i.e. 11

</syntaxhighlight>

=== أتمتة إنشاء الأقنعة ===
يمكننا إنشاء عدّة أقنعة (masks) من مجموعة قيمة منطقية <code>[[JavaScript/Boolean|Boolean]]</code> كما في الدالة الآتية:<syntaxhighlight lang="javascript">
function createMask() {
  var nMask = 0, nFlag = 0, nLen = arguments.length > 32 ? 32 : arguments.length;
  for (nFlag; nFlag < nLen; nMask |= arguments[nFlag] << nFlag++);
  return nMask;
}
var mask1 = createMask(true, true, false, true); // 11, i.e.: 1011
var mask2 = createMask(false, false, true); // 4, i.e.: 0100
var mask3 = createMask(true); // 1, i.e.: 0001
// etc.

alert(mask1); // 11, i.e.: 1011

</syntaxhighlight>

== دعم المتصفحات ==
{| class="wikitable"
!الميزة
!|Chrome
!Firefox
!Internet Explorer
!Opera
!Safari
|-
! الدعم الأساسي
|نعم
|نعم
|نعم
|نعم
|نعم
|}

== مصادر ومواصفات ==
* مسودة المعيار [https://tc39.github.io/ecma262/#sec-bitwise-shift-operators ECMAScript Latest Draft].
* معيار [http://www.ecma-international.org/ecma-262/6.0/#sec-bitwise-shift-operators ECMAScript 2015 (6th Edition)]‎.
* معيار [http://www.ecma-international.org/ecma-262/5.1/#sec-11.7 ECMAScript 5.1].
* معيار [http://www.ecma-international.org/publications/files/ECMA-ST-ARCH/ECMA-262,%201st%20edition,%20June%201997.pdf ECMAScript 1st Edition]. 
[[تصنيف:JavaScript|{{SUBPAGENAME}}]]
[[تصنيف:JavaScript Operator|{{SUBPAGENAME}}]]