В каком случае выполняются инструкции блока else

При изучении программирования в качестве практики часто приходится создавать «идеальные программы», которые в реальном мире работают совсем не так.

Иногда, например, нужно исполнить ряд инструкций только в том случае, если соблюдаются определенные условия. Для обработки таких ситуаций в языках программирования есть операторы управления. В дополнение к управлению потоком выполнения программы эти операторы используются для создания циклов или пропуска инструкций, когда какое-то условие истинно.

Операторы управления бывают следующих типов:

1. Оператор-выражение if
2. Оператор-выражение if-else
3. Оператор-выражение if-elif-else
4. Цикл while
5. Цикл for
6. Оператор-выражение break
7. Оператор-выражение continue

В этом уроке речь пойдет о первых трех операторах управления.

Синтаксис оператора if следующий:

if condition:
    <indented statement 1>
    <indented statement 2>

<non-indented statement>

Первая строчка оператора, то есть if condition: — это условие if, а condition — это логическое выражение, которое возвращает True или False. В следующей строке блок инструкций. Блок представляет собой одну или больше инструкций. Если он идет следом за условием if, такой блок называют блоком if.

Стоит обратить внимание, что у каждой инструкции в блоке if одинаковый отступ от слова if. Многие языки, такие как C, C++, Java и PHP, используют фигурные скобки ({}), чтобы определять начало и конец блока, но в Python используются отступы.

Каждая инструкция должна содержать одинаковое количество пробелов. В противном случае программа вернет синтаксическую ошибку. В документации Python рекомендуется делать отступ на 4 пробела. Такая рекомендация актуальная для и для этого .

Как это работает:

Когда выполняется инструкция if, проверяется условие. Если условие истинно, тогда все инструкции в блоке if выполняются. Но если условие оказывается неверным, тогда все инструкции внутри этого блока пропускаются.

Инструкции следом за условием if, у которых нет отступов, не относятся к блоку if. Например, <non-intenden statement> — это не часть блока if, поэтому она будет выполнена в любом случае.

Например:

number = int(input("Введите число: "))

if number > 10:
    print("Число больше 10")

Первый вывод:

Введите число: 100
Число больше 10

Второй вывод:

Введите число: 5

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

Рассмотрим следующий код:

number = int(input("Введите число: "))
if number > 10:
    print("первая строка")
    print("вторая строка")
    print("третья строка")

print("Выполняется каждый раз, когда вы запускаете программу")
print("Конец")

Первый вывод:

Введите число: 45
первая строка
вторая строка
третья строка
Выполняется каждый раз, когда вы запускаете программу
Конец

Второй вывод:

Введите число: 4
Выполняется каждый раз, когда вы запускаете программу
Конец

Здесь важно обратить внимание, что только выражения на строках 3, 4 и 5 относятся к блоку if. Следовательно, они будут исполнены только в том случае, когда условие if будет истинно. Но инструкции на строках 7 и 8 выполнятся в любом случае.

Консоль Python реагирует иначе при использовании операторов управления прямо в ней. Стоит напомнить, что для разбития выражения на несколько строк используется оператор продолжение (\). Но в этом нет необходимости с операторами управления. Интерпретатор Python автоматически активирует мультистрочный режим, если нажать Enter после условия if. Например:

>>>
>>> n = 100
>>> if n > 10:
...

После нажатия Enter на строке с условием if командная строка преобразуется с >>> на …. Консоль Python показывает … для многострочных инструкций. Это значит, что начатая инструкция все еще не закончена.

Чтобы закончить инструкцию if, нужно добавить еще одну инструкцию в блок if:

>>>
>>> n = 100
>>> if n > 10:
...     print("n v 10")
...

Python не будет автоматически добавлять отступ. Это нужно сделать самостоятельно. Закончив ввод инструкции, нужно дважды нажать Enter, чтобы исполнить инструкцию. После этого консоль вернется к изначальному состоянию.

>>>
>>> n = 100
>>> if n > 10:
...     print("n больше чем 10")
...
n больше чем 10
>>>

Все эти программы заканчиваются внезапно, не показывая ничего, если условие не истинно. Но в большинстве случаев пользователю нужно показать хотя бы что-нибудь. Для этого используется оператор-выражение if-else.

Оператор if-else

Оператор if-else исполняет одну порцию инструкций, если условие истинно и другое — если нет. Таким образом этот оператор предлагает два направления действий. Синтаксис оператора if-else следующий:

if  condition:
    # блок if
    statement 1
    statement 2
    and so on
else:
    # блок else
    statement 3
    statement 4
    and so on:

Как это работает:

Когда оператор if-else исполняется, условие проверяется, и если оно возвращает True, когда инструкции в блоке if исполняются. Но если возвращается False, тогда исполняются инструкции из блока else.

Пример 1: программа для расчета площади и длины окружности круга.

radius = int(input("Введите радиус: "))

if radius >= 0:
    print("Длина окружности = ",  2  *  3.14  *  radius)
    print("Площадь = ", 3.14 * radius ** 2)
else:
    print("Пожалуйста, введите положительное число")

Первый вывод:

Введите радиус: 4
Длина окружности = 25.12
Площадь = 50.24

Второй вывод:

Введите радиус: -12
Пожалуйста, введите положительное число

Теперь программа показывает корректный ответ пользователю, даже если условие if не является истинным. Это и требуется.

В инструкциях if-else нужно следить за тем, чтобы условия if и else находились на одном уровне. В противном случае программа вернет синтаксическую ошибку. Например:

radius = int(input("Введите радиус: "))

if radius >= 0:
    print("Длина окружности = ",  2  *  3.14  *  radius)
    print("Площадь = ", 3.14 * radius ** 2)

    else:
        print("Пожалуйста, введите положительное число")

Если попробовать запустить эту программу, то появится следующая ошибка:

$ python3 if_and_else_not_aligned.py
  File "if_and_else_not_aligned.py", line 6
    else:
       ^
SyntaxError: invalid syntax
$

Для исправления проблемы нужно вертикально выровнять if и else

Другой пример:

Пример 2: программа для проверки пароля, введенного пользователем.

password = input("Введите пароль: ")
if password == "sshh":
    print("Добро пожаловать")
else:
    print("Доступ запрещен")

Первый вывод:

Введите пароль: sshh
Добро пожаловать

Второй вывод:

Введите пароль: abc
Доступ запрещен

Вложенные операторы if и if-else

Использовать операторы if-else можно внутри других инструкций if или if-else. Это лучше объяснить на примерах:

Оператор if внутри другого if-оператора

Пример 1: программа, проверяющая, имеет ли студент право на кредит.

gre_score = int(input("Введите текущий лимит: "))
per_grad = int(input("Введите кредитный рейтинг: "))

if per_grad > 70:
    # внешний блок if
        if gre_score > 150:
            # внутренний блок if
	    print("Поздравляем, вам выдан кредит")
else:
    print("Извините, вы не имеете права на кредит")

Здесь оператор if используется внутри другого if-оператора. Внутренним называют вложенный оператором if. В этом случае внутренний оператор if относится к внешнему блоку if, а у внутреннего блока if есть только одна инструкция, которая выводит “Поздравляем, вам выдан кредит”.

Как это работает:

Сначала оценивается внешнее условие if, то есть per_grad > 70. Если оно возвращает True, тогда управление программой происходит внутри внешнего блока if. Там же проверяется условие gre_score > 150. Если оно возвращает True, тогда в консоль выводится "Congratulations you are eligible for loan". Если False, тогда программа выходит из инструкции if-else, чтобы исполнить следующие операции. Ничего при этом не выводится в консоль.

При этом если внешнее условие возвращает False, тогда выполнение инструкций внутри блока if пропускается, и контроль переходит к блоку else (9 строчка).

Первый вывод:

Введите текущий лимит: 160
Введите кредитный рейтинг: 75
Поздравляем, вам выдан кредит

Второй вывод:

Введите текущий лимит: 160
Введите кредитный рейтинг: 60
Извините, вы не имеете права на кредит

У этой программы есть одна маленькая проблема. Запустите ее заново и введите gre_score меньше чем 150, а per_grade — больше 70:

Вывод:

Введите текущий лимит: 140
Введите кредитный рейтинг: 80

Программа не выводит ничего. Причина в том, что у вложенного оператора if нет условия else. Добавим его в следующем примере.

Пример 2: инструкция if-else внутри другого оператора if.

gre_score = int(input("Введите текущий лимит: "))
per_grad = int(input("Введите кредитный рейтинг: "))

if per_grad > 70:
    if gre_score > 150:
        print("Поздравляем, вам выдан кредит")
    else:
        print("У вас низкий кредитный лимит")
else:
    print("Извините, вы не имеете права на кредит")

Вывод:

Введите текущий лимит: 140
Введите кредитный рейтинг: 80
У вас низкий кредитный лимит

Как это работает:

Эта программа работает та же, как и предыдущая. Единственное отличие — у вложенного оператора if теперь есть инструкция else. Теперь если ввести балл GRE меньше, чем 150, программа выведет: “У вас низкий кредитный лимит”

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

Оператор if-else внутри условия else

Пример 3: программа для определения оценки студента на основе введенных баллов.

score = int(input("Введите вашу оценку: "))

if score >= 90:
    print("Отлично! Ваша оценка А")
else:
    if score >= 80:
	print("Здорово! Ваша оценка - B")
    else:
	if score >= 70:
	    print("Хорошо! Ваша оценка - C")
	else:
	    if score >= 60:
		print("Ваша оценка - D. Стоит повторить материал.")
	    else:
		print("Вы не сдали экзамен")

Первый вывод:

Введите вашу оценку: 92
Отлично! Ваша оценка А

Второй вывод:

Введите вашу оценку: 72
Хорошо! Ваша оценка - C

Третий вывод:

Введите вашу оценку: 56
Вы не сдали экзамен

Как это работает:

Когда управление программой переходит к оператору if-else, проверяется условие на строке 3 (score >= 90). Если оно возвращает True, в консоль выводится “Отлично! Ваша оценка А”. Если значение неверное, управление переходит к условию else на 5 строке. Теперь проверяется условие score >= 80 (6 строка). Если оно верное, тогда в консоли выводится “Здорово! Ваша оценка — B”.

В противном случае управление программой переходит к условию else на 8 строке. И здесь снова имеется вложенный оператор if-else. Проверяется условие (score >= 70). Если оно истинно, тогда в консоль выводится “Хорошо! Ваша оценка — C”. В противном случае управление переходит к блоку else на 11 строке. В конце концов, проверяется условие (score >= 60). Если оно возвращает True, тогда в консоль выводится “Ваша оценка — D. Стоит повторить материал.” Если же False, тогда в консоли будет “Вы не сдали экзамен”. На этом этапе управление переходит к следующим инструкциям, написанным после внешнего if-else.

Хотя вложенные операторы if-else позволяют проверять несколько условий, их довольно сложно читать и писать. Эти же программы можно сделать более читабельными и простыми с помощью if-elif-else.

Оператор if-elif-else

Оператор if-elif-else — это альтернативное представление оператора if-else, которое позволяет проверять несколько условий, вместо того чтобы писать вложенные if-else. Синтаксис этого оператора следующий:

if condition_1:
    # блок if
    statement
    statement
    more statement
elif condition_2:
    # первый блок elif
    statement
    statement
    more statement
elif condition_3:
    # второй блок elif
    statement
    statement
    more statement

...

else
    statement
    statement
    more statement

Примечание: … означает, что можно писать сколько угодно условий eilf.

Как это работает:

Когда исполняется инструкция if-elif-else, в первую очередь проверяется condition_1. Если условие истинно, тогда исполняется блок инструкций if. Следующие условия и инструкции пропускаются, и управление переходит к операторам вне if-elif-else.

Если condition_1 оказывается ложным, тогда управление переходит к следующему условию elif, и проверяется condition_2. Если оно истинно, тогда исполняются инструкции внутри первого блока elif. Последующие инструкции внутри этого блока пропускаются.

Этот процесс повторяется, пока не находится условие elif, которое оказывается истинным. Если такого нет, тогда исполняется блок else в самом конце.

Перепишем программу с помощью if-elif-else.

score = int(input("Введите вашу оценку: "))

if score >= 90:
    print("Отлично! Ваша оценка А")
elif score >= 80:
    print("Здорово! Ваша оценка - B")
elif score >= 70:
    print("Хорошо! Ваша оценка - C")
elif score >= 60:
    print("Ваша оценка - D. Стоит повторить материал.")
else:
    print("Вы не сдали экзамен")

Первый вывод:

Введите вашу оценку: 78
Хорошо! Ваша оценка - C

Второй вывод:

Введите вашу оценку: 91
Отлично! Ваша оценка А

Третий вывод:

Введите вашу оценку: 55
Вы не сдали экзамен

Такую программу намного легче читать, чем в случае с вложенными if-else.

В этой статье мы изучим условные инструкции if, if...else, switch и тернарный оператор JavaScript, который очень часто используется в выражениях.

Условные инструкции и тернарный оператор

Условные инструкции – это инструкции языка JavaScript (ECMAScript), которые выполняют определенные действия в зависимости от значения некоторого условия.

Виды условных инструкций в JavaScript:

• if (с одной ветвью);
• if...else (с двумя ветвями);
• else if... (с несколькими ветвями);
• инструкция выбора switch.

Кроме условных инструкций в JavaScript имеется ещё тернарный оператор ?:.

Инструкция if

Синтаксис:

// condition – это условие
if (condition) {
  // блок кода, который выполняется один раз, если condition истинно
}

Инструкция if начинается с ключевого слова if, затем после пробела идут круглые скобки, в которых находится условие и далее блок инструкций в фигурных скобках. При этом блок кода выполняется только в том случае, если условие, заданное в круглых скобках () истинно.

В качестве условия можно указывать любое выражение. Если выражение приводится к истине (то есть, если Boolean(condition) === true), то блок код выполняется. В противном случае нет.

Например:

if (true) {
  console.log('Привет, мир!');
}

В этом примере условие правдиво, а значит, что блок кода будет выполнен, и мы в консоли увидим сообщение «Привет, мир!». Этот код приведен в качестве примера, так как в таком виде он не имеет никакого смысла.

Если блок кода состоит из одной инструкции, то фигурные скобки можно опустить:

if (true) console.log('Привет, мир!');

Но фигурные скобки лучше указывать, так как это улучшает читаемость кода.

Например, увеличим значение переменной num на 5, если её значение больше 4:

let num = 8;
if (num > 4) {
  num += 5;
}
console.log(num); // 13;

В этом примере условие приводится к true. А так как условие истинно, то выполняем то, что находится в блоке. В результате в консоль будет выведено значение 13.

Пример if, в условии которого используется оператор «НЕ»:

const article = {
  date: '18.05.2022'
}
if (!article.title) {
  console.log('Не указан заголовок!');
}

Здесь имеется объект article, содержащий одно свойство date. С помощью if мы выводем сообщение в консоль, если в объекте article нет свойства title или оно имеется, но его значение ложно.

Условие !article.title при приведении к булевому значению даст нам true. Так как свойства title нет в объекте article, то article.title вернёт undefined. А !undefined – это true.

Как только что выяснили условие правдиво, а следовательно, блок кода будет выполнен и мы в консоли увидим сообщение.

Инструкция if…else

Инструкция if…else состоит из 2 блоков кода. Если условие истинно, то выполняется первый блок кода, в противном случае – второй:

Синтаксис:

// condition – это условие
if (condition) {
  // блок кода, который выполняется, если условие истинно
} else {
  // блок кода, который выполняется, если условие ложно
}

В if...else всегда выполняется один из блоков. То есть в этой инструкции одновременно два блока выполнится не могут. При этом этот блок выполняется один раз. Если условие правдиво, то – первый блок, иначе – второй. После того как один из блоков выполнится интерпретатор JavaScript перейдёт к следующим за ним инструкциям.

Например, выведем в консоль сообщение о том, является ли число четным или нет:

const num = 5;
if (num % 2) {
  console.log('Число нечётное!');
} else {
  console.log('Число чётное!');
}

Если условие num % 2 правдиво, а в данном случае это так, то выполнится первый блок кода, который выведет в консоль «Число нечётное!».

Если значение переменной поменять на 4, то условие будет уже ложным и выполнится второй блок кода. В результате, в консоли мы увидим сообщение «Число чётное!».

Несколько условий else if

Если нужно проверить несколько вариантов условий, то можно использовать else if:

if (condition1) {
  // блок кода, который выполняется, если условие condition1 истинно
} else if (condition2) {
  // блок кода, который выполняется, если условие condition2 истинно
} else if (condition3) {
  // блок кода, который выполняется, если условие condition3 истинно
} else {
  // блок кода, который выполняется, если предыдущие условия ложны
}

Здесь всё как обычно:

• Если condition1 правдиво, то выполнится первый блок кода. Остальные условия и блоки кода не будут даже просматриваться. На этом выполнение if закончится.
• Если же первое условие ложно, то мы переходим к condition2. Если condition2 истинно, то выполнится второй блок кода и на этом выполнение инструкции if закончится.
• Если предыдущие условия ложны, то переходим к рассмотрению условия condition3 и так далее.
• Если все условия ложны, то выполняем последний блок кода, который указан после else без дополнительных условий.

Используя else if вы можете комбинировать много разных условий и строить длинные цепочки.

Пример, в котором выведем в консоль разные тексты, в зависимости от значения переменной val:

const val = 7;
if (val < 5) {
  console.log('Less than 5');
} else if (val < 10) {
  console.log('Less than 10');
} else {
  console.log('Greater than or equal to 10');
}

Пример, в котором показано как можно переписать эту инструкцию используя только if:

const val = 7;
if (val < 5) {
  console.log('Less than 5');
}
if (val > 5 && val < 10) {
  console.log('Less than 10');
}
if (val >= 10) {
  console.log('Greater than or equal to 10');
}

Кроме этого блок else не является обязательным:

const lang = 'ru';
if (lang === 'ru') {
  console.log('Это русский текст');
} else if (lang === 'en') {
  console.log('Это английский текст');
} else if (lang !== 'ru' || lang !== 'en') {
  console.log('Это не русский и не английский текст');
}

Очень часто if применяются внутри функций:

function greeting(time) {
  if (time > 18) {
    return 'Добрый вечер!';
  } else if (time > 11) {
    return 'Добрый день!';
  } else if (time > 4) {
    return 'Доброе утро!';
  }
  return 'Доброй ночи!';
}

greeting(10); // "Доброе утро!"

Эта функция будет возвращать разные приветствия в зависимости от времени суток. На вход она принимает один аргумент, который мы получаем с помощью параметра time. Далее в зависимости от значения параметра возвращаем ту или иную строку.

Условный тернарный оператор ?:

Тернарный оператор – это оператор JavaScript, который возвращает результат первого или второго выражения в зависимости от истинности условия.

Синтаксис:

// condition – условие
// expression1 – первое выражение
// expression2 – второе выражение
condition ? expression1 : expression2

Тернарный оператор является выражением, то есть он возвращает значение. У него три операнда: условие condition, первое выражения expression1 и второе выражение expression2. Для разделения операндов используются знаки ? и :.

Условие – это тоже выражение. Если условие истинно, то тернарный оператор возвращает результат первого выражения expression1. В противном случае, то есть, если условие ложно, то результат второго выражения expression2.

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

const value = 10;
const result = value > 10 ? 'Число больше 10!' : 'Число равно или меньше 10!';
console.log(result); // "Число равно или меньше 10!"

В этом примере мы объявили переменную value и присвоили ей число 10. Так как условие у нас ложно (то есть 10 не больше 10), то тернарный оператор вернёт нам результат вычисления второго выражения, то есть строку «Число равно или меньше 10!». После этого данная строка будет присвоена переменной result, которую мы создали с помощью ключевого слова const. После этого значение этой переменной будет выведено в консоль.

В JavaScript допустимы множественные тернарные операторы (?:):

const dayNumber = new Date().getDay();

day =
  (dayNumber === 0) ? 'Воскресенье' :
    (dayNumber === 1) ? 'Понедельник' :
      (dayNumber === 2) ? 'Вторник' :
        (dayNumber === 3) ? 'Среда' :
          (dayNumber === 4) ? 'Четверг' :
            (dayNumber === 5) ? 'Пятница' :
              (dayNumber === 6) ? 'Суббота' : 'Неизвестный день недели';

console.log(`Сегодня ${day.toLowerCase()}.`);

Вышеприведённый пример, но с использованием множественной записи инструкции if...else:

const dayNumber = new Date().getDay();

if (dayNumber === 0) {
  day = 'Воскресенье';
} else if (dayNumber === 1) {
  day = 'Понедельник';
} else if (dayNumber === 2) {
  day = 'Вторник';
} else if (dayNumber === 3) {
  day = 'Среда';
} else if (dayNumber === 4) {
  day = 'Четверг';
} else if (dayNumber === 5) {
  day = 'Пятница';
} else if (dayNumber === 6) {
  day = 'Суббота';
} else {
  day = 'Неизвестный день недели';
}

console.log(`Сегодня ${day.toLowerCase()}.`);

Инструкция switch

Инструкция switch предназначен для выполнения одного варианта инструкций из нескольких в зависимости от значения выражения. Выбор того или иного варианта определяется посредством строгого равенства результата выражения значению случая (case).

Синтаксис инструкции switch:

// expression – выражение
switch (expression) {
  case valueA:
    // действия, которые будут выполнены, если expression === valueA
    break; // прерываем дальнейшее выполнение switch
  case valueB:
    // действия, которые будут выполнены, если expression === valueB
    break; // прерываем дальнейшее выполнение switch
  // ...
  case valueN:
  // действия, которые будут выполнены, если expression === valueN
    break; // прерываем дальнейшее выполнение switch
  default:
    // действия по умолчанию, если expression не равно valueA, valueB, ..., valueN
}

Ключевое слово default является необязательным. Оно используется, когда необходимо задать инструкции, которые нужно выполнить, если результат выражения будет не равен ни одному значению варианта (case).

Инструкция break является необязательной. Она предназначена для прерывания выполнения инструкции switch и передачи управлению инструкции, идущей после него.

Например, выведем сообщение в консоль браузера о количестве конфет:

const countCandyBoys = 1;
const countCandyGirls = 2;
let message;
switch (countCandyBoys + countCandyGirls) {
  case 1:
    message = 'Одна конфета';
    break;
  case 2:
  case 3:
    message = 'Две или три конфеты';
    break;
  case 4:
    message = 'Четыре конфеты';
    break;
  default:
    message = 'Не одна, не две, не три и не четыре конфеты';
}
// выведем сообщение в консоль
console.log(message);

В вышеприведенном примере вычисленное выражение равно 3. Следовательно, будет выполнены инструкции message = 'Две или три конфеты' и break. Инструкция break прервёт дальнейшее выполнение инструкции switch и передаст управление инструкции, идущей после него, т.е. console.log(message). Она выведет в консоль сообщение «Две или три конфеты».

Например, выведем выведем в консоль текущий день недели:

let day = '';

switch (new Date().getDay()) {
  case 0:
    day = 'Воскресенье';
    break;
  case 1:
    day = 'Понедельник';
    break;
  case 2:
    day = 'Вторник';
    break;
  case 3:
    day = 'Среда';
    break;
  case 4:
    day = 'Четверг';
    break;
  case 5:
    day = 'Пятница';
    break;
  case 6:
    day = 'Суббота';
    break;
  default:
    day = 'Неизвестный день недели';
}

console.log(`Сегодня ${day.toLowerCase()}.`);

Пример, в котором не используется инструкция break:

const result = 'success';

switch (result) {
  case 'success':
    console.log('Успех!');
  case 'invalidCaptcha':
    console.log('Неверная капча!');
  default:
    console.log('Ошибка!');
}

В этом примере выражение инструкции switch равно success. Следовательно, будет выполнена инструкция console.log('Успех!'), которая выведет сообщение «Успех!» в консоль. Но так как после неё нет инструкции break, то выполнение скрипта будет продолжено в следующем варианте. Таким образом, инструкции будут выполняться до тех пока пока на пути не встретиться break или не будет достигнут конец инструкции switch. В результате выполнения этого примера в консоль будут выведены 3 сообщения: «Успех!», «Неверная капча!» и «Ошибка!».

В некоторых случаях может требоваться именно такое поведение, но не в этом. Здесь просто допущена ошибка.

Исправленный вариант примера:

const result = 'success';

switch (result) {
  case 'success':
    console.log('Успех!');
    break;
  case 'invalidCaptcha':
    console.log('Неверная капча!');
    break;
  default:
    console.log('Ошибка!');
}

В этой статье вы познакомитесь с условным операторам if…else, который позволяет принимать решения для организации ветвлений в JavaScript. 

В программировании часто возникает ситуация, когда необходимо выбрать, какой блок кода выполнять, на основе каких-то данных.

Например, в программе для учителя может быть 4 возможных блока кода, которые соответствуют выставлению оценок 5, 4, 3 и 2. Чтобы принять решение, какой блок выбрать, то есть какую оценку поставить, программе нужны данные: например, процент выполнения теста. 

Для принятия решений в программировании используют операторы сравнения и логические операторы. А для организации условных ветвлений, то есть выбора определенного блока кода, — условный оператор if…else. 

В JavaScript есть три формы оператора if…else:

• Оператор if.
• Оператор if…else.
• Оператор if…else if…else.

Оператор if в JavaScript

Давайте сначала договоримся, что инструкции — это команда или набор команд. То есть инструкции — просто кусок кода.  

Cинтаксис

if (условие) {
    инструкции;
}

Как это работает

1. Оператор if оценивает условие внутри круглых скобок ().
2. Если условие — true, выполняются инструкции в теле if. 
3. Если условие — false, инструкции в теле if игнорируются.

Примечание. Тело оператора if — код внутри фигурных скобок {} после if.

Пример

// проверяем, положительное ли число введено

const number = prompt("Введите число ");

// условие: число больше нуля?
if (number > 0) {
 // инструкция в теле оператора if
  console.log("Число положительное.");
}

// инструкция после if
console.log("Условные конструкции — это несложно.");

Предположим, пользователь ввел 2. В этом случае условие number > 0 равно true, потому что 2 > 0. Значит, код внутри тела if выполняется (см. рисунок выше).

Вывод 1

Введите число: 2
Число положительное.
Условные конструкции — это несложно.

Теперь предположим, пользователь ввел -1. В этом случае условие number > 0 равно false. Следовательно, тело оператора if пропускается, выполняется код после оператора (см. рисунок выше).

Вывод 2

Введите число: -1
Условные конструкции — это несложно.

Поскольку инструкция console.log("Условные конструкции — это несложно."); находится вне тела оператора if, она выполняется всегда, вне зависимости от условия if. 

Оператор if…else в JavaScript

У оператора if есть необязательный пункт — else. 

Синтаксис

if (условие) {
    // инструкции1 в теле if
else {
   // инструкции в теле else
}

Как это работает

1. Оператор if…else оценивает условие внутри скобок.

2. Если условие — true,
    • выполняются инструкции1 в теле if; 
   • инструкции в теле else игнорируются.

3. Если условие — false,
    • инструкции в теле if игнорируются;
    • выполняются инструкции2 в теле else. 

Пример

// определяет, какое введёно число: 
// положительное, отрицательное или ноль

const number = prompt("Введите число: ");

// проверяем, положительное число или нет
if (number > 0) {
  // инструкция в теле if 
  console.log("Это положительное число.");
}
// в противном случае — число отрицательно или ноль
else {
  // инструкция в теле else
  console.log("Это отрицательное число или ноль.");
}

// инструкция после конструкции if...else
console.log("Конструкция if...else — это несложно.");

Вывод 1

Введите число: 2
Это положительное число.
Конструкция if...else — это несложно. 

Предположим, пользователь ввел 2. В этом случае условие (number > 0) — true. Значит, инструкции в теле if выполнятся, а инструкции в теле else — проигнорируются.

Вывод 2

Введите число: -1
Это отрицательное число или ноль.
Конструкция if...else — это несложно.

Теперь предположим, что пользователь ввел 2. В этом случае условие (number > 0) — false. Значит, инструкции в теле if игнорируются, а инструкции в теле else — выполняются.

Оператор if…else if в JavaScript

Оператор if…else позволяет выбирать один из двух альтернативных блоков кода. Если нужно сделать выбор между тремя альтернативами, используют if…else if.

Синтаксис

if (условие1) {
    // инструкции1 в теле if
else if (условие2) {
   // инструкции2 в теле else if
} else {
   // инструкции3 в теле else
}

Как это работает

1. Если условие1 — true, выполняются инструкции1 в теле if.

2. Если условие1 — false, оценивается условие2.
    • Если условие2 — true, выполняются инструкции2 в теле else if.
    • Если условие2 — false, выполняются инструкции3 в теле else.

Пример

// определяет, какое число введено:
// положительное, отрицательное или ноль

const number = prompt("Введите число: ");

// проверяем, положительное число или нет
if (number > 0) {
    // инструкция1 в теле if
    console.log("Это положительное число.");
}
// раз число не положительное, проверяем, вдруг оно равно нулю
else if (number == 0) {
   // инструкция2 в теле else if
  console.log("Это ноль.");
}
// раз число не положительное или не ноль, значит, это отрицательное число
else {
    // инструкция3 в теле else
    console.log("Это отрицательное число.");
}

// инструкция после конструкции if...else if...else
console.log("Конструкция if...else if...else — это несложно.");

Вывод 

Введите число: 0
Это ноль.
Конструкция if...else if...else. — это несложно.

Предположим, пользователь ввел 0. Тогда условие1 (number > 0) — false. Тогда проверяется условие2 (number == 0). Условие2 — true, поэтому выполняется инструкция2.

Вложенные операторы if…else 

Один оператор if…else можно использовать внутри другого оператора if…else — и так сколько угодно раз. Такая конструкция называется вложенным оператором if…else.

Пример

// определяет, какое число введено:
// положительное, отрицательное или ноль

const number = prompt("Введите число: ");

if (number >= 0) {
    if (number == 0) {
        console.log("Это ноль.");
    } else {
        console.log("Это положительное число.");
    }
} else {
    console.log("Это отрицательное число.");
}

Вывод

Введите число: 5
Это положительное число.

Предположим, пользователь ввел 5. В этом случае условие (number >= 0) — true, поэтому управление программой передается во внешний оператор if. Далее оценивается услвоие внутреннего оператора if (number == 0). Поскольку оно false, выполняется инструкция из тела else внутреннего оператора if.

Совет. Как вы видите, вложенные if…else усложняют логику программу. Поэтому стоит избегать вложенных конструкций, если это возможно.

Иногда {} можно не использовать

Если в теле if…else находится только одна инструкция, фигурные скобки можно не писать.

Два кода ниже работают одинаково:

const number = 2;

if (number > 0) {
    console.log("Это положительное число.");
} else {
   console.log("Это отрицательное число или ноль.");
}

То же самое, но без скобок

const number = 2;

if (number > 0)
    console.log("Это положительное число.");
else
   console.log("Это отрицательное число или ноль.");

Условные конструкции

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

Условные конструкции позволяют выполнить те или иные действия в зависимости от определенных условий.

Конструкция if..else

Конструкция if..else проверяет некоторое условие и если это условие верно, то выполняет некоторые действия.
Простейшая форма конструкции if..else:

if(условие){
	
	некоторые действия
}

После ключевого слова if в круглых скобках идет условие, а после условия — блок кода с некоторыми действиями.
Если это условие истинно, то затем выполняются действия, которые помещены в блоке кода

Например:

const income = 100;
if(income > 50) {
	
	console.log("доход больше 50");
}

Здесь в конструкции if используется следующее условие: income > 50. Если это условие возвращает true, то есть если константа income имеет значение больше 50,
то браузер отображает сообщение. Если же значение income меньше 50, то никакого сообщения не отображается.

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

const income = 100;
if(income > 50) console.log("доход больше 50");

или перенести действия на следующую строку

const income = 100;
if(income > 50) 
	console.log("доход больше 50");

Причем условия могут быть сложными:

const income = 100;
const age = 19;
if(income > 50 && age > 18){

	console.log("доход больше 50");
	console.log("возраст больше 18");
}

Проверка наличия значения

Конструкция if позволяет проверить наличие значения. Например:

let myVar = 89;
if(myVar){
	
	console.log(`Переменная myVar имеет значение: ${myVar}`);
}

Если переменная myVar имеет значение, как в данном случае, то в условной конструкции она возвратит значение true.

Противоположный вариант:

let myVar;
if(myVar){
    console.log(`Переменная myVar имеет значение: ${myVar}`);
}

Здесь переменная myVar не имеет значения. (В реальности она равна undefined) Поэтому условие в конструкии if возвратит
false, и действия в блоке конструкции if не будут выполняться.

Но нередко для проверки значения переменной используют альтернативный вариант — проверяют на значение undefined и null:

if (myVar !== undefined && myVar !== null) {
	console.log(`Переменная myVar имеет значение: ${myVar}`);
}

Выражение else

Выше мы рассмотрели, как определить действия, которые выполняются, если условие после if истинно. Но что, если мы хотим также выполнять
еще один набор инструкций, если условие ложно? В этом случае можно использовать блок else.
Данный блок содержит инструкции, которые выполняются, если условие после if ложно, то есть равно false:

if(условие){
	действия, если условие истинно
}
else{
	действия, если условие ложно
}

То есть если условие после if истинно, выполняется блок if. Если условие ложно, выполняется блок else. Например:

const income = 45;
if(income > 50){

	console.log("Доход больше 50");
}
else{
	console.log("Доход меньше или равен 50");
}

Здесь константа income равна 45, поэтому условие после оператора if возвратит false,
и управление перейдет к блоку else.

Также если блок else содержит одну инструкцию, то можно сократить конструкцию:

const income = 45;
if(income > 50) console.log("Доход больше 50");
else console.log("Доход меньше или равен 50");

Альтернативные условия и else if

С помощью конструкции else if мы можем добавить альтернативное условие к блоку if. Например, выше в условие значение income может быть больше определенном значению может быть меньше, а может быть равно ему. Отразим это в коде:

const income = 50;
if(income > 50) {
	console.log("Доход больше 50");
}
else if(income === 50){
	console.log("Доход равен 50");
}
else{
	console.log("Доход меньше 50");
}

В данном случае выполнится блок else if. При необходимости мы можем использовать несколько блоков else if с разными условиями:

const income = 500;
if(income < 200){

	console.log("Доход ниже среднего");
}
else if(income>=200 && income<300){
	
	console.log("Чуть ниже среднего");
}
else if(income>=300 && income<400){
	
	console.log("Средний доход");
}
else{
	console.log("Доход выше среднего");
}

При этом блок else применять необязательно:

const income = 500;
if(income < 200){

	console.log("Доход ниже среднего");
}
else if(income>=200 && income<300){
	
	console.log("Чуть ниже среднего");
}
else if(income>=300 && income<400){
	
	console.log("Средний доход");
}

True или false

В javascript любая переменная может применяться в условных выражениях, но не любая переменная представляет тип boolean. И в этой связи
возникает вопрос, что возвратит та или иная переменная — true или false? Много зависит от типа данных, который представляет переменная:

• undefined

  Возвращает false

• null

  Возвращает false

• Boolean

  Если константа/переменная равна false, то возвращается false.
  Соответствено если константа/переменная равна true, то возвращается true

• Number

  Возвращает false, если число равно 0 или NaN (Not a Number), в остальных случаях возвращается true

  Например, следующая переменная будет возращать false:

  let x = NaN;
  if(x){	// false
  		
  }
  

• String

  Возвращает false, если константа/переменная равна пустой строке, то есть ее длина равна 0, в остальных случаях возвращается true

  const emptyText = "";	// false - так как пустая строка
  const someText = "javascript";	// true - строка не пустая
  

• Object

  Всегда возвращает true

  const user = {name:"Tom"};	// true
  const car = {};	// true
  

Конструкция switch..case

Конструкция switch..case является альтернативой использованию конструкции if..else и также позволяет обработать сразу
несколько условий:

const income = 200;
switch(income){

	case 100 : 
		console.log("Доход равен 100");
		break;
	case 200 : 
		console.log("Доход равен 200");
		break;
	case 500 : 
		console.log("Доход равен 500");
		break;
}

После ключевого слова switch в скобках идет сравниваемое выражение. Значение этого выражения последовательно сравнивается со значениями, помещенными после оператора сase. И если совпадение будет найдено, то будет выполняться определенный блок сase.

В конце каждого блока сase ставится оператор break, чтобы избежать выполнения других блоков. В данном случае константа income равна 200, поэтому будет выполняться блок

case 200 : 
	console.log("Доход равен 200");
	break;

Оператор break

Оператор break служит для того, чтобы избежать выполнения других условий. Например, мы могли бы написать:

let income = 200;
switch(income){
 
    case 100 : 
        console.log("Доход равен 100");
		income +=100;
		break;
    case 200 : 
        console.log("Доход равен 200");
		income +=100;
		break;
    case 500 : 
        console.log("Доход равен 500");
		income +=100;
		// break;	// здесь смысла в break нет, так как последний блок
}

Здесь опять income равно 200 и опять будет выполняться блок

case 200 : 
    console.log("Доход равен 200");
	income +=100;
	break;

Благодаря оператору break после выполнения блока произойдет выход из конструкции switch, и никакие другие блоки case не будут выполняться.

Но теперь уберем оператор break:

let income = 200;
switch(income){
 
    case 100 : 
        console.log("Доход равен 100");
		income +=100;
    case 200 : 
		console.log("Доход равен 200");
		income +=100;
    case 500 :
		console.log("Доход равен 500");
		income +=100;
}
console.log("Финальный доход равен", income);

Результат выполнения:

Доход равен 200
Доход равен 500
Финальный доход равен 400

Здесь изначально переменная income опять равна 200, соответственно будет выполняться блок

case 200 : 
    console.log("Доход равен 200");
	income +=100;

Значение income увеличивается на 100, однако в конце блока нет оператора break, поэтому управление перейдет к проверке условия в следующий блок:

case 500 : 
    console.log("Доход равен 500");
	income +=100;

И не важно, что income не равно 500 (а лишь 300 на данный момент), этот блок также будет выполняться.

Объединение условий

Однако при необходимости можно сразу обработать несколько условий:

const income = 200;
switch(income){

	case 100 :
	case 200 :
		console.log("Доход равен 100 или 200");
		break;
	case 500 : 
		console.log("Доход равен 500");
		break;
}

В данном случае для условия, когда income равно 100 и 200, выполняются одни и те же действия.

Условие по умолчанию — default

Если мы хотим также обработать ситуацию, когда совпадения не будет найдено, то можно добавить необязательный блок default:

const income = 700;
switch(income){

	case 100 : 
		console.log("Доход равен 100");
		break;
	case 200 : 
		console.log("Доход равен 200");
		break;
	case 500 : 
		console.log("Доход равен 500");
		break;
	default: 
        console.log("Доход неизвестной величины");
        break;
}

Написав инструкцию
if, может понадобиться указать альтернативный
блок инструкций, который следует
выполнить в том случае, если условие не
выполняется. Для этого после блока if
необходимо поместить блок else.

if
( выражение )

{

//этот фрагмент
выполняется, если выражение истинно

}

else

{

//этот фрагмент
выполняется в противном случае

}

Использование
блока else с инструкцией if позволяет
программам принимать довольно сложные
решения, но пока выбор ограничен только
вариантами «да — нет» (в математике
– бинарным выбором). Однако в языке РНР
можно принимать сложные решения в
каскадной последовательности.

Блок elseif инструкции if

С помощью конструкции
if-elseif-else можно проверить несколько
условий перед тем, как выполнить фрагмент
программы.

if(выражение_1)

{

//этот фрагмент
выполняется, если выражение истинно

}

elseiff (выражение_2)

{

//этот фрагмент
выполняется, если выражение 1 ложно,

//а выражение_2
истинно

}

else

{

//этот фрагмент
выполняется во всех остальных случаях

}

Если первое
выражение не истинно, то первый блок
игнорируется. В блоке elseif вычисляется
второе выражение, и если оно истинно,
то выполняется соответствующий фрагмент
программы. В противном случае выполняется
блок инструкций else. Блоков elseif может
быть сколько угодно, а блок else может
отсутствовать, если в нем нет необходимости.

<?php

$mood = «sad»;

if ($mood == «happy»)

{

print «I’m so happy!»;

}

elseif( $mood == «sad»
)

{

print «Control your
self!»;

}

else

{

print
«Just
$mood
…»;

}

?>

В переменной $mood
записана строка «sad». Она не совпадает
со строкой «happy», поэтому первый
блок игнорируется. В блоке elseif переменная
$mood сравнивается со строкой «sad» и,
поскольку это выражение истинно,
выполняется блок elseif.

Инструкция switch

Инструкция switch —
это еще один способ изменить поток
выполнения программы в зависимости от
значения некоторого выражения. Между
инструкциями switch и if есть существенная
разница. С помощью инструкции if и блока
elseif вы можете для принятия решения
вычислить несколько выражений, а
инструкция switch вычисляет только одно
выражение, но в зависимости от его
значения выполняет один из нескольких
блоков программы. Выражение в инструкции
if может быть только истинным или ложным,
а выражение инструкции switch может
принимать много значений, но они должны
быть простого типа, т.е. целое, или строка,
или булево значение.

switch (выражение)

{

case значение_1:

//выполняется, если
выражение равно значение_1

break;

case значение_2:

// выполняется,
если выражение равно значение_2

break;

default:

//выполняется, если
выражение не приняло

//ни одного из
перечисленных значений

}

Выражение в
инструкции switch чаще всего бывает простой
переменной. В каждом из блоков case значение
переменной сравнивается с указанным
значением, и если они совпадают, то
выполняется соответствующий блок.
Инструкция break прерывает выполнение
всей конструкции switch. Если слово break
опустить, то будет проверяться следующий
блок case. Если ни в одном из блоков case
значение переменной не совпало с
указанным значением, то выполняется
блок default.

<?php

$mood = «sad»;

switch ( $mood )

{

case «happy» :

print «I’m happy!»;

break;

case
«sad»:

print «Control your
self!»;

break;

default:

print «Just $mood «;

}

?>

Как и раньше, в
переменной $mood записана строка «sad».
Эта переменная используется в качестве
выражения в инструкции switch. В первом
блоке case проверяется совпадение этой
переменной со строкой «happy».
Совпадения нет, поэтому выполнение
программы переходит ко второму блоку
case. Здесь значение переменной $mood
совпадает со строкой «sad» и,
следовательно, выполняются соответствующие
инструкции. Заканчивается все инструкцией
break.

Соседние файлы в папке ПвИ

• #
• #