Switch case js: switch — JavaScript | MDN

switch — JavaScript | MDN

Инструкция switch сравнивает выражение со случаями, перечисленными внутри неё, а затем выполняет соответствующие инструкции.

switch (expression) {
  case value1:
    //Здесь выполняются инструкции, если результат выражения равен value1
    [break;]
  case value2:
    //Инструкции, соответствующие value2
    [break;]
  ...
  case valueN:
    //Инструкции, соответствующие значению valueN
    //statementsN
    [break;]
  default:
    //Здесь находятся инструкции, которые выполняются при отсутствии соответствующего значения
    //statements_def
    [break;]
}

expression

Выражение, значение которого сравнивается со всеми случаями.

case valueN

Случай, который проверяется на соответствие выражению (expression).

statementsN

Инструкции, которые выполняются, если expression соответствуют случаю.

statements_def

Инструкции, выполняемые если expression не соответствует ни одному случаю.

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

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

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

Пример: Использование

В этом примере, если expr равно «Bananas», программа находит случай «Bananas» и выполняет соответствующие инструкции. При выполнении инструкции

switch (expr) {
  case "Oranges":
    console.log("Oranges are $0.59 a pound.");
    break;
  case "Apples":
    console.log("Apples are $0.32 a pound.");
    break;
  case "Bananas":
    console.log("Bananas are $0.48 a pound.");
    break;
  case "Cherries":
    console.log("Cherries are $3.00 a pound.");
    break;
  case "Mangoes":
  case "Papayas":
    console.log("Mangoes and papayas are $2.79 a pound.");
    break;
  default:
    console.log("Sorry, we are out of " + expr + ".");
}

console.log("Is there anything else you'd like?");
 

Пример: Что случится, если не использовать break?

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

var foo = 0;
switch (foo) {
    case -1:
        console. log('negative 1');
        break;
    case 0: 
        console.log(0)
        
    case 1: 
        console.log(1);
        break; 
    case 2:
        console.log(2);
        break;
    default:
        console.log('default');
}

Пример: Использование нескольких значений для одного случая

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

Исходники этих способов здесь:

1. Switch statement multiple cases in JavaScript (Stack Overflow)
2. Multiple Criteria Single Case Switch Statement (Stack Overflow)

Первый способ

В первом способе используется то, что выполнение инструкции switch продолжится, если не использовать инструкцию break. Подробнее в примере «Что случится, если не использовать break?»

var foo = 1;
switch (foo) {
    case 0:
    case 1:
    case 2:
    case 3:
        alert('yes');
        break;
    default:
        alert('not');
} 

Второй способ

Другой способ, менее стандартный; во второй строке, где вы ожидали увидеть switch(foo), расположено постоянное значение true, и в случаях используются выражения вместо констант:

var foo = 1;
switch (true) { 
    case foo >= 0 && foo <= 3:
        alert('yes');
        break;
    default:
        alert('not');
}

BCD tables only load in the browser

Урок 11 по JScript — конструкция switch.

Доброго времени суток всем читателям блога scriptcoding.ru. В этой статье мы познакомимся с конструкцией языка программирования JScript — switch case, которая позволяет выполнять программный код в зависимости от условия.

Использование в сценариях js switch case конструкции актуально тогда, когда нужно выполнить то, или иное выражение в зависимости от условия. Конечно, для таких целей можно использовать и условный оператор if (смотрите статью «Урок 8 по JScript: Условного оператора if…else»), но это приведёт к расточительству строк кода, что не есть хорошо.

Давайте посмотрим на общий синтаксис конструкции switch case:

switch (<переменная>) {
case <значение1>:
<выражение1>
break;

…………………….

break;
default:
<выражение>
break;
}

Хорошо, теперь давайте рассмотрим все подробно. Сразу после ключевого слова js switch в круглых скобках указывается имя переменной, которую нужно проверить, после, идут фигурные скобки, между которыми будет проходить проверка. Как видим, после ключевого слова js

Конструкция JS SWITCH CASE

Хорошо, с теорией закончили, теперь можно приступить к программированию.

//*************************************
// конструкция js switch case
// Перебираем типы файлов и их количество
// switch_case.js
//*************************************
 
function my_fun (x){
var str_switch_case_js;
     switch (x){
                 case 1: str_switch_case_js="Число 1";
                 return str_switch_case_js;
                 case 2: str_switch_case_js="Число 2";
                 return str_switch_case_js;
                 case 3: str_switch_case_js="Число 3";
                 return str_switch_case_js;
                 case 4: str_switch_case_js="Число 4";
                 return str_switch_case_js;
                 case 5: str_switch_case_js="Число 5";
                 return str_switch_case_js;
                 default: str_switch_case_js="Другое значение";
                 return str_switch_case_js;
     }
}
 
WScript.  Echo (my_fun (5))

В данном случае всё просто, функции my_fun передается один параметр (смотрите статью «Урок 3 по JScript: Объявление пользовательских функций»), в теле функции находится конструкция js — switch case, которая проверяет передаваемый параметр. Видим, что проверке подлежат числа от 1 до 5 – в переменную str_switch_case_js записывается строка «Число 1», «Число 2», и так далее, во всех остальных случаях функция вернет строку «Другое значение».

Стоит сказать, что после ключевого слова case js может следовать не только число, но и любое произвольное выражение, например:

60*60*24:
Math.PI:
n+1:
a[0]:

Давайте рассмотрим такой программный код:

//*************************************
// Инструкция switch case, js сценарий
// 1_switch_case.js
//*************************************
 
//Объявляем переменные 
var FSO, Folder, Files, s, msg;     
var txt=0, log=0, exe=0, bat=0, ini=0, dll=0; ander=0
 
//Создаем объект FileSystemObject
FSO=WScript. CreateObject("Scripting.FileSystemObject");
 
//Создаем объект Folder для каталога Windows
Folder=FSO.GetFolder("C:\\Windows\\");
 
//Создаем коллекцию файлов  
Files=new Enumerator(Folder.Files);
//Цикл по всем файлам  
for (; !Files.atEnd(); Files.moveNext()) {  
//Получаем расширение файла (FSO.GetExtensionName)
     s=FSO.GetExtensionName(Files.item().Name);
 
     switch (s){
                 case "txt": txt++;
                 break;
                 case "log": log++;
                 break;
                 case "exe": exe++;
                 break;
                 case "bat":bat++;
                 break;
                 case "ini": ini++;
                 break;
                 case "dll": dll++;
                 break;
                 default: ander++;
                 break;
     }
 
} 
//Выводим полученный список типов файлов и их количество
msg = "txt\t" + txt + "\nlog\t" + log + "\nexe\t" + exe;
msg+="\nbat\t" + bat + "\nini\t" + ini + "\ndll\t" + dll + "\nДругие\t" + ander;
WScript. echo(msg);

Скачать архив с примерами

В данном сценарии выполняется довольно практическая задача: вначале мы получаем доступ к файлам, которые находятся в каталоге Windows (Тут мы использовали объект FileSystemObject). Переменная s будет хранить расширение файла, в блоке js switch case мы проверяем переменную s на тип файла: txt, log, exe, bat, ini и dll и подсчитываем их количество. Количество всех остальных типов файлов хранится в переменной ander.

Заявление switch | Учебник JavaScript

Обновляется!!! Справочник JavaScript

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

JavaScript Заявление Switch

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

Синтаксис

switch(expression) {
  case x:
    // блок кода
    break;
  case y:
    // блок кода
    break;
  default:
    // блок кода
}

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

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

Пример

Метод 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 ключевого слова, он выходит из блока переключателя.

Это остановит выполнение внутри блока.

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

Note: Если вы опустите оператор break, следующий регистр будет выполнен, даже если оценка не соответствует регистру.

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

Ключевое слово default указывает код для запуска, если нет ни одного case match:

Пример

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

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

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

Результатом текста будет:

Случай default не должен быть последним случаем в распределительном блоке:

Пример

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

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

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

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

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

Пример

switch (new Date().getDay()) {
  case 4:
  case 5:
    text = «Скоро выходные»;
    break;
  case 0:
  case 6:
    text = «Сейчас выходные»;
    break;
  default:
    text = «С нетерпением жду выходных»;
}

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

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

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

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

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

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

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

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

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

Пример

var x = «0»;
switch (x) {
  case 0:
    text = «Выкл»;
    break;
  case 1:
    text = «Вкл»;
    break;
  default:
    text = «Значение не найдено»;
}

javascript — Ext JS — начало

Я не соглашусь с уже принятым ответом.

1. They are both optional. I use neither.

Хорошо, не слишком полезно. Aptana — это IDE общего назначения. Он основан на Eclipse, но в отличие от ванильного Eclipse (который ориентирован на Java). Aptana имеет множество дополнений и плагинов для работы с JavaScript, PHP и других «веб-ориентированных» разработок. Я фактически сам использую Aptana, даже для Ext development, потому что это работает для меня. Обсуждения IDE, как правило, становятся религиозными — у каждого есть свои требования и проблемы, YMMV. Aptana действительно поддерживает автозаполнение, основанное на каркасе, в том числе для Ext JS (хотя я думаю, что они все еще находятся на более старой версии). Обратите внимание, что вы можете выполнять те же действия, что и Aptana (обычно-spekaing) с использованием WebStorm, Komodo, NetBeans, TextMate или любого старого текстового редактора — просто зависит от того, какие функции, специфичные для IDE, вам полезны или нет.

Ext Designer (теперь Sencha Architect ), с другой стороны, НЕ универсальная IDE — она ​​строго предназначена как средство разработки внешнего интерфейса. Однако это выходит за рамки простого «размещения виджетов» на странице. Вы можете легко перетащить все на свои места, а также просмотреть, как они будут отображаться, подключить хранилища данных к виджетам с привязкой к файлам (снова с помощью простых взаимодействий перетаскивания/перетаскивания), включая контекстно-зависимые настройки конфигурации и свойств (что значительно упрощает знать, какие опции доступны без необходимости обращаться к документам API постоянно) и т. д. Затем архитектор генерирует классы в формате наилучшего практического кода, которые вы можете зайти в свое приложение, а затем расширить по мере необходимости своей собственной бизнес-логикой. Вывод Архитектор мог бы в основном стать исходным проектом для Aptana (или что-то еще), где вы создавали бы свой код приложения (хотя многие люди придерживаются исключительно Architect).

Что касается учебников, недавно был обновлен сайт docs Sencha.com и включает в себя множество обучающих программ, обновленных для самых последних версий of Ext. Конечно, официальные примеры также являются хорошим местом для начала. Лучшей книгой по разработке Ext является, вероятно, Jay Garcia Ext JS в действии , хотя, к сожалению, это еще не обновлен для Ext 4 (в настоящее время он работает над этим). Это отличный обзор концепций и лучших практик для Ext в целом, хотя, и многое из того, что в этой книге все еще будет применяться сегодня.

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

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

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

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

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

Синтаксис

переключатель (, выражение ) {
case x :
// кодовый блок
break;
case y :
// кодовый блок
break;
по умолчанию:
// кодовый блок
}

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

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

Пример

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

(воскресенье = 0, понедельник = 1, вторник = 2 ..)

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

переключатель (новая дата ().getDay ()) {
case 0:
day = «воскресенье»;
перерыв;
case 1:
day = «понедельник»;
перерыв;
case 2:
day = «вторник»;
перерыв;
case 3:
day = «среда»;
перерыв;
case 4:
day = «четверг»;
перерыв;
case 5:
day = «пятница»;
перерыв;
case 6:
day = «суббота»;
}

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

Разрыв Ключевое слово

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

Это остановит выполнение внутри блока переключателя.

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

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

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

Ключевое слово по умолчанию определяет код для запуска, если нет совпадение регистра:

Пример

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

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

переключатель (новая дата (). getDay ()) {
case 6:
text = «Сегодня суббота»;
перерыв;
case 0:
text = «Сегодня воскресенье»;
перерыв;
по умолчанию:
text = «С нетерпением жду выходных»;
}

Результат текста будет:

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

Пример

переключатель (новая дата ().getDay ()) {
по умолчанию:
text = «С нетерпением жду выходных»;
перерыв;
корпус 6:
text = «Сегодня суббота»;
перерыв;
case 0:
text = «Сегодня воскресенье»;
}

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

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

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

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

Пример

переключатель (новая дата (). getDay ()) {
case 4:
case 5:
text = «Скоро выходные»;
перерыв;
case 0:
case 6:
text = «Выходные»;
перерыв;
по умолчанию:
text = «С нетерпением жду выходных»;
}

Сведения о переключении

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

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

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

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

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

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

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

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

Пример

var x = «0»;
переключатель (x) {
case 0:
text = «Off»;
перерыв;
case 1:
text = «Вкл.»;
перерыв;
по умолчанию:
text = «Значение не найдено»;
}

  переключатель (выражение) {
  case value1:
    
    
    [перерыв;]
  case value2:
    
    
    [перерыв;]
  ...
  case valueN:
    
    
    [перерыв;]
  [По умолчанию:
    
    
    [перерыв;]]
}  

  switch (expr) {
  case 'Апельсины':
    console.log («Апельсины стоят 0,59 доллара за фунт»);
    перерыв;
  case 'Яблоки':
    console.log («Яблоки по 0,32 доллара за фунт»);
    перерыв;
  case 'Bananas':
    console.log («Бананы стоят 0,48 доллара за фунт»);
    перерыв;
  case 'Cherries':
    console.log («Вишни стоят 3 доллара за фунт»);
    перерыв;
  футляр "Манго":
  case 'Papayas':
    приставка.журнал («Манго и папайя стоят 2,79 доллара за фунт»);
    перерыв;
  По умолчанию:
    console.log ('Извините, у нас закончилось' + expr + '.');
}

console.log ("Хотите еще чего-нибудь?");
  

  var foo = 0;
switch (foo) {
  Дело 1:
    приставка. журнал ('отрицательный 1');
    перерыв;
  case 0:
    console.log (0);
    
  Дело 1:
    console.log (1);
    перерыв;
  случай 2:
    console.log (2);
    перерыв;
  По умолчанию:
    console.log ("по умолчанию");
}  

  var foo = 5;
switch (foo) {
  случай 2:
    console.log (2);
    перерыв;
  По умолчанию:
    console.log ('по умолчанию')
    
  Дело 1:
    приставка.журнал ('1');
}
  

  var Animal = 'Жираф';
switch (Animal) {
  case 'Cow':
  футляр "Жираф":
  case 'Dog':
  case 'Свинья':
    console.log ('Это животное не вымерло.');
    перерыв;
  чехол 'Динозавр':
  По умолчанию:
    console.log ('Это животное вымерло.');
}  

  var foo = 1;
var output = 'Вывод:';
switch (foo) {
  case 0:
    output + = 'So';
  Дело 1:
    output + = 'Что';
    output + = 'Is';
  случай 2:
    output + = 'Ваш';
  случай 3:
    output + = 'Имя';
  случай 4:
    вывод + = '?';
    приставка.журнал (вывод);
    перерыв;
  случай 5:
    вывод + = '!';
    console.log (вывод);
    перерыв;
  По умолчанию:
    console.log («Пожалуйста, выберите число от 0 до 5!»);
}  

  const action = 'say_hello';
switch (действие) {
  case 'say_hello':
    let message = 'привет';
    console.log (сообщение);
    перерыв;
  case 'say_hi':
    пусть сообщение = 'привет';
    console.log (сообщение);
    перерыв;
  По умолчанию:
    console.log ('Получено пустое действие.');
    перерыв;
}  

  const action = 'say_hello';
switch (действие) {
  case 'say_hello': {
    let message = 'привет';
    приставка.журнал (сообщение);
    перерыв;
  }
  case 'say_hi': {
    пусть сообщение = 'привет';
    console.log (сообщение);
    перерыв;
  }
  По умолчанию: {
    console.log ('Получено пустое действие.');
    перерыв;
  }
}  

  const name = "Юлиана";

switch (name) {
  дело «Юлиана»:
    console.log («Она Джулиана»);
    перерыв;
  футляр «Томь»:
    console.log («Она не Джулиана»);
    перерыв;
}  

  const name = "Крис";

switch (name) {
  дело «Юлиана»:
    приставка.журнал («Она Джулиана»);
    перерыв;
  футляр «Томь»:
    console.log («Она не Джулиана»);
    перерыв;
  По умолчанию:
    console.log («Извините, совпадений нет»);
}  

  const LOGIN_SUCCESS = "LOGIN_SUCCESS";
const LOGIN_FAILED = "LOGIN_FAILED";

const authState = {
  токен: "",
  ошибка: "",
};

function authReducer (state = authState, action) {
  переключатель (действие.тип) {
    case LOGIN_SUCCESS:
      return {... состояние, токен: action.payload};
    case LOGIN_FAILED:
      return {... состояние, ошибка: action.payload};
    По умолчанию:
      вернуть состояние;
  }
}  

  LOGIN_SUCCESS = "LOGIN_SUCCESS"
LOGIN_FAILED = "LOGIN_FAILED"

auth_state = {"токен": "", "error": ""}


def auth_reducer (state = auth_state, action = {}):
    mapping = {
        LOGIN_SUCCESS: {** состояние, "токен": действие ["полезная нагрузка"]},
        LOGIN_FAILED: {** состояние, "ошибка": действие ["полезная нагрузка"]},
    }

    вернуть mapping.get (действие ["тип"], состояние)  

  >>> my_dict = {
    "name": "Джон",
    "город": "Рим",
    «возраст»: 44
    }

>>> my_dict ["not_here"]

  

  >>> my_dict = {
    "name": "Джон",
    "город": "Рим",
    «возраст»: 44
    }

>>> my_dict.get ("not_here", "не найдено")

  

 
    вернуть mapping.get (действие ["тип"], состояние)  

  function authReducer (state = authState, action) {

    По умолчанию:
      вернуть состояние;
  }
}  

  const LOGIN_SUCCESS = "LOGIN_SUCCESS";
const LOGIN_FAILED = "LOGIN_FAILED";

const authState = {
  токен: "",
  ошибка: "",
};

function authReducer (state = authState, action) {
  переключатель (действие.тип) {
    case LOGIN_SUCCESS:
      return {... состояние, токен: action.payload};
    case LOGIN_FAILED:
      return {... состояние, ошибка: action.payload};
    По умолчанию:
      вернуть состояние;
  }
}  

  function authReducer (state = authState, action) {
  const mapping = {
    [LOGIN_SUCCESS]: {... состояние, токен: action.payload},
    [LOGIN_FAILED]: {... состояние, ошибка: action.payload}
  };

  вернуть отображение [действие.тип] || государственный;
}  

  const mapping = {
    [LOGIN_SUCCESS]: {... состояние, токен: action.payload},
    [LOGIN_FAILED]: {... состояние, ошибка: action.payload}
  };  

  const mapping = {
    [LOGIN_SUCCESS]: {... состояние, токен: action.payload},
    [LOGIN_FAILED]: {... состояние, ошибка: action.payload}
  };  

  console.time («образец»);
for (let i = 0; i <2000000; i ++) {
  const nextState = authReducer (authState, {
    тип: LOGIN_SUCCESS,
    полезная нагрузка: "some_token"
  });
}
приставка.timeEnd ("образец");  

  для т в {1..10}; сделать узел switch.js >> switch.txt; готово
для t в {1..10}; сделать node map.js >> map.txt; выполнено  

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

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

JavaScript

  переключатель (выражение)
{
Дело 1:
    //код
    перерыв;
случай 2:
    //код
    перерыв;
По умолчанию:
}  

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

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

Альтернатива оператору switch в JavaScript с функциональной особенностью | Автор: Хадзиме Ямасаки Вукелич

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

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

• это блок
• он имеет единый блок для всех случаев
• он не переводит случаи в значения
• он не применяет случай по умолчанию

Блок - это группа операторов, а не выражение.Его нельзя вернуть, передать, присвоить переменным… вы поняли. Вы не можете сказать что-то вроде:

 return switch (someVal) {
 // .... 
} 

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

Допустим, у вас есть код вроде этого:

 переключатель (действие) {
 case 'UPDATE': 
 const val = msg [0] 
 return {... model, val} 
 case 'REPLACE': 
 const val = msg [1] 
 возврат {...model, val, active: false} 
} 

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

Эту проблему легко исправить. Вы можете объявить блок для каждого случая:

 переключатель (действие) {
 case 'UPDATE': {
 const val = msg [0] 
 return {... model, val} 
} 
 case 'REPLACE': { 
 const val = msg [1] 
 return {... model, val, active: false} 
} 
} 

Это даже не так ужасно, но приводит к дополнительному синтаксису.

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

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

 case a: x -> x 
 case b: x -> y 
 case c: x -> z 

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

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

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

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

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

 const matched = x => ({
 on: () => matched (x), 
 иначе: () => x, 
}) const match = x => ({
 on: (pred, fn) => (pred (x)? matched (fn (x)): match (x)), 
 в противном случае: fn => fn (x), 
}) 

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

 match (50) 
.на (x => x <0, () => 0) 
. на (x => x> = 0 && x <= 1, () => 1) 
. в противном случае (x => x * 10) 
 // => 500 

Функция match создает контекст для значения, которое мы ей передаем. Этот контекст позволяет нам отображать значение в контексте, используя любое количество функций, каждая из которых имеет функцию защиты, которая позволяет нам «пропускать» оценку, если какое-либо условие не выполняется. У нас также есть метод else () , который поймает значение, если ни один из охранников не разрешил вызвать функцию сопоставления.

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

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

 // ПРИМЕР 1match (50) 
 // теперь мы находимся в контексте соответствия. On (x => x <0, () => 0) 
 // Поскольку 50 не <0, мы остаемся в контексте match (50).on (x => x> = 0 && x <= 1, () => 1) 
 // Поскольку 50 не находится между 0 и 1, мы остаемся в контексте match (50). в противном случае (x => x * 10 ) 
 // Мы все еще находимся в совпадении (50), иначе вызывается обратный вызов, 
 // и мы возвращаем 500 
 // ПРИМЕР 2match (0) 
 // теперь мы находимся в контексте соответствия. On (x => x <0, () => 0) 
 // 0 не <0, поэтому мы остаемся в match (0) context.on (x => x> = 0 && x <= 1, () => 1) 
 // Поскольку 0 удовлетворяет этому охраннику, мы используем возвращаемое значение функции 
 // и помещаем его в согласованный контекст.Теперь мы находимся в 
 // сопоставленном (1) контексте .. в противном случае (x => x * 10) 
 // Мы находимся в сопоставленном контексте, поэтому обратный вызов игнорируется, и 
 // вместо этого мы получаем 1 обратно 

Функция match решает все проблемы с использованием переключателя в декларативном коде:

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

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

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

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

 const done = x => ({
 попытка: () => done (x), наконец, 
: fn => fn (x), 
 }) const until = (pred, x) => ({
 попытка: fn => {
 const y = fn (x) 
 return pred (y)? done (y): until (pred, x) 
}, 
 наконец: (_, fn) => fn (x), 
}) 

Функция until () инкапсулирует шаблон попытки сопоставить значение с другим, пока результат не будет удовлетворять некоторому условию.Я оставлю это в качестве упражнения моим читателям, чтобы выяснить, как работает до () .

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

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

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

Я хотел бы услышать ваше мнение по этой теме.

Оператор переключения Javascript | Преобразование строкового и целочисленного типов