Conditional statements

In programming, conditional statements are constructs that make it possible to control a program flow based on conditions. The condition can, for example, refer to a specific variable or the state of a program. If the condition is met, the code within the conditional statement is executed. Otherwise the code is skipped or an alternative code block is executed.

There are two types of conditional statements in Kotlin: if statements and when expressions.

The if statement allows an action to be performed if a condition is true. The syntax of the if statement is similar to other programming languages, but there are some differences.

The general syntax of if statement in Kotlin is as follows:

if (Condition) { // Condition = Bedingung
   // auszuführender Code-Block, wenn die Bedingung wahr ist
}

Here is a simple example:

fun main() {
    val number: Int = 20

    if (number > 10) {
        println("The number is greater than 10")
    }
}

This code defines a variable called number with the value 10. Then a conditional statement is introduced with the if statement. The condition is number > 5, which means that the code block inside the curly braces will only be executed if the variable number greater than 5 is. In this case that is the case, there number the value 10  has that is greater than 5  is. Therefore, the code inside the curly braces is executed and the output “The number is greater than 5” is printed on the console.

Basically, if the code block consists of only one expression, the curly braces can be omitted:

fun main() {
    val number = 20

    if (number > 10)
    println("The number is greater than 10")
}

The if-else statement allows one of two blocks of code to be executed depending on whether a condition is true or false. The syntax of if-else statement in Kotlin is as follows:

if (Condition) {
    // Code-Block, der ausgeführt wird, wenn die Bedingung wahr ist
} else {
    // Code-Block, der ausgeführt wird, wenn die Bedingung falsch ist
}



fun main() {
    val age = 18

    if (age >= 18) {
        println("You are of legal age")
    } else {
        println("You are a minor")
    }
}

This code defines a variable called age with the value 18. Then a conditional statement with the if-Instruction initiated. The condition is age > = 18, which means that the block of code inside the curly braces will only be executed if the person's age is 18 or older. In this case that is the case because age is the value 18 has, which means that the person is of legal age. Therefore, the code inside the first curly braces is executed and the output “You are of legal age” is printed on the console. If the condition is false (i.e. the person's age is under 18), the code within the elsestatement executed and the output “You are a minor” is printed on the console.

The if statement can also return a value. For example, we can find the maximum of two numbers:

fun main() {
    val a = 5
    val b = 10

    val c = if(a > b) a else b
    println(c) // 10
}

If additional actions need to be performed to determine the returned value, these actions can be placed in code blocks:

fun main() {
    val a = 5
    val b = 10

    val c = if(a > b) {
        println("Variable a = $a")
        a
    } else {
        println("Variable b = $b")
        b
    }
}

At the end of each block the returned value is specified.

Kotlin also has that if-else-if statement, which allows checking multiple conditions and executing different blocks of code depending on the conditions. The syntax for the if-else-if statement is as follows:

   if (Condition1) {
      // Code-Block, der ausgeführt wird, wenn Bedingung1 wahr ist
   } else if (Condition2) {
      // Code-Block, der ausgeführt wird, wenn Bedingung2 wahr ist
   } else if (Condition3) {
      // Code-Block, der ausgeführt wird, wenn Bedingung3 wahr ist
   } else {
     // Code-Block, der ausgeführt wird, wenn keine der Bedingungen wahr ist
   }

Here is an example of using the if-else-if statement to determine the grading system based on the score:

fun main() {
    val score = 80

    if (score >= 90) {
    println("You have got A")
    } else if (score >= 80) {
    println("You have got B")
    } else if (score >= 70) {
    println("You have got C")
    } else {
    println("You have got F")
   }
}

When is a conditional statement in Kotlin that allows checking a variety of conditions and executing the corresponding block of code associated with the appropriate condition.

when (variable) {
option1 -> {
      // Code-Block, der ausgeführt wird, wenn variable mit option1 übereinstimmt
}
option2 -> {
      // Code-Block, der ausgeführt wird, wenn variable mit option2 übereinstimmt
}
...
else -> {
      // Code-Block, der ausgeführt wird, wenn keine der Optionen übereinstimmt
}
}

Here is an example of using when to determine the day of the week based on the day of the week:

fun main() {
    val dayOfWeek = 5

    when (dayOfWeek) {
         1 -> println("Monday")
         2 -> println("Tuesday")
         3 -> println("Wednesday")
         4 -> println("Thursday")
         5 -> println("Friday")  // "Friday" wird zurückgegeben
         6 -> println("Saturday")
         7 -> println("Sunday")
    else -> println("The day is not known")
    }
}

Comparison with group of values

A comparison can be made with a group of values. It is possible to define the same actions for several of these values ​​at the same time. In this case the values ​​are listed separated by commas,

fun main() {
  val a: Int = 100

  when (a) {
       100, 200 -> println("Variable 'a' is 100 or 200") // Der String "Variable 'a' is 100 or 200" wird zurückgegeben
       else -> println("The value of the variable 'a' is unknown")      
  }
}

You can also compare a value to a whole range of values ​​using the in operator .

fun main() {
  val a: Int = 120

  when (a) {
      in 0..100 -> println("Variable 'a' is within the range of 0 to 100")
      in 101..200 -> println("Variable 'a' is within the range of 101 to 200") // a = 120 und liegt im Bereich 101 bis 200
      in 201..300 -> println("Variable 'a' is within the range of 201 to 300")
  }
}

If the in operator makes it possible to find out whether a value is within a certain range, the combination of operators allows !in checking whether a value is not contained in a specific sequence.

fun main() {
    val a = 201

    when (a)  {
         in 0..100 -> println("Variable 'a' is within the range of 0 to 100")
         !in 101..200 -> println("Variable 'a' is NOT within the range of 101 to 200") // 201 ist nicht Bestandteil des Bereichs 101 bis 200
    }
}

when expression and dynamically calculated values

The when expression can also be compared with dynamically calculated values.

fun main() {
    val a: Int = 50
    val b: Int = 30
    val c: Int = 20

    when (a) {
         b - c -> println("a = b - c")
         b + c -> println("a = b + c")  // 30 + 20 = 50, dementsprechend wird der String "a = b + c" ausgegeben
         else -> println("Undefined value")
    }
}

When can also accept a dynamically calculated object.

fun main() {
    val a: Int = 50
    val b: Int = 30

    when (a - b) {   // 50 - 30 = 20
         10 -> println("a - b = 10")
         20 -> println("a - b = 20")   // Der String "a - b = 20" wird ausgegeben
         else -> println("Undefined value")
    }
}

It is even possible to define variables that will be available within the when expression.

fun main() {
    val a: Int = 50
    val b: Int = 30

    when (val c: Int = a + b) {   // 50 + 30 = 80
         40 -> println("a + b = 40")
         60 -> println("a + b = 60")
         80 -> println("a + b = 80")   // c = 80, dementsprechend wird der String "a + b = 80" ausgegeben
         else -> println("Variable 'c' = $c")
    }
}

The construction When can also be used as an alternative to if..else be used. The value of an object does not necessarily have to be compared. Instead, a series of conditions are checked. Once one of the conditions returns true, the associated set of statements is executed.

fun main() {
    val a: Int = 50
    val b: Int = 50

    when {
         (a > b) -> println("a > b")
         (a < b) -> println("a < b")
         (a == b) -> println("a = b") // 50 = 50, dementsprechend wird der String "a = b" ausgegeben
    }
}

Similar to the if construct, the when expression return a value. The result returned is through the arrow operator -> Are defined.

fun main() {
    val a: Int = 50
    val b: Int = 50

    val sum: Int = a + b // 50 + 50 = 100
    val result: Int = when(sum) {
        in 0..99 -> 0
        in 100..199 -> 1 // Wert der Variable "sum" liegt im Bereich 100..199, dementsprechend wird der Wert "1" zurückgegeben
        else -> 2
    }
    println(result)
}