§ 4. Логические операции И и ИЛИ
Логика высказываний позволяет строить составные высказывания. Они создаются из нескольких простых высказываний путем соединения их друг с другом с помощью логических операций НЕ, И, ИЛИ и др.
4.1. Логическая операция И
Определение истинности или ложности составного высказывания зависит от того, являются ли истинными или ложными простые высказывания, входящие в его состав, а также от той логической операции, которая их связывает.
Составное высказывание А И В, образованное в результате объединения двух простых высказываний А и B логической операцией И, истинно тогда и только тогда, когда А и В одновременно истинны (пример 4.1 и пример 4.2).
Операцию И называют логическим умножением. Равенства 1 · 1 = 1, 1 · 0 = 0, 0 · 1 = 0, 0 · 0 = 0, верные для обычного умножения, верны и для логического умножения.
Представим таблицу истинности для логической операции И:
А И В
Если хотя бы одно из простых высказываний, связанных операцией И, будет ложным, то и составное высказывание будет ложным.
Для записи логической операции И используют следующие обозначения: A И B, A AND B, A · B, A * B, A ∧ B, A & B.
4.2. Логическая операция ИЛИ
Составное высказывание А ИЛИ В, образованное в результате объединения двух простых высказываний А и B логической операцией ИЛИ, ложно тогда и только тогда, когда А и В одновременно ложны (пример 4.3).
Другими словами, составное высказывание А ИЛИ В будет истинным, если истинно хотя бы одно из двух составляющих его простых высказываний (пример 4.4).
Таблица истинности для логической операции ИЛИ имеет следующий вид:
Операцию ИЛИ называют логическим сложением. Равенства 1 + 0 = 1, 0 + 1 = 1, 0 + 0 = 0, верные для обычного сложения, верны и для логического сложения.
Для записи логической операции ИЛИ можно использовать следующие выражения: A ИЛИ B, A OR B, A + B, A ∨ B, A | B.
Если в логическом выражении присутствует несколько логических операций, то важно определить порядок их выполнения. Наивысшим приоритетом обладает операция НЕ. Логическая операция И, т. е. логическое умножение, выполняется раньше операции ИЛИ — логического сложения (пример 4.5* и пример 4.6*).
Для изменения порядка выполнения логических операций используют скобки: в этом случае сначала выполняются операции в скобках, а затем — все остальные.
Логические операции И и ИЛИ подчиняются переместительному закону:
A И B = B И A ;
A ИЛИ B = B ИЛИ A .
Чтобы определить значение составного логического выражения, иногда достаточно знать значение только одного простого высказывания.
Так, если в составном высказывании с операцией И значение хотя бы одного простого высказывания является ложным, то и значение составного высказывания будет ложным. Если в составном высказывании с операцией ИЛИ значение хотя бы одного простого будет истинным, то и значение составного высказывания будет истинным (пример 4.7).
Данное высказывание является составным, поскольку оно содержит два простых высказывания:
«Число 456 трехзначное» (высказывание А) и «Число 456 четное» (высказывание В). Высказывания А и В соединены вместе логической операцией И, в результате получено составное высказывание А И B. Высказывание А истинно, высказывание В истинно. Поэтому высказывание А И B истинно: (А И B) = 1.
Пример 4.2. Высказывание А: «Геракл — герой древнегреческой мифологии». Истинно, А = 1.
Высказывание В: «Геракл — сын бога Зевса». Истинно, B = 1.
Высказывание А И В: «Геракл — герой древнегреческой мифологии И сын бога Зевса». Истинно, (А И В) = 1.
Пример 4.3. Проанализируем высказывание «Семиклас-сники изучают философию или астрономию».
Данное составное высказывание образовано из двух простых высказываний: «Семиклассники изучают философию» (высказывание А), «Семиклас-сники изучают астрономию» (высказывание В), которые связаны логической операцией ИЛИ. В результате получилось составное высказывание А ИЛИ B. Высказывание А ложно, высказывание В ложно. Поэтому высказывание А ИЛИ B ложно: (А ИЛИ B) = 0.
Пример 4.4. Высказывание А: «Франциск Скорина — белорусский первопечатник». Истинно, А = 1.
Высказывание В: «Стефан Баторий — турецкий султан». Ложно, B = 0.
Высказывание «Франциск Скорина — белорусский первопечатник, ИЛИ Стефан Баторий — турецкий султан» будет истинным, (А ИЛИ В) = 1.
Пример 4.5*.
Рассмотрим выражение: А ИЛИ B И НЕ С. Распишем по действиям вычисление значения логического выражения:
Значение высказывания F, полученное в 3-м действии, определит значение исходного логического выражения.
Пример 4.6*.
Пусть высказывание А = 1, B = 0, С = 0. Найдем значение логического выражения: А ИЛИ B И НЕ С.
Значит, при начальных значениях А = 1, B = 0, С = 0 значение логического выражения А ИЛИ B И НЕ С истинно.
Пример 4.7. Высказывание А: «Прогноз погоды обещает дожди». Высказывание В: «Сейчас на улице идет дождь».
Высказывание А И B будет ложным, если мы увидели, что на улице нет дождя (независимо от того, что обещал прогноз погоды).
1 В каких условиях составное высказывание А И В может быть истинным?
- Если А истинно и В истинно.
- Если А ложно, а В истинно.
- Если А истинно, а В ложно.
- Если А ложно и В истинно.
2 В каких случаях составное высказывание А ИЛИ В может быть ложным?
- Если А ложно, а В истинно.
- Если А истинно, а В ложно.
- Если А истинно и В истинно.
- Если А ложно и В ложно.
Упражнения
1 Определите, истинными или ложными являются нижеприведенные составные высказывания.
- Мяч круглый, ИЛИ Земля плоская.
- Кролики — домашние животные, И баобаб растет в Беловежской пуще.
- Клавиатура — устройство ввода информации, ИЛИ винчестер — устройство вывода информации.
- М. Ю. Лермонтов написал стихотворение «Парус», И И. А. Крылов написал басню «Квартет».
- Сосна — хвойное дерево, И кедр — не хвойное дерево.
- Процессор — устройство обработки информации в компьютере, ИЛИ наушники — не устройство ввода информации.
- Континенты и острова — это большие участки суши.
2 О том, как прошли летние каникулы, Кира рассказала своим друзьям следующее:
- Я была у бабушки в деревне, и рядом с деревней было озеро.
- По озеру плавала лодка или утка.
- Мы с бабушкой насобирали малины и смородины.
- Я составила букет из цветов. В нем были ромашки или гвоздики.
Подготовьте к каждому из высказываний Киры рисунки, учитывая, что все высказывания истинны.
3 Откройте файл с рисунком и разложите грибы по корзинкам так, чтобы было истинным следующее высказывание: «В большой корзине все грибы съедобные, и в маленькой корзине все грибы несъедобные».
4 Откройте файл с рисунком и поставьте все цветы в вазы так, чтобы было истинным высказывание: «В синей вазе все цветы розы, или в красной вазе все цветы не красного цвета».
5* Найдите значения логических выражений, если А = 1, B = 1, С = 0, D = 0.
Выражения и операторы
Эта глава описывает выражения и операторы языка JavaScript, такие как операторы присваивания, сравнения, арифметические, битовые, логические, строчные, и различные специальные операторы.
Полный и детальный список операторов и выражений также доступен в этом руководстве.
Операторы
В JavaScript есть следующие типы операторов. Данный подраздел описывает каждый тип и содержит информацию об их приоритетах друг над другом.
- Операторы присваивания
- Операторы сравнения
- Арифметические операторы
- Битовые (поразрядные) операторы
- Логические операторы
- Строковые операторы
- Условный (тернарный) оператор
- Оператор запятая
- Унарные операторы
- Операторы отношения
- Приоритет операторов
JavaScript поддерживает бинарные и унарные операторы, а также ещё один специальный тернарный оператор — условный оператор. Бинарная операция использует два операнда, один перед оператором и другой за ним:
operand1 operator operand2
Например: 3+4 или x*y .
В свою очередь унарная операция использует один операнд, перед или после оператора:
operator operand
operand operator
Например: x++ или ++x .
Операторы присваивания
В результате операции присваивания операнду слева от оператора присваивания (en-US) (знак » table-container»>
| Имя | Сокращённый оператор | Смысл |
|---|---|---|
| Присваивание (en-US) | x = y | x = y |
| Присваивание со сложением (en-US) | x += y | x = x + y |
| Присваивание с вычитанием (en-US) | x -= y | x = x — y |
| Присваивание с умножением (en-US) | x *= y | x = x * y |
| Присваивание с делением (en-US) | x /= y | x = x / y |
| Присваивание по модулю (en-US) | x %= y | x = x % y |
| Присваивание с левым сдвигом (en-US) | x | x = x |
| Присваивание с правым сдвигом (en-US) | x >>= y | x = x >> y |
| Присваивание с беззнаковым сдвигом вправо (en-US) | x >>>= y | x = x >>> y |
| Присваивание с побитовым AND (en-US) | x &= y | x = x & y |
| Присваивание с побитовым XOR (en-US) | x ^= y | x = x ^ y |
| Присваивание с побитовым OR (en-US) | x |= y | x = x | y |
Деструктуризация
Для более сложного присваивания в JavaScript есть синтаксис деструктуризации — это выражение, которое позволяет извлекать данные из массивов или объектов, используя синтаксис, который зеркалирует конструкторы массивов и литералы объектов.
var foo = ["one", "two", "three"]; // без деструктуризации var one = foo[0]; var two = foo[1]; var three = foo[2]; // с деструктуризацией var [one, two, three] = foo;
Операторы сравнения
Оператор сравнения (en-US) сравнивает свои операнды и возвращает логическое значение, базируясь на истинности сравнения. Операнды могут быть числами, строками, логическими величинами или объектами. Строки сравниваются на основании стандартного лексикографического порядка, используя Unicode-значения. В большинстве случаев, если операнды имеют разный тип, то JavaScript пробует преобразовать их в тип, подходящий для сравнения. Такое поведение обычно происходит при сравнении числовых операндов. Единственным исключением из данного правила является сравнение с использованием операторов === и !== , которые производят строгое сравнение на равенство или неравенство. Эти операторы не пытаются преобразовать операнды перед их сравнением. Следующая таблица описывает операторы сравнения в контексте следующего примера кода:
var var1 = 3, var2 = 4;
| Оператор | Описание | Примеры, возвращающие true |
|---|---|---|
| Равно ( == ) | Возвращает true, если операнды равны. | 3 == var1 «3» == var1 3 == ‘3’ |
| Не равно ( != ) | Возвращает true, если операнды не равны. | var1 != 4 var2 != «3» |
| Строго равно ( === ) | Возвращает true, если операнды равны и имеют одинаковый тип. Смотрите также Object.is и sameness in JS. | 3 === var1 |
| Строго не равно( !== ) | Возвращает true, если операнды не равны и/или имеют разный тип. | var1 !== «3» 3 !== ‘3’ |
| Больше ( > ) | Возвращает true, если операнд слева больше операнда справа. | var2 > var1 «12» > 2 |
| Больше или равно ( >= ) | Возвращает true, если операнд слева больше или равен операнду справа. | var2 >= var1 var1 >= 3 |
| Меньше ( < ) | Возвращает true, если операнд слева меньше операнда справа. | var1 < var2 "2" < 12 |
| Меньше или равно ( | Возвращает true, если операнд слева меньше или равен операнду справа. | var1 |
Примечание: (=>) не оператор, а нотация Стрелочных функций.
Арифметические операторы
Арифметические операторы (en-US) используют в качестве своих операндов числа (также литералы или переменные) и в качестве результата возвращают одно числовое значение. Стандартными арифметическими операторами являются сложение (+), вычитание (-), умножение (*), и деление (/). При работе с числами с плавающей точкой эти операторы работают аналогично их работе в большинстве других языках программирования (обратите внимание, что деление на ноль возвращает бесконечность Infinity ). Например:
.log(1 / 2); /* возвращает 0.5 */ console.log(1 / 2 == 1.0 / 2.0); /* возвращает true */
Кроме того, JavaScript позволяет использовать следующие арифметические операторы, представленные в таблице:
| Оператор | Описание | Пример |
|---|---|---|
| Остаток от деления (en-US) ( % ) | Бинарный оператор. Возвращает целочисленный остаток от деления двух операндов. | 12 % 5 вернёт 2. |
| Инкремент (en-US) ( ++ ) | Унарный оператор. Добавляет единицу к своему операнду. Если используется в качестве префикса ( ++x ), то возвращает значение операнда с добавленной к нему единицей; а в случае применения в качестве окончания ( x++ ) возвращает значение операнда перед добавлением к нему единицы. | Если x равно 3, тогда ++x установит значение x равным 4 и вернёт 4, напротив x++ вернёт 3 и потом установит значение x равным 4. |
| Декремент (en-US) ( — ) | Унарный оператор. Вычитает единицу из значения своего операнда. Логика данного оператора аналогична оператору инкремента. | Если x равно 3, тогда —x установит значение x равным 2 и вернёт 2, напротив x— вернёт 3 и потом установит значение x равным 2. |
| Унарный минус (en-US) — | Унарный оператор. Возвращает отрицательное значение своего операнда. | Если x равно 3, тогда -x вернёт -3. |
| Унарный плюс (en-US) ( + ) | Унарный оператор. Пытается конвертировать операнд в число, если он ещё не оно. | +»3″ вернёт 3 . +true вернёт 1. |
| Возведение в степень (en-US) ( ** ) Экспериментальная возможность | Возводит основание в показатель степени , как, основаниестепень | 2 ** 3 вернёт 8 . 10 ** -1 вернёт 0.1 . |
Битовые (поразрядные) операторы
Битовые операторы (en-US) обрабатывают свои операнды как последовательности из 32 бит (нулей и единиц), а не как десятичные, шестнадцатеричные или восьмеричные числа. Например, десятичное число 9 имеет двоичное представление 1001. Битовые операторы выполняют операции над таким двоичным представлением, но результат возвращают как обычное числовое значение JavaScript.
Следующая таблица обобщает битовые операторы JavaScript.
| Оператор | Использование | Описание |
|---|---|---|
| Побитовое И (en-US) | a & b | Возвращает единицу в каждой битовой позиции, для которой соответствующие биты обеих операндов являются единицами. |
| Побитовое ИЛИ (en-US) | a | b | Возвращает единицу в каждой битовой позиции, для которой один из соответствующих битов или оба бита операндов являются единицами. |
| Исключающее ИЛИ (en-US) | a ^ b | Возвращает единицу в каждой битовой позиции, для которой только один из соответствующих битов операндов является единицей. |
| Побитовое НЕ (en-US) | ~ a | Заменяет биты операнда на противоположные. |
| Сдвиг влево (en-US) | a | Сдвигает a в двоичном представлении на b бит влево, добавляя справа нули. |
| Сдвиг вправо с переносом знака (en-US) | a >> b | Сдвигает a в двоичном представлении на b бит вправо, отбрасывая сдвигаемые биты. |
| Сдвиг вправо с заполнением нулями (en-US) | a >>> b | Сдвигает a в двоичном представлении на b бит вправо, отбрасывая сдвигаемые биты и добавляя слева нули. |
Битовые логические операторы
Основной смысл работы битовых логических операторов состоит в следующем:
-
Операнды преобразуются в 32-битные целые числа и представляются в виде последовательности бит (нулей и единиц). Числа, имеющие более 32 битов будут сокращены. Например, следующее число имеет больше 32 битов и сконвертируется в 32-х битное:
До : 11100110111110100000000000000110000000000001 После : 10100000000000000110000000000001
Например, двоичным представлением числа 9 является 1001, а двоичным представлением пятнадцати — 1111. Результаты применения к этим числам битовых логических операторов выглядят следующим образом:
| Выражение | Результат | Двоичное описание |
|---|---|---|
| 15 & 9 | 9 | 1111 & 1001 = 1001 |
| 15 | 9 | 15 | 1111 | 1001 = 1111 |
| 15 ^ 9 | 6 | 1111 ^ 1001 = 0110 |
| ~15 | -16 | ~«00000000. «00001111 = «1111«1111«. «11110000 |
| ~9 | -10 | ~«00000000«. «0000«1001 = «1111«1111«. «1111«0110 |
Обратите внимание, что все 32 бита преобразуются с использованием битового оператора НЕ, и что величины с наиболее значимым (самым левым) битом равным 1 представляют собой отрицательные числа (в представлении дополнения до двух).
Битовые операторы сдвига
Битовые операторы сдвига используют два операнда: первый представляет величину, подлежащую сдвигу, а второй операнд указывает число битовых позиций на которое должен быть сдвинут первый операнд. Направление операции сдвига определяется используемым оператором.
Операторы сдвига преобразуют свои операнды в 32-битные целые числа и возвращают результат того же типа, каким является левый операнд.
Операторы сдвига перечислены в следующей таблице.
| Оператор | Описание | Пример |
|---|---|---|
| Сдвиг влево (en-US) ( | Данный оператор сдвигает первый операнд на указанное количество бит влево. Излишние биты, сдвинутые влево, отбрасываются. Справа число дополняется нулевыми битами. | 9 |
| Сдвиг вправо с переносом знака (en-US) ( >> ) | Данный оператор сдвигает первый операнд на указанное количество бит вправо. Излишние биты, сдвинутые вправо, отбрасываются. Слева число дополняется копиями крайнего слева бита. | 9>>2 равно 2, так как 1001 после сдвига на 2 бита вправо превращается в 10, что соответствует числу 2. Подобным же образом -9>>2 равно -3, так как знак сохраняется. |
| Сдвиг вправо с заполнением нулями (en-US) ( >>> ) | Данный оператор сдвигает первый операнд на указанное количество бит вправо. Излишние биты, сдвинутые вправо, отбрасываются. Слева число дополняется нулевыми битами. | 19>>>2 равно 4, так как 10011 после сдвига на 2 бита вправо превращается в 100, что соответствует числу 4. Для неотрицательных чисел сдвиг вправо с заполнением нулями и сдвиг вправо с переносом знака дают одинаковый результат. |
Логические операторы
Логические операторы (en-US) обычно используются с булевыми (логическими) значениями; при этом возвращаемое ими значение также является булевым. Однако операторы && и || фактически возвращают значение одного из операндов, поэтому, если эти операторы используются с небулевыми величинами, то возвращаемая ими величина также может быть не булевой. Логические операторы описаны в следующей таблице.
| Оператор | Использование | Описание |
|---|---|---|
| Логическое И (en-US) ( && ) | expr1 && expr2 | (Логическое И) Возвращает операнд expr1 , если он может быть преобразован в false ; в противном случае возвращает операнд expr2 . Таким образом, при использовании булевых величин в качестве операндов, оператор && возвращает true , если оба операнда true ; в противном случае возвращает false . |
| Логическое ИЛИ (en-US) ( || ) | expr1 || expr2 | (Логическое ИЛИ) Возвращает операнд expr1 , если он может быть преобразован в true ; в противном случае возвращает операнд expr2 . Таким образом, при использовании булевых величин в качестве операндов, оператор || возвращает true , если один из операндов true ; если же оба false , то возвращает false . |
| Логическое НЕ (en-US) ( ! ) | !expr | (Логическое НЕ) Возвращает false , если операнд может быть преобразован в true ; в противном случае возвращает true . |
Примерами выражений, которые могут быть преобразованы в false являются: null, 0, NaN, пустая строка («») или undefined.
Следующий код демонстрирует примеры использования оператора && (логическое И).
var a1 = true && true; // t && t возвращает true var a2 = true && false; // t && f возвращает false var a3 = false && true; // f && t возвращает false var a4 = false && 3 == 4; // f && f возвращает false var a5 = "Cat" && "Dog"; // t && t возвращает Dog var a6 = false && "Cat"; // f && t возвращает false var a7 = "Cat" && false; // t && f возвращает false
Следующий код демонстрирует примеры использования оператора || (логическое ИЛИ).
var o1 = true || true; // t || t возвращает true var o2 = false || true; // f || t возвращает true var o3 = true || false; // t || f возвращает true var o4 = false || 3 == 4; // f || f возвращает false var o5 = "Cat" || "Dog"; // t || t возвращает Cat var o6 = false || "Cat"; // f || t возвращает Cat var o7 = "Cat" || false; // t || f возвращает Cat
Следующий код демонстрирует примеры использования оператора ! (логическое НЕ).
var n1 = !true; // !t возвращает false var n2 = !false; // !f возвращает true var n3 = !"Cat"; // !t возвращает false
Сокращённая оценка
Так как логические выражения вычисляются слева направо, они проверяются на возможность выполнения сокращённой оценки с использованием следующих правил:
- false && anything — сокращение с результатом false.
- true || anything — сокращение с результатом true.
Правила логики гарантируют, что данные вычисления всегда корректны. Обратите внимание, что часть «anything» представленных выше выражений не вычисляется, таким образом удаётся избежать любых побочных эффектов вычисления данной части.
Строковые операторы
В дополнение к операторам сравнения, которые могут использоваться со строковыми значениями, оператор (+) позволяет объединить две строки, возвращая при этом третью строку, которая представляет собой объединение двух строк-операндов:
.log("my " + "string"); // в консоли выведется строка "my string".
Сокращённый оператор присваивания += также может быть использован для объединения (конкатенации) строк:
var mystring = "alpha"; mystring += "bet"; // получается значение "alphabet" и присваивается mystring.
Условный (тернарный) оператор
Условный оператор является единственным оператором JavaScript, который использует три операнда. Оператор принимает одно из двух значений в зависимости от заданного условия. Синтаксис оператора:
condition ? val1 : val2
Предупреждение: val1 и val2 обязательно должны что-то возвращать, поэтому в этой конструкции нельзя использовать continue или break
Если condition (условие) — истина, то оператор принимает значение val1 . В противном случае оператор принимает значение val2 . Вы можете использовать условный оператор во всех случаях, где может быть использован стандартный оператор.
var status = age >= 18 ? "adult" : "minor";
Данное выражение присваивает значение «adult» переменной status , если age имеет значение 18 или более. В противном случае переменной status присваивается значение «minor».
Оператор запятая
Оператор запятая ( , ) просто вычисляет оба операнда и возвращает значение последнего операнда. Данный оператор в основном используется внутри цикла for , что позволяет при каждом прохождении цикла одновременно обновлять значения нескольких переменных.
Например, если a является двумерным массивом, каждая строка которого содержит 10 элементов, то следующий код с использованием оператора запятая позволяет выполнять одновременное приращение двух переменных. Данный код выводит на экран значения диагональных элементов массива:
for (var i = 0, j = 9; i 9; i++, j--) document.writeln("a[" + i + "][" + j + "] token operator">+ a[i][j]);
Унарные операторы
Унарная операция — операция только с одним операндом.
delete
Оператор delete выполняет удаление объекта, свойства объекта, или элемента массива с заданным индексом. Синтаксис оператора:
delete objectName; delete objectName.property; delete objectName[index]; delete property; // допустимо только внутри with
где objectName представляет собой имя объекта, property — свойство объекта, а index — целое число, указывающее на положение (номер позиции) элемента в массиве.
Четвёртый вариант использования позволяет удалить свойство объекта, но допускается только внутри with .
Вы можете использовать оператор delete для удаления переменных, объявленных неявно, но вы не можете с его помощью удалять переменные, объявленные с помощью var .
После применения оператора delete свойство элемента меняется на undefined . Оператор delete возвращает true если выполнение операции возможно; оператор возвращает false , если выполнение операции невозможно.
= 42; var y = 43; myobj = new Number(); myobj.h = 4; // создаём свойство h delete x; // возвращает true (можно удалить переменную объявленную неявно) delete y; // возвращает false (нельзя удалить переменную объявленную с помощью var) delete Math.PI; // возвращает false (нельзя удалить встроенные свойства) delete myobj.h; // возвращает true (можно удалить пользовательские свойства) delete myobj; // возвращает true (можно удалить объект объявленный неявно)
Удаление элементов массива
Удаление элемента массива не влияет на длину массива. Например, если вы удалите a[3] , элемент a[4] останется a[4], a[3] станет undefined.
Когда элемент массива удаляется с помощью оператора delete , то из массива удаляется значение данного элемента. В следующем примере элемент trees[3] удалён с помощью оператора delete . Однако, элемент trees[3] остаётся адресуемым и возвращает значение undefined .
var trees = new Array("redwood", "bay", "cedar", "oak", "maple"); delete trees[3]; if (3 in trees) // условие не выполняется >
Если вы хотите, чтобы элемент оставался в массиве, но имел значение undefined, то используйте ключевое слово undefined вместо оператора delete . В следующем примере элементу trees[3] присвоено значение undefined , но элемент при этом остаётся в массиве:
var trees = new Array("redwood", "bay", "cedar", "oak", "maple"); trees[3] = undefined; if (3 in trees) // данный блок кода выполняется >
Оператор typeof
Оператор typeof используется одним из следующих способов:
typeof operand typeof (operand)
Оператор typeof возвращает строку обозначающую тип невычисленного операнда. Значение operand может быть строкой, переменной, дескриптором, или объектом, тип которого следует определить. Скобки вокруг операнда необязательны.
Предположим, вы определяете следующие переменные:
var myFun = new Function("5 + 2"); var shape = "round"; var size = 1; var today = new Date();
Оператор typeof возвращает следующие результаты для этих переменных:
typeof myFun; // возвращает "function" typeof shape; // возвращает "string" typeof size; // возвращает "number" typeof today; // возвращает "object" typeof dontExist; // возвращает "undefined"
Для дескрипторов true и null оператор typeof возвращает следующие результаты:
typeof true; // возвращает "boolean" typeof null; // возвращает "object"
Для чисел и строк оператор typeof возвращает следующие результаты:
typeof 62; // возвращает "number" typeof "Hello world"; // возвращает "string"
Для свойств оператор typeof возвращает тип значения данного свойства:
typeof document.lastModified; // возвращает "string" typeof window.length; // возвращает "number" typeof Math.LN2; // возвращает "number"
Для методов и функций оператор typeof возвращает следующие результаты:
typeof blur; // возвращает "function" typeof eval; // возвращает "function" typeof parseInt; // возвращает "function" typeof shape.split; // возвращает "function"
Для встроенных объектов оператор typeof возвращает следующие результаты:
typeof Date; // возвращает "function" typeof Function; // возвращает "function" typeof Math; // возвращает "object" typeof Option; // возвращает "function" typeof String; // возвращает "function"
Оператор void
Оператор void используется любым из следующих способов:
void (expression) void expression
Оператор void определяет выражение, которое должно быть вычислено без возвращения результата. expression — это выражение JavaScript, требующее вычисления. Скобки вокруг выражения необязательны, но их использование является правилом хорошего тона.
Вы можете использовать оператор void для указания на то, что операнд-выражение является гипертекстовой ссылкой. При этом выражение обрабатывается, но не загружается в текущий документ.
Следующий код служит примером создания гипертекстовой ссылки, которая бездействует при нажатии на неё пользователем. Когда пользователь нажимает на ссылку, void(0) вычисляется равным undefined , что не приводит ни к каким действиям в JavaScript.
a href="javascript:void(0)">Нажмите здесь, чтобы ничего не произошлоa>
Приведённый ниже код создаёт гипертекстовую ссылку, которая подтверждает отправку формы при клике на ней пользователем:
a href="javascript:void(document.form.submit())"> Нажмите здесь, чтобы подтвердить отправку формыa >
Операторы отношения
Оператор отношения сравнивает свои операнды и возвращает результат сравнения в виде булева значения.
Оператор in
Оператор in возвращает true, если указанный объект имеет указанное свойство. Синтаксис оператора:
propNameOrNumber in objectName
где propNameOrNumber — строка или числовое выражение, представляющее имя свойства или индекс массива, а objectName — имя объекта.
Некоторые примеры способов использования оператора in :
// Массивы var trees = new Array("redwood", "bay", "cedar", "oak", "maple"); 0 in trees; // возвращает true 3 in trees; // возвращает true 6 in trees; // возвращает false "bay" in trees; // возвращает false (следует указать индекс элемента массива, // а не значение элемента) "length" in trees; // возвращает true (length является свойством объекта Array) // Встроенные объекты "PI" in Math; // возвращает true var myString = new String("coral"); "length" in myString; // возвращает true // Пользовательские объекты var mycar = make: "Honda", model: "Accord", year: 1998 >; "make" in mycar; // возвращает true "model" in mycar; // возвращает true
Оператор instanceof
Оператор instanceof возвращает true, если заданный объект является объектом указанного типа. Его синтаксис:
objectName instanceof objectType
где objectName — имя объекта, тип которого необходимо сравнить с objectType , а objectType — тип объекта, например, Date или Array .
Используйте оператор instanceof , когда вам необходимо подтвердить тип объекта во время выполнения программы. Например, при перехвате исключений вы можете создать различные программные переходы для обработки исключений в зависимости от типа обрабатываемого исключения.
Например, следующий код использует оператор instanceof для проверки того, является ли объект theDay объектом типа Date . Так как theDay действительно является объектом типа Date , то программа выполняет код, содержащийся в утверждении if .
var theDay = new Date(1995, 12, 17); if (theDay instanceof Date) // выполняемый код >
Приоритет операторов
Приоритет операторов определяет порядок их выполнения при вычислении выражения. Вы можете влиять на приоритет операторов с помощью скобок.
Приведённая ниже таблица описывает приоритет операторов от наивысшего до низшего.
| Тип оператора | Операторы |
|---|---|
| свойство объекта | . [] |
| вызов, создание экземпляра объекта | () new |
| отрицание, инкремент | ! ~ — + ++ — typeof void delete |
| умножение, деление | * / % |
| сложение, вычитание | + — |
| побитовый сдвиг | > >>> |
| сравнение, вхождение | < >= in instanceof |
| равенство | == != === !== |
| битовое-и | & |
| битовое-исключающее-или | ^ |
| битовое-или | | |
| логическое-и | && |
| логическое-или | || |
| условный (тернарный) оператор | ?: |
| присваивание | = += -= *= /= %= <>= >>>= &= ^= |= |
| запятая | , |
Более подробная версия данной таблицы, содержащая ссылки и дополнительную информацию по каждому оператору, находится в справочнике JavaScript.
Выражения
Выражением является любой корректный блок кода, который возвращает значение.
Концептуально, существуют два типа выражений: те которые присваивают переменной значение, и те, которые вычисляют значение без его присваивания.
Выражение x = 7 является примером выражения первого типа. Данное выражение использует оператор = для присваивания переменной x значения 7. Само выражение также равняется 7.
Код 3 + 4 является примером выражения второго типа. Данное выражение использует оператор «+» для сложения чисел 3 и 4 без присваивания переменной полученного результата 7.
Все выражения в JavaScript делятся на следующие категории:
- Арифметические: вычисляются в число, например: 3.14159 (Используют арифметические операторы).
- Строковые: вычисляются в текстовую строку, например: «Fred» или «234» (Используют строковые операторы).
- Логические: вычисляются в true или false (Используют логические операторы).
- Основные выражения: Базовые ключевые слова и основные выражения в JavaScript.
- Левосторонние выражения: Значениям слева назначаются значения справа.
Основные выражения
Базовые ключевые слова и основные выражения в JavaScript.
Оператор this
Используйте ключевое слово this для указания на текущий объект. В общем случае this указывает на вызываемый объект, которому принадлежит данный метод. Используйте this следующим образом:
this["propertyName"] this.propertyName
Предположим, функция validate выполняет проверку свойства value некоторого объекта; задан объект, а также верхняя и нижняя граница величины данного свойства:
function validate(obj, lowval, hival) if (obj.value lowval || obj.value > hival) alert("Неверное значение!"); >
Вы можете вызвать функцию validate для обработчика события onChange для каждого элемента формы, используя this для указания на элемент формы, как это показано в следующем примере:
b>Введите число от 18 до 99:b> input type="text" name="age" size="3" onChange="validate(this, 18, 99);" />
Оператор группировки
Оператор группировки «скобки» ( ) контролирует приоритет вычислений в выражениях. Например, вы можете переопределить порядок так, чтобы сложение выполнялось до умножения:
var a = 1; var b = 2; var c = 3; // обычный порядок a + b * c; // 7 // по умолчанию выполняется так a + (b * c); // 7 // теперь поменяем приоритет с помощью скобок, // чтобы сложение выполнялось до умножения (a + b) * c; // 9 // что эквивалентно следующему a * c + b * c; // 9
Упрощённый синтаксис создания массивов и генераторов
Упрощённый синтаксис — экспериментальная возможность JavaScript, которая возможно будет добавлена в будущие версии ECMAScript. Есть 2 версии синтаксиса:
Упрощённый синтаксис для массивов.
Упрощённый синтаксис для генераторов.
Упрощённые синтаксисы существуют во многих языках программирования и позволяют вам быстро собирать новый массив, основанный на существующем. Например:
[for (i of [ 1, 2, 3 ]) i*i ]; // [ 1, 4, 9 ] var abc = [ "A", "B", "C" ]; [for (letters of abc) letters.toLowerCase()]; // [ "a", "b", "c" ]
Левосторонние выражения
Значениям слева назначаются значения справа.
new
Вы можете использовать оператор new для создания экземпляра объекта пользовательского типа или одного из встроенных объектов. Используйте оператор new следующим образом:
var objectName = new objectType([param1, param2, . , paramN]);
super
Ключевое слово используется, чтобы вызывать функции родительского объекта. Это полезно и с классами для вызова конструктора родителя, например.
super([arguments]); // вызывает конструктор родителя. super.functionOnParent([arguments]);
Оператор расширения
Оператор расширения позволяет выражению расширяться в местах с множеством аргументов (для вызовов функций) или множестве элементов (для массивов).
Пример: Сегодня, если у вас есть массив и вы хотите создать новый с существующей частью первого, то литерального синтаксиса массива уже не достаточно, и вы должны писать императивный (без вариантов) код, используя комбинацию push , splice , concat и т.д. Но с этим оператором код становится более коротким:
var parts = ["shoulder", "knees"]; var lyrics = ["head", . parts, "and", "toes"];
Похожим образом оператор работает с вызовами функций:
function f(x, y, z) > var args = [0, 1, 2]; f(. args);
- « Предыдущая статья
- Следующая статья »
Found a content problem with this page?
- Edit the page on GitHub.
- Report the content issue.
- View the source on GitHub.
This page was last modified on 7 авг. 2023 г. by MDN contributors.
Your blueprint for a better internet.
MDN
Support
- Product help
- Report an issue
Our communities
Developers
- Web Technologies
- Learn Web Development
- MDN Plus
- Hacks Blog
- Website Privacy Notice
- Cookies
- Legal
- Community Participation Guidelines
Visit Mozilla Corporation’s not-for-profit parent, the Mozilla Foundation.
Portions of this content are ©1998– 2023 by individual mozilla.org contributors. Content available under a Creative Commons license.
Основы программирования на языке Python. Часть 2
На минутку представим себя богами. В первой части этой статьи мы с вами разобрали самые базовые элементы программирования. Или на нашем, на «божественном» — мы научились создавать самый простой мир, в котором живут разные человечки со своими особенностями, но без целей в жизни. Пора заставить их что-то делать и использовать свой потенциал по максимуму. Для этого переходим на новый уровень.
Условная конструкция. Табуляция
В этой статье мы будем переводить с алгоритмического языка на язык Python то, что выучили в одной из предыдущих статей — «Основы алгоритмов». Также мы успели изучить создание и применение переменных в Python, и то, какие типы данных могут быть им присвоены, в статье «Основы программирования на языке Python. Часть 1». Но далеко на этом не уедешь — нет никакой гибкости, никаких дополнительных возможностей, ничего интересного.
Условная конструкция if-elif-else — первый шаг на пути к разнообразию. Ее цель — совершать конкретные действия при конкретных обстоятельствах.
Эта логическая конструкция расшифровывается так — «если-иначе». Даже без нашего четкого осознания она появляется в повседневной жизни везде. Самая простая идея алгоритма с ветвлением (с условием): «Если в холодильнике нет продуктов, их надо купить, прежде чем начать готовить ужин, иначе можно сразу начинать готовку».
Как в программе Python выглядят ветвления?
Подробно разберем строение этой конструкции:
- if — главная команда создания условия, ее одной уже достаточно. С ней конструкция будет выглядеть так:
Если выполнится, то будет запущено , иначе не произойдет ничего.
if :
else:
Если выполнится, то будет запущен блок , а если оно не выполнится — запустится .
- elif — команда для создания сложного условия, когда у нас есть не два исхода, а больше.
if :
elif :
elif :
…
else:
В зависимости от выполнения какого-то из будет запущено соответствующее . Команда else в данном случае не обязательна: если она есть, при невыполнении всех условий выполнится ее тело, а если ее нет — просто не произойдет ничего.
Табуляцию можно проставить либо нажатием клавиши Tab, либо используя несколько идущих подряд пробелов. Традиционно табуляции соответствует 4 пробела. Но нельзя одновременно использовать и пробелы, и Tab — в одном блоке должно быть только что-то одно.
Про табуляцию вообще нельзя забывать и нужно быть с ней аккуратнее:
- если ее проставить неправильно — программа будет выполняться не так, как мы задумали;
- если не проставить совсем — программа не сможет даже запуститься.
А чем вообще может быть условие команды?
Это должна быть такая конструкция, про которую определенно можно сказать, истинна она или ложна. Например, 5 > 1 — истина (True), а 5 > 10 — ложь (False).
Для записи условий в Python предусмотрены как математические операторы сравнения, так и логические операторы:
Математические операторы сравнения работают так же, как и в школьном курсе алгебры. Только обратите внимание, что большинство из них записывается иначе, и могут применяться не только для чисел, а и для других типов данных.
Когда мы попробуем вывести на экран результат выполнения условия, мы увидим, что он может вернуть:
- либо значение True, которое соответствует выполнению записанного условия;
- либо False, соответствующее невыполнению условия.
x = 15
y = 16
print(x == y)
print((y > x) and (x > 5))
Это как раз и есть тот самый тип данных bool из предыдущей части статьи.
А ниже приведен пример кода, в котором разная расстановка отступов дает нам совершенно разное поведение программ.
Циклы. Тип range
Как в программе Python выглядят циклы?
Циклы используются для многократного повторения определенной команды или набора команд. Для выделения тела цикла также используется табуляция.
В Python есть два цикла — while и for.
Цикл while будет повторять команды своего тела до тех пор, пока выполняется условие, записанное для него.
Структура записи этого цикла:
Например, нам нужно уменьшать значение переменной a в 2 раза нацело до тех пор, пока она не станет меньше или равной переменной b. Для этого в условии цикла прописываем сравнение переменных, а в теле цикла — уменьшение значения переменной a. Пока условие выполняется (то есть принимает значение True), будет выполняться тело цикла, а когда оно перестанет выполняться — свою работу продолжит основной блок кода.
a = 1000000
b = 16
while a > b:
a //= 2
print(a)
После первой итерации (запуска содержимого цикла) переменная а будет равна 500 000, после второй — 250 000 и т.п. Итерации будут повторяться, пока будет продолжать быть истинным выражение a > b. Когда итерации цикла завершаются, мы видим итоговое значение переменной а после всех делений — 15.
Бесконечный цикл — ситуация, когда цикл while сам по себе никогда не сможет завершить свою работу, то есть значение его условия никогда не перестанет быть равным True.
Но как вообще можно в него попасть?
- Случайно, когда в записи условия работы цикла была допущена ошибка.
В приведенном примере цикл будет работать до тех пор, пока значение переменной b больше 0. Но никакого изменения этой переменной не происходит, она не меняет своего значения, и, соответственно, никогда не станет меньше или равной 0. А значит, цикл никогда не завершит свою работу.
- Специально. Редко, но это имеет смысл. Например, когда условие работы цикла зависит от большого количества параметров, проще будет прямо в цикле указать, что ему стоит прекратить свою работу.
Для создания бесконечного цикла в условии работы нужно прописать выражение, результат которого всегда будет равен True. Например, это может быть само значение True или условие сравнения 0 == 0, также возвращающее всегда True (0 действительно всегда равен 0).
Для остановки цикла используется команда break. Когда цикл натыкается на нее, он моментально прекращает свою работу. Не сработает и последующий блок кода, не будет и следующего шага цикла — программа сразу перескакивает в основной блок кода после цикла.
В примере мы создали бесконечный цикл, но, как только значение a станет меньше или равным b, выполнится условие if и сработает команда break, которая завершит цикл.
Цикл for необходим для выполнения команды или набора команд определенное количество раз или перебора набора данных.
Этот цикл похож на человека, выкладывающего продукты на кассе в магазине. Сколько бы ни было продуктов в корзине — он каждый достанет из корзины и положит на ленту, перебирая по очереди все продукты.
Структура записи цикла for:
Здесь мы сталкиваемся с понятием коллекции — той самой нашей «корзины с покупками», то есть какой-то структуры данных, содержащей много различных значений в себе. Пока что мы из таких типов структур данных знакомы со строками и списками из первой части статьи, а ниже в этой статье разберем еще одну — range.
Как работает цикл for? На каждом шаге цикла будет принимать новое значение из , после чего будет выполняться .
По традиции, если перебираемая переменная не несет в себе особой смысловой нагрузки, ее называют i, j или k.
может принимать любое значение, которое можно перебрать.
Команда range позволяет создавать диапазоны — последовательности целых чисел, отличающихся друг от друга на одно и то же число — разницу или шаг диапазона.
Есть несколько способов создания диапазона:
- range(a) — диапазон целых чисел от 0 до (a — 1) с шагом 1.
Например: range(5) — 0, 1, 2, 3, 4.
- range(a, b) — диапазон чисел от a до (b — 1) с шагом 1.
Например: range(2, 7) — 2, 3, 4, 5, 6.
- range(a, b, step) — диапазон чисел от a до (b — 1) с разницей между соседними числами, равной step.
Например: range(1, 17, 3) — 1, 4, 7, 10, 13, 16.
Взаимозаменяемость циклов
Сейчас мы будем заниматься практикой, а заодно посмотрим, как с помощью разных циклов можно решить одну и ту же задачу.
Задача.
У нас есть список чисел a. Нужно вывести на экран его содержимое, по одному числу в строке.
Решение №1.
Чтобы выполнить задачу, нам необходимо перебрать каким-то циклом все его элементы и каждый вывести на экран. Тогда напрашивается самое очевидное решение:
for i in a:
print(i)
Мы берем каждый элемент списка и выводим его, все просто. Но это не единственный способ.
Решение №2.
Мы можем вместо элементов списка перебирать числа-позиции элементов в списке а и выводить на экран элементы на соответствующих позициях. Это можно сделать, например, так:
for i in range(len(a)):
print(a[i])
Здесь len(a) — это длина списка а. Мы используем ее, чтобы понять, до какого числа надо перебирать i, чтобы на i-тых позициях списка все еще были элементы. Это же можно тоже записать другим способом:
Разные подходы к применению циклов позволяют всегда выбирать наиболее удобный под конкретные задачи. Например, здесь нам не важны позиции элементов списка и проще всего было использовать первое решение. Но в разных контекстах задач могут быть разные преимущества и недостатки каждого из циклов.
Вложенные структуры
После знакомства с условными конструкциями и циклами разброс наших возможностей сильно возрастает. Но он возрастет еще сильнее, если мы научимся правильно их комбинировать и использовать одно в другом.
Для этого можем воспользоваться вложенными структурами, когда одна конструкция находится внутри другой.
Такой пример уже мелькнул — когда мы говорили о бесконечном цикле и команде break. Мы сделали так, что внутри цикла команда break выполнится только при истинности условия, для чего прямо внутри цикла while мы использовали условную конструкцию if.
Чтобы программа «не сошла с ума», пытаясь понять, где тело цикла, а где тело условия, мы продолжили использовать табуляцию.
Весь блок условия находится в цикле, поэтому табуляция цикла никуда не делась. Тело вложенного условия получает свою собственную табуляцию прямо поверх предыдущей. Эти разные табуляции отмечены зеленым и синим цветом.
Вложенные структуры — удобный способ повысить возможности программы. Здесь мы никак не ограничены: мы можем вкладывать циклы в циклы, условия в условия, циклы в условия и так далее. Количество вложений также ничем не ограничено.
| Важно запомнить: если друг в друга вкладывается несколько циклов for, их переменные должны иметь разные имена. |
Разберем в качестве примера следующий код:
n = 1
for i in range(3):
for j in range(2):
n += 2
n *= 3
print(n)
Какое число на экране будет в результате этой программы?
У нас есть внутренний цикл и внешний. Тело внутреннего цикла запускается дважды: при j = 0 и j =1. Каждый раз значение n увеличивается на 2. Значит, в процессе работы внутреннего цикла значение n увеличивается на 2 * 2 = 4.
Тогда тело внешнего цикла — прибавление к n 4 и умножение на 3. Цикл повторяется трижды — i принимает значения 0, 1, 2. Тогда после первой итерации внешнего цикла n=(1+4)*3=15, после второй итерации n=(15+4)*3=57, после третьей — n=(57+4)*3=183.
На экран будет выведено 183.
Импорт модулей
Для еще большего увеличения мощи нашей программы мы можем использовать модули — наборы инструментов с готовыми решениями части наших задач.
Это легко сравнить с проведением ремонта в квартире. Мы можем что-то сделать простыми инструментами, которые лежат на балконе. Но гораздо эффективнее будет съездить в магазин за специальными инструментами. Так мы не только шкаф — ракету соберем.
Какие есть модули и какие в них есть инструменты — мы будем изучать по мере необходимости. Сейчас главное — узнать, как именно это делается. И делать мы это будем на примере модуля math, в котором лежит прекрасная функция sqrt. Она умеет извлекать корни чисел.
Если вдруг случилось так, что вы совсем забыли, как извлекаются корни чисел, то советуем обратиться к нашей статье по математике «Понятие корня».
Для получения инструментов модуля необходимо произвести его импорт — добавление модуля или его частей в программу. Сделать это можно несколькими способами:
import math
При такой записи доступ к конкретной функции мы получим, прописав название этого модуля, после него через точку — название необходимой функции.
- Импорт всех функций модуля:
from math import *
При такой записи в нашу программу попадают вообще все функции модуля, для доступа к которым теперь не нужно прописывать название самого модуля.
- Импорт конкретных функций модуля:
from math import sqrt
Такая запись даст нам доступ только к конкретным функциям из всего модуля, которые мы импортируем.
Понимание условий и циклов необходимо для решения любых задач на программирование. Разберем пример задачи №6 ОГЭ.
Дана программа на языке программирования Python:
a = int(input())
b = int(input())
if a == 15 or b == 50:
print(“Да”)
else:
print(“Нет”)
Было проведено 9 запусков. В качестве переменных a и b пользователь вводил следующие значения. Первое значение – переменная a, второе значение – переменная b.
(15; 19); (19; 50); (10; 26); (10; 56); (8; 50); (10; 10); (50; 50); (10; 2); (10; 40).
Определите количество запусков, при которых программа выведет «Да».
Решение.
Заметим, что программа печатает «Да», если a = 15 или b = 50, то есть выполнение хотя бы одного из равенств говорит о том, что программа выведет «Да».
Проверим пары чисел на условия:
— (15; 19) — выполнено a = 15;
— (19; 50) — выполнено b = 50;
— (10; 26) — не выполнено;
-(10; 56) — не выполнено;
— (8; 50) — выполнено b = 50;
— (10; 10) — не выполнено;
— (50; 50) — выполнено b = 50;
— (10; 2) — не выполнено;
— (10; 40) — не выполнено.
Нам подойдут все пары, кроме тех, где написано «не выполнено». Их всего 4 штуки.
Ответ: 4
Существует математическое доказательство того, что с помощью циклов и условий можно реализовать совершенно любой алгоритм. Но использование циклов и условий — только самый базовый уровень программирования, и какие-то сложные вещи нам останутся недоступны.
Это все равно что собирать автомобиль, имея под рукой только листы металла. Дальше вы узнаете про много особенностей языка, упрощающих создание алгоритмов, чтобы заменить эти листы металла на заготовки деталей и прочие более удобные для сборки элементы. Но прежде чем работать с более высокоуровневыми конструкциями, надо попрактиковаться в работе с уже пройденным материалом, например, в этой статье.
Фактчек
- Табуляция — способ структуризации кода, где отдельные блоки кода выделяются отступами.
- Условная конструкция if-elif-else необходима для выполнения определенных блоков кода при определенных исходах условия.
- Циклы нужны для многократного повторения блока кода. Цикл while выполняет блок кода, пока выполняется переданное ему условие; цикл for перебирает переданные ему значения.
- Импортируя модули, мы можем получить доступ к функциям, которые изначально в программе доступны не были.
Проверь себя
Задание 1.
Без запуска кода определите, что будет выведено на экран в результате выполнения программы:
Задание 2.
Без запуска кода определите, что будет выведено на экран в результате выполнения программы:
x = 250
if x < 100:
print(x + 25)
elif x print(x — 100)
Задание 3.
Без запуска кода определите, что будет выведено на экран в результате выполнения программы:
b = 0
for i in range(5):
b = b + i
print(b)
Задание 4.
Без запуска кода определите, что будет выведено на экран в результате выполнения программы:
x = 50
y = 20
while x < y:
x -= 20
print(x)
Ответы: 1. — 4; 2. — 3; 3. — 3; 4. — 3.
ЕСЛИ (функция ЕСЛИ)
Функция ЕСЛИ — одна из самых популярных функций в Excel. Она позволяет выполнять логические сравнения значений и ожидаемых результатов.
Поэтому у функции ЕСЛИ возможны два результата. Первый результат возвращается в случае, если сравнение истинно, второй — если сравнение ложно.
Например, функция =ЕСЛИ(C2=»Да»;1;2) означает следующее: ЕСЛИ(С2=»Да», то вернуть 1, в противном случае вернуть 2).
Функция ЕСЛИ, одна из логических функций, служит для возвращения разных значений в зависимости от того, соблюдается ли условие.
ЕСЛИ(лог_выражение; значение_если_истина; [значение_если_ложь])
- =ЕСЛИ(A2>B2;»Превышение бюджета»;»ОК»)
- =ЕСЛИ(A2=B2;B4-A4;»»)
Имя аргумента
лог_выражение (обязательно)
Условие, которое нужно проверить.
значение_если_истина (обязательно)
Значение, которое должно возвращаться, если лог_выражение имеет значение ИСТИНА.
значение_если_ложь (необязательно)
Значение, которое должно возвращаться, если лог_выражение имеет значение ЛОЖЬ.
Простые примеры функции ЕСЛИ
- =ЕСЛИ(C2=»Да»;1;2)
В примере выше ячейка D2 содержит формулу: ЕСЛИ(C2 = Да, то вернуть 1, в противном случае вернуть 2)
- =ЕСЛИ(C2=1;»Да»;»Нет»)
В этом примере ячейка D2 содержит формулу: ЕСЛИ(C2 = 1, то вернуть текст «Да», в противном случае вернуть текст «Нет»). Как видите, функцию ЕСЛИ можно использовать для сравнения и текста, и значений. А еще с ее помощью можно оценивать ошибки. Вы можете не только проверять, равно ли одно значение другому, возвращая один результат, но и использовать математические операторы и выполнять дополнительные вычисления в зависимости от условий. Для выполнения нескольких сравнений можно использовать несколько вложенных функций ЕСЛИ.
- =ЕСЛИ(C2>B2;»Превышение бюджета»;»В пределах бюджета»)
В примере выше функция ЕСЛИ в ячейке D2 означает: ЕСЛИ(C2 больше B2, то вернуть текст «Превышение бюджета», в противном случае вернуть текст «В пределах бюджета»)
- =ЕСЛИ(C2>B2;C2-B2;0)
На рисунке выше мы возвращаем не текст, а результат математического вычисления. Формула в ячейке E2 означает: ЕСЛИ(значение «Фактические» больше значения «Плановые», то вычесть сумму «Плановые» из суммы «Фактические», в противном случае ничего не возвращать).
- =ЕСЛИ(E7=»Да»;F5*0,0825;0)
В этом примере формула в ячейке F7 означает: ЕСЛИ(E7 = «Да», то вычислить общую сумму в ячейке F5 и умножить на 8,25 %, в противном случае налога с продажи нет, поэтому вернуть 0)
Примечание: Если вы используете текст в формулах, заключайте его в кавычки (пример: «Текст»). Единственное исключение — слова ИСТИНА и ЛОЖЬ, которые Excel распознает автоматически.
Распространенные неполадки
0 (ноль) в ячейке
Не указан аргумент значение_если_истина или значение_если_ложь. Чтобы возвращать правильное значение, добавьте текст двух аргументов или значение ИСТИНА/ЛОЖЬ.
Как правило, это указывает на ошибку в формуле.
Дополнительные сведения
Вы всегда можете задать вопрос эксперту в Excel Tech Community или получить поддержку в сообществах.