Урок 4: Boolean – логический тип данных в Kotlin. Операторы сравнения

4 1 scaled - Android [Kotlin] для начинающих

Смотрите видеоурок бесплатно на удобной для вас платформе:

Здравствуйте. Представим, что нам нужно создать часть логики программы, которая решает, можно ли пользователю открыть доступ к определенному контенту в зависимости от его возраста. Как мы можем сделать проверку на достижение совершеннолетия с помощью Kotlin?

Этот урок призван разложить по полочкам значения терминов, связанных с логическим типом данных. Конкретно рассмотрим: логические операторы, операторы сравнения и присваивания.

Операторы присваивания и сравнения

Начнем с последнего. Раз и навсегда определим, что оператор присваивания вы уже давно знаете — он обозначается знаком равенства. Оператор присваивания присваивает данные справа от знака равно данным слева. А оператор “двойное равно” (==) является оператором сравнения. Он сравнивает два значения между собой.

Операторы сравнения

Окей. С путаницей разобрались, теперь повторим и более предметно рассмотрим все операторы сравнения.

>, <, >=, <=, ==, !=

Все, кроме последних двух, используются в классической математике. Оставшиеся операторы проверяют равенство и неравенство значений, чтобы определить, равны ли или различаются данные между собой.

Все эти операторы сравнивают между собой данные различных типов. Результатом сравнения всегда могут быть только два значения: истина (обозначается как true) или ложь (обозначается как false). Такие операции еще называют “Операции отношения”.

Операторы ссылочного сравнения

Есть еще операторы ссылочного сравнения. Сейчас их понимание не несет ключевой роли, просто знайте, что они есть. Эти операторы могут понадобиться, когда нужно проверить, ссылаются ли две переменные на один и тот же объект в памяти, а не просто имеют одинаковое значение.

Оператор ссылочного сравнения — это === (равно) и !== (не равно) соответственно. Результат сравнения будет истиной, если обе сравниваемые переменные ссылаются на один объект и наоборот.

Примеры операторов сравнения

Следующие примеры наглядно покажут, как операторы могут возвращать результат сравнения.

Представим, что в вашем разрабатываемом приложении есть скрытый контент, который доступен, только если пользователю исполнилось 18 лет. Пользователь вводит свой возраст и в определенном месте ваша программа должна обработать введенное число и выдать положительный или отрицательный результат. Пока ограничимся этим функционалом.

Работа с константами

Приступим. Добавим возрастной порог, с которым будем сравнивать возраст пользователя. Объявим переменную, которая будет константой. То есть ее значение не должно поменяться ни при каких обстоятельствах.

Почему бы просто не объявить переменную через val? Потому что значение, с которым мы сравниваем (18), точно не будет изменяться. При компиляции вместо переменных в байт-коде сразу подставляются значения констант, что увеличивает производительность программы. Кроме того, это является хорошей практикой и принято стилистически.

Константы нельзя объявлять локально, поэтому вынесем ее за пределы метода. Также константы принято писать большими буквами, разделяя слова нижним подчеркиванием. Официально этот стиль написания называется UPPER CASE в сочетании со snake_case.

const val AGE_OF_MAJORITY = 18

Введенный пользователем возраст будет храниться в переменной userAge. Допустим, это будет 42 года.

val userAge = 42

Проверка возраста пользователя

Теперь сравним возраст пользователя с минимальным допустимым и сохраним результат в переменную comparisonResult. Укажем, что эта переменная имеет логический тип Boolean. Теперь в нее можно поместить одно из двух значений: true или false.

val comparisonResult: Boolean

Первый момент, который нужно отметить: созданную переменную уже можно проинициализировать значением true или false, и она будет его хранить. Для демонстрации присвоим ей значение false и выведем значение переменной в консоль. Это сделано лишь для примера.

val comparisonResult: Boolean = false
println(comparisonResult)

Зафиксировали. Второй ключевой момент – в переменную можно положить результат сравнения какого-либо выражения (простого или составного). Именно этот кейс мы будем использовать в нашей программе по распознаванию возраста. Начнем сравнивать возраст пользователя с константным.

val comparisonResult: Boolean = userAge >= AGE_OF_MAJORITY
println(comparisonResult)

После запуска программы видим в консоли результат true. Да, 42 больше или равно, чем число 18. Поэтому нашему пользователю откроется страница со скрытым контентом. Помним, что данные сначала сравниваются, затем результат присваивается переменной слева от знака равно. И давайте оформим результат более красиво, используя интерполяцию строк, о которых мы говорили на предыдущем уроке.

println("Результат проверки возраста пользователя: $comparisonResult")

Так гораздо лучше. Если подставить в качестве возраста пользователя другие значения, изменится и результат, например, пусть это будет подросток 15 лет. В консоли выведется результат сравнения false.

Для пущей наглядности вот еще пара простейших примеров. В консоль будет печататься непосредственно результат сравнения.

println(0 < -1) // false
println(1 == 1) // true
println(2 == 3) // false
println(7 != 8) // true

Окей, мы разобрали операторы сравнения.

Логические операторы

Идем дальше, рассмотрим логические операторы. Они помогут нам создать составное выражение сравнения, когда нужно сравнивать несколько условий одновременно.

Логические операторы выглядят и произносятся так: ‘и’, ‘или’, ‘не’

&&, ||, !,

Пример использования логических операторов

Чтобы понять, как их использовать, давайте дополним бизнес-требования к нашей программе. Представим, что скрытый контент доступен пользователям от 18 лет (это мы уже реализовали) и, например, пользователям до 65 лет.

То есть будет промежуток от 18 до 65. Это означает, что у нас появляется уже два условия, которые нужно проверять: что возраст больше или равен 18 и меньше или равен 65.

Добавим новую необходимую для работы константу и напишем условие.

const val RETIREMENT_AGE = 65
comparisonResult = userAge >= AGE_OF_MAJORITY && userAge <= RETIREMENT_AGE

Логический оператор &&

Здесь мы используем логический оператор &&. Он гарантирует, что результат будет формироваться исходя из двух сравнений.

Если одно из сравнений вернет false, то конечный результат comparisonResult также будет false. Оператор && требует, чтобы оба условия были выполнены, чтобы результат был true. То есть оба условия (слева и справа от оператора) должны вернуть истину, чтобы итоговый результат также был истиной.

Кроме того, я не использовал круглые скобки для операций отношения, потому что в данном случае это не обязательно — приоритет выполнения операций уже учитывает правильный порядок. Однако, я рекомендую использовать скобки в более сложных выражениях для повышения читабельности кода.

А также скобки обязательны, если вы хотите использовать инфиксные функции and или or вместо символов && и ||. Не будем заострять на них внимание сейчас, но выглядит это вот так.

comparisonResult = (userAge >= AGE_OF_MAJORITY) and (userAge <= RETIREMENT_AGE)

Логический оператор ||

Далее. Оператор || позволяет также делать комбинированные условия. В этом случае comparisonResult будет true, если хотя бы одно из сравнений вернет true. Первое или второе. Например: если возраст больше или равен совершеннолетию, или если возраст равен или менее пенсионного возраста.

comparisonResult = (userAge >= AGE_OF_MAJORITY) || (userAge <= RETIREMENT_AGE)

Логический оператор отрицания (!)

Хорошо, далее — логический оператор отрицания. Если поставить его перед Boolean переменной или выражением в скобках, он инвертирует значение с true на false и наоборот. Представьте, что вы Дэвид Вашингтон герой фильма Ноллана ‘Довод’ входите в кабину инвертирования — все, что раньше шло вперед, стало бы двигаться назад. В целом логическое отрицание работает подобным образом, превращая true в false и наоборот, инвертируя текущее состояние.

Пример логического отрицания

Вот простой пример для переменных. Объявили Boolean переменную a и присвоили ей true. Объявили переменную b и присвоили ей значение a с отрицанием. Таким образом, в переменную b записался инвертированный результат false.

val a = true
val b = !a
println(b)

Применение логического отрицания в проверке возраста

Чтобы показать на примере нашего выражения, модернизируем его следующим образом. Добавим отрицание перед вторым сравнением и изменим знак на “больше или равно”. Это необходимо, чтобы исключить возрастные значения, превышающие пенсионный возраст, из доступных для выполнения условия.

Таким образом, мы делаем проверку более гибкой и соответствующей бизнес-логике задачи.

comparisonResult = (userAge >= AGE_OF_MAJORITY) && !(userAge >= RETIREMENT_AGE)

Звучит полностью это так. Конечный результат будет true, если возраст пользователя больше или равен совершеннолетию и, если возраст пользователя НЕ больше или равен пенсионному возрасту.

Наконец, хотел бы рассказать о сокращении, которое делает код более элегантным и удобным. Текущее выражение сравнения представляет собой проверку, входит ли возраст в диапазон допустимых значений между 18 и 65. Использование ключевого слова in позволяет существенно сократить запись.

Мы можем написать так, практически дословно:

comparisonResult = userAge in AGE_OF_MAJORITY..RETIREMENT_AGE

И звучит это следующим образом: результат будет true, когда userAge находится в (in) промежутке от 18 до 65. А если мы поставим перед in знак отрицания – то будет означать, что выражение также вернет true, если число находится ВНЕ заданного диапазона.

comparisonResult = userAge !in AGE_OF_MAJORITY..RETIREMENT_AGE

Для тех, кто собрался стать Android-разработчиком

Пошаговаясхема
Пошаговая
схема

Описание процесса обучения от основ Kotlin до Android-разработчика

Бесплатныеуроки
Бесплатные
уроки

Авторский бесплатный курс по основам языка программирования Kotlin

Обучающийбот
Обучающий
бот

Тренажер и самоучитель по Котлин – бесплатные тесты и практика

Поделиться уроком

Ответить

Ваш адрес email не будет опубликован. Обязательные поля помечены *