المعاملات في جافا سكريبت (JavaScript Operators)
تعتبر المعاملات في جافا سكريبت (JavaScript Operators) من أهم الأدوات التي يعتمد عليها المبرمج في تنفيذ العمليات داخل البرامج. فهي التي تتيح التعامل مع القيم والمتغيرات بطرق متعددة مثل المقارنة والإسناد والعمليات الحسابية والمنطقية. وتكمن أهميتها في كونها تُستخدم تقريباً في كل جزء من أجزاء الكود البرمجي، سواء في العمليات الحسابية البسيطة أو في بناء الشروط واتخاذ القرارات.
في جافا سكريبت، المُعامل هو رمز يُجري عملية على حد أو أكثر، مثل المتغيرات أو القيم، ويُرجع نتيجة. وتقرأ التعليمات البرمجية الخاصة بالمعاملات في الغالب من اليسار الى اليمين أي أن في حال وجدنا طرفين يكون الطرف الأول هو الأيسر والطرف الثاني هو الأيمن لنأخذ تعبيرًا بسيطًا: في التعبير ( 6=3+2 ) يُسمى 2 هو الطرف الأول و 3 الطرف الثاني ويُعرف (+) بالمُعامل الحسابي الخاص بالجمع.
و تتضمن جافا سكريبت أنواع متعددة من المعاملات (JavaScript Operators) سنتعرف على بعضها في هذا المقال وهي:
- المعاملات الحسابية (Arithmetic Operators).
- معاملات التعيين (Assignment Operators).
- معاملات المقارنة (Comparison Operators).
- المعاملات المنطقية (Logical Operators).
- معاملات البت (Bitwise Operators).
المعاملات الحسابيّة في جافا سكريبت JavaScript Arithmetic Operators
المُعاملات الحسابية في جافا سكريبت هي معاملات تُجري عمليات حسابية على القيم العددية معظم المُعاملات الحسابية هي مُعاملات ثنائية أي تُجري عمليات حسابية على حدين (طرفين). بعض المُعاملات الحسابية هي مُعاملات أحادية أي تُجري العمليات الحسابية على حد واحد (طرف واحد).
تدعم جافا سكريبت العديد من العمليات الحسابية، مثل الجمع والطرح والضرب والقسمة، وغيرها. ويستخدم الرموز الشائعة للعمليات الحسابية. فيما يلي قائمة بالمعاملات الحسابية في جافا سكريبت JavaScript Arithmetic Operators مع رموزها ووظائفها:
| اسم المعامل | الرمز | الوصف |
|---|---|---|
| الجمع (Addition) | + | معامل ثنائي يقوم بإجراء عملية الجمع على الطرفين. |
| الطرح (Subtraction) | - | معامل ثنائي يقوم بطرح الطرف الأول من الثاني. |
| الضرب (Multiplication) | * | معامل ثنائي يجري عملية الضرب بين الطرفين. |
| القسمة (Division) | / | معامل ثنائي يقوم بقسمة الطرف الأول (البسط)على الطرف الثاني (المقام). |
| باقي القسمة (Modulus) | % | معامل ثنائي يرجع عدد صحيح يمثل باقي قسمة البسط على المقام. |
| الزيادة (Increment) | ++ | معامل أحادي يزيد قيمة العدد بمقدار واحد. |
| النقصان (Decrement) | -- | معامل أحادي يُنقص قيمة العدد بمقدار واحد. |
| الأسي (Exponential ) | ** | معامل ثنائي يرجع قيمة الأس بين الطرف الأول (الأساس) والطرف الثاني (الأس). |
أمثلة على المعاملات الحسابية (Arithmetic Operators) في JavaScript
معامل الجمع (Addition Operator):
يستخدم معامل الجمع مع القيم الرقمية ويُمكن استخدامه أيضًا مع قيم غير رقمية مثل النصوص، فتكون حالات استخدامة كتالي:
- يرجع معامل الجمع قيمة عددية تمثل نتيجة الجمع فقط إذا كان أطراف المعامل الأيمن والأيسر قيم عددية.
- أما في حال كان أحد الطرفين نص، فإن مُعامل الجمع يُحوّل الطرف الآخر إلى نص ويربطه بالطرف الأول.
- وإذا كان الطرفان نصوص فإن معامل الجمع سيقوم بربط يربط الطرفين معاً لتكوين عبارة نصية واحدة .
لنرى التطبيق في الامثلة التالية:
...........
console.log( 5 + 10); //15
console.log( '5' + 10); // 510
console.log( '5' + 10); // 510
console.log( '5' + '10');// 510
........... معامل الطرح (Subtraction Operator):
يستخدم مُعامل الطرح مع القيم الرقمية ويُمكن استخدامه أيضًا مع قيم غير رقمية مثل النصوص، فتكون حالات استخدامة كتالي:
- إذا كان كلا الطرفين عددًا، فإن المعامل ينفذ عملية الطرح ويكون الناتج رقم .
- إذا كان أيٌّ من الطرفين أو كلاهما نصوص (تحتوي على أرقام فقط)، فإنه يُحوّل النص أولًا إلى رقم ثم يُجري عمليات الطرح.
- وإذا كانت النص تحتوي على قيمة غير رقمية، فسوف يُعيد القيمة NaN.
- وإذا كان أي أطرف المعامل NaN أو ما لا نهاية (Infinity)، فستكون النتيجة NaN أو Infinity على التوالي.
لنرى التطبيق في الامثلة التالية:
...........
console.log(10 -5); //5
console.log(5 -10); // -5
console.log(NaN -5); // NaN
console.log(Infinity -5); // Infinity
console.log('10' -5); //5
console.log(10 -'5'); //5
console.log('10' -'5'); //5
console.log('10x' -5); // NaN
........... معامل الضرب (Multiplication Operator)
يُعطي معامل الضرب في جافا سكريبت ناتج ضرب عددين. ويطبق معامل الضرب قواعد الإشارات فإذا كان الطرفين لهما نفس الإشارة، يكون الناتج موجبًا، إذا كان الطرفين لهما إشارتان مختلفتان يكون الناتج سالبًا. كما يعمل مع القيم النصية فإذا كان أيٌّ من الأطراف أو كلاهما قيمة رقمية على شكل نص يُحوّل النص إلى عدد ثم يُرجع ناتجهما. إلا إذا احتوى النص على حرف ستكون النتيجة NaN. لنرى التطبيق في الامثلة التالية:
...........
console.log( 5 * 10 ); // 50
console.log( '5' * 10 ); // 50
console.log( 5 * '10' ); // 50
console.log( '5' * '10' ); // 50
console.log( '5x' * 10 ); // NaN
........... معامل القسمة (Division Operator)
معامل القسمة في جافا سكريبت يقوم بقسمة الطرف الأيسر (القاسم / البسط) على الطرف الأيمن (المقسوم عليه / المقام ) ويُرجع معامل القسمة حاصل القسمة . يراعي معامل القسمة القواعد الرياضية مثل قواعد الإشارات وفي حال كان المقام يساوي صفر ستكون النتيجة Infinity و NaN في حال كان كل من البسط والمقام أصفار، لاحظ الأمثلة التالية:
...........
console.log(10 / 5); // 2
console.log(-10 / 5); // -2
console.log(10 / -5); // -2
console.log(-10 /-5); // -2
console.log(10 / 0); // Infinity
console.log(0 / 0); // NaN
........... مُعامل الباقي (Modulus Operator )
يُرجع مُعامل الباقي في جافا سكريبت الباقي عند قسمة الطرف الأيسر على الطرف الأيمن. ويُعرف أيضًا باسم (Remainder Operator). ويطبق قواعد الاشارة الرياضية فإذا كان احد الطرفين ( البسط أو المقام ) سالبة تكون النتيجة سالبة وتكون موجبة فيما عدا ذلك. لنرى التطبيق في الأمثلة التالية:
...........
let x = 52;
let y = 10;
let z = x % y;
console.log(z) //2
........... معامل الزيادة (Increment Operator)
معامل الزيادة (Increment) معامل أحادي ويعمل على حالتين :
- الحالة الأولى وتُعرف بـ Prefix increment هنا يكون المعامل قبل المتغير وفي هذه الحالة يزيد معامل الزيادة قيمة المتغير بواحد (1) قبل استخدام قيمته الحالية.
- الحالة الثانية وتُعرف بـ Postfix increment هنا يكون معامل الزيادة بعد المتغير وفي هذه الحالة يزيد معامل الزيادة قيمة المتغير بواحد (1) بعد استخدام قيمته الحالية.
لنرى الأمثلة التالية:
...........
let x = 5, y = 5;
//prefix Increment
console.log( ++x ); // 6
//postfix Increment
console.log( y++ ); // 5
........... معامل النقصان (Decrement Operator)
معامل النقصان معامل أحادي ويعمل على حالتين :
- الحالة الأولى وتُعرف بـPrefix decrement هنا يكون المعامل قبل المتغير وفي هذه الحالة يُنقص معامل النقصان واحد (1) من قيمة المتغير قبل استخدام قيمته الحالية.
- الحالة الثانية وتُعرف بـ Postfix decrement هنا يكون معامل النقصان بعد المتغير وفي هذه الحالة يُنقص معامل النقصان واحد (1) من قيمة المتغير بعد استخدام قيمته الحالية.
لنرى الأمثلة التالية:
...........
//prefix Decrement
console.log( --x ); // 4
//postfix Decrement
console.log( y-- ); // 5
........... المعامل الأسي (Exponential Operator)
المعامل الأسي معامل ثنائي يعمل على إرجاع نتيجة رفع قيمة ما لقوى معينة حيث تكون القيمة على اليسار هي الأساس والقيمة على اليسار هي الأُس لنرى المثال التالي :
...........
x = 2, y = 5;
console.log( x ** y); // 32
console.log( y ** x); // 25
........... تُعد المعاملات الحسابية (Arithmetic Operators) من أكثر المعاملات استخداماً في جافا سكريبت، إذ تُمكّن المبرمج من إجراء العمليات الرياضية بسهولة ووضوح. وفهم طريقة عمل كل معامل واستخدامه بشكل صحيح يساعد على كتابة أكواد دقيقة وفعالة في مختلف التطبيقات البرمجية.
معاملات التعيين في جافا سكريبت JavaScript Assignment Operators
تُستخدم مُعاملات التعيين Assignment Operators في جافا سكريبت لتعيين قيم للمتغيرات. وتعرف ايضاً بمعملات الإسناد وهي مُعاملات ثنائية أي يتعامل مُعامل التعيين مع طرفين، بحيث يُعيّن (يسند) قيمة للطرف الأيسر بناءً على قيمة الطرف الأيمن. ( من اليمين الى اليسار). الطرف الأيسر يكون دائمًا مُتغيرًا، والطرف الأيمن قد يكون قمية (رقم او نص أو منطقية) أو مُتغيرًا أو تعبيرًا (عملية حسابية على سبيل المثال).
ويعمل معامل الإسناد البسيط مع أنواع أخرى من المُعاملات، مثل الحسابية والمنطقية، للحصول على مُعاملات إسناد مُركبة. مثلاً تجري مُعاملات الإسناد الحسابية معاملات عملية حسابية وتُسند النتيجة إلى الطرف الأيسر. فيما يلي قائمة بمعاملات التعيين المتوفرة في JavaScript:
| الإسـم | الرمز | مثال | يكافئ |
|---|---|---|---|
| التعيين البسيط (Assignment) | = | a = b | a = b |
| تعيين الجمع (Addition Assignment) | += | a += b | a = a + b |
| تعيين الطرح (Subtraction Assignment) | -= | a -= b | a = a - b |
| تعيين الضرب (Multiplication Assignment) | *= | a *= b | a = a * b |
| تعيين القسمة (Division Assignment) | /= | a /= b | a = a / b |
| تعيين الباقي (Remainder Assignment) | %= | a %= b | a = a % b |
| تعيين الأس (Exponentiation Assignment) | **= | a **= b | a = a ** b |
معامل التعيين البسيط Assignment
يُعيّن مُعامل التعيين البسيط قيمةً لمتغير، يمكننا تعيين قيمة واحدة لعدة متغيرات و يُعرف هذا بتسلسل التعيين. لنرى المثال التالي:
...........
let x = 5 , y = x;
console.log(y);
........... معامل تعيين الجمع Addition Assignment
يقوم مُعامل تعيين الجمع بجمع القيمتين على طرفي المعامل وإسناد النتيجة للطرف الأيسر. لنرى المثال التالي:
...........
let x = 5;
x += 3;
console.log(x); //8
........... معامل تعيين الطرح Subtraction Assignment
يقوم معامل تعيين الطرح بطرح القيمتين على طرفي المعامل وإسناد النتيجة للطرف الأيسر. لنرى المثال التالي:
...........
let x = 5;
x -= 3;
console.log(x); //2
........... معامل تعيين الضرب Multiplication Assignment
يقوم معامل تعيين الضرب بضرب القيمتين على طرفي المعامل وإسناد النتيجة للطرف الأيسر. لنرى المثال التالي:
...........
let x = 5;
x *= 3;
console.log(x); //15
........... معامل تعيين القسمة Division Assignment
يقوم معامل تعيين القسمة بقسمة القيمتين على طرفي المعامل وإسناد النتيجة للطرف الأيسر. لنرى المثال التالي:
...........
let x = 6;
x /= 3;
console.log(x); //2
........... معامل تعيين باقي القسمة Remainder Assignment
يقوم معامل تعيين الباقي بقسمة القيمتين على طرفي المعامل وإسناد باقي القسمة في الطرف الأيسر. لنرى المثال التالي:
...........
let x = 52;
let y = 10;
x %= y;
console.log(x) // 2
........... معامل تعيين الأس Exponentiation Assignment
يقوم معامل تعيين الأس بحساب الأس بين طرفي المعامل حيث يكون الطرف الأيسر الأساس والطرف الأيمن الأس ثم يسند النتيجة الى الطرف الأيسر.لنرى المثال التالي:
...........
let x = 2, y = 5;
y **= x
console.log( y); // 25
........... إن معاملات التعيين (Assignment Operators) من الأدوات الأساسية في جافا سكريبت، إذ تسهّل عملية إسناد القيم وتحديث المتغيرات بطرق مختصرة وفعّالة. وفهم استخدام كل نوع من معاملات التعيين يساعد المبرمج على كتابة كود أكثر وضوحاً وتنظيماً.
معاملات المقارنة في جافا سكريبت JavaScript Comparison Operators
معاملات المقارنة Comparison Operators في جافا سكريبت تقوم بالمقارنة بين متغيرين أو قيمتين، وتُرجع قيمة منطقية، إما صحيحة أو خاطئة بناءً على نتيجة المقارنة. معاملات المقارنة هي معاملات ثنائية، حيث تُجري عمليات على طرفين. على سبيل المثال، يمكننا استخدام معاملات المقارنة للتحقق من تساوي القيم على طرفي المعامل حيث يمكن أن تكون أطراف المعامل قيمًا عددية، أو نصية، أو منطقية..
وتُستخدم معاملات المقارنة مع التعبيرات المنطقية (Logical Expressions) حيث يُقيّم التعبير المنطقي إما صحيحًا أو خاطئًا. في جافا سكريبت هناك ثمانية معاملات مقارنة لإجراء أنواع مختلفة من المقارنات.فيما يلي قائمة بكل معامل مقارنة مع مثال:
| اسم المٌعامل | الرمز | مثال |
|---|---|---|
| المساواة (Equal) | == | a == b |
| عدم المساواة (Not Equal) | !== | a !== b |
| المساواة الصارمة ( Strict Equality) | === | a === b |
| عدم المساواة الصارمة (Strict Inequality) | !=== | a !=== b |
| أكبر من (Greater Than) | > | a > b |
| أكبر من أو يساوي (Greater Than or Equal) | >= | a >= b |
| أقل من (Less Than) | < | a < b |
| أصغر من أو يساوي (Less Than or Equal) | <= | a <= b |
كيف تقارن معاملات المقارنة (Comparison Operators) في جافا سكريبت؟
لمعاملات المقارنة في جافا سكريبت كيفية خاصة للتعامل مع القيم في التعابير البرمجية وتفسيرها وبالتالي مقارنتها، يمكن تلخيص هذه الكفية بالنقاط التالية :
- إذا كان كلا طرفي معامل المقارنة من نفس النوع، تُقارن مُعاملات المقارنة القيم. أما إذا كان الطرفين من نوعين مختلفين تُجري جافا سكريبت تحويلًا مناسبًا للنوع للمقارنة، و يُعرف هذا باسم "إكراه النوع- Type Coercion".
- تُجرى المقارنة بالتحقق من القيم العددية للطرفين إذا كان كلا الطرفين أرقام وتُقارن النصوص بناءً على الترتيب الأبجدي باستخدام قيم Unicode. يتم إجراء إكراه النوع التالي عند مقارنة النص برقم.
- إذا كان النص يحتوي على قيمة رقمية فقط، يُحوّل إلى نوع رقمي.
- إذا كان النص يحتوي أيضًا على قيم غير رقمية، يُحوّل إلى NaN.
- إذا كان النص فارغ، يُحوّل إلى صفر.
- لا يُجري مُعاملا المساواة الصارمة (===) وعدم المساواة الصارمة (==!) تحويلًا للنوع قبل إجراء عملية المقارنة (مقارنة صارمة).
- هناك بعض القيم الخاطئة في جافا سكريبت (مثل 0 و false والنص الفارغ "", null و undefined وNaN ) تتعامل جافا سكريبت مع هذه القيم الخاطئة بشكل مختلف أثناء إجراء المقارنة. فيما يلي القيم الخاطئة: −
- جميع معاملات المقارنة (باستثناء === و ==!) تُحوِّل القيم الخاطئة والسلاسل النصية الفارغة إلى صفر قبل إجراء المقارنة.
- تُحوِّل معاملات أقل من وأكبر من القيم null إلى صفر والقيم undefined إلى NaN.
نرى أن للمعاملات المقارنة في جافا سكريبت طريقة خاصة في قرأة القيم وأنواعها حتى انها تحول أنواع القيم في بعض الحالات، لنفهم هذا أكثر سنقدم فيما يلي شرح مع الأمثلة لكل معامل مقارنة في جافا سكريبت ….
مُعامل المساواة Equal في جافا سكريبت
يتحقق مُعامل المساواة من تساوي قيمتي الطرفين. يُرجع القيمة "true" إذا كانت الأطراف مُتساوية، وإلا يُرجع القيمة "false". إذا كان الطرفين من نوعين مختلفين، يُجري المُعامل تحويلًا للنوع ثم يُقارن .لنرى بعض أمثلة:
...........
const x = 3;
const y = 4;
let str = 'Hi';
console.log ( x == 3); //true
console.log ( x == y); //false
console.log ( str == 'Hi'); //true
console.log ( 2 == '2'); //true
console.log ( 0 == false); //true
console.log ( 0 == ''); //true
........... مُعامل عدم المساواة Not Equal في جافا سكريبت
يتحقق مُعامل عدم المساواة من عدم تساوي قيمتي الطرفين. يُرجع القيمة "true" إذا لم يكن الطرفان متساويين، وإلا يُرجع القيمة "false". وكما هو الحال مع مُعامل المساواة، يُجرى تحويل النوع إذا لم يكن الطرفان من نفس النوع. لنرى بعض أمثلة:
...........
const x = 3;
const y = 4;
let str = 'Hi';
console.log ( x != 3); //false
console.log ( x != y); //true
console.log ( str != 'Hi'); //false
console.log ( 2 != '2'); //false
console.log ( 0 != false); //false
console.log ( 0 != ''); //false
........... مُعامل المساواة الصارمة Strict Equality في جافا سكريبت
يتحقق مُعامل المساواة الصارمة من مطابقة القيمة والنوع بين بيانات الطرفين و يُرجع القيمة "true" إذا كان المُعاملان متساويين ومن نفس النوع. بمعنى آخر، يتحقق من تساوي الطرفين دون تحويل النوع. إذا كان الطرفين من نوعين مختلفين، يُرجع القيمة "false" دون الحاجة إلى التحقق من القيمة. لنرى بعض الأمثلة:
...........
const x = 3;
const y = 4;
let str = 'Hi';
console.log ( x === 3); //true
console.log ( x === y); //false
console.log ( str === 'Hi'); //true
console.log ( 2 === '2'); //false
console.log ( 0 === false); //false
console.log ( 0 === ''); //false
........... مُعامل عدم المساواة الصارم Strict Inequality
يتحقق مُعامل عدم المساواة الصارم strict inequality مما إذا كان الطرفان غير متطابقان في القيمة أو النوع. يُرجع القيمة "true" إذا كان الطرفان من نفس النوع ولكنهما غير متساويين أو من نوعين مختلفين. وكما هو الحال مع مُعامل المساواة الصارمة، يتحقق هذا المُعامل أولاً من عدم مساواة الطرفين دون تحويل النوع. إذا كان الطرفان من نوعين مختلفين، يُرجع القيمة "true" دون الحاجة إلى التحقق من القيمة. لاحظ المثال التالي:
...........
const x = 3;
const y = 4;
let str = 'Hi';
console.log ( x !== 3); //false
console.log ( x !== y); //true
console.log ( str !== 'Hi'); //false
console.log ( 2 !== '2'); //true
console.log ( 0 !== false); //true
console.log ( 0 !== ''); //true
........... مُعامل أكبر من Greater Than
يتحقق معامل أكبر من Greater Than مما إذا كانت قيمة المتغير الأيسر أكبر من قيمة المتغير الأيمن. إذا كانت الإجابة بنعم، يُرجع القيمة "true"، وإلا يُرجع القيمة "false". لاحظ الأمثلة التالية:
...........
const x = 3;
const y = 4;
let str0 = 'Hi';
let str1 = 'Hello';
console.log ( x > 3); //false
console.log ( x > y); //false
console.log ( str0 > 'Hi'); //false
console.log ( str0 > str1 ); //true
console.log ( 2 > '2'); //false
console.log ( 0 > false); //false
console.log ( 0 > ''); //false
........... مُعامل أكبر من أو يساوي Greater Than or Equal
يتحقق معامل أكبر من أو يساوي مما إذا كانت قيمة المتغير الأيسر أكبر من أو تساوي قيمة المتغير الأيمن. إذا كانت الإجابة بنعم، يُرجع "true"، وإلا "false". انظر الأمثلة التالية:
...........
const x = 3;
const y = 4;
let str0 = 'Hi';
let str1 = 'Hello';
console.log ( x >= 3); //true
console.log ( x >= y); //false
console.log ( str0 >= 'Hi'); //true
console.log ( str0 >= str1 ); //true
console.log ( 2 >= '2'); //true
console.log ( 0 >= false); //true
console.log ( 0 >= ''); //true
........... مُعامل أقل من Less Than
يُرجع معامل أقل من القيمة "true" إذا كانت قيمة المتغير الأيسر أقل من قيمة المتغير الأيمن، وإلا يُرجع القيمة "false". انظر الأمثلة التالية:
...........
//Less Than Operator
const x = 3;
const y = 4;
let str0 = 'Hi';
let str1 = 'Hello';
console.log ( x < 3); //false
console.log ( x < y); //true
console.log ( str0 < 'Hi'); //false
console.log ( str0 < str1 ); //false
console.log ( 2 < '2'); //false
console.log ( 0 < false); //false
console.log ( 0 < ''); //false
........... مُعامل أصغر من أو يساوي Less Than or Equal
يتحقق معامل أصغر من أو يساوي مما إذا كانت قيمة المتغير الأيسر أصغر من أو تساوي قيمة المتغير الأيمن. إذا كانت الإجابة بنعم، يُرجع القيمة "true".انظر الأمثلة :
...........
const x = 3;
const y = 4;
let str0 = 'Hi';
let str1 = 'Hello';
console.log ( x <= 3); //true
console.log ( x <= y); //true
console.log ( str0 <= 'Hi'); //true
console.log ( str0 <= str1 ); //false
console.log ( 2 <= '2'); //true
console.log ( 0 <= false); //true
console.log ( 0 <= ''); //true
........... مقارنة القيم null و undefined و NaN
في جافا سكريبت، القيم null و undefined و NaN هي قيم خاطئة لا تُحوَّل إلى صفر (0) للمقارنة. القيمتان null و undefined متساويتان القيمة لا النوع . و نوع NaN هو عدد، ولكنه لا يساوي صفرًا. ومن المثير للاهتمام أن NaN لا يساوي NaN نفسه. لاحظ الأمثلة فيما يلي:
...........
console.log(null == undefined); // true
console.log(null === undefined); //false
console.log(0 == NaN); //false
console.log(0 == undefined); //false
console.log(0 == null); //false
console.log(NaN == NaN); //false
........... تُعتبر معاملات المقارنة (Comparison Operators) من العناصر المهمة في جافا سكريبت إذ تُستخدم لاتخاذ القرارات داخل البرامج من خلال مقارنة القيم. ويسهم فهم هذه المعاملات واستخدامها بدقة في بناء شروط منطقية صحيحة وتحسين دقة عمل الكود البرمجي.
المعاملات المنطقية في جافا سكريبت JavaScript Logical Operators
تُستخدم المعاملات المنطقية في جافا سكريبت عادةً مع أطرف ذات قيم منطقية، وتُرجع قيمة منطقية. وتعرف أيضاٌ باسم المعاملات العلائقية ( Relational Operators). في جافا سكريبت هناك ثلاثة أنواع رئيسية من العوامل المنطقية: (&& - AND) و(|| - OR) و (! -NOT). تُستخدم هذه العوامل للتحكم في سير البرنامج. فيما يلي قائمة بالمعاملات المنطقية مع وصفها ومثال عليها.
| اسم المُعامل | الرمز | الوصف |
|---|---|---|
| Logical AND | && | يرجع ture فقط اذا كانت كل الحدود صحيحة. |
| Logical OR | || | يرجع false فقط اذا كانت كل الحدود خاطئة. |
| Logical NOT | ! | يعكس القيم من true الى false والعكس. |
خصائص المعاملات المنطقية في جافا سكريبت (JavaScript Logical Operators)
تتميز المعاملات المنطقية في JavaScript بخصائص منها :
- على الرغم من أن المعاملات المنطقية تُستخدم عادةً مع القيم المنطقية، إلا أنه يمكن استخدامها مع أي نوع. فكل قيمة غير منطقية تُحوّل إلى قيمة منطقية. وتُحوّل القيم الخاطئة إلى "false" والقيم الصحيحة إلى "true".
- هناك ست قيم خاطئة في جافا سكريبت: false, null، undefined ، 0 ، "" (النص الفارغ)، NaN. تُمعامل القيم الأخرى غير القيم الخاطئة كقيم صحيحة. لذا، فإن الأرقام غير الصفرية، والنص غير الفارغ، وما إلى ذلك، تُعتبر قيمًا صحيحة.
- قد يُرجع المعاملان( && و|| ) قيمة أحد الأطراف بناءً على الشرط. إذا كانت الأطراف غير منطقية، فإنها تُرجع قيمة غير منطقية. لكن معامل (!) يُرجع دائمًا قيمة منطقية.
- يمكن أن تتعامل معاملات المنطق مع قيم صريحة أو متغيرات (Variables) أو تعبيرات (Expressions). تُقيّم هذه القيم أولًا إلى ما يعادلها منطقيًا قبل إجراء العملية المنطقية. لنرى الأمثلة عليها في الجزء التالي…
المُعامل المنطقي AND في جافا سكريبت
يُقيّم المُعامل المنطقي AND القيم من اليسار إلى اليمين. إذا كان من الممكن تحويل القيمة الأولى إلى قيمة خاطئة، فسيرجع false وإلا سيستمر لتقييم القيمة الثانية. . بشكل عام سيُعيد المُعامل AND القيمة true إذا كان كلا الطرفين صحيحين، وإلا سيُعيد القيمة false. لنرى الأمثلة فيما يلي:
...........
console.log( true && true); //true
console.log( true && false); //false
console.log( false && true); //false
console.log( false && false); //false
........... بالنسبة للقيم الرقمية سيعيد معامل AND الطرف الأيسر إذا كانت القيم خاطئة (0، -0، و0n)، و إلا فسيعيد القيمة في الطرف الأيمن. بالنسبة لقيم النصوص، تُحوَّل النصوص الفارغة إلى قيم خاطئة، والنصوص غير الفارغة إلى قيم صحيحة. انظر المثال التالي:
...........
console.log( 0 && 5); //0
console.log( 5 && 0); //0
console.log( 5 && 10); //10
// With string && oprateror returns the large value, with empty value returns nothing
let str0 = 'Hello';
let str1 = '';
let str2 = 'World';
console.log(str0 && str1);
console.log(str1 && str2);
console.log(str0 && str2); // World
........... وبنفس الطريقة يعمل معاملAND المنطقي مع القيم null و undefined لنرى المثال:
...........
console.log(undefined && true ); // undefined
console.log(null && true ); // null
........... معاملات AND متعددة
إذا كان لدينا معاملات ِAND متعددة في تعبير (Expression)، فإنّ المعامل AND يُقيّم التعبير من اليسار إلى اليمين، ويُحوّل كل حد من حدود التعبير إلى قيمة منطقية. إذا كانت النتيجة خاطئة، فإنه يُعيد قيمة ذلك الحد ويُنهي التنفيذ. إذا كانت جميع الحدود صحيحة، فإنه يُعيد قيمة الحد الأخير. لنرى المثال التالي:
...........
console.log( true && true && false); //false
console.log( true && 5 && null); //null
console.log( 2 && 5 && 3); //3
........... المعامل المنطقي OR في جافا سكريبت
يُقيّم معامل OR المنطقي أيضًا المعاملات من اليسار إلى اليمين. إذا أمكن تحويل الطرف الأول إلى true، فسيُعيد قيمة المعامل الأول، وإلا فسيُعيد قيمة الطرف الثاني. عمومًا، لمجموعة من المتغيرات المنطقية، يُرجع OR قيمة flase إذا كانت قيمة كلا المتغيرين خاطئة، وإلاسيُرجع قيمة true. لنرى الأمثلة التالية:
...........
console.log( true || true); //true
console.log( true || false); //true
console.log( false || true); //true
console.log( false || false); //false
........... بالنسبة للأرقام، يُرجع المعامل OR الطرف الأول إذا كانت قيمًا صحيحة (باستثناء 0، -0، و0n)، وإلا يُرجع الطرف الثاني. أما القيم النصية، فتُحوَّل النصوص الفارغة إلى قيمة false والنصوص غير الفارغة إلى قيمة true. انظر المثال التالي:
...........
console.log( 0 || 5); // 5
console.log( 5 || 0); // 5
console.log( 5 || 10); // 5
let str0 = 'Hello';
let str1 = '';
let str2 = 'World';
console.log(str0 || str1); //Hello
console.log(str1 || str2); //World
console.log(str0 || str2); //Hello
........... وبنفس الطريقة يعمل معامل OR المنطقي مع القيم null و undefined لنرى المثال:
...........
console.log(undefined || true ); // true
console.log(null || true ); // true
........... معاملات OR متعددة
قد يكون لدينا معاملات OR متعددة في تعبير (Expression)،. يُقيّم OR التعبير من اليسار إلى اليمين، ويُحوّل كل حد من حدود التعبير إلى قيمة منطقية. إذا كانت النتيجة صحيحة، يُعيد قيمة ذلك الحد ويُنهي التنفيذ. إذا كانت جميع الحدود للتعبير خاطئة، يُعيد قيمة آخر حد. لنرى المثال التالي:
...........
console.log( true || true || false); //true
console.log( true || 5 || null); //true
console.log( 2 || 5 || 3); //2
........... المُعامل المنطقي NOT في جافا سكريبت
مُعامل NOT المنطقي هو مُعامل أحادي. يُرجع القيمة False إذا كان من الممكن تحويل المُعامل إلى True، وإلا يُرجع القيمة True. وكما هو الحال مع مُعاملي AND و OR المنطقيين، يُمكن استخدام مُعامل NOT المنطقي هذا أيضًا مع المُعاملات غير المنطقية. ولكنه يُرجع دائمًا قيمة منطقية. لنرى المثال التالي:
...........
console.log( !true); //false
console.log( !false); //true
console.log( !0); //true
console.log( !3); //false
let str0 = 'Hello';
let str1 = '';
console.log( !str0); //false
console.log( !str1); //true
// Not with undefined and null
console.log( !undefined ); // true
console.log( !null); // true
........... أولوية التنفيذ للمعاملات المنطقية المتعددة
في جافا سكريبت قد يحتوي التعبير على أكثر من معامل منطقي واحد، في هذه الحالة، تُقيّم المعاملات بناءً على أولويتها .حيث يحظى المعامل NOT له الأولوية القصوى. ثم المعامل AND له أولوية أعلى من معامل OR .ليكون الترتيب كتالي:
- NOT (!).
- AND (&&).
- OR (||).
لنرى المثال التالي:
...........
console.log ( !true && true || false); //false
console.log ( !false && true || true); //true
........... وتُعد المعاملات المنطقية (Logical Operators) من الأدوات الأساسية في التحكم بتدفق البرامج في جافا سكريبت، فهي تمكّن المبرمج من الجمع بين الشروط والتحقق من منطق التعبيرات بدقة. ويساعد إتقان استخدامها على كتابة أكواد أكثر ذكاءً ومرونة في معالجة القرارات البرمجية.
معاملات البت في جافا سكريبت JavaScript Bitwise Operators
معاملات البت (Bit) في جافا سكريبت هي معاملات تُجري عمليات على الأعداد الصحيحة بمستوى النظام الثنائي (Binary). تمثل الأرقام في النظام الثنائي بمجموعة من الـ bits مثلاً يأخذ الرقم بايت واحد أي 8 bits وعند معالجة القيم تعالج معاملات البت كل بت من هذه القيم.
تُشبه معاملات البت (Bitwise Operators) المعاملات المنطقية (Logical Operators)، ولكنها تعمل على كل بت على حدة. كما أنه ليس من الشائع استخدام معاملات البت (Bitwise Operators). وتتوفر جافا سكريبت سبعة مُعاملات بتّية (bitwise operators) فيما يلي قائمة بمُعاملات البتّية مع الوصف…
| اسم المُعامل | الرمز | الوصف |
|---|---|---|
| Bitwise AND | & | يُرجع 1 إذا كان كلا البتين له قيمة 1، وإلا سيرجع 0. |
| Bitwise OR | | | يُرجع 1 إذا كان أي من البتين 1، وإلا سيرجع 0. |
| Bitwise NOT | ! | يُرجع 1 إذا كان البت 0، وإلا سيرجع 0. |
| Bitwise XOR | ^ | يُرجع 1 إذا كان كلا البتين مختلفين، وإلا سيرجع 0. |
| Left Shift | << | ازاحة إلى اليسار تدفع الأصفار من اليمين متجاهله البتات الموجودة في أقصى اليسار. |
| Right Shift | >> | ازاحة إلى اليمين تدفع بنسخة من البت الموجود في أقصى اليسار من اليسار، وتتجاهل البتات الموجودة في أقصى اليمين . |
| Right Shift with Zero | >>> | ازاحة إلى اليمين تدفع الأصفار من اليسار، مع تجاهل البتات الموجودة في أقصى اليمين . |
قبل أن لنرى طريقة العمل مع معاملات البت (Bitwise Operators) في جافا سكريبت دعونا نستعرض Truth Table يوضح عمل معاملات AND و OR و NOT و XOR
| A | B | A & B | A | B | A ^ B | ~ B |
|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 | 1 |
| 0 | 1 | 0 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 | 0 |
مُعامل Bitwise AND في جافا سكريبت
يُجري مُعامل Bitwise-AND عملية AND منطقية ع على كل زوج من البتات الصحيحة على طرفي المعامل. وبعد العملية، يُرجع قيمة عددية صحيحة بالبتات المُحدّثة. عند تطبيق مُعامل AND بتّي على زوج من البتات، يُعيد القيمة 1 إذا كان كلا البتّين 1، وإلا يُعيد القيمة 0.لاحظ / ي المثال التالي:
...........
/* How present 2 and 3 numbers in binary with 8 bit (byte)
2 = 00000010
3 = 00000011
*/
const a = 2;
const b = 3;
//AND (&)
let c = a & b;
const binaryString = c.toString(2);
const eightBitBinary = binaryString.padStart(8, '0');
console.log(c +"\t"+ eightBitBinary ); //2 00000010
........... معامل Bitwise OR في جافا سكريبت
يُجري معامل Bitwise OR عملية OR على كل زوج من البتات الصحيحة على طرفي المعامل. بعد العملية، و يُرجع قيمة عددية صحيحة بالبتات المُحدّثة.عند تطبيق معامل OR بتّي على زوج من البتات، يُرجع القيمة 1 إذا كان أيٌّ من البتات 1، وإلا يُرجع القيمة 0.لاحظ / ي المثال التالي:
...........
/* How present 1 and 2 numbers in binary with 8 bit (byte)
1 = 00000001
2 = 00000010
*/
const a = 1;
const b = 2;
//OR (|)
let c =b | a;
const binaryString = c.toString(2);
const eightBitBinary = binaryString.padStart(8, '0');
console.log(c +"\t"+ eightBitBinary ); //3 00000011
........... مُعامل Bitwise XOR بتّي في جافا سكريبت
يُجري مُعامل Bitwise XOR عملية XOR على كل زوج البتّات الصحيحة. بعد العملية، يُعيد قيمة عدد صحيح بالبتات المُحدّثة.عند تطبيق مُعامل XOR بتّي على زوج بتّات، يُعيد القيمة 1 إذا كان كلا البتّين مختلفين، وإلا يُعيد القيمة 0. لاحظ / ي المثال التالي:
...........
/* How present 1 and 2 numbers in binary with 8 bit (byte)
1 = 00000001
2 = 00000010
*/
const a = 1;
const b = 2;
//OR (|)
let c =b | a;
const binaryString = c.toString(2);
const eightBitBinary = binaryString.padStart(8, '0');
console.log(c +"\t"+ eightBitBinary ); //3 00000011
........... مُعامل Bitwise NOT في جافا سكريبت
يُجري مُعامل Bitwise NOT عملية NOT على كل بت من العدد الثنائي. وهو مُعامل أحادي يعكس كل بت من العدد الثنائي ويُعيد المُتمم الثاني إلى العدد الثنائي. لاحظ / ي المثال التالي:
...........
/* How present 2 in binary with 8 bit (byte)
2 = 00000010
*/
const a = 2;
let c = ~a ;
const binaryString = c.toString(2);
const eightBitBinary = binaryString.padStart(8, '0');
console.log(c +"\t"+ eightBitBinary ); //-3 00000-11
........... مُعامل الإزاحة لليسار Bitwise Left Shift في جافا سكريبت
يُحرك مُعامل الإزاحة لليسار Bitwise Left Shift في جافا سكريبت جميع البتات في القيمة على يساره إلى اليسار بعدد الخانات المُحددة في القيمة على يمينه . تُملأ البتات الجديدة بالأصفار من اليمين واليسار، وتُهمَل مُعظم البتات. إزاحة قيمة إلى اليسار بمقدار موضع واحد تُعادل ضربها في 2، وإزاحتها موضعين تُعادل ضربها في 4، وهكذا.لاحظ / ي المثال التالي:
...........
/* How present 0, 1, 2 and 3 numbers in binary with 8 bit (byte)
2 = 00000010
3 = 00000011
4 = 00000100
*/
const a = 3;
let b = a << 1;
let c = a << 2;
const binaryString = b.toString(2);
const eightBitBinary = binaryString.padStart(8, '0');
console.log(b +"\t"+ eightBitBinary); //6 00000110
const binaryString0 = c.toString(2);
const eightBitBinary0 = binaryString0.padStart(8, '0');
console.log(c +"\t"+ eightBitBinary0); //12 00001100
........... مُعامل الإزاحة لليمين Bitwise Right Shift
يُحرك مُعامل إزاحة البتات لليمين Bitwise Right Shift جميع البتات في القيمة على يساره إلى اليمين بعدد الخانات المُحددة في القيمة على يمينه. يُدخل نُسخًا من البتات الموجودة في أقصى اليسار من اليسار، ويتجاهل البتات الموجودة في أقصى اليمين. وبهذه الطريقة، يُحافظ على إشارة العدد.لاحظ / ي المثال التالي:
...........
/* How present 0, 1, 2 and 3 numbers in binary with 8 bit (byte)
0 = 00000000
1 = 00000001
2 = 00000010
3 = 00000011
*/
const a = 3;
let b = a >> 1;
let c = a >> 2;
const binaryString = b.toString(2);
const eightBitBinary = binaryString.padStart(8, '0');
console.log(b +"\t"+ eightBitBinary); //1 00000001
const binaryString0 = c.toString(2);
const eightBitBinary0 = binaryString0.padStart(8, '0');
console.log(c +"\t"+ eightBitBinary0); //0 00000000
........... معامل الإزاحة اليمنى مع الصفر Right Shift with Zero
معامل الإزاحة اليمنى مع الصفر Right Shift with Zero مشابه جدًا لمعامل الإزاحة اليمنى. فهو يملأ البتات اليسرى دائمًا بالصفر دون الالتفات إلى إشارة البت..لاحظ / ي المثال التالي:
...........
/* How present 0, 1, 2 and 3 numbers in binary with 8 bit (byte)
0 = 00000000
1 = 00000001
2 = 00000010
3 = 00000011
*/
const a = 3;
let b = a >>> 1;
let c = a >>> 2;
const binaryString = b.toString(2);
const eightBitBinary = binaryString.padStart(8, '0');
console.log(b +"\t"+ eightBitBinary); //1 00000001
const binaryString0 = c.toString(2);
const eightBitBinary0 = binaryString0.padStart(8, '0');
console.log(c +"\t"+ eightBitBinary0); //0 00000000
........... كما رأينا تُستخدم معاملات البت (Bitwise Operators في جافا سكريبت للتعامل مع البيانات على مستوى البتات، مما يمنح المبرمج قدرة أكبر على التحكم في القيم الثنائية وتنفيذ العمليات المنخفضة المستوى بكفاءة. ويساعد فهم هذه المعاملات على كتابة أكواد أكثر احترافية في التطبيقات التي تتطلب معالجة دقيقة وسريعة للبيانات.
في الختام، يمكن القول إن المعاملات في جافا سكريبت (JavaScript Operators) تشكل جزءاً محورياً في بناء المنطق البرمجي وتنفيذ العمليات داخل البرامج. فهي الأداة التي تمكّن المبرمج من التعامل مع البيانات بمرونة، سواء من خلال إجراء الحسابات، أو المقارنات، أو اتخاذ القرارات المنطقية، أو حتى معالجة القيم على مستوى البتات. إن إتقان استخدام هذه المعاملات يُعد خطوة أساسية نحو كتابة كود منظم وفعّال يسهم في تطوير تطبيقات قوية وديناميكية باستخدام لغة JavaScript.
جميع الأمثلة لهذا المقال متوفرة على الرابط هنا.