The switch Statementڕستەی switch

A program often compares one value with a list of fixed values: day 1 means Sunday, day 2 means Monday, and so on. An else if ladder can do it (The else if ladder), but Java has a statement made for this job: the Switch statement. It works out the value in its brackets once, then goes straight to the Case label with the same value and runs the code there. So a switch tests equality: one value against many possible values.

بەرنامە (Program) زۆرجار یەک نرخ لەگەڵ لیستێک نرخی جێگیر بەراورد دەکات: ڕۆژی 1 واتە یەکشەممە، ڕۆژی 2 واتە دووشەممە و بەم شێوەیە. پەیژەیەکی else if دەتوانێت ئەم کارە بکات (پەیژەی else if)، بەڵام Java ڕستەیەکی (Statement) تایبەتی بۆ ئەم کارە هەیە: ڕستەی switch. نرخی ناو کەوانەکانی یەک جار دەدۆزێتەوە، پاشان ڕاستەوخۆ دەچێت بۆ ئەو بەشی caseـەی کە هەمان نرخی هەیە و کۆدەکەی ئەوێ جێبەجێ دەکات. کەواتە switch یەکسانی دەپشکنێت: یەک نرخ بەرامبەر بە چەندین نرخی گونجاو.

A switch has a value in brackets and a block in braces. Each case gives one value and a colon, followed by the statements for that case. break; ends the case and leaves the switch. The default: part runs when no case matches. A switch can have any number of cases; default is optional, and so is the break after the last part. Every case value must have the same type as the value in the brackets.

switch نرخێک لە ناو کەوانەی بچووک و بلۆکێکی کۆدی (Code block) لە ناو کەوانەی ⁦{ }⁩ـدا هەیە. هەر caseـێک یەک نرخ و دوو خاڵ دەنووسێت، لە دوایدا ڕستەکانی ئەو caseـە دێن. break; caseـەکە کۆتایی پێ دەهێنێت و لە switch دەردەچێت. بەشی default: کاتێک جێبەجێ دەبێت کە هیچ caseـێک نەگونجێت. switch دەتوانێت هەر ژمارەیەک case لەخۆ بگرێت؛ default ئارەزوومەندانەیە، breakـی دوای دوایین بەشیش هەروەها. نرخی هەموو caseـێک دەبێت هەمان جۆری نرخی ناو کەوانەکانی هەبێت.

You may also put braces around the statements of one case (case 1: { … break; }), as some books do. They are allowed but not needed: a case runs from its label down to the break.

دەتوانیت کەوانەی ⁦{ }⁩ بە دەوری ڕستەکانی یەک caseـیشدا دابنێیت (case 1: { … break; })، وەک هەندێک کتێب دەیکەن. ڕێگەپێدراون بەڵام پێویست نین: caseـێک لە بەشی caseـەکەیەوە تا break جێبەجێ دەبێت.

Here value is 10. Java compares it with the cases from the top: case 10 matches, so it prints Value is 10, and break jumps to the first statement after the switch. The same break also ends loops: break in a switch and in a loop.

لێرەدا value دەکاتە ⁦10. Java⁩ لە سەرەوە لەگەڵ caseـەکان بەراوردی دەکات: case 10 دەگونجێت، بۆیە Value is 10 چاپ دەکات و break بازدەدات بۆ یەکەم ڕستە لە دوای switch. هەمان break خولەکانیش (Loop) کۆتایی پێ دەهێنێت: break لە switch و لە خولدا.

With value = 25 no case matches, so default prints Value is not 10, 20 or 30. The second half of the animation shows what happens when the breaks are missing: Forgetting break explains it.

کاتێک value = 25، هیچ caseـێک ناگونجێت، بۆیە default Value is not 10, 20 or 30 چاپ دەکات. نیوەی دووەمی وێنە جووڵاوەکە پیشان دەدات چی ڕوو دەدات کاتێک breakـەکان ون بن: لەبیرچوونی break ڕوونی دەکاتەوە.

The value usually comes from the user. This program reads a day number with Scanner (Keyboard input) and prints the name of one of the five school and working days in the Kurdistan Region, Sunday to Thursday:

نرخەکە زۆرجار لە بەکارهێنەرەوە (User) دێت. ئەم بەرنامەیە بە Scanner ژمارەی ڕۆژێک دەخوێنێتەوە (نێوخستەی کیبۆرد) و ناوی یەکێک لە پێنج ڕۆژی خوێندن و کاری هەرێمی کوردستان چاپ دەکات، لە یەکشەممەوە تا پێنجشەممە:

In Java 17 the value in the brackets may be a char, byte, short or int, one of their wrapper classes Character, Byte, Short and Integer (Java takes the number out of the object; Wrapper classes explains them), a String, or an enum (Enums in a switch). String came in Java 7 (2011); enums and wrapper classes have worked since Java 5 (2004), the version that added enums and automatic boxing.

لە ⁦Java 17⁩ـدا نرخی ناو کەوانەکان دەتوانێت char، byte، short یان int بێت، یان یەکێک لە کلاسە پێچەرەوەکانی (Wrapper class) ئەوان: Character، Byte، Short و Integer (Java ژمارەکە لە ئۆبجێکتەکە (Object) دەردەهێنێت؛ کلاسە پێچەرەوەکان ڕوونیان دەکاتەوە)، یان String، یان ئینەمێک (Enum) (ئینەمەکان لە switchـدا). String لە ⁦Java 7⁩ـدا ⁦(2011)⁩ هات؛ ئینەمەکان و کلاسە پێچەرەوەکان لە ⁦Java 5⁩ـەوە ⁦(2004)⁩ کار دەکەن، ئەو وەشانەی ئینەمەکان و پێچانەوەی خۆکاری (Autoboxing) زیاد کرد.

A long, float, double or boolean cannot be the value of a switch in Java 17. javac's message is confusing: it first talks about patterns, a feature of newer Java versions, and then says that the int labels do not fit a long:

long، float، double یان boolean ناتوانن نرخی switch بن لە ⁦Java 17⁩ـدا. هەڵەنامەی javac سەرلێشێوێنەرە: سەرەتا باسی patterns دەکات، تایبەتمەندییەکی وەشانە نوێیەکانی Java، پاشان دەڵێت نرخەکانی intـی ناو caseـەکان لەگەڵ long ناگونجێن:

A double or a boolean gives the same kind of message. For such values write an if … else ladder; a boolean has only two values, so a plain if … else is the right tool. When a long surely holds a small number, a cast is possible: switch ((int) code) compiles and prints two (Narrowing).

double یان booleanـیش هەمان جۆرە پەیام دەدەن. بۆ ئەم نرخانە پەیژەیەکی if … else بنووسە؛ boolean تەنیا دوو نرخی هەیە، بۆیە if … elseـێکی سادە ئامرازی دروستە. کاتێک دڵنیایت longـێک ژمارەیەکی بچووک هەڵدەگرێت، گۆڕینی جۆر (Type conversion) دەکرێت: switch ((int) code) کۆمپایل دەبێت و two چاپ دەکات (تەسککردنەوەی جۆر).

break is optional. Without it, Java does not stop at the end of the matching case: it falls through and runs the statements of the following cases too, until it meets a break or the end of the switch. The cases above the matching one never run. This is called Fall-through. Here courses is 3 and no case has a break:

break ئارەزوومەندانەیە. بەبێ ئەو، Java لە کۆتایی caseـە گونجاوەکەدا ناوەستێت: تێدەپەڕێت و ڕستەکانی caseـەکانی دواتریش جێبەجێ دەکات، تا دەگاتە breakـێک یان کۆتایی ⁦switch. case⁩ـەکانی سەرووی caseـە گونجاوەکە هەرگیز جێبەجێ نابن. ئەمە پێی دەڵێن تێپەڕین. لێرەدا courses دەکاتە 3 و هیچ caseـێک breakـی نییە:

javac compiles a fall-through without a word, because sometimes it is wanted. Add the option -Xlint:fallthrough and javac prints a warning for every case that the case above it falls into:

javac بێ هیچ قسەیەک تێپەڕینێک کۆمپایل دەکات، چونکە هەندێک جار مەبەستە. ئەگەر هەڵبژاردەی -Xlint:fallthrough زیاد بکەیت، javac بۆ هەر caseـێک کە caseـی سەرووی تێی دەپەڕێت هۆشدارییەک چاپ دەکات:

The program still compiles and runs the same; the warnings only point at the places to check. -Xlint on its own turns on all of javac's recommended warnings. When you want a fall-through, a comment such as // falls through on purpose tells the next reader, or use the grouped labels of the next screen.

بەرنامەکە هەر کۆمپایل دەبێت و وەک پێشوو کار دەکات؛ هۆشدارییەکان تەنیا ئەو شوێنانە پیشان دەدەن کە دەبێت بپشکنرێن. -Xlint بە تەنیا هەموو هۆشدارییە پێشنیارکراوەکانی javac چالاک دەکات. ئەگەر تێپەڕینت دەوێت، لێدوانێکی (Comment) وەک // falls through on purpose خوێنەری داهاتوو ئاگادار دەکاتەوە، یان کۆکردنەوەی بەشەکانی case لە شاشەی داهاتوو بەکار بهێنە.

Fall-through helps when several values need the same code. Write their labels one under the other with no statements between them: days 1 to 5 all reach School day. Since Java 14 one label can also list several values: case 1, 2, 3, 4, 5: and case 6, 7: give the same results.

تێپەڕین بەسوودە کاتێک چەند نرخێک پێویستیان بە هەمان کۆد هەیە. بەشەکانی caseـی ئەوان لە ژێر یەکتردا بنووسە بێ ئەوەی هیچ ڕستەیەک لە نێوانیاندا بێت: ڕۆژەکانی 1 تا 5 هەموویان دەگەنە School day. لە ⁦Java 14⁩ـەوە یەک case دەتوانێت چەند نرخێک بنووسێت: case 1, 2, 3, 4, 5: و case 6, 7: هەمان ئەنجام دەدەن.

A String can be the value of a switch too. Java compares it with each case the way equals does (Comparing strings): exactly, letter by letter, and capital letters matter. Football positions make a good example:

Stringـیش دەتوانێت نرخی switch بێت. Java بە هەمان شێوەی equals لەگەڵ هەر caseـێک بەراوردی دەکات (بەراوردکردنی زنجیرەنووسەکان): ڕێک، پیت بە پیت و پیتی گەورەش گرنگە. پۆستەکانی تۆپی پێ نموونەیەکی باشن:

Striker with a capital S matches no case. Compare a lower-case copy instead: with switch (position.toLowerCase()), Striker and GOALKEEPER work too (Upper and lower case):

Striker بە Sـی گەورە لەگەڵ هیچ caseـێک ناگونجێت. لە جیاتی ئەوە کۆپییەکی پیت بچووک بەراورد بکە: بە switch (position.toLowerCase())، Striker و GOALKEEPERـیش کار دەکەن (پیتی گەورە و بچووک):

A String variable can also hold Null: no object at all. To compare a String, the switch has to use the object, so a null stops the program with a NullPointerException:

گۆڕاوێکی (Variable) String دەتوانێت بێنرخیش هەڵبگرێت: هیچ ئۆبجێکتێک نییە. switch بۆ بەراوردکردنی Stringـێک دەبێت ئۆبجێکتەکە بەکار بهێنێت، بۆیە null بە NullPointerException بەرنامەکە دەوەستێنێت:

<local2> is a hidden copy of position that javac made; line 4 is the switch. Check for null first: if (position == null) { … } else { switch (position) { … } } prints No position given instead. (Exceptions explains the error itself.)

<local2> کۆپییەکی شاراوەی positionـە کە javac دروستی کردووە؛ دێڕی ⁦4 switch⁩ـەکەیە. سەرەتا بێنرخ بپشکنە: if (position == null) { … } else { switch (position) { … } } لە جیاتی ئەوە No position given چاپ دەکات. (هەڵاوێردەکان خودی هەڵەکە ڕوون دەکاتەوە.)

javac checks every label: a case value must be a Constant, either a literal such as 1, 'A' or "Hawler" or a final variable that holds one. It must fit the type of the switch value, and no value may appear twice. The order of the cases does not matter: any order the problem needs is fine.

javac هەموو caseـێک دەپشکنێت: نرخی case دەبێت نەگۆڕ (Constant) بێت: یان لیتەراڵێکی (Literal) وەک 1، 'A' یان "Hawler"، یان گۆڕاوێکی final کە یەکێکی وای هەڵگرتبێت. دەبێت لەگەڵ جۆری نرخی switch بگونجێت و هیچ نرخێک دووجار نەیەت. ڕیزبەندیی caseـەکان گرنگ نییە: هەر ڕیزبەندییەک کە کێشەکە پێویستی بێت باشە.

A String label in an int switch gives incompatible types: String cannot be converted to int. A final constant is fine: with final int LIMIT = 5;, the label case LIMIT: compiles and prints limit for 5.

caseـێکی String لە switchـێکی intـدا incompatible types: String cannot be converted to int دەدات. نەگۆڕێکی final باشە: بە final int LIMIT = 5;، case LIMIT: کۆمپایل دەبێت و بۆ 5 limit چاپ دەکات.

default is optional, and it may stand anywhere in the block, even first. Java still tries every case first and goes to default only when none matches. But default is a label like the others: without a break it falls through into the cases written after it:

default ئارەزوومەندانەیە و دەتوانێت لە هەر شوێنێکی بلۆکەکەدا بێت، تەنانەت یەکەمیش. Java هەر سەرەتا هەموو caseـەکان تاقی دەکاتەوە و تەنیا کاتێک دەچێت بۆ default کە هیچیان نەگونجێت. بەڵام default وەک ئەوانی تر بەشێکە: بێ break بەرەو ئەو caseـانە تێدەپەڕێت کە لە دوای نووسراون:

Since Java 14 a case can use an arrow: case 3 -> statement;. An arrow case runs only its own statement, so it never falls through and needs no break. Several values share one arrow with commas, and default -> catches the rest. New Java code mostly uses this form:

لە ⁦Java 14⁩ـەوە caseـێک دەتوانێت تیر بەکار بهێنێت: case 3 -> statement;. caseـی تیر تەنیا ڕستەکەی خۆی جێبەجێ دەکات، بۆیە هەرگیز تێناپەڕێت و پێویستی بە break نییە. چەند نرخێک بە فاریزە یەک تیر بەش دەکەن و default -> ئەوانی تر دەگرێت. کۆدی نوێی Java زیاتر ئەم شێوەیە بەکار دەهێنێت:

For several statements, put a block after the arrow: case 2 -> { … }. One switch must use one form: mixing -> and : labels gives different case kinds used in the switch.

بۆ چەند ڕستەیەک، بلۆکێک لە دوای تیرەکە دابنێ: case 2 -> { … }. هەر switchـێک دەبێت یەک شێوە بەکار بهێنێت: تێکەڵکردنی -> و : هەڵەی different case kinds used in the switch دەدات.

A switch can also be a Switch expression: it produces a value that you store or print. Each arrow gives the value for its case, and the whole switch stands on the right of =. Mind the ; after the closing brace: the switch is part of an assignment statement.

switch دەتوانێت دەربڕینی switchـیش بێت: نرخێک بەرهەم دەهێنێت کە هەڵیدەگریت یان چاپی دەکەیت. هەر تیرێک نرخی caseـەکەی خۆی دەدات و هەموو switchـەکە لە لای ڕاستی = دادەنرێت. ئاگاداری ; بە لە دوای کەوانەی داخستن: switch بەشێکە لە ڕستەیەکی دانانی نرخ (Assignment).

A switch expression must give a value for every possible input, so it needs a default (unless it switches on an enum and lists every constant). Without one, javac stops: the switch expression does not cover all possible input values.

دەربڕینی switch دەبێت بۆ هەموو نێوخستەیەکی (Input) گونجاو نرخێک بدات، بۆیە پێویستی بە default هەیە (مەگەر لەسەر ئینەمێک بێت و هەموو نەگۆڕەکانی بنووسێت). بەبێ ئەو، javac دەوەستێت: the switch expression does not cover all possible input values.

When a case needs some statements before its value, give it a block and finish with yield value;. yield belongs to switch expressions; a switch statement uses break. February needs a decision: 29 days in a leap year (divisible by 4 but not by 100, or by 400), otherwise 28. The block uses the ternary operator:

کاتێک caseـێک پێش نرخەکەی پێویستی بە چەند ڕستەیەک هەیە، بلۆکێکی بدەرێ و بە yield value; کۆتایی پێ بهێنە. yield هی دەربڕینەکانی switchـە؛ ڕستەی switch break بەکار دەهێنێت. شوبات پێویستی بە بڕیارێک هەیە: لە ساڵی کەبیسەدا ⁦29⁩ ڕۆژ (دابەشی 4 دەبێت بەڵام نەک دابەشی ⁦100⁩، یان دابەشی ⁦400⁩ دەبێت)، ئەگەر نا ⁦28⁩. بلۆکەکە کارپێکەری سێیانی بەکار دەهێنێت:

A block that ends without yield does not compile: switch rule completes without providing a value. yield also works with colon labels inside a switch expression, but arrows are the usual choice.

بلۆکێک کە بێ yield کۆتایی بێت کۆمپایل نابێت: switch rule completes without providing a value. yield لەگەڵ شێوەی دوو خاڵیشدا لە ناو دەربڕینی switchـدا کار دەکات، بەڵام تیر هەڵبژاردنی باوە.

Use switch when one value is compared with fixed values for equality: day numbers, menu choices, operator characters, words. Use if … else for ranges (mark >= 90), conditions on several variables, decimal numbers and booleans. Both can solve many problems; pick the one that reads more clearly.

switch بەکار بهێنە کاتێک یەک نرخ لەگەڵ نرخی جێگیر بۆ یەکسانی بەراورد دەکرێت: ژمارەی ڕۆژ، هەڵبژاردنی مێنیو (Menu)، نیشانەی کارپێکەر (Operator)، وشە. if … else بۆ ماوە (mark >= 90)، مەرجەکانی (Condition) سەر چەند گۆڕاوێک، ژمارە کەرتییەکان (Float) و بوولیانەکان (Boolean) بەکار بهێنە. هەردووکیان دەتوانن زۆر کێشە چارەسەر بکەن؛ ئەوەیان هەڵبژێرە کە ڕوونتر دەخوێنرێتەوە.

Sometimes a range can become cases. Marks come in bands of ten, and mark / 10 uses integer division: 76 / 10 is 7, so every mark from 70 to 79 lands on case 7:

هەندێک جار ماوەیەک دەکرێت بە case. نمرەکان دە بە دە پۆل دەکرێن و mark / 10 دابەشکردنی ژمارەی تەواو بەکار دەهێنێت: ⁦76 / 10⁩ دەکاتە 7، بۆیە هەموو نمرەیەک لە ⁦70⁩ تا ⁦79⁩ دەکەوێتە سەر case 7:

101 / 10 is also 10, so a mark of 101 prints Excellent: test the range first with if (mark < 0 || mark > 100), as the grade ladder does. The trick works only when every band has the same width.

هەروەها ⁦101 / 10⁩ دەکاتە ⁦10⁩، بۆیە نمرەی ⁦101⁩ Excellent چاپ دەکات: سەرەتا ماوەکە بە if (mark < 0 || mark > 100) بپشکنە، وەک پەیژەی نمرەکان دەیکات. ئەم فێڵە تەنیا کاتێک کار دەکات کە پانیی هەموو پۆلەکان وەک یەک بێت.

The real javac messages of the last four rows:

پەیامە ڕاستەقینەکانی javac بۆ چوار ڕیزی کۆتایی: