Условный оператор в c: Условные операторы в Си : использование if-else, switch

Содержание

Условный (тернарный) оператор — JavaScript

Условный (тернарный) оператор — единственный оператор в JavaScript, принимающий три операнда: условие, за которым следует знак вопроса (?), затем выражение, которое выполняется, если условие истинно, сопровождается двоеточием (:), и, наконец, выражение, которое выполняется, если условие ложно. Он часто используется в качестве укороченного варианта условного оператора if.

Оператор возвращает значение выражения1, если условие верно, и значение выражения2 в противном случае. Например, чтобы вывести сообщение, текст которого зависит от значения переменной isMember, можно использовать такое выражение:

"The fee is " + (isMember ? "$2.00" : "$10.00")

Также можно присваивать значения переменным на основе результатов работы тернарного оператора :

var elvisLives = Math.PI > 4 ? "Да" : "Нет";

Возможны множественные тернарные операции (обратите внимание: условный оператор ассоциативен справа):

var firstCheck = false,
    secondCheck = false,
    access = firstCheck ? "Доступ запрещён" : secondCheck ? "Доступ запрещён" : "Доступ разрешён";

console.log( access );

Тернарные операции можно использовать и сами по себе — для выполнения различных операций:

var stop = false, age = 16;

age > 18 ? location.assign("continue.html") : stop = true;

Также возможно выполнять несколько операций на каждое сравнение, разделив их запятыми:

var stop = false, age = 23;

age > 18 ? (
    alert("Хорошо, вы можете продолжить."),
    location.assign("continue.html")
) : (
    stop = true,
    alert("Простите, вы ещё так юны!")
);

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

var age = 16;

var url = age > 18 ? (
    alert("Хорошо, вы можете продолжить."),
    
    
    "continue.html" 
) : (
    alert("Вы слишком молоды!"),
    alert("Простите :-("),
    
    "stop.html" 
);

location.assign(url);

Вложенный условный оператор в C++. Урок 5.

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

Структура вложенного условного оператора

Почему мы называем вложенный условный оператор? Потому что мы взяли условный оператор и положили в него еще один. Поэтому и говорят. Вложенный условный оператор. Это как матрешка. Взяли матрешку и положили в нее еще одну. Взяли еще одну матрешку и положили еще глубже. И так далее.

Какая вложенность может быть?

Сколько угодно. Ходит такая легенда, что какие-то студенты, умудрились вложить 256 операторов. Но так делать не стоит. В промышленном программировании есть стандарт. Не более трех условных операторов. И если вы написали 3 и испытываете необходимость сделать четвертую вложенность. Остановитесь. Что-то вы делаете неправильно.

Сравнение двух путей

Посмотрите на изображение сверху и снизу. И подумайте, будут ли они тождественными (равными)? В принципе будут. С точки зрения реализации, они не совсем одинаковы. Но с точки зрения работы программы, они будут работать одинаково.

Давайте проверим так ли это. Посмотрите на изображение 1. Если a больше b и условие выполнилось, мы заходим внутрь нашей программы и проверяем следующее условие. Если c меньше d и условие выполнилось, мы заходим внутрь и выполняем тот набор действий, который нам необходим.

Давайте теперь проверим изображение 2. Если a больше b и c меньше d, только при выполнении обоих этих условиях, мы заходим внутрь этого условия и выполняем тот же самый набор действий.

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

Вложенный if

Плюсы:
Вложенный if позволяет проявлять определенную гибкость. Мы не проверяем сразу все условия. Мы проверили первое условие, если оно выполнилось, тогда мы переходим к проверке второго условия. А если не выполнилось, мы второе тогда даже проверять не будем.

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

Сложный условный оператор

Плюсы:
Код читается наглядно и он более краток.

Минусы:
Мы ограничиваем себя в действиях. Иногда, некоторые вещи при помощи подобного условия написать невозможно.

Решение задач

Подробный разбор задачи

По правилам этикета при приветствии «Доброе утро» говорят только с 6:00 до 10:59, «Добрый день» — с 11:00 до 17:59, «Добрый вечер» — с 18:00 и до 22:59.

Вам дан номер текущего часа h. Требуется вывести

  1. Good morning, если нужно сказать «Доброе утро»;
  2. Good day, если нужно сказать «Добрый день»;
  3. Good evening, если нужно сказать «Добрый вечер».

С клавиатуры вводится целое число h (8 Решение:

Урок назад мы бы решили нашу задачу вот таким способом:

Но мы можем пойти другим путем. Более изящным, если поставим себе задачу – уменьшить количество условий.

Как мы можем это сделать?

Мы же можем записать так?
if (t
    Тогда утро;
} else {
    А что сюда?
}

Вполне можем, так как знаем, что первое значение, которое нам могут задать – это 6. И любая цифра от 6 до 11 будет означать утро. А в противном случае…

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

Значит в else мы можем вписать два других наших условия. И выглядеть будет примерно так:

if (t
    cout
} else {
    if (t = 11;
        cout
    } else { // t >= 18;
        cout
    }
}

Почему это происходит? Мы с вами знаем, что не попали в первое условие, значит идем по программе дальше и записываем 2 других условия внутри выражения «иначе».

Високосный год

Дан номер года. Требуется определить количество дней в этом году, учитывая, что обычный год насчитывает 365 дней, а високосный –— 366 дней. Високосным считается год, делящийся на 4, но не делящийся на 100, либо делящиеся на 400 (например, годы 700, 1400 и 1800 не являются високосными, а 1600 и 2000 –— являются).

Формат входных данных
Вводится неотрицательное целое число y (0 31−1) — номер года.

Формат выходных данных
Выведите количество дней в данном году.
Примеры
входные данные
3
16
выходные данные
365
366

Видео по теме урока

Условный оператор Если в языке 1С 8.3, 8.2 (в примерах)

Условный оператор Если в языке 1С 8.3, 8.2 (в примерах)

Вступайте в мою группу помощник программиста.
В ней мы обсуждаем программирование в 1С.

2017-12-18T21:54:41+00:00Дата Если Массивы Математика Процедуры Строки Циклы
Диалоги ОписаниеТипов ОперационнаяСистема Приложение Соответствие
СписокЗначений Структура ТаблицаЗначений ФайловаяСистема Формат

ОбщиеОбъекты Запросы ПрикладныеОбъекты УниверсальныеФункции

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

Полный синтаксис (нажмите, чтобы раскрыть)

Условный оператор «Если»

Описание:

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

Синтаксис:

Если <Логическое выражение> Тогда
    // Операторы
[ИначеЕсли <Логическое выражение> Тогда]
    // Операторы
[Иначе]
    // Операторы
КонецЕсли;

Параметры:

ЕслиКлючевое слово, которое начинает структуру оператора условного выполнения.
<Логическое выражение>Логическое выражение.
ТогдаОператоры, следующие за Тогда выполняются, если результатом логического выражения является значение Истина.
// ОператорыИсполняемый оператор или последовательность таких операторов.
ИначеЕслиЛогическое выражение, следующее за ключевым словом ИначеЕсли, вычисляется только тогда, когда условия в Если и всех предшествующих ИначеЕсли оказались равны Ложь. Операторы, следующие за конструкцией ИначеЕсли — Тогда, выполняются, если результат логического выражения в данном ИначеЕсли равен Истина.
ИначеОператоры, следующие за ключевым словом Иначе, выполняются, если результаты логических выражений в конструкции Если и всех предшествующих конструкциях ИначеЕсли оказались равны Ложь.
КонецЕслиКлючевое слово, которое завершает структуру оператора условного выполнения.

  

Тернарный условный оператор

Описание:

Позволяет вычислить одно из двух заданных выражений в зависимости от результата вычисления логического выражения.

Синтаксис:

?(<Логическое выражение>, <Выражение 1>, <Выражение 2>)

Параметры:

<Логическое выражение>Логическое выражение, результат вычисления которого определяет одно из результирующих выражений, которые будут вычислены. Если результат его вычисления Истина, то будет вычисляться <Выражение 1>. Если результат Ложь – то <Выражение 2>.
<Выражение 1>Результирующее выражение, которое будет вычисляться, если результат логического выражения Истина.
<Выражение 2>Результирующее выражение, которое будет вычисляться, если результат логического выражения Ложь.

Возвращаемое значение:

Результат вычисления одного из результирующих выражений.

Оглавление (нажмите, чтобы раскрыть)

&НаКлиенте
Процедура ВыполнитьКод(Команда)
 
    /// Как составить оператор Если в 1с 8.3, 8.2
 
    Если 1 > 0 Тогда // Истина
        // блок операторов
        Сообщить("Компьютер выполнит все команды из этого блока.");
        Сообщить("Один больше нуля.");
    КонецЕсли;
 
    Если 1 < 0 Тогда // Ложь
        Сообщить("Один меньше нуля.");
    Иначе
        Сообщить("Сработает именно эта ветка условного оператора (#А).");
        Сообщить("Один больше нуля.");
    КонецЕсли;
 
    Если 1 < 0 Тогда // Ложь
        Сообщить("Один меньше нуля.");
    ИначеЕсли 1 = 0 Тогда // Ложь
        Сообщить("Один равен нулю.");
    Иначе
        Сообщить("Сработает именно эта ветка условного оператора (#Б).");
        Сообщить("Один больше нуля.");
    КонецЕсли;
 
    /// Как составить тернарный оператор ? в 1с 8.3, 8.2
 
    Текст = ?(1 > 2, "Один больше двух.",  "Один не больше двух.");
    Сообщить(Текст); // выведет "Один не больше двух."    
 
КонецПроцедуры
 
/// Скачать и выполнить эти примеры на компьютере

Скачать эти примеры в виде тестовой базы (как загрузить, как исследовать)

Условный оператор Если в языке 1С 8.3, 8.2 (в примерах)

Дата Если Массивы Математика Процедуры Строки Циклы
Диалоги ОписаниеТипов ОперационнаяСистема Приложение Соответствие
СписокЗначений Структура ТаблицаЗначений ФайловаяСистема Формат

ОбщиеОбъекты Запросы ПрикладныеОбъекты УниверсальныеФункции

С уважением, Владимир Милькин (преподаватель школы 1С программистов и разработчик обновлятора).

Как помочь сайту: расскажите (кнопки поделиться ниже) о нём своим друзьям и коллегам. Сделайте это один раз и вы внесете существенный вклад в развитие сайта. На сайте нет рекламы, но чем больше людей им пользуются, тем больше сил у меня для его поддержки.

Нажмите одну из кнопок, чтобы поделиться:

Инструкция if-elif-else, проверка истинности, трехместное выражение if/else

Условная инструкция if-elif-else (её ещё иногда называют оператором ветвления) — основной инструмент выбора в Python. Проще говоря, она выбирает, какое действие следует выполнить, в зависимости от значения переменных в момент проверки условия.

Синтаксис инструкции if

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

if test1:
    state1
elif test2:
    state2
else:
    state3

Простой пример (напечатает ‘true’, так как 1 — истина):

>>> if 1:
...     print('true')
... else:
...     print('false')
...
true

Чуть более сложный пример (его результат будет зависеть от того, что ввёл пользователь):

a = int(input())
if a < -5:
    print('Low')
elif -5 <= a <= 5:
    print('Mid')
else:
    print('High')

Конструкция с несколькими elif может также служить отличной заменой конструкции switch — case в других языках программирования.

Проверка истинности в Python

  • Любое число, не равное 0, или непустой объект — истина.
  • Числа, равные 0, пустые объекты и значение None — ложь
  • Операции сравнения применяются к структурам данных рекурсивно
  • Операции сравнения возвращают True или False
  • Логические операторы and и or возвращают истинный или ложный объект-операнд

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

X and Y

Истина, если оба значения X и Y истинны.

X or Y

Истина, если хотя бы одно из значений X или Y истинно.

not X

Истина, если X ложно.

Трехместное выражение if/else

Следующая инструкция:

if X:
    A = Y
else:
    A = Z

довольно короткая, но, тем не менее, занимает целых 4 строки. Специально для таких случаев и было придумано выражение if/else:

A = Y if X else Z

В данной инструкции интерпретатор выполнит выражение Y, если X истинно, в противном случае выполнится выражение Z.

>>> A = 't' if 'spam' else 'f'
>>> A
't'

2.2. Условный оператор (if)

2.2.1. Базовый синтаксис

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

Пример такой команды:

if a == 137:
    print("Угадал")

Здесь подразумевается, что есть переменная a, и команда тогда работает так:
если переменная a равна 137, то вывести на экран слово «Угадал».

Соответственно, общий вид команды следующий:

if условие:
    действия

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

В качестве действий можно указывать любые команды питона, которые вы знаете или еще узнаете:
ввод данных через input, присваивания, вывод данных, другие if’ы и что угодно еще.
(Подробные примеры будут ниже.)

Такую конструкцию вы просто пишете внутри основной программы, например:

a = int(input())
if a == 137:
    print("Угадал!")
print("Программа завершена")

Тут с клавиатуры вводится число a, проверяется, равно ли оно 137,
если равно, то выводится «Угадал», и независимо от значения a выводится
«Программа завершена». Обратите внимание, что print("Угадал!")
написано с отступом от левого края, поэтому эта команда будет выполняться,
только если a==137, а вот print("Программа завершена") написано без отступа,
поэтому это продолжение основной программы, а не часть if’а. Независимо от значения a
после проверки (и, если надо, выполнения) if’а программа продолжит выполняться дальше,
и выведет «Программа завершена».

(Конечно, напишите этот код и поэкспериментируйте с ним. Вообще, по всем примерам,
которые я привожу тут и буду приводить в других темах, пишите код и экспериментируйте.)

2.2.2. Условия

Сначала подробнее поговорим про то, что можно писать в условии.

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

  • == проверяет на равенство: запись if a == 137: обозначает «если переменная a
    равна 137». Обратите внимание, что тут два знака «равно», потому что одиночный знак «равно»
    имеет совсем другой смысл — это присваивание, и его нельзя (и не имеет смысла) использовать в if.
  • > — больше: if a > 137: обозначает «если переменная a больше 137».
  • < — меньше.
  • >= — больше или равно. Обратите внимание, что пишется так же, как читается: «больше или равно»,
    соответственно, >=, а вовсе не =>.
  • <= — меньше или равно. Аналогично, пишется именно <=, а не =<.
  • != — не равно.

По обе стороны от сравнения можно писать любые выражения. Можно просто переменные или числа,
а можно и любые сложные выражения, например, можно написать

if sqrt(a*b+10) >= abs(2*(3-c)) + 5:

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

Во-вторых, в if можно комбинировать несколько условий. Например, если вам надо проверить,
что a == 10 и b == 20. Это пишется так:

Такое условие будет выполняться, только если выполняются оба перечисленных простых условия,
т.е. только если и a == 10, и b == 20.

Есть следующие такие операторы («логические операторы»):

  • and — И. Проверка ... and ... срабатывает, только если оба условия, замененные на ..., верны.
  • or — ИЛИ. Проверка ... or ... срабатывает, если верно хотя бы одно из двух указанных условий (или оба одновременно).
  • not — НЕ. Оно применяется к одному условию (а не к двум, как выше) и инвертирует его значение: not ... срабатывает, только если
    условие, замененное на ..., неверно.

Например:

if a == 0 or not (b > 0 and c < 0):

сработает, если a равно нулю, или если не выполняется условие «одновременно b>0 и c<0».

Обратите внимание на скобки для указания порядка действий;
если бы вы написали без скобок if a == 0 or not b > 0 and c < 0:, то было бы непонятно,
к чему относится not и в каком порядке надо делать действия.

Более конкретный пример про скобки: сравните следующие два выражения:

if a == 0 and (b == 0 or c == 0):

if (a == 0 and b == 0) or c == 0:

Эти выражения имеют разный смысл; например, ситуация a==1, b==1, c==0 подходит под второе выражение,
но не под первое. Поймите, почему, и заодно подумайте, какие есть еще случаи,
в которых значения этих выражений отличатся.

Поэтому в любых сложных логических выражениях надо обязательно ставить скобки для указания порядка действий.
Запись просто if a == 0 and b == 0 or c == 0 обозначает непонятно что. Конечно, компьютер выберет некоторый порядок действий,
но лучше всегда указать его явно.

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

if a + 24 < b * 3 or (sqrt(a + 2) > b + a and a > 3):

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

вовсе не обозначает «если a или b равны нулю», потому что сравнение ==0 тут относится только к b,
а левая часть оператора or, в которой написано просто a, не является сравнением.
Запись if a: не имеет смысла (представьте себе, что a==40; что тогда обозначает запись «если 40»? Не «если 40 больше нуля»,
а просто «если 40»), потому и запись a or b == 0 не имеет смысла. И даже если вы поставите скобки: if (a or b) == 0,
это тоже не будет работать, потому что совершенно непонятно, чему равно, например, 40 or 30.

Примечание

На самом деле сказанное в предыдущем абзаце, конечно же, не совсем верно. Запись if a: в питоне обозначает «если a не равно нулю», соответственно запись
if a or b == 0 обозначает «если a не равно нулю, или b равно нулю». Но это вовсе не то, чего вы могли ожидать,
и вообще, таким наявным сравнением с нулем лучше не пользоваться, за исключением особых случаев. Если вы хотите сравнить переменную
с нулем, так явно и пишите: if a == 0 и т.п.

Примечание

Запись if (a or b) == 0 тоже на самом деле имеет некоторый смысл, но тоже не тот, который вы можете подумать.
Но поясню эту ситуацию чуть подробнее. Питон, как и любой язык программирования — он достаточно формален и не понимает чистого человеческого языка,
пусть даже иногда кажется, что понимает. В частности, любые выражения, что арифметические, что вот такие логические,
питон вычисляет по порядку. Вас в школе учили вычислять значение арифметических выражений с учетом порядка действий: например,
если есть выражение 10 + 20 * 30, то надо сначала умножить 20 * 30, получить 600, и потом вычислить 10 + 600.
Аналогично выражение (a or b) == 0 вычисляется так: надо сначала вычислить a or b, и только полученный результат уже сравнивать с нулем.
А вовсе не сравнить с нулем отдельно a и отдельно b, как вы могли бы подумать.

Примечание

И конечно тут правильнее говорить про логический тип данных — это собственно то, что получается в результате сравнений
и логических операций, и то, что можно использовать в if. Это тип данных, который может хранить
только два значения, которые в питоне называются True (истина, условие верно) и False (ложь, условие неверно),
например, у выражения 10 > 0 результат будет True,
а у выражения True and False результат будет False. И, например, если у вас написано:

то питон поступает так: он сначала вычисляет значение 10 > 0, получает True, потом вычисляет 8 > 10,
получает False, потом вычисляет True and False, получает False, т.е. условие не верно.

Но для базового понимания того, как работает if, это пока не нужно.

2.2.4. Тело условного оператора

«Тело» любой составной команды (правда, вы пока знаете только про if) — это другие команды, которые выполняются внутри нее.
Там можно писать вообще любые другие команды. Главное — писать с отступом, чтобы питон понял, что это часть if’а, а не продолжение
основной программы.

Пример:

...
if a == 0:
    print("Ноль")
    b = int(input())
    if b == 0:
        print("И это тоже ноль!")
    print("-----")

Обратите внимание, что внутри if можно писать еще один if, и его тело будет с дополнительным отступом.
Т.е. тут print("И это тоже ноль!") выполнится, только если b тоже оказалось равно нулю, а вот
print("-----") выполнится независимо от b (но, конечно, надо, чтобы a было нулем).

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

2.2.5. else и elif

То, что мы писали выше — это, как говорят, краткая форма if. Она указывает только что делать, если условие выполнилось.
Есть полная форма if, она указывает, что делать, если условие выполнилось, а что делать, если оно не выполнилось:

if a == 0:
    print("Ноль")
else:
    print("Не ноль")

Часть «что делать, если условие не выполнилось», начинается с команды else: (с двоеточием!), причем она должна быть на том же уровне отступа,
что и сам if. Под else, как и под if, можно писать любые команды,
тоже с дополнительным отступом.

Пример:

if a == 0:
    if b == 0:
        print("Два нуля")
    else:
        print("Только b не ноль")
else:
    if b == 0:
        print("Только a не ноль")
    else:
        print("Обе переменные не нули")

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

if a < 0:
    print("Отрицательное")
else:
    if a == 0:
        print("Ноль")
    else:
        print("Положительное")

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

if a < 0:
    print("Отрицательное")
elif a == 0:
    print("Ноль")
else:
    print("Положительное")

Это полный эквивалент предыдущего кода, только чуть покороче и — главное — без лишних отступов ступенькой.
Еще раз: elif — это просто сокращение от else if, позволяющее чуть красивее писать код, ничего больше.

Еще пример:

if d = "Notrh":
    print("Идем на север")
elif d == "South":
    print("Идем на юг")
elif d == "West":
    print("Идем на запад")
elif d == "East":
    print("Идем на восток")
else:
    print("??!!")

То же самое можно было бы написать и через else/if, но были бы очень некрасивые отступы.

Условный оператор if — else — Операторы

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

Формат оператора if-else

Полный формат

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

   if ( Условие )                                       // Заголовок оператора и условие
{
Блок операторов 1,                           // Если условие истинно, то..
составляющих тело1                           //..выполняются операторы тела 1
}else                                         // А если условие ложно..
{
Блок операторов 2,                           // ..то выполняются..
составляющих тело 2                          // ..операторы тела 2
}

Формат с отсутствующей частью else

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

   if ( Условие )                                    // Заголовок оператора и условие
{
Блок операторов 1,                           // Если условие истинно, то..
составляющих тело1                           //..выполняются операторы тела 1
}

Формат с отсутствующими фигурными скобками

В случае, если тело оператора if-else состоит из одного оператора, то обрамляющие
фигурные скобки можно опустить.

   if ( Условие )                                           // Заголовок оператора и условие
Оператор;                                     // Если условие истинно, то..
// ..выполняется этот оператор

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


Если условие оператора if-else является истинным, то
передать управление первому
оператору тела 1, а после выполнения всех операторов тела 1 передать управление
оператору, следующему за оператором if-else. Если условие оператора if-else является
ложным, то:

— если в операторе if-else имеется ключевое слово else, то передать
управление первому оператору тела 2, а после выполнения всех операторов тела 2
передать управление оператору, следующему за оператором if-else;

— если в операторе
if-else нет ключевого слова else, то передать управление оператору, следующему
за оператором if-else.

Примеры применения оператора if-else

Рассмотрим несколько примеров, демонстрирующих использование оператора if-else.


Задача 9. Составить программу, в которой реализуются следующие условия: если цена по финансовому инструменту поднялась выше некоторого значения, сообщить
об этом трейдеру, а если нет, то не осуществлять никаких действий.

Один из вариантов решения этой задачи может выглядеть, например, так (onelevel.mq4):


int start()                                   
{
double
Level,                                     
Price;                                     
Level=1.2753;                              
Price=Bid;                                 
if (Price>Level)                           
{
Alert("Курс превысил заданный уровень");
}
return;                                    
}

Прежде всего необходимо отметить, что программа создана как эксперт. Этим полагается,
что программа будет находиться в работе достаточно долго, с тем чтобы, когда текущая
цена превысит заданный уровень, на экране появилось интересующее нас сообщение. В программе имеется всего одна специальная функция start(). В начале функции объявлены
и прокомментированы переменные. Далее численно задаётся уровень цены и запрашивается
текущая цена.

Oператор if-else используется в следующих строках программы:


if (Price>Level)                           
{
Alert("Курс превысил заданный уровень");
}

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

На рис. 37 представлена функциональная схема, в соответствии с которой могут развиваться
события при исполнении оператора if-else.


Рис. 37. Функциональная схема исполнения оператора if-else в программе
onelevel.mq4.

В этой и последующих схемах ромб символизирует проверку условия. Стрелки показывают,
куда будет передано управление после исполнения текущего блока операторов
(термин «блок операторов» означает некоторый произвольный набор операторов,
находящихся в непосредственной близости друг к другу). Рассмотрим схему
более подробно.

К блоку ‘Предыдущие вычисления’ (серый прямоугольник на схеме) в программе
onelevel.mq4 относятся следующие:

   double
Level,                                     
Price;                                     
Level=1.2753;                              
Price=Bid;

После исполнения последнего оператора в этом блоке управление передаётся на заголовок
оператора if-else, в котором проверяется условие Цена выше заданной? (ромб на схеме, рис.
37):

   if (Price>Level)

Иными словами, можно сказать, что на этом этапе программа ищет ответ на вопрос, является
ли заключённое в круглые скобки утверждение истинным. Само утверждение звучит
буквально так, как оно написано: значение переменной Price больше значения переменной
Level (цена больше заданного уровня). К моменту, когда программа определяет истинность
этого утверждения, у неё уже имеются численные значения переменных Price и Level.
И ответ зависит от соотношения этих значений. Если курс ниже заданного уровня (значение
Price меньше или равно значению Level), то утверждение ложно, а если выше, то утверждение
истинно.

Таким образом, куда будет передано управление после проверки условия, зависит от текущей
ситуации на рынке (!). Если цена по финансовому инструменту остаётся ниже заданного уровня (ответ — Нет, т.е. утверждение ложно), то,
в соответствии с правилом исполнения оператора if-else, управление
будет передано за пределы оператора, в данном случае — в блок Последующие вычисления, а именно в строку:

   return;

При этом легко увидеть, что сообщение трейдеру не выдаётся.

Если же цена по финансовому инструменту превышает заданный в программе уровень (ответ
— Да, т.е. утверждение истинно), то управление передаётся в тело оператора if-else, а именно в строки:

      {
Alert("Курс превысил заданный уровень");
}

Результатом исполнения функции Alert() будет появление на экране небольшого окна
с надписью:


Курс превысил заданный уровень

Функция Alert() является единственным оператором тела оператора if-else, поэтому
после её исполнения оператор if-else является полностью выполненным, а значит, управление
должно быть передано оператору, следующему за ним, т.е. в строку:

   return;

В результате исполнения оператора return функция start() закончит свою работу, и
программа перейдёт в режим ожидания тика. На новом тике (несущем и новую цену по
финансовому инструменту) функция start() будет снова исполнена. И в зависимости
от того, превысил или не превысил текущий курс заданный уровень, будет или не будет
выдано заложенное в программу сообщение.

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


Задача 10. Составить программу, в которой реализуются следующие условия: если
цена поднялась выше некоторого значения 1, то сообщить об этом трейдеру, если цена
опустилась ниже некоторого значения 2, то сообщить об этом трейдеру, в остальных
случаях не осуществлять никаких действий.

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

— находится ли цена выше-ниже уровня 1;

— находится ли цена выше-ниже уровня 2.

Решение задачи 10. Вариант 1

Действуя формально, можно составить следующий алгоритм решения:


Рис. 38. Функциональная схема исполнения операторов if-else в программе
twolevel.mq4.

Программа, реализующая этот алгоритм, может выглядеть так
(twolevel.mq4):


int start()                                 
{
double
Level_1,                                 
Level_2,                                 
Price;                                   
Level_1=1.2850;                          
Level_2=1.2800;                          
Price=Bid;                               
if (Price > Level_1)                     
{
Alert("Цена находится выше уровня 1");
}
if (Price < Level_2)                     
{
Alert("Цена находится ниже уровня 2");
}
return;                                  
}

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

Кратко охарактеризуем исполнение программы.

После выполнения предварительных вычислений управление поступает в первый оператор
проверки if-else:


if (Price > Level_1)                     
{
Alert("Цена находится выше уровня 1");
}

Независимо от того, какие события произойдут при исполнении этого оператора (будет
ли выдано сообщение трейдеру), по окончании его исполнения управление будет передано
в следующий оператор if-else:


if (Price < Level_2)                     
{
Alert("Цена находится ниже уровня 2");
}

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

Здесь необходимо заметить, что одной из важных целей, преследуемых программистом
при составлении программ, является оптимизация алгоритма. Рассматриваемые примеры — лишь демонстрация, поэтому являют собой короткую,
а значит и быстро исполняемую программу. Программа, которую предполагается использовать
в практической работе, обычно значительно больше. Она может обрабатывать значения
сотен переменных, использовать множество проверок, каждая из которых выполняется
в течение некоторого времени. В результате этого появляется опасность, что длительность
работы специальной функции start() превысит временной промежуток между тиками. Это
будет означать, что некоторые тики могут остаться необработанными. Разумеется,
это — крайне нежелательная ситуация, и программисту следует прилагать усилия для
того, чтобы не допустить этого. Одним из методов уменьшения времени исполнения
программы является оптимизация алгоритма.

Посмотрим на последний пример ещё раз, теперь уже с точки зрения экономии ресурсов.
Например, какой смысл проводить во втором блоке проверку «Цена ниже
заданной?», если при проверке в первом блоке уже выяснилось, что цена выше
верхнего уровня? Понятно, что в этом случае цена не может оказаться ниже нижнего
уровня, значит, при этих условиях выполнять проверку во втором блоке (а также
исполнять набор
операторов в этом блоке) нет необходимости.

Решение задачи 10. Вариант 2

Учитывая эти рассуждения, рассмотрим следующий, оптимизированный алгоритм:


Рис. 39. Функциональная схема исполнения операторов if-else в программе
twoleveloptim.mq4.

В соответствии с алгоритмом, представленным на этой схеме, лишние операции выполняться
уже не будут. После подготовительных вычислений проводится проверка Цена выше заданной? В случае если цена выше, то выдаётся сообщение трейдеру и управление передаётся
на Последующие вычисления, при этом анализ ситуации по второму критерию (Цена ниже заданной?) не производится. И только в том случае, если цена не оказалась выше верхнего уровня
(ответ — Нет), управление передаётся на второй проверочный блок, в котором и проводится необходимая
при этих условиях проверка. Если цена оказывается ниже нижнего уровня, то выдаётся соответствующее
сообщение, а если нет, то управление передаётся на дальнейшие вычисления. Очевидно,
что при работе программы по этому алгоритму никаких лишних действий не производится,
в результате чего вычислительные ресурсы расходуются лишь по мере необходимости.

Программная реализация этого алгоритма предполагает использование вложенного оператора
if-else (twoleveloptim.mq4):


int start()                                  
{
double
Level_1,                                  
Level_2,                                  
Price;                                    
Level_1=1.2850;                           
Level_2=1.2800;                           
Price=Bid;                                
if (Price > Level_1)                      
{
Alert("Цена находится выше уровня 1"); 
}
else
{
if (Price < Level_2)                   
{
Alert("Цена находится ниже уровня 2");
}
}
return;                                   
}

Обратите внимание на этот блок вычислений:


if (Price > Level_1)                      
{
Alert("Цена находится выше уровня 1"); 
}
else
{
if (Price < Level_2)                   
{
Alert("Цена находится ниже уровня 2");
}
}

Оператор if-else, в котором проверяется второе условие, является составной частью
первого оператора if-else, проверяющего первое условие. Применение вложенных операторов
очень распространено в практике программирования, зачастую является оправданным,
а в некоторых случаях — единственным возможным решением. Разумеется, в реальных
программах вместо функции Alert() могут быть использованы другие функции или операторы,
выполняющие полезные действия.

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


Задача 11. Составить программу, в которой реализуются следующие условия: если
цена находится в заданном диапазоне значений, то не осуществлять никаких действий; если
цена вышла за пределы заданного диапазона, то сообщить об этом трейдеру.

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

Здесь, как и в предыдущих решениях, необходимо проверять положение цены относительно
двух уровней — верхнего и нижнего. Алгоритм решения, представленный на рис. 38, нами уже был отвергнут ранее как неэффективный. Поэтому в соответствии с последними
рассуждениями можно предложить такой вариант решения:


Рис. 40. Функциональная схема одного из вариантов алгоритма решения Задачи 11.

Однако в использовании такого алгоритма нет необходимости. На схеме наглядно показано,
что данный алгоритм предполагает использование в разных местах программы одного
и того же блока сообщений. Программные строки будут повторяться, несмотря на то,
что результатом их исполнения будут одинаковые сообщения. Гораздо эффективнее в
данном случае использовать один оператор if-else со сложным условием:


Рис. 41. Функциональная схема исполнения оператора if-else в программе
compoundcondition.mq4.

Код программы, реализующий этот алгоритм, выглядит так (compoundcondition.mq4):


int start()                                    
{
double
Level_1,                                    
Level_2,                                    
Price;                                      
Level_1=1.2850;                             
Level_2=1.2800;                             
Price=Bid;                                  
if (Price>Level_1 || Price<Level_2)         
{
Alert("Цена находится за пределами диапазона");
}
return;                                     
}

Ключевым моментом в этом программном решении является использование сложного условия
в операторе if-else:

if (Price>Level_1 || Price<Level_2)         
{
Alert("Цена находится за пределами диапазона");
}

Написанное простыми словами, это условие выглядит так: если значение переменной
Price больше значения переменной Level_1 или значение переменной Price меньше значения переменной Level_2, то исполнять тело
оператора if-else. Использование логических операций (&&,|| и !) при составлении условий операторов if-else разрешено и широко применяется в практике
программирования (см. Логические операции).

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

   if ( A>B && (B<=C || (N!=K && F>B+3)) )

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

Объединение условных операторов

Также известен как: Consolidate Conditional Expression

Проблема

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

Решение

Объедините все условия в одном условном операторе.

До

double disabilityAmount() {
  if (seniority < 2) {
    return 0;
  }
  if (monthsDisabled > 12) {
    return 0;
  }
  if (isPartTime) {
    return 0;
  }
  // Compute the disability amount.
  // ...
}

После

double disabilityAmount() {
  if (isNotEligibleForDisability()) {
    return 0;
  }
  // Compute the disability amount.
  // ...
}

До

double DisabilityAmount() 
{
  if (seniority < 2) 
  {
    return 0;
  }
  if (monthsDisabled > 12) 
  {
    return 0;
  }
  if (isPartTime) 
  {
    return 0;
  }
  // Compute the disability amount.
  // ...
}

После

double DisabilityAmount()
{
  if (IsNotEligibleForDisability())
  {
    return 0;
  }
  // Compute the disability amount.
  // ...
}

До

function disabilityAmount() {
  if ($this->seniority < 2) {
    return 0;
  }
  if ($this->monthsDisabled > 12) {
    return 0;
  }
  if ($this->isPartTime) {
    return 0;
  }
  // compute the disability amount
  ...

После

function disabilityAmount() {
  if ($this->isNotEligibleForDisability()) {
    return 0;
  }
  // compute the disability amount
  ...

До

def disabilityAmount():
    if seniority < 2:
        return 0
    if monthsDisabled > 12:
        return 0
    if isPartTime:
        return 0
    # Compute the disability amount.
    # ...

После

def disabilityAmount():
    if isNotEligibleForDisability():
        return 0
    # Compute the disability amount.
    # ...

До

disabilityAmount(): number {
  if (seniority < 2) {
    return 0;
  }
  if (monthsDisabled > 12) {
    return 0;
  }
  if (isPartTime) {
    return 0;
  }
  // Compute the disability amount.
  // ...
}

После

disabilityAmount(): number {
  if (isNotEligibleForDisability()) {
    return 0;
  }
  // Compute the disability amount.
  // ...
}

Причины рефакторинга

Код содержит множество чередующихся операторов, которые выполняют одинаковые действия. Причина разделения операторов неочевидна.

Главная цель объединения операторов — извлечь условие оператора в отдельный метод, упростив его понимание.

Достоинства

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

  • Объединив все операторы в одном, вы позволяете выделить это сложное условие в новый метод с названием, отражающим суть этого выражения.

Порядок рефакторинга

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

  1. Объедините множество условий в одном с помощью операторов и и или. Объединение операторов обычно следует такому правилу:

    • Вложенные условия соединяются с помощью оператора и.

    • Условия, следующие друг за другом, соединяются с помощью оператора или.

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

Устали читать?

Сбегайте за подушкой, у нас тут контента на 7 часов чтения.

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

Предварительные требования: Базовая компьютерная грамотность, базовое понимание HTML и CSS, первые шаги в JavaScript.
Цель: Чтобы понять, как использовать условные структуры в JavaScript.