Javascript switch case несколько значений: Конструкция «switch»

Javascript switch case несколько значений

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

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

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

case и default называют вариантами switch .

Обратите внимание, что вариант default , не является обязательным.

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

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

Пример работы инструкции switch :

На изображении ниже показан порядок выполнения:

Пример без инструкции break :

Для выхода из switch может использоваться не только инструкция break , но также и инструкция return (если switch находится внутри функции) или continue (если switch находится внутри цикла).

Несколько вариантов можно ассоциировать с одним и тем же программным кодом:

Варианты case не обязательно должны записываться друг под другом, для удобства их можно расположить в ряд:

Возможность использовать выражения в case позволяет писать такой код:

Учебник JavaScript

Практика

Работа с DOM

Практика

Некоторые продвинутые вещи

Рекомендованное ES6

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

Регулярки

Разное

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

Практика

• урок исключен (мало материала), по аяксу скоро будет отдельный учебник (много материала)
  Работа с
  AJAX в JavaScript –>
  Работа с
  AJAX + PHP –>

Контекст

Drag-and-Drop

• Урок №
  Введение
  в ООП в стиле ES6
• Урок №
  Основы
  работы с ООП
• Урок №
  Наследование
  классов в JavaScript
  Продвинутая работа
  с классами на JavaScript –>
• Урок №
  Применение
  ООП при работе с DOM
• Урок №
  Практика
  по ООП в JavaScript
• Тут скоро будут еще уроки
  по функциональному и прототипному
  стилю ООП.

Практика по ООП

Ваша задача: посмотрите, попробуйте повторить.

Практика

Promise ES6

Библиотека jQuery

Тк. jQuery устаревает, объявляю эти уроки не обязательными и выношу в конец учебника (так по уровню уроки середины учебника, если что). В перспективе переедет в отдельный учебник по jq.

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

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

То есть нам нужно иметь возможность спросить у JavaScript ‘Если’.

Например так: если эта переменная меньше нуля, то вывести ‘отрицательно’, иначе (то есть если она больше нуля) вывести ‘положительно’.

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

Обратите внимание на то, что блок else не обязателен.

Логическое выражение представляет собой тот самый вопрос, который мы хотим задать JavaScript. Например, чтобы спросить ‘переменная a больше нуля’ мы напишем так: a > 0.

Сокращенный синтаксис

В случае, если в фигурных скобках if или else будет только одно выражение, можно эти фигурные скобки не писать:

Равенство по значению и типу

Для того, чтобы сравнить на

равенство следует использовать оператор двойное равно ==, а не одиночное =, как можно было подумать.

Почему так? Потому что одиночное равно зарезервировано за присваиванием. Смотрите пример:

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

Кроме оператора == существует еще и оператор ===. Их различие в том, что === сравнивает не только по значению, но и по типу, а == сравнивает только по значению.

Чтобы полностью разобраться в этом внимательно изучите примеры:

Не равно

Для того, чтобы спросить

‘не равно’, существует операторы != и !==. Первый игнорирует различие в типах, а второй – нет.

Все операции сравнения

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

a == b

a равно b

a === b

a равно b и они одинаковы по типу

a != b

a не равно b

a !== b

a не равно b или a равно b, но ни разные по типу

a b

a больше b

a = b

a больше или равно b

Несколько условий сразу

Иногда может быть нужно составить какое-то сложное условие

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

Для этого существуют операторы && (логическое И) и || (логическое ИЛИ).

Работа с логическими переменными

Многие функции JavaScript в результате своей работы возвращают либо true (истина), либо false (ложь). Эти значения довольно удобны при своей работе, но новичкам бывает довольно сложно понять их.

Представим себе, что переменная a равна

true. В таком случае конструкцию if можно записать так:

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

Прием такой: конструкцию a == true можно заменить на более простую: вместо if (a == true) написать if (a) и она будет работать аналогично.

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

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

Вложенные if

Предположим, нам необходимо спросить у JavaScript такую вещь: если переменная a не определена, то вывести ‘Введите a’, если определена, то проверить – больше нуля

a или нет. Если больше нуля – то вывести ‘Больше нуля!’, если меньше – вывести ‘Меньше нуля’.

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

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

Недостатком конструкции предыдущего примера является большое количество фигурных скобок.

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

Можно использовать несколько else if, но злоупотреблять этим не стоит (лучше будет воспользоваться конструкцией switch-case

, о которой ниже).

Несколько if

Пусть у нас есть такая задача: сайт поддерживает 3 языка – русский, английский, немецкий. Переменная lang может принимать 3 значения – ‘ru’, ‘en’ и ‘de’. В зависимости от значения переменной lang следует вывести фразу на одном из языков.

Решение: можно было бы воспользоваться вложенными ифами или else if. Выглядело бы это примерно так:

Такое решение не слишком красивое – блок else здесь не нужен! Проще всего будет написать не один длинный if с несколькими else, а несколько if вообще без else

:

Однако это решение тоже не слишком удобно. Представьте, что у вас будет не три языка, а 10 – вам придется написать 10 конструкций if.

Для таких случаев существует конструкция switch-case.

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

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

Изучите ее синтаксис:

Решим нашу задачу с тремя языками с помощью данной конструкции:

Что вам делать дальше:

Приступайте к решению задач по следующей ссылке: задачи к уроку.

Когда все решите – переходите к изучению новой темы.

Иногда вместо множества вложенных операторов if можно использовать инструкцию switch .

Switch позволяет сравнить выражение с множеством значений, что позволяет избавиться от серии операторов if и сделать код более компактным.

Инструкция switch

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

Синтаксис оператора switch выглядит следующим образом:

• Выполнение инструкции начинается с вычисления выражения n. Его иногда называют тестовым.
• Выполняется проверка на строгое равенство значения тестового выражения n и значений меток в предложениях case (первому значению value1, затем второму value2 и так далее) в порядке их следования в теле инструкции switch.
• Если соответствие установлено – switch начинает выполняться от соответствующей директивы case и далее, до ближайшего break (или до конца switch, если break отсутствует).
• Если совпадения не произошло, то выполняются инструкции default-ветви. Ветвь default не является обязательной, поэтому при ее отсутствии управление передается следующей за инструкцией switch, т.е. тело ее просто пропускается.

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

Пример работы инструкции switch:

При отсутствии инструкции break в каком-либо варианте, управление будет передано инструкциям, относящимся к следующим вариантам. При этом остальные проверки на соответствие выражению не будут выполняться. Интерпретатор JavaScript выйдет из инструкции switch, только когда дойдет до её конца или встретит break. Очевидно, это не то, что обычно нужно для решения задачи выбора. Поэтому каждый блок case, как правило, необходимо заканчивать инструкцией Ьreak или return.

Пример без break:

На заметку: Для выхода из инструкции switch может использоваться не только break, но также и инструкции return или continue, если switch находится внутри функции или цикла соответственно.

Группировка case

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

В примере ниже case 1, case 2 и case 3 выполняют один и тот же код:

Второй способ группировки case, менее стандартный – во второй строке, где вы ожидали увидеть switch(x), расположено постоянное булево значение true , а в значении case используется выражение вместо константы:

Примечание: Несмотря на то, что инструкция switch позаимствована из других языков, в JavaScгipt она имеет свои особенности. Во-первых, она работает со всеми типами данных, так что ее можно использовать с числами, строками и даже с объектами. Во-вторых, значения (case) для сравнения с выражением инструкции switch могут быть не только константами, но и переменными и даже выражениями.

Определите время года

Пользователь вводит значение переменной num. Переменная num может принимать 4 числовых значения: 1, 2, 3 или 4. Если она имеет значение 1, то в переменную result запишите ‘весна’, если имеет значение 2 – ‘лето’ и так далее. Решите задачу через switch-case.

Как известно prompt возвращает строку, например ‘3’, а не число 3. Т.к. оператор switch предполагает строгое равенство ===, так что совпадения не будет. Для преобразования строки, введенной пользователем, в число необходимо перед prompt поставить унарный +.

JS JavaScript Switch

---

Оператор switch используется для выполнения различных действий, основанных на различных условиях.

---

Оператор переключения JavaScript

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

Синтаксис

switch(expression) {
    case n:
        code block
        break;
    case n:
        code block
        break;
    default:
        code block
}

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

• Выражение switch вычисляется один раз.
• Значение выражения сравнивается со значениями каждого регистра.
• Если совпадение, выполняется связанный блок кода.

Пример

Метод getDay () возвращает день недели как число от 0 до 6.

(Sunday=0, Monday=1, Tuesday=2 ..)

В этом примере для вычисления названия дня недели используется номер дня недели:

switch (new Date().getDay()) {
    case 0:
        day = «Sunday»;
        break;
    case 1:
        day = «Monday»;
        break;
    case 2:
        day = «Tuesday»;
        break;
    case 3:
        day = «Wednesday»;
        break;
    case 4:
        day = «Thursday»;
        break;
    case 5:
        day = «Friday»;
        break;
    case 6:
        day = «Saturday»;
}

Результат дня будет:

---

---

Ключевое слово Break

Когда JavaScript достигает ключевого слова break , он вырывается из блока switch.

Это остановит выполнение большего количества кода и тестирования дела внутри блока.

Когда спичка найдена, и работа сделана, настало время для перерыва. Нет необходимости в большем тестировании.

Перерыв может сэкономить много времени выполнения, поскольку он «игнорирует» выполнение всего остального кода в блоке switch.

Не обязательно ломать последний случай в блоке переключателя. Блок ломается (заканчивается) там в любом случае.

---

Ключевое слово по умолчанию

Ключевое слово Default указывает код для выполнения, если совпадений нет.

Пример

Метод getDay () возвращает день недели как число от 0 до 6.

Если сегодня нет ни субботы (6), ни воскресенья (0), напишите сообщение по умолчанию:

switch (new Date().getDay()) {
    case 6:
        text = «Today is Saturday»;
        break;
    case 0:
        text = «Today is Sunday»;
        break;
    default:
        text = «Looking forward to the Weekend»;
}

The result of text will be:

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

Пример

switch (new Date(). getDay()) {
    default:
        text = «Looking forward to the Weekend»;
        break;
    case 6:
        text = «Today is Saturday»;
        break;
    case 0:
        text = «Today is Sunday»;
}

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

---

Общие блоки кода

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

В этом примере CASE 4 и 5 используют один и тот же блок кода, а 0 и 6 используют другой блок кода:

Пример

switch (new Date().getDay()) {
    case 4:
    case 5:
        text = «Soon it is Weekend»;
        break;
    case 0:
    case 6:
        text = «It is Weekend»;
        break;
    default:
        text = «Looking forward to the Weekend»;
}

---

Детали переключения

Если несколько вариантов соответствуют значению регистра, выбирается первый вариант.

Если совпадающие случаи не найдены, программа продолжает метку по умолчанию .

Если метка по умолчанию не найдена, программа переходит к операторам после переключателя.

---

Строгое сравнение

Варианты переключения используют строгое сравнение (= = =).

Значения должны быть одного и того же типа для сопоставления.

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

В этом примере не будет совпадения для x:

Пример

var x = «0»;
switch (x) {
    case 0:
        text = «Off»;
        break;
    case 1:
        text = «On»;
        break;
    default:
        text = «No value found»;
}

---

JavaScript: switch case — выбор вариантов

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

Даже если решение может иметь несколько вариантов, к любой цели будет вести только один путь, но путей обычно несколько, и нужно делать выбор.

Классический условный оператор if (условие) {алгоритм 1, если условие истинно} else {алгоритм 2, если условие ложно} дает только два варианта выбора. Но даже простая реальная задача дает всегда много вариантов.

Простое «не одно», но одно условие

Конструкция JavaScript, switch case = несколько значений условия. Аналогичное можно получить использованием комбинаций оператора If. Однако, несомненно, первый вариант синтаксически и семантически более корректен. Кроме того, формально решение по второму варианту потребует от разработчика большей квалификации:

Здесь комбинация if (…) {…} else {…} и try {…} cath (…) {…} обеспечивает начало процедуры AJAX-обмена в алгоритме. Обработка ответа выполняется аналогичным набором условных операторов.

JavaScript switch case: пример

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

Конструкция JavaScript switch case позволяет предусмотреть несколько алгоритмов в зависимости от значения переменной или значения выражения. Важно учитывать, что выбор нужного алгоритма будет произведен по точному совпадению значения условия в switch () и того значения, что указано в case. Символ «1» и цифра 1 — это не одно и тоже, преобразование типов здесь не производится.

Выполнение нескольких секций

Характерной особенностью вариантов выбора в конструкции JavaScript switch case является отсутствие скобок блоков — {…}, которым поручено определять только начало и конец тела этого оператора. Каждая секция case завершается оператором break, которого может и не быть.

В этих примерах пропущен break в первой секции case. Вариант слева выдаст результат Variant2, потому как именно с него начнется выполнение, а в варианте справа будет получено Variant1Variant2, так как будет выполнено первое, но никакого эффекта не будет от второго условия, а кроме того, ничего не мешает выполнить операторы первой секции, затем второй: между ними нет оператора break, а дважды JavaScript switch case не делает. Следует отметить, что изменение переменной iCond в теле конструкции никакого эффекта не даст.

Реальность кода и реальность задачи

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

Операторы выбора могут вставляться друг в друга. В их секциях case могут быть условными операторами, циклами, любыми другими конструкциями. Не следует пренебрегать областями видимости переменных. Используемое везде должно быть описано глобально.

Однако не следует злоупотреблять JavaScript. Switch case — отличный инструмент ветвления, но не мобильный на больших объемах кода. Чем продуманнее и функциональнее исполнен выбор вариантов, тем сложнее его будет менять впоследствии.

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

С этой точки зрения основной недостаток JavaScript switch case вытекает из ее размера и сложности. Если не злоупотреблять этим, можно обеспечить достижение делаемого компактными и небольшими вариантами выбора.

Условие + решение = новый виток движения

Правильно сформулированная задача приближает решение. Хотя задача, по определению, сама не может ничего решать и приближать.

Условие используется повсеместно (частная маленькая задача). Исполнение условия = исполнение некоторого кода. Использование на JavaScript switch case — это и дань моде, и очевидная необходимость. Так делаются на всех языках, потому как просто и удобно.

Когда-то рождался «Лисп» и «Пролог», аналогичные им языки программирования. Были баталии по поводу операторов перехода и меток. Пытался получить приличный рейтинг функциональный стиль написания программ. Сегодня массовый разработчик увлеченно пропагандирует объектно-ориентированные идеи.

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

Использование оператора switch в Go

Введение

Условные выражения дают программистам возможность предписывать программам производить определенные действия, если условие выполняется, и другое действие, если условие не выполняется. Нам часто нужно сравнивать определенную переменную с разными возможными значениями и выполнять разные действия для разных результатов. Это можно реализовать, используя только операторы if. Однако написание программного обеспечения предусматривает необходимость не только делать так, чтобы все работало, но и показывать свои намерения себе и другим разработчикам. switch — это альтернативный условный оператор, с помощью которого удобно показывать действия программ Go в ситуациях с разными возможными вариантами.

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

Структура оператора switch

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

package main

import "fmt"

func main() {
    flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}

    for _, flav := range flavors {
        if flav == "strawberry" {
            fmt.Println(flav, "is my favorite!")
            continue
        }

        if flav == "vanilla" {
            fmt.Println(flav, "is great!")
            continue
        }

        if flav == "chocolate" {
            fmt. Println(flav, "is great!")
            continue
        }

        fmt.Println("I've never tried", flav, "before")
    }
}

Результат будет выглядеть следующим образом:

Output
chocolate is great!
vanilla is great!
strawberry is my favorite!
I've never tried banana before

В main мы определяем срез вкусов мороженого. Затем мы используем цикл for для итерации. Мы используем три оператора if для вывода разных сообщений, показывающих разные предпочитаемые вкусы мороженого. Каждый оператор if должен использовать оператор continue для остановки выполнения цикла for, чтобы последнее сообщение по умолчанию не выводилось для предпочитаемых вкусов мороженого.

При добавлении новых вкусов мороженого нам нужно добавлять операторы if для каждого нового случая. Для дублирующихся сообщений, как в случае с "vanilla" и "chocolate", следует использовать дублирующиеся операторы if. Тем, кто будет читать наш код в будущем (в том числе и нам), будет сложнее понять код из-за большого количества повторяющихся операторов if, что затрудняет понимание их функции — сравнение переменной с разными значениями и выполнение разных действий. Кроме того, общее сообщение задается отдельно от условий и выглядит не связанным с ними. Оператор switch поможет нам лучше организовать эту логику.

Оператор switch начинается с ключевого слова switch, за которым идет переменная в базовой форме, для которой производится сравнение. Далее идет пара фигурных скобок ({}), в которых могут быть заключены разные варианты. Варианты описывают, какие действия должна выполнять программа Go, если переданная оператору switch переменная имеет значение, указанное в данном варианте. В следующем примере предыдущий пример конвертирован с использованием оператора switch вместо нескольких операторов if:

package main

import "fmt"

func main() {
    flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}

    for _, flav := range flavors {
        switch flav {
        case "strawberry":
            fmt. Println(flav, "is my favorite!")
        case "vanilla", "chocolate":
            fmt.Println(flav, "is great!")
        default:
            fmt.Println("I've never tried", flav, "before")
        }
    }
}

Результат выглядит так же:

Output
chocolate is great!
vanilla is great!
strawberry is my favorite!
I've never tried banana before

Мы снова определяем срез вкусов мороженого в программе main и используем выражение range для итерации вкусов. Однако в данном случае мы используем выражение switch, которое оценивает переменную flav. Мы используем два выбирающих предложения для указания предпочтений. Нам больше не требуются операторы continue, поскольку только один вариант выполняется оператором switch. Также мы сможем комбинировать дублирующуюся логику условий "chocolate" и "vanilla", разделив их запятой в объявлении варианта. Вариант default используется как универсальный для всех случаев. Оно выполняется для всех вкусов, которые не включены в тело выражения switch. В данном случае для варианта "banana" будет использоваться программа default и будет выведено сообщение I've never tried banana before.

Упрощенная форма оператора switch используется в самом распространенном случае: при сравнении переменной с несколькими альтернативными значениями. Также она обеспечивает дополнительное удобство, если мы хотим выполнять одно и то же действие для нескольких разных значений и другое действие, если не выполняется ни одно из заданных условий. Для этого используется ключевое слово default.

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

Общий оператор switch

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

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    rand.Seed(time.Now().UnixNano())
    target := rand.Intn(100)

    for {
        var guess int
        fmt.Print("Enter a guess: ")
        _, err := fmt.Scanf("%d", &guess)
        if err != nil {
            fmt.Println("Invalid guess: err:", err)
            continue
        }

        if guess > target {
            fmt.Println("Too high!")
            continue
        }

        if guess < target {
            fmt.Println("Too low!")
            continue
        }

        fmt.Println("You win!")
        break
    }
}

Результат зависит от случайного числа и от того, как хорошо вы играете в игру. Вот пример результатов одного игрового сеанса:

Output
Enter a guess: 10
Too low!
Enter a guess: 15
Too low!
Enter a guess: 18
Too high!
Enter a guess: 17
You win!

Для нашей игры на отгадывание требуется случайное число для сравнения, и поэтому мы используем функцию rand.Intn из пакета math/rand. Чтобы убедиться в получении разных значений target при каждой игре мы используем rand.Seed для рандомизации генератора случайных чисел по текущему времени. Аргумент 100 для rand.Intn дает нам число в диапазоне 0–100. Затем мы используем цикл for для сбора предположений игрока.

Функция fmt.Scanf дает нам способ считывания вводимых пользователем данных в и сохранения в переменную по нашему выбору. Она использует глагол строки формата, конвертирующий вводимые пользователем данные в ожидаемый нами тип. Здесь %d означает, что мы ожидаем значение int, и мы передаем адрес переменной guess, чтобы у fmt. Scanf была возможность задать эту переменную. После обработки всех ошибок парсинга мы используем два оператора if для сравнения догадки пользователя со значением target. Возвращаемая строка вместе с булевым значением определяют, какое сообщение будет выведено игроку, и будет ли закрыта игра.

Эти операторы if скрывают тот факт, что все значения в диапазоне, с которым сравнивается переменная, связаны друг с другом. При этом сложно сразу определить, не пропустили ли мы какую-то часть диапазона. В следующем примере предыдущий пример модифицирован с использованием оператора switch:

package main

import (
    "fmt"
    "math/rand"
)

func main() {
    target := rand.Intn(100)

    for {
        var guess int
        fmt.Print("Enter a guess: ")
        _, err := fmt.Scanf("%d", &guess)
        if err != nil {
            fmt.Println("Invalid guess: err:", err)
            continue
        }

        switch {
        case guess > target:
            fmt. Println("Too high!")
        case guess < target:
            fmt.Println("Too low!")
        default:
            fmt.Println("You win!")
            return
        }
    }
}

Результат выглядит примерно следующим образом:

Output
Enter a guess: 25
Too low!
Enter a guess: 28
Too high!
Enter a guess: 27
You win!

В этой версии игры на отгадывание мы заменили блок операторов if на оператора switch. Мы пропускаем аргумент выражения для switch, поскольку мы используем switch только для объединения условий. Каждое выбирающее предложение содержит отдельное выражение сравнения guess и target. Как и в первом случае, когда мы заменили операторы if на оператор switch, нам больше не нужно использовать выражения continue, поскольку выполняется только одно выбирающее предложение. Наконец, выражение default отвечает за случай, когда guess == target, поскольку все остальные возможные варианты рассмотрены в двух других выбирающих предложениях.

В приведенных примерах выполнялось только одно выбирающее выражение. Иногда нужно объединить варианты поведения нескольких выбирающих предложений. Оператор switch имеет еще одно ключевое слово для этой цели.

Fallthrough

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

package main

import "fmt"

func main() {
    flavors := []string{"chocolate", "vanilla", "strawberry", "banana"}

    for _, flav := range flavors {
        switch flav {
        case "strawberry":
            fmt.Println(flav, "is my favorite!")
            fallthrough
        case "vanilla", "chocolate":
            fmt. Println(flav, "is great!")
        default:
            fmt.Println("I've never tried", flav, "before")
        }
    }
}

Результат будет выглядеть примерно так:

Output
chocolate is great!
vanilla is great!
strawberry is my favorite!
strawberry is great!
I've never tried banana before

Как мы уже видели, мы определяем срез строк для представления вкусов и используем цикл for для итерации. Здесь оператор switch повторяет использованный ранее, но в нем используется ключевое слово fallthrough в конце выбирающего предложения для варианта "strawberry". Так Go запускает тело case "strawberry": и вначале выводит строку strawberry is my favorite!. При появлении fallthrough выполняется тело следующего выбирающего предложения. При этом будет выполнено тело выражения case "vanilla", "chocolate": и будет выведен текст strawberry is great!.

Ключевое слово fallthrough нечасто используется разработчиками на Go. Обычно повторное использование кода, реализуемое через ключевое слово fallthrough, лучше обеспечить посредством определения функции в общем коде. По этой причине использовать fallthrough не рекомендуется.

Заключение

Оператор switch помогает нам передать другим разработчикам, читающим наш код, что сравниваемые значения в наборе как-то связаны друг с другом. Это упрощает добавление других вариантов поведения и позволяет правильно обрабатывать все варианты, которые мы могли забыть благодаря использованию default. Когда вы в следующей раз будете писать код с несколькими оператора if для одной и той же переменной, попробуйте переписать его с помощью switch. Так вам будет проще переделать код, если в будущем потребуется добавить другие альтернативные значения.

Если вы хотите узнать больше о языке программирования Go, ознакомьтесь с нашей серией статей о программировании на языке Go.

Swift | Конструкция switch

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

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

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

var num: Int = 22

switch num {
case 0:
    print("Переменная равна 0")
case 10:
    print("Переменная равна 10")
case 22:
    print("Переменная равна 22")
default:
    print("не удалось распознать число")
}

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

Если совпадение не будет найдено, то выполняется оператор default.

В данном случае так как переменная num равна 22, будет выполняться следующий блок case:

case 22:
    print("Переменная равна 22")

В других языках программирования, в которых также есть конструкция switch/case, обычно в конце блока case ставится оператор break для прерывания выполнения и выхода из блока switch/case. В Swift использовать оператор break в подобных случаях необязательно. Однако бывают случаи, когда мы не хотим обрабатывать какие-то определенные значения и просто хотим выйти из конструкции switch. В этом случае после оператора case или default можно указать оператор break:

var num: Int = 0

switch num {
case 0:
    print("Переменная равна 0")
case 10:
    break
case 22:
    print("Переменная равна 22")
default:
    break
}

В данном случае если num равно 10 или другому числу, отличному от 0 или 22, просто произойдет выход из switch.

С помощью знака подчеркивания _ можно задать соответствие всем остальным значениям:

let number = 5
switch number {
case 1:
    print("Number = 1")
case 2:
    print("Number = 2")
case _:
    print("Number не равно ни 1, ни 2, но это не точно")
}

Также мы можем сравнивать выражение не с одним значением, а с группой значений:

var num: Int = 20

switch num {
case 0, 10: 	// если num равно 0 или 10
    print("Переменная равна 0 или 10")
case 11. .<20:	// если num в диапазоне от 11 до 20, не включая 20
    print("Переменная находится в диапазоне от 11 до 20")
case 20...30:	// если num в диапазоне от 20 до 30
    print("Переменная находится в диапазоне от 20 до 30")
default:
    print("не удалось распознать число")
}

Оператор case 0, 10 задает два сравниваемых значения 0 и 10 и срабатывает, если выражение равно одному из этих значений.

Оператор case 11..<20 определяет целый диапазон значений от 11 до 20 (не включая 20) и срабатывает, если выражение равно значению из этого диапазона.

Оператор case 20...30 определяет целый диапазон значений от 20 до 30 (включая оба числа) и срабатывает, если выражение равно значению из этого диапазона.

В версии Swift 4 мы можем опускать одну границу диапазона:

let i = 8
switch i {
case ...<0:
    print("i - отрицательное число")
case 1...:
    print("i - положительное число")
case 0:
    print("i равно 0")
default:break
}

Кортежи в switch/case

Кроме выражений простых типов можно сравнивать кортежи:

let personInfo = ("Tom", 22)
switch personInfo {
case ("Bob", 33):
    print("Имя: Bob, возраст: 33")
case (_, 22):
    print("Имя: \(personInfo. 0) и возраст: 22")
case ("Tom", _):
    print("Имя: Tom и возраст: \(personInfo.1))
case ("Tom", 1...30):
    print("Имя: Tom и возраст от 1 до 30)
default:
    print("Информация не распознана")
}

Здесь кортеж personInfo последовательно сравнивается с тремя кортежами в операторах case. При сравнении мы можем задать полный кортеж:

case ("Bob", 33):
    print("Имя: Bob, возраст: 33")

Либо мы также можем опустить один из элементов кортежа, подставив вместо него знак подчеркивания _:

case (_, 22):
    print("Имя: \(personInfo.0) и возраст: 22")

В этом случае не имеет значение, чему равен первый элемент кортежа, главное, чтобы второй элемент кортежа был равен 22.

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

case ("Tom", 1...30):
    print("Имя: Tom и возраст от 1 до 30)

В этом случае второй элемент кортежа должен находиться в диапазоне от 1 до 30.

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

Но если мы хотим, чтобы также выполнялся и следующий оператор case (или оператор default), то в конце предыдущего блока case следует использовать оператор fallthrough:

let personInfo = ("Tom", 22)
switch personInfo {
case ("Bob", 33):
    print("Имя: Bob, возраст: 33")
case (_, 22):
    print("Имя: \(personInfo.0) и возраст: 22")
	fallthrough
case ("Tom", _):
    print("Имя: Tom и возраст: \(personInfo.1))
default:
    print("Информация не распознана")
}

Связывание значений

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

let number = 5
switch number {
case 1:
    print("Number = 1")
case 2:
    print("Number = 2")
case let n:
    print("Number = \(n)")
}

В данном случае если значение number не равно 1 и 2, то оно передается константе n, которая используется в рамках своего блока case.

При этом привязка может выполняться к переменным и константам более сложных типов, например, кортежей:

let personInfo = ("Tom", 22)
switch personInfo {
case (let name, 22):
    print("Имя: \(name) и возраст: 22")
case ("Tom", let age):
    print("Имя: Tom и возраст: \(age)")
case let (name, age):
    print("Имя: \(name) и возраст: \(age)")
}

Если второй элемент в personInfo равен 22, то срабатывает блок

case (let name, 22):
    print("Имя: \(name) и возраст: 22")

Здесь переменная name получает значение первого элемента из кортежа personInfo.

Причем в этой конструкции не используется блок default, так как блок

case let (name, age):
    print("Имя: \(name) и возраст: \(age)")

фактически перекрывает все возможные случаи, которые не попадают под предыдущие операторы case. В этом блоке определяется константа (хотя это может быть и переменная), которая состоит из элементов кортежа personInfo.

Оператор where

Если при выполнении блока case мы хотим задать дополнительные условия, то в этом случае нам поможет оператор where. Например:

let i = 8
switch i {
case let k where k < 0:
    print("i - отрицательное число")
case let k where k > 0:
    print("i - положительное число")
case 0:
    print("i is 0")
default:break
}

Пример с кортежами:

let personInfo = ("Tom", 22)
switch personInfo {

case ("Tom", _) where personInfo.1 > 10 && personInfo.1 < 15:
    print("Имя: Tom и возраст от 10 до 15")
	
case ("Tom", _) where personInfo.1 >= 20:
    print("Имя: Tom и возраст от 20 и выше")
	
default:
    print("Неизвестно")
}

Выражения where определяют дополнительные условия. И если они не выполняются, то соответственно блок case тоже не выполняется.

Условные операторы If и Switch

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

Реализовать все это позволяют условные операторы.

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

В JavaScript имеются следующие условные операторы:

• Оператор if используется для определения блока кода, который будет выполняться, если заданное условие соблюдается (возвращает true)
• Оператор else используется для определения блока кода, который будет выполняться, если то же условие не соблюдается (возвращает false)
• Оператор else if используется для определения нового условия, если первое условие не соблюдается (возвращает false)
• Оператор switch определяет несколько альтернативных блоков кода

Оператор if

Оператор if используется для определения блока JavaScript кода, который будет выполняться, если заданное условие соблюдается (возвращает true).

Синтаксис:

if (условие) {
   блок кода, выполняемый если условие возвращает true
}

Внимание! Ключевое слово if пишется в нижнем регистре. Использование больших букв (If или IF) приведет к ошибке JavaScript.

Сформируем строку приветствия «Добрый день», если время меньше 18:00:

if (hour < 18) {
    greeting = "Добрый день";
}

Оператор else

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

Синтаксис:

if (условие) {
   блок кода, выполняемый если условие возвращает true
} else {
   блок кода, выполняемый если условие возвращает false
}

Если время меньше 18:00, сформируем строку приветствия «Добрый день», в обратном случае сформируем строку приветствия «Добрый вечер»:

if (hour < 18) {
    greeting = "Добрый день";
} else {
    greeting = "Добрый вечер";
} 

Оператор else if

Оператор else if является частью и продолжением оператора if и используется для определения нового условия, если первое условие не соблюдается (возвращает false).

Синтаксис:

if (условие1) {
   блок кода, выполняемый если условие1 возвращает true
} else if (условие2) {
   блок кода, выполняемый если условие1 возвращает false, а условие2 true
} else {
   блок кода, выполняемый если условие1 и условие2 возвращают false
}

Если время меньше 10:00, сформируем строку приветствия «Доброе утро», если нет, но при это меньше 20:00, сформируем строку приветствия «Добрый день», в обратном случае сформируем строку приветствия «Добрый вечер»:

if (time < 10) {
  greeting = "Доброе утро";
} else if (time < 20) {
  greeting = "Добрый день";
} else {
  greeting = "Добрый вечер";
}

Оператор switch

Оператор switch используется для выполнения различных действий в зависимости от различных условий.

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

Синтаксис:

switch(выражение) {
   case n:
     блок кода
     break;
   case n1:
     блок кода
     break;
   default:
     блок кода
}

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

• Сначала вычисляется выражение в операторе switch.
• Затем его значение сравнивается со значениями каждого оператора case.
• Если найдено совпадение, то выполняется соответствующий блок кода.

Пример:
Метод getDay() объекта Date возвращает номер дня недели в диапазоне от 0 до 6. Воскресенье=0, Понедельник=1, Вторник=2 и т. д. Мы используем номер дня недели, чтобы определить его имя:

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

Ключевое слово break

Когда совпадение найдено, и работа сделана, приходит время прекратить проверку, так как в ней больше нет необходимости. Для этого и существует ключевое слово break.

Когда интерпретатор JavaScript достигает ключевое слово break, он прерывает выполнение блока оператора switch.

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

В последнем блоке case использовать ключевое слова break не нужно. Этот блок прекратит работу оператора switch в любом случае.

Ключевое слово default

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

Пример:
Метод getDay() объекта Date возвращает номер дня недели в диапазоне от 0 до 6. Если сегодня ни Воскресенье (0), ни Суббота (6), то возвращается сообщение по умолчанию:

switch (new Date().getDay()) {
    case 6:
        text = "Сегодня суббота";
        break; 
    case 0:
        text = "Сегодня воскресенье";
        break; 
    default: 
        text = "Будем ждать выходных";
}

Блок выбора по условию default не обязательно должен быть последним в блоке оператора switch:

switch (new Date(). getDay()) {
    default: 
        text = "Будем ждать выходных";
        break;
    case 6:
        text = "Сегодня суббота";
        break; 
    case 0:
        text = "Сегодня воскресенье";
}

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

Общие блоки кода

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

В следующем примере условие 4 и 5 определяют общий блок кода, а 0 и 6 определяют другой общий блок кода:

switch (new Date().getDay()) {
    case 4:
    case 5:
        text = "Скоро выходные";
        break; 
    case 0:
    case 6:
        text = "Сегодня выходной";
        break;
    default: 
        text = "Будем ждать выходных";
}

Операторы цикла For и While. Операторы Break и Continue Вверх Тип Boolean, логические операторы и операторы сравнения

VBA Excel. Оператор Select Case (синтаксис, примеры)

Оператор Select Case, выполняющий одну или более групп операторов VBA Excel в зависимости от значения управляющего выражения. Синтаксис, компоненты, примеры.

Описание оператора Select Case

Оператор Select Case используется в VBA Excel для управления отдельными блоками операторов в зависимости от значения управляющего выражения (переменной) и сравнительных условий, задаваемых ключевым словом Case.

Синтаксис оператора Select Case

Select Case <strong>выражение</strong> Case <strong>условие 1</strong> [<strong>операторы 1</strong>] Case <strong>условие 2</strong> [<strong>операторы 2</strong>] —————— Case <strong>условие n</strong> [<strong>операторы n</strong>] Case Else [<strong>операторы</strong>] End Select

Компоненты оператора Select Case

• выражение – любое числовое или строковое выражение, переменная;
• условие – диапазон значений или выражение с операторами сравнения и ключевым словом Is*;
• операторы – блок операторов VBA Excel, который выполняется при вхождении значения управляющего выражения в диапазон, заданный в условии, или при возврате выражением с операторами сравнения значения True;
• блок операторов после ключевой фразы Case Else** выполняется в том случае, если в предыдущих условиях Case не будет найдено совпадений со значением управляющего выражения (переменной).

* Редактор VBA Excel автоматически добавляет ключевое слово Is в условия с операторами сравнения.
** Компонент Case Else с соответствующим блоком операторов необязательны, но рекомендуется их использовать для обработки непредвиденных значений управляющего выражения (переменной).

Примеры использования в VBA Excel

Пример 1

Пример использования оператора Select Case с операторами сравнения в условиях:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

Sub primer1() Dim a As Integer, b As String a = InputBox(«Введите число от 1 до 5», «Пример 1», 1)   Select Case a     Case Is = 1       b = «один»     Case Is = 2       b = «два»     Case Is = 3       b = «три»     Case Is = 4       b = «четыре»     Case Is = 5       b = «пять»     Case Else       b = «Число не входит в диапазон от 1 до 5»   End Select MsgBox b End Sub

Этот пример аналогичен первому примеру из статьи VBA Excel. Функция Choose, с помощью которой и следует решать подобные задачи в VBA Excel.

Пример 2

Пример использования оператора Select Case с заданным диапазоном в условиях:

Sub primer2() Dim a As Integer, b As String a = InputBox(«Введите число от 1 до 30», «Пример 2», 1) Select Case a Case 1 To 10 b = «Число » & a & » входит в первую десятку» Case 11 To 20 b = «Число » & a & » входит во вторую десятку» Case 21 To 30 b = «Число » & a & » входит в третью десятку» Case Else b = «число » & a & » не входит в первые три десятки» End Select MsgBox b End Sub

Для решения подобной задачи в VBA Excel можно использовать многострочную конструкцию оператора If…Then…Else, но решение с Select Case выглядит изящней.

Замените оператор switch и несколько «if и else», используя литералы объектов — [en-US].

Итак, во-первых, что такое Switch Statement?

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

  function UserPolicy (type) {
  switch (type) {
    case 'admin':
      верните "Этот пользователь является администратором!"
      перерыв
    case 'client':
      return "Этот пользователь является клиентом!"
      перерыв
    кейс "продавец":
      return "Этот пользователь - продавец!"
      перерыв
    По умолчанию:
      верните "Упс, у этого парня нет профиля пользователя"
  }
}

UserPolicy () // 'Ой, у этого парня нет профиля пользователя'
UserPolicy ('admin') // "Этот пользователь является администратором!"
  

Войти в полноэкранный режимВыйти из полноэкранного режима

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

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

  function UserPolicy (type) {
  пусть userType
  if (type === 'admin') {
    userType = 'Этот пользователь является администратором!'
  } else if (type === 'client') {
    userType = 'Этот пользователь является клиентом!'
  } else if (type === 'продавец') {
    userType = 'Этот пользователь - продавец!'
  } еще {
    userType = 'Упс, у этого парня нет профиля пользователя'
  }

  return `Тип пользователя: $ {userType}`
}
  

Войти в полноэкранный режимВыйти из полноэкранного режима

Проблемы с переключателем

У switch есть несколько проблем: от процедурного потока управления до нестандартного способа обработки блоков кода, остальная часть JavaScript использует фигурные скобки, а switch — нет. Синтаксически это не лучшее из JavaScript, равно как и его дизайн. Мы вынуждены вручную добавлять перерыв; операторов в каждом случае, что может привести к сложной отладке и вложенным ошибкам в дальнейшем, если мы забудем! К этому нужно относиться осторожно.

Мы часто используем объектный поиск для вещей в JavaScript, часто для вещей, о которых мы никогда не думали об использовании switch для — так почему бы не использовать литерал Object для замены switch? Объекты намного более гибкие, лучше читаются и удобны в обслуживании, и нам не нужно вручную ломать; каждый случай.Они намного дружелюбнее и для начинающих разработчиков JavaScript, поскольку являются стандартными объектами.

Причины не использовать переключатель

• По мере увеличения числа «случаев» производительность объекта (хеш-таблицы) становится лучше, чем средняя стоимость коммутатора (порядок рассмотрения дела). Объектный подход — это поиск по хеш-таблице, и переключатель должен оценивать каждый случай, пока не будет найдено совпадение и разрыв.

• Более удобный и читаемый.Нам также не нужно беспокоиться о перерыве; провалившиеся заявления и дела — это просто Объект.

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

  function UserPolicy (type) {
  // Мы создаем константу, которая получает объект и каждое из его свойств.
  // будут значения, соответствующие нашим типам
  const Users = {
    admin: 'Этот пользователь является администратором!',
    client: 'Этот пользователь - клиент!',
    Продавец: "Этот пользователь - продавец!",
    по умолчанию: "Упс, у этого парня нет профиля пользователя"
  }

  return Users [тип] || Пользователи.По умолчанию
}

UserPolicy () // 'Ой, у этого парня нет профиля пользователя'
UserPolicy ('admin') // "Этот пользователь является администратором!"
  

Войти в полноэкранный режимВыйти из полноэкранного режима

Обзор

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

// Я не навязываю правила — это просто еще один способ решения наших повседневных проблем

Заявление о переключении Javascript

— как это работает и как его использовать

Оператор Switch — одна из старейших функций JavaScript. Тем не менее, он используется не так часто, как if...else . Это прискорбно. Оператор switch иногда может работать лучше и сделать ваш код более читабельным. Из этого туториала Вы узнаете, что такое оператор switch в JavaScript, как его использовать и когда.

Введение в оператор switch

Для работы у каждого оператора switch JavaScript должны быть три вещи. Первым делом это ключевое слово switch . Каждый оператор switch должен начинаться с этого ключевого слова. Второе — это выражение, которое нужно сравнить со значением case.Подробнее о блоках кейсов вы узнаете в разделе «Блоки кейсов».

Выражение заключено в круглые скобки после ключевого слова switch . Далее следует фигурные скобки с блоком кода. Этот блок кода является телом оператора switch.

  // Синтаксис оператора переключения
switch (выражение) {
  // тело с блоком кода
}
  

Корпусный блок

Оператор переключения

JavaScript работает аналогично if ....else заявление. В случае if .... else , существует какое-то условие, и вы «проверяете», является ли это условие либо истинным , либо ложным . Затем вы можете выполнить код, специфичный для каждого логического значения или одного из них. Оператор Switch использует другой синтаксис, но результат тот же.

Оператор switch в JavaScript работает с двумя частями. Первое — это выражение, которое вы хотите проверить. Вторая часть представляет собой корпусный блок. Этот блок case также является третьим, что вам нужно для работы переключателя.Каждый блок case, который вы добавляете в оператор switch, должен иметь какое-то значение.

Немного как это работает. Когда вы выполняете оператор switch, он будет делать две вещи. Во-первых, он будет принимать выражение, которое вы передали в круглых скобках после ключевого слова switch . Во-вторых, он сравнит это выражение со значениями, которые вы указали для каждого оператора. Теперь поговорим о блоках кейсов.

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

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

Если вы хотите добавить новый блок case, вы добавляете его в тело оператора switch внутри фигурных скобок.Когда дело доходит до блоков case, нет ограничений на то, сколько из них вы можете использовать. Вы можете добавить столько блоков case, сколько захотите.

  // Оператор переключения с одним блоком case
switch (выражение) {
  значение case:
    // Что-то делаем, если 'значение' совпадает с 'выражением'
    break // Остановить выполнение оператора switch
}


// Оператор переключения с несколькими блоками case
switch (выражение) {
  значение case:
    // Что-то делаем, если 'значение' совпадает с 'выражением'
    break // Остановить выполнение оператора switch
  case firstDifferentValue:
    // Что-то делаем, если firstDifferentValue совпадает с выражением
    break // Остановить выполнение оператора switch
  case secondDifferentValue:
    // Что-то делаем, если 'secondDifferentValue' совпадает с 'выражением'
    break // Остановить выполнение оператора switch
  case thirdDifferentValue:
    // Сделаем что-нибудь, если 'thirdDifferentValue' совпадает с 'выражением'
    break // Остановить выполнение оператора switch
}


// Пример с календарем
// Создаем выражение для проверки
const today = 'среда'

// Создаем оператор переключения
// и передаем значение переменной 'сегодня' в качестве аргумента
switch (сегодня) {
  case 'Monday':
    // Если значение сегодняшнего дня - понедельник, делаем следующее
    приставка. log ('Сегодня понедельник.')
    break // Остановить выполнение оператора switch

  case 'Вторник':
    // Если значение сегодняшнего дня - "вторник", делаем следующее
    console.log ('Сегодня вторник.')
    break // Остановить выполнение оператора switch

  case 'среда':
    // Если значение сегодняшнего дня - среда, делаем следующее
    console.log ('Сегодня среда.')
    break // Остановить выполнение оператора switch

  case 'Четверг':
    // Если сегодня значение «Четверг», делаем следующее
    console.log ('Сегодня четверг.')
    break // Остановить выполнение оператора switch

  case 'Friday':
    // Если значение сегодняшнего дня - Пятница, делаем следующее
    приставка.log ('Сегодня пятница.')
    break // Остановить выполнение оператора switch

  case 'суббота':
    // Если значение сегодняшнего дня - суббота, делаем следующее
    console.log ('Сегодня суббота.')
    break // Остановить выполнение оператора switch

  case 'Воскресенье':
    // Если значение сегодняшнего дня - воскресенье, выполните следующие действия. 
    console.log ('Сегодня воскресенье.')
    break // Остановить выполнение оператора switch
}

// Выход:
// 'Это среда.'


// Примечание 1:
// Пустые строки между блоками case
// просто для улучшения читаемости кода.// Заметка 2:
// Вы также можете передать строку
// для прямого переключения оператора: switch ('Monday') {...}
  

Случай по умолчанию

Мы обсуждали, что каждый блок case должен иметь какое-то значение. Есть одно исключение из этого правила. Единственное исключение — случай по умолчанию. Этот регистр по умолчанию не требует никакого значения. Это также означает одно. Если какой-либо предыдущий случай завершился неудачей или не остановил выполнение оператора switch, будет выполнено значение по умолчанию.

Назначение случая по умолчанию — служить в качестве резервного.Он должен выполняться, когда по какой-либо причине ни один из случаев в переключателе не соответствует выражению, переданному переключателю в качестве аргумента. Одно следует помнить. Регистр по умолчанию также будет применяться, если любой другой регистр соответствует выражению, но не остановил выполнение оператора switch.

Итак, убедитесь, что вы знаете, какой результат вы хотите. Вы хотите использовать регистр по умолчанию только тогда, когда никакой другой регистр не соответствует выражению, переданному для переключения в качестве аргумента? Или вы хотите использовать его в любом случае? Если вы хотите, чтобы произошло первое, не забудьте остановить оператор switch сразу после того, как он выполнит код, который вы хотите выполнить (подробнее об этом в разделе «Оператор Break»).

Создание варианта по умолчанию аналогично созданию обычного варианта со значением. В случае случая по умолчанию вы начинаете с ключевого слова default вместо case . Затем за этим ключевым словом следует двоеточие и блок кода. Помните, что этот код будет выполняться по умолчанию, либо если ни один регистр не соответствует, либо если ни один блок case не останавливает выполнение оператора switch.

  // Создать оператор переключения
switch (выражение) {
  значение case:
    // Что-то делаем, если 'значение' совпадает с 'выражением'
    break // Остановить оператор switch

  По умолчанию:
    // Что-то делать, если ни одно значение case не соответствует 'выражению'
    // или если ни один из случаев не останавливает выполнение оператора switch
}


// Пример с календарем и регистром по умолчанию
// Создаем выражение для проверки
const today = 'Кто знает.'

// Создаем оператор переключения
// и передаем значение переменной 'сегодня' в качестве аргумента
switch (сегодня) {
  case 'Monday':
    // Если значение сегодняшнего дня - понедельник, делаем следующее
    console.log ("Сегодня понедельник.")
    break // Остановить выполнение оператора switch

  case 'Вторник':
    // Если значение сегодняшнего дня - "вторник", делаем следующее
    console.log ('Сегодня вторник.')
    break // Остановить выполнение оператора switch

  case 'среда':
    // Если значение сегодняшнего дня - среда, делаем следующее
    console. log ('Сегодня среда.')
    break // Остановить выполнение оператора switch

  case 'Четверг':
    // Если сегодня значение «Четверг», делаем следующее
    console.log ('Сегодня четверг.')
    break // Остановить выполнение оператора switch

  case 'Friday':
    // Если значение сегодняшнего дня - Пятница, делаем следующее
    console.log ('Сегодня пятница.')
    break // Остановить выполнение оператора switch

  case 'суббота':
    // Если значение сегодняшнего дня - суббота, делаем следующее
    console.log ('Сегодня суббота.')
    break // Остановить выполнение оператора switch

  По умолчанию:
    // Если ни один другой регистр не соответствует выражению
    // используем значение по умолчанию и предполагаем, что день воскресенье
    приставка.log ('Сегодня воскресенье.')
}

// Выход:
// 'Сегодня воскресенье'.
  

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

Группировка дел

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

Группировать два или более дел просто и быстро. Во-первых, вы должны буквально собрать эти кейсы вместе. Все предметы должны идти по порядку, один за другим. Во-вторых, вы должны опустить блок case во всех случаях, предшествующих последнему в группе. Только последний случай в группе будет иметь блок case.

  // Пример оператора switch с сгруппированными случаями
const language = 'JavaScript'

// Создаем оператор переключения
смена языка) {
  // Это начало первой группы кейсов
  // 'Это свободно типизированный язык. ' сообщение
  // будет напечатан, если язык равен 'JavaScript',
  // "Жемчуг", "Питон" или "Рубин"
  case 'JavaScript':
  футляр "Жемчуг":
  case 'Python':
  case 'Ruby':
    console.log ('Это язык со слабой типизацией.')
    перерыв
  // Это конец первой группы кейсов

  // Это начало второй группы случаев
  // 'Это строго типизированный язык.' сообщение
  // будет напечатан, если язык равен 'C',
  // Go или Java
  case 'C':
  case 'Go':
  case 'Java':
    console.log ('Это строго типизированный язык.')
    перерыв
  // Это конец второй группы случаев

  // Это обычный отдельный блок case
  case 'English':
    console.log ('Это не язык программирования.')
    перерыв

  По умолчанию:
    console.log ('Этот язык неизвестен.')
}

// Выход:
// 'Это слабо типизированный язык.'
  

Оператор разрыва

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

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

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

  // Пример 1: использование оператора break
// Создаем оператор переключения, который останавливает
// когда любой регистр соответствует выражению
switch (выражение) {
  значение case:
    // Что-то делаем, если 'значение' совпадает с 'выражением'
    break // Остановить выполнение оператора switch

  значение case:
    // Что-то делаем, если 'значение' совпадает с 'выражением'
    break // Остановить выполнение оператора switch

  По умолчанию:
    // Сделаем что-нибудь, если ни один регистр не соответствует 'выражению'
}


// Пример 2: исключение оператора break
// Создаем оператор переключения, который не останавливается
// когда какой-то регистр соответствует выражению
switch (выражение) {
  значение case:
    // Что-то делаем, если 'значение' совпадает с 'выражением'
    // а затем перейдем к другим случаям

  значение case:
    // Что-то делаем, если 'значение' совпадает с 'выражением'
    // а затем продолжаем регистрацию по умолчанию

  По умолчанию:
    // Сделаем что-нибудь, если ни один регистр не соответствует 'выражению'
}
  

Пропуск заявления о перерыве

Оператор break не требуется. Это означает две вещи. Во-первых, JavaScript не выдаст ошибку, если вы ее забудете. Во-вторых, вы можете опустить его, когда захотите, чтобы получить желаемый результат. Например, вы можете опустить его в одном блоке case, если хотите, чтобы оператор продолжал выполнение, и добавить его в другой, чтобы остановить выполнение.

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

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

  // Создать оператор переключения, который выполняет несколько случаев
switch (3) {
  Дело 1:
    console.log ('Значение 1.')
    break // Остановить выполнение оператора switch
    // Примечание: этот разрыв применяться не будет
    // потому что значение равно 1, а выражение равно 3

  случай 2:
    приставка. log ('Значение 2')

  случай 3:
    // Значение 3, поэтому этот случай будет превышен
    console.log ('Значение 3')
    // перерыв отсутствует, поэтому переключение продолжится
    // и выполняем все последующие кейсы
    // Соответствие между выражением
    // и значение этих кейсов больше не имеет значения

  случай 4:
    // Предыдущее дело было выполнено
    // и не было перерыва для остановки оператора
    // Этот оператор будет выполнен
    // даже если значение не соответствует выражению
    console.log ('Значение 4.')

  случай 5:
    // Не было перерыва для остановки оператора
    // в предыдущем операторе, поэтому этот оператор
    // также будет выполняться
    // Значение снова не имеет значения
    console.log ('Значение 5')
    break // Остановить выполнение оператора switch

  case 6:
    // Случай выше содержит оператор break
    // так что это дело не будет выполнено
    console.log ('Значение 6.')

  По умолчанию:
    перерыв
}

// Выход
// 'Значение 3'
// 'Значение 4. '
// 'Значение 5.'
  

Когда использовать оператор switch

Когда лучше использовать оператор switch и когда if...else ? Общий ответ таков: это зависит от обстоятельств. В основном это зависит от того, что вам нравится и что вы предпочитаете. При сравнении производительности switch и if ... else разница не будет значительной. Это может быть несколько миллисекунд, что-то еле заметное.

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

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

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

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

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

Заключение: Заявление о переключении JavaScript

Оператор переключения

JavaScript может выглядеть странно.На обучение может потребоваться некоторое время. Однако оно того стоит. Switch может помочь вам сделать ваш код более читаемым и чище. Я надеюсь, что это руководство помогло вам узнать, что такое оператор JavaScript switch, как он работает и как его использовать, а также когда.

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

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

Станьте покровителем Значок PayPal Пожертвовать через Paypal

Связанные

Почему я предпочитаю объекты операторам переключения

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

Оператор переключения

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

Давайте быстро посмотрим, как выглядит типичный оператор switch:

  переключатель (выражение) {
    case x: {
        
        перерыв;
    }
    case y: {
        
        перерыв;
    }
    По умолчанию: {
        
    }
}  

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

Ключевое слово break необязательно.

Ключевое слово break позволяет нам останавливать выполнение блоков, когда условие уже выполнено.Если вы не добавите ключевое слово break в оператор switch, он не выдаст ошибку. Случайное отсутствие ключевого слова break может означать выполнение кода, о выполнении которого вы даже не подозреваете, это также добавляет несогласованности в наши реализации, мутации, утечки памяти и уровни сложности при отладке проблем. Давайте посмотрим на представление этой проблемы:

  переключатель ("первый") {
    case 'first': {
        console. log ('первый случай');
    }
    case 'second': {
        приставка.журнал ('второй случай');
    }
    case 'third': {
        console.log («третий случай»);
        перерыв;
    }
    По умолчанию: {
        console.log («бесконечно»);
    }
}  

Если вы выполните этот фрагмент кода в консоли, вы увидите, что на выходе будет

.

  первый чехол
второй случай
третий корпус  

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

Фигурные скобки на каждом корпусе —

НЕ обязательные.

Фигурные скобки представляют блока кода в javascript, так как ECMAscript 2015 мы можем объявлять переменные с блокировкой области с использованием таких клавиш, как const или let , что отлично (но не так хорошо для случаев переключения), поскольку фигурные скобки не являются обязательными, мы можем получить ошибки из-за дублирования переменных, давайте посмотрим, что произойдет, когда мы выполним код ниже:

  переключатель ("второй") {
    case 'first':
        пусть позиция = 'первая';
        приставка.журнал (позиция);
        перерыв;
    case 'второй':
        пусть позиция = 'второй';
        console.log (позиция);
        перерыв;
    По умолчанию:
        console.log («бесконечно»);
}  

получаем:

  Uncaught SyntaxError: Идентификатор "позиция" уже объявлен  

Это возвращает ошибку, потому что переменная позиция уже была объявлена ​​в первом случае и, поскольку у нее нет фигурных скобок, она поднял, то к моменту, когда второй случай пытается его объявить, он уже существует и BOOM .

Теперь представьте, что может произойти при использовании операторов switch с непоследовательными ключевыми словами break и фигурными скобками:

  переключатель ("первый") {
    case 'first':
        пусть позиция = 'первая';
        console.log (позиция);
    case 'второй':
        console.log (`второй имеет доступ к $ {position}`);
        позиция = 'второй';
        console.log (позиция);
    По умолчанию:
        console.log («бесконечно»);
}  

Это приведет к консольному журналу следующего:

  первый
второй имеет доступ к первому
второй
бесконечный  

Только представьте, количество ошибок и мутаций, которые могут быть внесены из-за этого, возможности безграничны… В общем, хватит операторов switch, мы пришли сюда, чтобы поговорить о другом подходе, мы пришли сюда, чтобы поговорить об объектах.

Объекты для более безопасного поиска

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

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

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

  const getPosition = position => {
    const position = {
        first: 'первый',
        second: 'второй',
        третий: 'третий',
        по умолчанию: 'бесконечный'
    };

    вернуть позиции [позиция] || позиции.По умолчанию;
};

const position = getPosition ('первый');
const otherValue = getPosition ('четвертый');  

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

  const getPosition = position =>
    ({
        first: 'первый',
        second: 'второй',
        третий: "третий"
    } [должность] || 'бесконечный');

const positionValue = getPosition ('первый');
const otherValue = getPosition ('четвертый');  

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

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

Работа с логическими значениями

Мне нравится создавать свои функции таким образом, чтобы они возвращали согласованные типы значений, но, поскольку javascript — это язык с динамической типизацией, могут быть случаи, когда функция может возвращать динамические типы, поэтому я учту это в этом примере. и я создам функцию, которая возвращает логическое значение , undefined или строку , если ключ не найден.

  const isNotOpenSource = language =>
    ({
        vscode: ложь,
        возвышенный текст: правда,
        neovim: ложь,
        fakeEditor: undefined
    } [язык] || 'неизвестный');

const sublimeState = isNotOpenSource ('возвышенный текст');  

Выглядит здорово, правда? Но подождите, похоже, у нас проблема … что произойдет, если мы вызовем функцию с аргументом 'vscode' или fakeEditor вместо этого ?, ммм, давайте посмотрим:

1. Он будет искать ключ в объекте.
2. Он увидит, что значение ключа vscode — false .
3. Он попытается вернуть false , но с false || 'unknown' — это unknown , мы вернем неверное значение.

У нас будет такая же проблема для ключа fakeEditor .

О нет, хорошо, не паникуйте, давайте разберемся с этим:

  const isNotOpenSource = editor => {
    const editors = {
        vscode: ложь,
        возвышенный текст: правда,
        neovim: ложь,
        fakeEditor: undefined,
        по умолчанию: 'unknown'
    };

    вернуть редактора в редакторы? editors [редактор]: редакторы.По умолчанию;
};

const codeState = isNotOpenSource ('vscode');
const fakeEditorState = isNotOpenSource ('fakeEditor');
const sublimeState = isNotOpenSource ('возвышенный текст');
const webstormState = isNotOpenSource ('webstorm');  

И это решает проблему, но … Я хочу, чтобы вы спросили себя: действительно ли это проблема? Я думаю, нам следует больше беспокоиться о том, зачем нам нужна функция, которая в первую очередь возвращает логическое значение , undefined или строку , это серьезное несоответствие, в любом случае, это всего лишь возможное решение для очень острый случай.

Работа с функциями

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

  const getParsedInputValue = type => {
    const emailParser = email => `email, $ {email}`;
    const passwordParser = пароль => `пароль, $ {пароль}`;
    const BirthdateParser = date => `date, $ {date}`;

    const parsers = {
        электронная почта: emailParser,
        пароль: passwordParser,
        дата рождения: BirthdateParser,
        по умолчанию: значение => значение
    };

    вернуть парсеры [тип] || парсеры.По умолчанию;
};


const parsedEmail = getParsedInputValue ('электронная почта') ('[email protected]');
const parsedName = getParsedInputValue ('имя') ('Enmanuel');  

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

  const getValue = type => {
    const email = () => '[email protected]';
    const пароль = () => '12345';

    const parsers = {
        электронное письмо,
        пароль,
        по умолчанию: () => 'по умолчанию'
    };

    return (парсеры [тип] || парсеры.По умолчанию)();
};

const emailValue = getValue ('электронная почта');
const passwordValue = getValue ('имя');  

Общие кодовые блоки

Операторы

Switch позволяют нам определять общие блоки кода для нескольких условий.

  переключатель (редактор) {
    case 'atom':
    case 'возвышенный':
    case 'vscode':
        return 'Это редактор кода';
        перерыв;
    case 'webstorm':
    case 'pycharm':
        return 'Это IDE';
        перерыв;
    По умолчанию:
        вернуть "неизвестно";
}  

Как подойти к этому с помощью объектов? Мы могли бы сделать это следующим образом:

  const getEditorType = type => {
    const itsCodeEditor = () => 'Это редактор кода';
    const itsIDE = () => 'Это IDE';

    const editors = {
        атом: itsCodeEditor,
        возвышенный: itsCodeEditor,
        vscode: itsCodeEditor,
        webstorm: itsIDE,
        pycharm: itsIDE,
        по умолчанию: () => 'unknown'
    };

    return (редакторы [тип] || редакторы.По умолчанию)();
};

const vscodeType = getEditorType ('vscode');  

И теперь у нас есть подход, который:

1. Более структурированный.
2. Лучше масштабируется.
3. Легче в обслуживании.
4. Проще протестировать.
5. Более безопасен, имеет меньше побочных эффектов и рисков.

На что обратить внимание

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

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

Заключение

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

ОК, разработчики будущего, вот и все, я надеюсь, вам понравилась статья, если да, то вам, вероятно, понравится и эта статья о фабричном шаблоне. Кроме того, не забудьте поделиться им и подписаться, вы можете найти меня в твиттере или связаться со мной по электронной почте [email protected], увидимся в следующем.

Оператор переключения регистра JavaScript, объясненный с помощью различных элементов HTML

Оператор JS switch case

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

Структура оператора switch case JavaScript

Вот как вы можете использовать оператор switch case в JavaScript:

1 2 3 4 5 6 7 8 9 10 11 12 13 140002 14 18 19 20 21

switch (expression_here) { case 1: // Выполнить код JS, если case 1 оценивается как истинный break; case 2: // Выполнить код JS, если case 2 оценивается как истинный break; default: // Выполнить код JS, если ни один из вышеперечисленных случаев не верен break; }

На следующем рисунке показано, как выполняется инструкция switch JS:

Ниже приведены несколько примеров, объясняющих, как можно просто использовать оператор JavaScript switch с различными элементами HTML.

Простой пример с цифрами для пояснения корпуса переключателя

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

См. Демонстрацию и код онлайн:

См. Онлайн-демонстрацию и код

В разделе