switch ב-Java: case, נפילה (fall-through) ותחביר החץ

בשביל מה switch קיים

switch משווה ערך אחד מול רשימה של אפשרויות קבועות ומריץ את הענף שמתאים. כשאתם מוצאים את עצמכם כותבים שרשרת ארוכה של if/else if שבודקת שוב ושוב את אותו משתנה מול קבועים שונים, switch אומר את אותו הדבר בצורה ברורה יותר.

הוא עושה רק בדיקות שוויון מול קבועים שידועים בזמן קומפילציה: הוא לא יכול לבדוק טווחים או לשלב תנאים. לדברים כאלה הישארו עם if/else.

משפט switch הקלאסי

הצורה המסורתית משתמשת בתוויות case עם נקודתיים וב-break אחרי כל ענף:

public class Main {
    public static void main(String[] args) {
        int day = 3;

        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            default:
                System.out.println("Some other day");
        }
    }
}

Java מחשבת את day, קופצת ל-case המתאים, מריצה את הפקודות שלו, וה-break יוצא מה-switch. ענף ה-default רץ כששום דבר אחר לא מתאים: חשבו עליו כעל ה-else. הוא אופציונלי, אבל מומלץ לכלול אותו כדי שערכים לא צפויים לא יחמקו בשקט.

מלכודת ה-break: נפילה הלאה (fall-through)

זה הבאג הנפוץ ביותר ב-switch. אם משמיטים break, הביצוע לא עוצר בסוף ה-case המתאים: הוא נופל אל ה-case הבא וממשיך לרוץ עד שהוא פוגש break או את הסוגר המסולסל הסוגר:

public class Main {
    public static void main(String[] args) {
        int level = 1;

        switch (level) {
            case 1:
                System.out.println("Level 1");
                // no break - falls through!
            case 2:
                System.out.println("Level 2");
            case 3:
                System.out.println("Level 3");
                break;
        }
    }
}

אולי ציפיתם לקבל רק Level 1, אבל התוכנית מדפיסה את שלוש השורות. מכיוון של-case 1 אין break, השליטה מחליקה ישר אל case 2 ו-case 3. הוסיפו תמיד break, אלא אם אתם באמת רוצים נפילה הלאה, וכשאתם כן מסתמכים עליה, השאירו הערה כדי שהקורא הבא יידע שזה בכוונה.

קיבוץ מקרים

לנפילה הלאה יש שימוש לגיטימי ומסודר אחד: לערום תוויות case כך שכמה ערכים יחלקו בלוק אחד. שימו את התוויות אחת אחרי השנייה בלי קוד ביניהן:

public class Main {
    public static void main(String[] args) {
        char grade = 'B';

        switch (grade) {
            case 'A':
            case 'B':
            case 'C':
                System.out.println("Pass");
                break;
            case 'D':
            case 'F':
                System.out.println("Fail");
                break;
            default:
                System.out.println("Unknown grade");
        }
    }
}

כאן 'A', 'B' ו-'C' מריצים כולם את אותה שורת "Pass". זו הדרך המיועדת לומר "כל אחד מהערכים האלה עושה את אותו הדבר".

switch על מחרוזות

אתם לא מוגבלים למספרים. מאז Java 7 אפשר לעשות switch על String, וזה מושלם לבחירות מתפריט או לשמות של פקודות:

public class Main {
    public static void main(String[] args) {
        String command = "stop";

        switch (command) {
            case "start":
                System.out.println("Starting...");
                break;
            case "stop":
                System.out.println("Stopping...");
                break;
            default:
                System.out.println("Unknown command: " + command);
        }
    }
}

ההתאמה רגישה לאותיות גדולות וקטנות: "Stop" לא יתאים ל-"stop", ולכן כדאי לנרמל קודם (למשל command.toLowerCase()) אם הקלט מגיע באותיות שונות. עוד מלכודת אחת: אם command הוא null, ה-switch זורק NullPointerException, אז הגנו מפני null לפני שמגיעים אליו.

תחביר החץ המודרני

גרסאות Java חדשות יותר (14 ומעלה) מוסיפות צורת חץ, case label -> ..., שמתקנת את מלכודת הנפילה כבר בתכנון. כל case עם חץ מריץ בדיוק ענף אחד ואף פעם לא נופל הלאה, כך שאין break שאפשר לשכוח:

public class Main {
    public static void main(String[] args) {
        int day = 6;

        switch (day) {
            case 1, 2, 3, 4, 5 -> System.out.println("Weekday");
            case 6, 7          -> System.out.println("Weekend");
            default            -> System.out.println("Invalid day");
        }
    }
}

שימו לב שמקבצים ערכים עם פסיק (case 6, 7) במקום לערום תוויות, ואין אף break באופק. לכמה פקודות משתמשים בבלוק: case 1 -> { ...; ... }. העדיפו את הצורה הזו בקוד חדש: היא קצרה יותר ומעלימה סוג שלם של באגים.

switch כביטוי

צורת החץ יכולה גם להפיק ערך. ביטוי switch מחזיר תוצאה שאפשר להשים ישירות למשתנה, בלי משתנה זמני ובלי השמה חוזרת בכל ענף:

public class Main {
    public static void main(String[] args) {
        int month = 4;

        int days = switch (month) {
            case 1, 3, 5, 7, 8, 10, 12 -> 31;
            case 4, 6, 9, 11           -> 30;
            case 2                     -> 28;
            default -> throw new IllegalArgumentException("Bad month: " + month);
        };

        System.out.println("Days: " + days);
    }
}

כל ה-switch (...) { ... } מחושב למספר שנשמר ב-days. שימו לב לנקודה-פסיק אחרי הסוגר המסולסל: היא חלק מפקודת ההשמה. ביטוי switch חייב להיות ממצה (לכסות כל ערך אפשרי), ולכן יש כאן default. שימו לב גם שענף שלא מתאים לשום ערך יכול לזרוק חריגה במקום להחזיר ערך. אם ענף צריך כמה פקודות לפני שהוא מחזיר ערך, השתמשו בבלוק עם yield:

case 2 -> {
    boolean leap = (year % 4 == 0);
    yield leap ? 29 : 28;
}

yield הוא הדרך שבה בלוק חץ מחזיר את הערך שלו, המקבילה בעולם הביטויים ל-break שנושא תוצאה.

הבא בתור: לולאות for

switch בוחר ענף אחד מתוך רבים; לפעמים צריך דווקא לחזור על בלוק הרבה פעמים. לולאת for מריצה קוד מספר מבוקר של פעמים, סופרת לאורך טווח או עוברת על כל פריט, והיא הנושא של העמוד הבא.