Условные выражения

Последнее обновление: 23.05.2021

Условные выражения представляют некоторое условие, которое возвращает значение типа Boolean: либо true (если условие истинно), либо false (если условие ложно).

Операции отношения

  • > (больше чем): возвращает true, если первый операнд больше второго. Иначе возвращает false

    val a = 11
    val b = 12
    val c : Boolean =  a > b
    println(c)      // false - a меньше чем b
    
    val d = 35 > 12
    println(d)      // true - 35 больше чем 12
    
  • < (меньше чем): возвращает true, если первый операнд меньше второго. Иначе возвращает false

    val a = 11
    val b = 12
    val c =  a < b	// true
    
    val d = 35 < 12	// false
    
  • >= (больше чем или равно): возвращает true, если первый операнд больше или равен второму

    val a = 11
    val b = 12
    val c = a >= b      // false
    val d = 11 >= a     // true
    
  • <= (меньше чем или равно): возвращает true, если первый операнд меньше или равен второму.

    val a = 11
    val b = 12
    val c = a <= b      // true
    val d = 11 <= a     // false
    
  • == (равно): возвращает true, если оба операнда равны. Иначе возвращает false

    val a = 11
    val b = 12
    val c = a == b		// false
    val d = b == 12		// true
    
  • != (не равно): возвращает true, если оба операнда НЕ равны

    val a = 11
    val b = 12
    val c = a != b		// true
    val d = b != 12		// false
    

Логические операции

Операндами в логических операциях являются два значения типа Boolean. Нередко логические операции объединяют несколько операций отношения:

  • and: возвращает true, если оба операнда равны true.

    val a = true
    val b = false
    val c = a and b      					// false
    val d = (11 >= 5) and (9 < 10)     // true
    println(c)
    println(d)
    
  • or: возвращает true, если хотя бы один из операндов равен true.

    val a = true
    val b = false
    val c = a or b      					// true
    val d = (11 < 5) or (9 > 10)     // false
    
  • xor: возвращает true, если только один из операндов равен true. Если операнды равны, возвращается false

    val a = true
    val b = false
    val c = a xor b      			// true
    val d = a xor (90 > 10)    	// false
    
  • !: возвращает true, если операнд равен false. И, наоборот, если операнд равен true, возвращается false.

    val a = true
    val b = !a  // false
    val c = !b  // true
    

    В качестве альтернативы оператору ! можно использовать метод not():

    val a = true
    val b = a.not()  // false
    val c = b.not()  // true
    
  • in: возвращает true, если операнд имеется в некоторой последовательности.

    val a = 5
    val b = a in 1..6		// true - число 5 входит в последовательность от 1 до 6
    
    val c = 4
    val d = c in 11..15		// false - число 4 НЕ входит в последовательность от 11 до 15
    

    Выражение 1..6 создает последовательность чисел от 1 до 6. И в данном случае оператор in проверяет, есть ли значение переменной a в этой последовательности. Поскольку значение переменной a имеется в данной последовательности, то возвращается true.

    А выражение 11..15 создает последовательность чисел от 11 до 15. И поскольку значение переменной с в эту последовательность не входит, поэтому возвращается false.

    Если нам, наоборот, хочется возвращать true, если числа нет в указанной последовательности, то можно применить комбинацию операторов !in:

    val a = 8
    val b = a !in 1..6		// true - число 8 не входит в последовательность от 1 до 6
    
Помощь сайту
WebMoney
  • P378451176208
  • Z280152397659
ЮMoney/Яндекс-Деньги
  • 410011174743222
PayPal
  • metanit22@mail.ru
Перевод на карту
  • Номер карты: 4048415020898850