مشغلات Unity C# التي يجب معرفتها
Unity هو محرك ألعاب يوفر الكثير من "heavy-lifting" للمطورين من حيث الوظائف ويسمح لهم بالتركيز بالكامل على عملية التطوير. وهو يستخدم C# كلغة برمجة رئيسية.
كما هو الحال مع أي لغة برمجة، تتكون لغة C# من مجموعة من الوظائف الخاصة والأنواع والفئات والمكتبات وما إلى ذلك، ولكنها تحتوي أيضًا على قائمة من الرموز الخاصة (المشغلات) التي لكل منها وظيفتها الخاصة. في هذا المنشور، سأقوم بإدراج هذه الرموز وسأشرح ما تفعله، بحيث تتمكن في المرة القادمة التي تفتح فيها البرنامج النصي من فهم معنى كل جزء بسرعة.
المشغلات في C# هي بعض الرموز الخاصة التي تقوم بإجراء بعض الإجراءات على المتعاملين.
في C#، هناك 6 أنواع من المشغلات المضمنة: المشغلات الحسابية، ومشغلات المقارنة، والمشغلات المنطقية البوليانية، ومشغلات البتات والتحويل، ومشغلات المساواة، والمشغلات المتنوعة. إن معرفة كل هذه الأنواع من المشغلات سوف تجعلك مبرمجًا أفضل على الفور.
1. العمليات الحسابية
يقوم المشغلون التاليون بإجراء عمليات حسابية باستخدام متغيرات من أنواع رقمية:
- مشغلات أحادية ++ (زيادة)، و-- (نقصان)، و+ (زائد)، و- (ناقص)
- العمليات الثنائية * (الضرب)، / (القسمة)، % (الباقي)، + (الجمع)، و- (الطرح)
عامل الزيادة ++
يعني عامل "add one" (أو ++) += 1، بمعنى آخر، إنها طريقة سريعة لإضافة عدد صحيح واحد إلى قيمة عددية، دون الحاجة إلى كتابة تعليمات برمجية إضافية. يمكن إضافة هذا العامل إما قبل القيمة أو بعدها، مما يؤدي إلى سلوك مختلف:
//The result of x++ is the value of x before the operation, as the following example shows:
int i = 4;
Debug.Log(i); // output: 4
Debug.Log(i++); // output: 4
Debug.Log(i); // output: 5
//The result of ++x is the value of x after the operation, as the following example shows:
double a = 2.5;
Debug.Log(a); // output: 2.5
Debug.Log(++a); // output: 3.5
Debug.Log(a); // output: 3.5عامل التناقص --
عامل "subtract one" هو عكس عامل ++ (-= 1)، أي أنه يطرح عددًا صحيحًا واحدًا من قيمة عددية. ويمكن أيضًا إضافته قبل أو بعد القيمة:
The result of x-- is the value of x before the operation, as the following example shows:
int i = 4;
Debug.Log(i); // output: 4
Debug.Log(i--); // output: 4
Debug.Log(i); // output: 3
The result of --x is the value of x after the operation, as the following example shows:
double a = 2.5;
Debug.Log(a); // output: 2.5
Debug.Log(--a); // output: 1.5
Debug.Log(a); // output: 1.5مشغلات أحادية + و -
يعيد عامل + الأحادي قيمة المتعامل الخاص به، ويحسب عامل - الأحادي النفي العددي للمتعامل الخاص به.
Debug.Log(+5); // output: 5
Debug.Log(-5); // output: -5
Debug.Log(-(-5)); // output: 5
uint a = 6;
var b = -a;
Debug.Log(b); // output: -6
Debug.Log(b.GetType()); // output: System.Int64
Debug.Log(-double.NaN); // output: NaNعامل الضرب *
يقوم عامل الضرب * بحساب حاصل الضرب المضاعف لمتعاملاته:
Debug.Log(6 * 3); // output: 18
Debug.Log(1.5 * 3.5); // output: 5.25
Debug.Log(0.1m * 24.4m); // output: 2.44مشغل القسم /
يقوم عامل القسمة / بقسمة المتغير الأيسر على المتغير الأيمن.
إذا كان أحد المتغيرات عشريًا، فلا يمكن لمتغير آخر أن يكون عددًا عشريًا أو عددًا مزدوجًا، لأن أيًا من المتغيرات العشرية أو المزدوجة لا يمكن تحويلها ضمنيًا إلى عدد عشري. يجب عليك تحويل متغير العدد العشري أو المزدوج صراحةً إلى نوع العدد العشري.
Debug.Log(13 / 5); // output: 2
Debug.Log(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Debug.Log((double)a / b); // output: 2.6
Debug.Log(16.8f / 4.1f); // output: 4.097561
Debug.Log(16.8d / 4.1d); // output: 4.09756097560976
Debug.Log(16.8m / 4.1m); // output: 4.0975609756097560975609756098عامل الباقي %
يقوم عامل الباقي % بحساب الباقي بعد قسمة المتغير الأيسر على المتغير الأيمن.
- بالنسبة لمتغيرات أنواع الأعداد الصحيحة، فإن نتيجة a % b هي القيمة الناتجة عن a - (a / b) * b
Debug.Log(5 % 4); // output: 1
Debug.Log(5 % -4); // output: 1
Debug.Log(-5 % 4); // output: -1
Debug.Log(-5 % -4); // output: -1- بالنسبة للمعاملات العشرية، فإن عامل الباقي % يعادل عامل الباقي من نوع System.Decimal.
Debug.Log(-5.2f % 2.0f); // output: -1.2
Debug.Log(5.9 % 3.1); // output: 2.8
Debug.Log(5.9m % 3.1m); // output: 2.8عامل الجمع +
يحسب عامل الجمع + مجموع متغيراته. يمكنك أيضًا استخدام عامل الجمع + لربط السلاسل ودمج المندوبين.
Debug.Log(6 + 5); // output: 11
Debug.Log(6 + 5.3); // output: 11.3
Debug.Log(6.1m + 5.2m); // output: 11.3عامل الطرح -
عامل الطرح - يطرح المتغير الأيمن من المتغير الأيسر. يمكنك أيضًا استخدام عامل - لإزالة المندوب.
Debug.Log(48 - 4); // output: 44
Debug.Log(6 - 5.3); // output: 0.7
Debug.Log(8.5m - 3.3m); // output: 5.22. عوامل المقارنة
تقارن عوامل المقارنة < (less than), > (greater than), <= (less than or equal), and >= (أكبر من أو يساوي)، والمعروفة أيضًا باسم عوامل المقارنة العلائقية، بين متغيراتها. وتدعم جميع أنواع الأعداد الصحيحة والفاصلة العائمة هذه العوامل.
عامل أقل من <
يعيد عامل < القيمة true إذا كان المتغير الأيسر أقل من المتغير الأيمن، وإلا فإنه يعود القيمة false.
Debug.Log(8.0 < 6.1); // output: False
Debug.Log(6.1 < 6.1); // output: False
Debug.Log(1.0 < 6.1); // output: True
Debug.Log(double.NaN < 6.1); // output: False
Debug.Log(double.NaN >= 6.1); // output: Falseأكبر من المشغل >
يعيد عامل > القيمة true إذا كان المتغير الأيسر أكبر من المتغير الأيمن، وإلا فإنه يعود القيمة false.
Debug.Log(8.0 > 6.1); // output: True
Debug.Log(6.1 > 6.1); // output: False
Debug.Log(1.0 > 6.1); // output: False
Debug.Log(double.NaN > 6.1); // output: False
Debug.Log(double.NaN <= 6.1); // output: Falseعامل أقل من أو يساوي <=
يعيد عامل <= القيمة true إذا كان المتغير الأيسر أقل من أو يساوي المتغير الأيمن، وإلا يعيد القيمة false.
Debug.Log(8.0 <= 6.1); // output: False
Debug.Log(6.1 <= 6.1); // output: True
Debug.Log(1.0 <= 6.1); // output: True
Debug.Log(double.NaN > 6.1); // output: False
Debug.Log(double.NaN <= 6.1); // output: Falseعامل أكبر من أو يساوي >=
يعيد عامل >= القيمة true إذا كان المتغير الأيسر أكبر من أو يساوي المتغير الأيمن، وإلا يعيد القيمة false.
Debug.Log(8.0 >= 6.1); // output: True
Debug.Log(6.1 >= 6.1); // output: True
Debug.Log(1.0 >= 6.1); // output: False
Debug.Log(double.NaN < 6.1); // output: False
Debug.Log(double.NaN >= 6.1); // output: False3. المعاملات المنطقية البوليانية
يقوم المشغلون التاليون بإجراء عمليات منطقية باستخدام المتغيرات المنطقية:
- عامل أحادي ! (النفي المنطقي).
- العمليات الثنائية & (AND المنطقية)، و| (OR المنطقية)، و^ (OR المنطقية الحصرية). تقوم هذه العمليات دائمًا بتقييم كلا المتعاملين.
- مشغلات ثنائية && (AND منطقية شرطية) و|| (OR منطقية شرطية). تقوم هذه المشغلات بتقييم المتغير الأيمن فقط إذا كان ذلك ضروريًا.
عامل النفي المنطقي !
يحسب عامل البادئة الأحادية ! النفي المنطقي لمتغيره. أي أنه ينتج true إذا تم تقييم المتغير على أنه false، وfalse إذا تم تقييم المتغير على أنه true.
bool passed = false;
Debug.Log(!passed); // output: True
Debug.Log(!true); // output: Falseعامل AND المنطقي &
يقوم عامل & بحساب AND المنطقية لمتغيراته. تكون نتيجة x وy صحيحة إذا تم تقييم كل من x وy على أنها صحيحة. وإلا تكون النتيجة خاطئة.
يقوم عامل & بتقييم كل من المتغيرين حتى إذا تم تقييم المتغير الأيسر على أنه خاطئ، بحيث تكون نتيجة العملية خاطئة بغض النظر عن قيمة المتغير الأيمن.
bool SecondOperand()
{
Debug.Log("Second operand is evaluated.");
return true;
}
bool a = false & SecondOperand();
Debug.Log(a);
// Output:
// Second operand is evaluated.
// False
bool b = true & SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// Trueعامل OR الحصري المنطقي ^
يحسب عامل ^ OR المنطقي الحصري، المعروف أيضًا باسم XOR المنطقي، لمعاملاته. تكون نتيجة x ^ y صحيحة إذا تم تقييم x على أنها صحيحة وتم تقييم y على أنها خاطئة، أو تم تقييم x على أنها خاطئة وتم تقييم y على أنها صحيحة. بخلاف ذلك، تكون النتيجة خاطئة. أي أنه بالنسبة للمعاملات المنطقية، يحسب عامل ^ نفس النتيجة مثل عامل التباين !=.
Debug.Log(true ^ true); // output: False
Debug.Log(true ^ false); // output: True
Debug.Log(false ^ true); // output: True
Debug.Log(false ^ false); // output: Falseعامل OR المنطقي |
يحسب عامل | قيمة OR المنطقية لمعاملاته. تكون نتيجة x | y صحيحة إذا تم تقييم x أو y على أنها صحيحة، وإلا تكون النتيجة خاطئة.
يقوم عامل | بتقييم كلا المعاملين حتى إذا تم تقييم المعامل الأيسر على أنه صحيح، بحيث تكون نتيجة العملية صحيحة بغض النظر عن قيمة المعامل الأيمن.
bool SecondOperand()
{
Debug.Log("Second operand is evaluated.");
return true;
}
bool a = true | SecondOperand();
Debug.Log(a);
// Output:
// Second operand is evaluated.
// True
bool b = false | SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// Trueعامل AND المنطقي الشرطي &&
يحسب عامل AND المنطقي الشرطي &&، المعروف أيضًا باسم عامل AND المنطقي "short-circuiting"، عامل AND المنطقي لمتعاملاته. تكون نتيجة x && y صحيحة إذا تم تقييم كل من x وy على أنها صحيحة، وإلا تكون النتيجة خاطئة. إذا تم تقييم x على أنها خاطئة، فلن يتم تقييم y.
bool SecondOperand()
{
Debug.Log("Second operand is evaluated.");
return true;
}
bool a = false && SecondOperand();
Debug.Log(a);
// Output:
// False
bool b = true && SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// Trueعامل OR المنطقي الشرطي ||
يحسب عامل OR المنطقي الشرطي ||، المعروف أيضًا باسم عامل OR المنطقي "short-circuiting"، عامل OR المنطقي لمتعاملاته. تكون نتيجة x || y صحيحة إذا تم تقييم x أو y على أنها صحيحة. وإلا، تكون النتيجة خاطئة. إذا تم تقييم x على أنها صحيحة، فلا يتم تقييم y.
bool SecondOperand()
{
Debug.Log("Second operand is evaluated.");
return true;
}
bool a = true || SecondOperand();
Debug.Log(a);
// Output:
// True
bool b = false || SecondOperand();
Debug.Log(b);
// Output:
// Second operand is evaluated.
// True4. مشغلات البتات والتحويل
يقوم المشغلون التاليون بإجراء عمليات بتية أو عمليات تحويل باستخدام متغيرات من الأنواع الرقمية الصحيحة أو نوع char:
- عامل أحادي ~ (مكمل بت)
- مشغلات التحويل الثنائي << (left shift) and >> (التحويل إلى اليمين)
- مشغلات ثنائية & (AND منطقية)، | (OR منطقية)، و^ (OR منطقية حصرية)
عامل المكمل الثنائي ~
ينتج عامل ~ مكملًا بتيًا لمتعامله عن طريق عكس كل بت.
uint a = 0b_0000_1111_0000_1111_0000_1111_0000_1100;
uint b = ~a;
Debug.Log(Convert.ToString(b, toBase: 2));
// Output:
// 11110000111100001111000011110011عامل التحويل إلى اليسار <<
يقوم عامل << بتحويل متغيره الأيسر إلى اليسار بعدد البتات التي يحددها متغيره الأيمن. للحصول على معلومات حول كيفية تحديد المتغير الأيمن لعدد التحويلات، راجع عدد التحويلات في قسم عوامل التحويل.
uint x = 0b_1100_1001_0000_0000_0000_0000_0001_0001;
Debug.Log($"Before: {Convert.ToString(x, toBase: 2)}");
uint y = x << 4;
Debug.Log($"After: {Convert.ToString(y, toBase: 2)}");
// Output:
// Before: 11001001000000000000000000010001
// After: 10010000000000000000000100010000مشغل التحويل إلى اليمين >>
يقوم عامل >> بنقل المتغير الأيسر إلى اليمين بعدد البتات التي يحددها المتغير الأيمن.
uint x = 0b_1001;
Debug.Log($"Before: {Convert.ToString(x, toBase: 2), 4}");
uint y = x >> 2;
Debug.Log($"After: {Convert.ToString(y, toBase: 2), 4}");
// Output:
// Before: 1001
// After: 10يتم تعيين مواضع البتات الفارغة ذات الترتيب العالي استنادًا إلى نوع المتغير الأيسر على النحو التالي:
- إذا كان المتغير الأيسر من النوع int أو long، فإن عامل التحويل إلى اليمين يقوم بتحويل حسابي: يتم نشر قيمة البت الأكثر أهمية (بت الإشارة) للمتغير الأيسر إلى مواضع البتات الفارغة ذات الترتيب الأعلى. أي أن مواضع البتات الفارغة ذات الترتيب الأعلى يتم ضبطها على صفر إذا كان المتغير الأيسر غير سالب ويتم ضبطها على واحد إذا كان سالبًا.
int a = int.MinValue;
Debug.Log($"Before: {Convert.ToString(a, toBase: 2)}");
int b = a >> 3;
Debug.Log($"After: {Convert.ToString(b, toBase: 2)}");
// Output:
// Before: 10000000000000000000000000000000
// After: 11110000000000000000000000000000- إذا كان المتغير الأيسر من نوع uint أو ulong، فإن عامل التحويل إلى اليمين ينفذ تحويلًا منطقيًا: يتم دائمًا تعيين مواضع البتات الفارغة ذات الترتيب العالي على الصفر.
uint c = 0b_1000_0000_0000_0000_0000_0000_0000_0000;
Debug.Log($"Before: {Convert.ToString(c, toBase: 2), 32}");
uint d = c >> 3;
Debug.Log($"After: {Convert.ToString(d, toBase: 2), 32}");
// Output:
// Before: 10000000000000000000000000000000
// After: 10000000000000000000000000000عامل AND المنطقي &
يقوم عامل & بحساب AND المنطقي لكل بت من متغيراته الصحيحة.
uint a = 0b_1111_1000;
uint b = 0b_1001_1101;
uint c = a & b;
Debug.Log(Convert.ToString(c, toBase: 2));
// Output:
// 10011000عامل OR الحصري المنطقي ^
يقوم عامل ^ بحساب OR المنطقية الحصرية للبت الواحد، والمعروفة أيضًا باسم XOR المنطقية للبت الواحد، لمتعاملاتها الصحيحة.
uint a = 0b_1111_1000;
uint b = 0b_0001_1100;
uint c = a ^ b;
Debug.Log(Convert.ToString(c, toBase: 2));
// Output:
// 11100100عامل OR المنطقي |
يقوم عامل | بحساب OR المنطقي لكل بت من متغيراته الصحيحة.
uint a = 0b_1010_0000;
uint b = 0b_1001_0001;
uint c = a | b;
Debug.Log(Convert.ToString(c, toBase: 2));
// Output:
// 101100015. مشغلي المساواة
يتحقق عاملي == (المساواة) و!= (عدم المساواة) مما إذا كانت متغيراتهم متساوية أم لا.
عامل المساواة ==
يعيد عامل المساواة == القيمة true إذا كانت متغيراته متساوية، وإلا يعيد القيمة false.
int a = 1 + 2 + 3;
int b = 6;
Debug.Log(a == b); // output: True
char c1 = 'a';
char c2 = 'A';
Debug.Log(c1 == c2); // output: False
Debug.Log(c1 == char.ToLower(c2)); // output: Trueعامل عدم المساواة !=
يعيد عامل عدم المساواة != القيمة true إذا لم تكن متغيراته متساوية، وإلا فإنه يعيد القيمة false. بالنسبة لمتغيرات الأنواع المضمنة، فإن التعبير x != y ينتج نفس النتيجة مثل التعبير !(x == y).
int a = 1 + 1 + 2 + 3;
int b = 6;
Debug.Log(a != b); // output: True
string s1 = "Hello";
string s2 = "Hello";
Debug.Log(s1 != s2); // output: False
object o1 = 2;
object o2 = 2;
Debug.Log(o1 != o2); // output: True6. مشغلين متنوعين
المشغلات المتنوعة الشائعة هي ?: للتحقق من الشرط، و:: للوصول إلى أحد أعضاء مساحة اسم مستعار، و$ لاستيفاء السلسلة.
؟: المشغل
يقوم عامل الشرط ?:، المعروف أيضًا باسم عامل الشرط الثلاثي، بتقييم تعبير منطقي وإرجاع نتيجة أحد التعبيرين، اعتمادًا على ما إذا كان تقييم التعبير المنطقي صحيحًا أم خطأ، كما يوضح المثال التالي:
bool condition = true;
Debug.Log(condition ? 1 : 2); // output: 1:: المشغل
استخدم مؤهل الاسم المستعار لمساحة الأسماء:: للوصول إلى عضو في مساحة أسماء مستعارة. يمكنك استخدام المؤهل:: فقط بين معرفين. يمكن أن يكون المعرف الموجود على الجانب الأيسر أيًا من الأسماء المستعارة التالية:
- اسم مستعار لمساحة اسم تم إنشاؤه باستخدام توجيه استخدام الاسم المستعار:
using forwinforms = System.Drawing;
using forwpf = System.Windows;
public class Converters
{
public static forwpf::Point Convert(forwinforms::Point point) => new forwpf::Point(point.X, point.Y);
}- اسم مستعار خارجي.
- الاسم المستعار العالمي، وهو الاسم المستعار لمساحة الأسماء العالمية. مساحة الأسماء العالمية هي مساحة الأسماء التي تحتوي على مساحات الأسماء والأنواع التي لم يتم إعلانها داخل مساحة أسماء مسماة. عند استخدامها مع المؤهل::، يشير الاسم المستعار العالمي دائمًا إلى مساحة الأسماء العالمية، حتى إذا كان هناك الاسم المستعار لمساحة الأسماء العالمية المحدد من قبل المستخدم.
namespace MyCompany.MyProduct.System
{
class Program
{
static void Main() => global::System.Console.WriteLine("Using global alias");
}
class Console
{
string Suggestion => "Consider renaming this class";
}
}عامل $
يحدد الحرف الخاص $ سلسلة نصية كسلسلة نصية مُقحَمة. والسلسلة النصية المُقحَمة هي سلسلة نصية قد تحتوي على تعبيرات مقحَمة. وعندما يتم حل سلسلة نصية مُقحَمة إلى سلسلة نتيجة، يتم استبدال العناصر التي تحتوي على تعبيرات مقحَمة بالتمثيلات النصية لنتائج التعبيرات.
في السلاسل المقحمة، يتم استخدام علامة الدولار ($) لإخبار مُجمِّع C# بأن السلسلة التي تليها يجب تفسيرها كسلسلة مقحمة. تغلف الأقواس المتعرجة القيم (للمتغيرات) المراد تضمينها في النص.
لتحديد حرف سلسلة كسلسلة متداخلة، أضف إليه الرمز $. لا يمكنك ترك أي مسافة بيضاء بين الرمز $ وعلامة " التي تبدأ حرف سلسلة.
string name = "John";
var date = DateTime.Now;
Debug.Log($"Hello, {name}! Today is {date.DayOfWeek}, it's {date:HH:mm} now.");
// Output:
// Hello, John! Today is Wednesday, it's 19:40 now.