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

Условные выражения представляют некоторое условие, которое возвращает значение типа 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 = 15 <= 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