Unity C# מפעילי חובה

Unity הוא מנוע משחק שעושה הרבה "heavy-lifting" למפתחים מבחינת פונקציונליות ומאפשר להם להתמקד לחלוטין בתהליך הפיתוח. הוא משתמש ב-C# כשפת התכנות הראשית.

כמו בכל שפת תכנות, C# מורכבת ממערך של פונקציות מיוחדות, סוגים, מחלקות, ספריות וכו', אך יש לה גם רשימה של סמלים (אופרטורים) מיוחדים שלכל אחד יש פונקציה משלו. בפוסט הזה, אפרט את הסמלים הללו ואסביר מה הם עושים, כך שבפעם הבאה שתפתחו סקריפט, תוכלו להבין במהירות מה המשמעות של כל חלק.

אופרטורים ב-C# הם כמה סמלים מיוחדים שמבצעים פעולה כלשהי על אופרנדים.

ב-C#, ישנם 6 סוגים של אופרטורים מובנים: אופרטורים אריתמטיים, אופרטורים של השוואה, אופרטורים לוגיים בוליאניים, אופרטורים של Bitwise ו-shift, אופרטורים של שוויון ואופרטורים שונים. הכרת כולם תהפוך אותך למתכנת טוב יותר באופן מיידי.

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

אופרטורים אונריים + ו-

האופרטור unary + מחזיר את הערך של האופרנד שלו והאופרטור unary - מחשב את השלילה המספרית של האופרנד שלו.

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.2

2. מפעילי השוואה

ההשוואה < (less than), > (greater than), <= (less than or equal), and >= (גדול מ- או שווה), הידועה גם בשם יחסי, אופרטורים משווים את האופרנדים שלהם. אופרטורים אלה נתמכים על ידי כל סוגי המספרים האינטגרליים והנקודה צפה.

פחות מאופרטור <

האופרטור < מחזיר אמת אם האופרנד השמאלי שלו קטן מהאופרנד הימני, אחרת 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

גדול יותר מהמפעיל >

האופרטור > מחזיר אמת אם האופרנד השמאלי שלו גדול מהאופרנד הימני, אחרת 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

אופרטור קטן או שווה <=

האופרטור <= מחזיר אמת אם האופרנד השמאלי שלו קטן או שווה לאופרנד הימני שלו, אחרת 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

אופרטור גדול או שווה >=

האופרנט >= מחזיר אמת אם האופרנד השמאלי שלו גדול או שווה לאופרנד הימני שלו, אחרת 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: False

3. אופרטורים לוגיים בוליאניים

האופרטורים הבאים מבצעים פעולות לוגיות עם אופרנדים bool:

• Unary ! אופרטור (שלילה לוגי).
• בינארי & (ולוגי AND), | אופרטורים (OR לוגי), ו-^ (אופרטורים בלעדיים לוגיים). אופרטורים אלה תמיד מעריכים את שני האופרנדים.
• בינארי && (AND לוגי מותנה) ו || (OR לוגי מותנה) אופרטורים. אופרטורים אלה מעריכים את האופרנד הימני רק אם זה נחוץ.

מפעיל שלילה לוגית!

הקידומת האנרית! האופרטור מחשב את השלילה הלוגית של האופרנד שלו. כלומר, הוא מייצר אמת, אם האופרנד מוערך ל-false, ו-false, אם האופרנד מוערך כ-true.

bool passed = false;
Debug.Log(!passed);  // output: True
Debug.Log(!true);    // output: False

אופרטור AND לוגי &

האופרטור & מחשב את ה-AND הלוגי של האופרנדים שלו. התוצאה של x ו-y היא נכונה אם גם x וגם y מוערכים כאמת. אחרת, התוצאה היא שקר.

האופרטור & מעריך את שני האופרנדים גם אם האופרנד השמאלי מוערך ל-false, כך שתוצאת הפעולה היא שקר ללא קשר לערך של האופרנד הימני.

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 מוערך לא נכון. אחרת, התוצאה שקרית. כלומר, עבור אופרנדים bool, האופרטור ^ מחשב את אותה תוצאה כמו אופרטור אי השוויון !=.

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 מוערכים כ-true, אחרת, התוצאה היא שקר.

ה- | האופרנד מעריך את שני האופרנדים גם אם האופרנד השמאלי מוערך כ-true, כך שתוצאת הפעולה נכונה ללא קשר לערך של האופרנד הימני.

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 מוערכים כ-true, אחרת, התוצאה היא שקר. אם x מוערך כ-false, 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.
// True

4. אופרטורים של Bitwise ו-shift

האופרטורים הבאים מבצעים פעולות סיביות או העברה עם אופרנדים מסוגים מספריים אינטגרליים או מסוג char:

• אופרטור Unary ~ (השלמה סיבית).
• אופרטורי משמרת בינאריים << (left shift) and >> (משמרת ימינה).
• בינארי & (ולוגי AND), | אופרטורים (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:
// 10110001

5. מפעילי שוויון

האופרטורים == (שוויון) ו-!= (אי-שוויון) בודקים אם האופרנדים שלהם שווים או לא.

מפעיל שוויון ==

אופרטור השוויון == מחזיר אמת אם האופרנדים שלו שווים, אחרת 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

מפעיל אי שוויון !=

אופרטור האי-שוויון != מחזיר אמת אם האופרנדים שלו אינם שווים, אחרת שקר. עבור האופרנדים של הטיפוסים המובנים, הביטוי 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: True

6. מפעילים שונים

אופרטורים שונים נפוצים הם ?: עבור בדיקות מותנות, :: עבור גישה לחבר במרחב שמות בעל כינוי, ו-$ עבור אינטרפולציה של מחרוזת.

?: מפעיל

האופרטור המותנה ?:, המכונה גם האופרטור המותנה הטרינרי, מעריך ביטוי בוליאני ומחזיר את התוצאה של אחד משני הביטויים, תלוי אם הביטוי הבוליאני מוערך כ-true או false, כפי שמראה הדוגמה הבאה:

bool condition = true;
Debug.Log(condition ? 1 : 2); // output: 1

:: מפעיל

השתמש במאפיין הכינוי של מרחב השמות:: כדי לגשת לחבר במרחב שמות בעל כינוי. אתה יכול להשתמש ב-: qualifier רק בין שני מזהים. המזהה השמאלי יכול להיות כל אחד מהכינויים הבאים:

• כינוי מרחב שמות שנוצר עם הוראה באמצעות כינוי:

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);
}

• כינוי חיצוני.
• הכינוי הגלובלי, שהוא הכינוי הגלובלי של מרחב השמות. מרחב השמות הגלובלי הוא מרחב השמות שמכיל מרחבי שמות וסוגים שאינם מוכרזים בתוך מרחב שמות בעל שם. בשימוש עם ה-:: qualifier, הכינוי הגלובלי תמיד מתייחס למרחב השמות הגלובלי, גם אם יש את הכינוי של מרחב השמות הגלובלי המוגדר על ידי המשתמש.

namespace MyCompany.MyProduct.System
{
    class Program
    {
        static void Main() => global::System.Console.WriteLine("Using global alias");
    }

    class Console
    {
        string Suggestion => "Consider renaming this class";
    }
}

מפעיל $

התו המיוחד $ מזהה מחרוזת מילולית כמחרוזת אינטרפולציה. מחרוזת אינטרפולציה היא מחרוזת מילולית שעשויה להכיל ביטויי אינטרפולציה. כאשר מחרוזת אינטרפולציה נפתרת למחרוזת תוצאה, פריטים עם ביטויי אינטרפולציה מוחלפים בייצוגי המחרוזת של תוצאות הביטוי.

ב-Interpolated Strings, סימן הדולר ($) משמש כדי לומר למהדר 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.