Содержание

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), который не является обязательным. Если случая по умолчанию нет, выполнение продолжается на инструкции, следующей сразу после switch. По соглашению, случай default описывается последним, но это не является строгим правилом.

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

switch.

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

switch

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

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», если значение foo равно 0, 1, 2 или 3.

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

  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.

..case

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

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

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

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

…………………….

case <значениеN>:


<выражениеN

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

Хорошо, теперь давайте рассмотрим все подробно. Сразу после ключевого слова js switch в круглых скобках указывается имя переменной, которую нужно проверить, после, идут фигурные скобки, между которыми будет проходить проверка. Как видим, после ключевого слова js case следует значение, которое может принимать переменная. То есть, идёт проверка: если переменная ровна значению 1, то, выполнить одно выражение, если значению 2 – то другое, и так n-е количество раз. Ключевое слово default прописывается в конце, программный код в нём будет выполняться в том случае, если ни одно из предыдущих значений не подошло. Также, обратите внимание на оператор

break (выход из цикла), если его не прописывать, то будет происходить последовательна проверка всех меток js case, даже в том случае, если подходящее значение уже найдено. При желании, можно вместо break использовать оператор jscript return.

Конструкция 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 = «Значение не найдено»;
}

Попробуй сам »


Коммутатор

— JavaScript | MDN

Оператор переключателя оценивает выражение, сопоставление значения выражения с предложением case и выполняет связанные операторы с этим case , а также операторами в case s, которые следуют соответствующий футляр .

  переключатель (выражение) {
  case value1:
    
    
    [перерыв;]
  case value2:
    
    
    [перерыв;]
  ...
  case valueN:
    
    
    [перерыв;]
  [По умолчанию:
    
    
    [перерыв;]]
}  
выражение
Выражение, результат которого сопоставляется с каждым предложением case .
корпус значение N Дополнительно
Предложение case , используемое для сопоставления с выражением .Если выражение соответствует указанному значениеN , утверждения внутри предложения case являются выполняется либо до конца оператора switch , либо до перерыв .
по умолчанию Дополнительно
Предложение по умолчанию ; если предусмотрено, это предложение выполняется, если значение выражение не соответствует ни одному из предложений case .

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

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

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

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

В следующем примере, если expr оценивается как Bananas , программа сопоставляет значение с case case 'Bananas' и выполняет связанное заявление. Когда встречается break , программа прерывается. switch и выполняет оператор после switch .Если перерыв опущены, выписка по делу «Вишни» также будет казнен.

  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 ("по умолчанию");
}  

Могу ли я поставить

по умолчанию между случаями?

Да, можно! JavaScript вернет вас к по умолчанию , если не может найти совпадение:

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

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

Методы для множественных критериев

case

Этот метод также обычно называют сквозным.

Multi-
корпус : одиночная операция

Этот метод использует тот факт, что если нет разрыва ниже case clause он продолжит выполнение следующего case clause независимо от того, соответствует ли case критериям.(См. Раздел «Что произойдет, если я забуду перерыв ?)

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

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

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

  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!»);
}  

Результат этого примера:

Значение Текст журнала
foo — это NaN или нет 1 , 2 , 3 , 4 , 5 или 0 Пожалуйста, выберите число от 0 до 5!
0 Вывод: так как вас зовут?
1 Вывод: как вас зовут?
2 Вывод: Ваше имя?
3 Выход: Имя?
4 Выход:?
5 Выход:!

Переменные области блока в пределах

переключатель операторов

С поддержкой ECMAScript 2015 (ES6), доступной в большинстве современных браузеров, будет бывают случаи, когда вы хотите использовать , пусть и const операторов для объявления переменных с блочной областью видимости.

Взгляните на этот пример:

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

Этот пример выведет ошибку Uncaught SyntaxError: Идентификатор 'message' уже был объявлен , который Вы, наверное, не ожидали.

Это потому, что первые let message = 'hello'; конфликтует со вторым пуском оператор let message = 'hi'; даже в отдельном корпусе пункты case 'say_hello': и case 'say_hi': . В конечном итоге это связано с тем, что оба оператора let интерпретируются как повторяющиеся объявления с тем же именем переменной в той же области блока.

Мы можем легко это исправить, заключив в скобки наши case clauses:

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

Этот код теперь будет выводить hello в консоль, как и должно, без каких-либо ошибок вообще нет.

Таблицы BCD загружаются только в браузере

Возможно, вам не понадобится переключение в JavaScript

Простите за заголовок clickbaity, но разработчики JavaScript так любят переключаться.Есть ли лучшая альтернатива?

tl; dr : есть, но медленнее.

Без переключателя, без партии

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

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

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

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

Когда имя — «Юлиана», мы печатаем сообщение и немедленно выходим из блока с перерывом . Когда переключатель находится внутри функции, вы можете опустить , разрыв , если вы возвращаетесь из каждого предложения.

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

  const name = "Крис";

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

Переключатель также активно используется в редукторах Redux (хотя Redux Toolkit упростил шаблон), чтобы избежать тонны , если . Рассмотрим этот пример:

  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};
    По умолчанию:
      вернуть состояние;
  }
}  

Что с этим не так? Почти ничего. Но есть ли лучшая альтернатива?

Изучение Python

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

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

  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 (действие ["тип"], состояние)  

В Python мы можем смоделировать switch с помощью словаря.Случай по умолчанию в основном заменяется значением по умолчанию для dict.get () .

Python вызывает KeyError при доступе к несуществующему ключу:

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

>>> my_dict ["not_here"]

  

Метод .get () — более безопасная альтернатива прямому доступу по ключу, поскольку он не вызывает повышение и позволяет указать значение по умолчанию для несуществующих ключей:

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

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

  

Итак, эта строка в Python:

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

в JavaScript эквивалентно:

  function authReducer (state = authState, action) {

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

Что я имею в виду? Давайте применим тот же стиль Pythonic к JavaScript.

Альтернатива выключателю

Снова рассмотрим предыдущий пример:

  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}
  };

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

Way намного чище если вы спросите меня. Этот хороший рефакторинг возможен благодаря современному JavaScript, а именно имен вычисляемых свойств (ECMAScript 2015) :

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

Здесь свойства для отображения вычисляются «на лету» из двух констант: LOGIN_SUCCESS и LOGIN_FAILED .Тогда есть распространение объекта (ECMAScript 2018) :

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

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

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

Но, , как этот код выполняет ?

Как насчет спектаклей?

Коммутатор превосходит причудливый синтаксис .

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

  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; выполнено  

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

Переключатель Отображение
43,033 71.609
40,247 64,800
37.814 66,123
37,967 63,871
37,616 68,133
38,534 69,483
37,261 67,353
41,662 66.113
38,867 65,872
37,602 66,873

Смело делайте выводы. Спасибо за прочтение!

Ресурсы

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

Случай переключения JavaScript - Studytonight

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

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

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

JavaScript

switch : синтаксис

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

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

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

ПРИМЕЧАНИЕ: Если мы не добавим оператор break после операторов кода в блоке switch case, то интерпретатор будет выполнять каждый случай после совпадающего варианта.

JavaScript Switch case: пример

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

В приведенном выше примере мы использовали оператор break для завершения случая переключения.

Пример сценария переключателя JavaScript без перерыва

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

JavaScript Switch Case по умолчанию

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

Этим мы рассмотрели оператор 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 | Преобразование строкового и целочисленного типов


Учебник по Javascript


Соответствие типа инструкции переключения


Если параметр оператора switch - строка, а параметр case - целое число, они не совпадают. В качестве примера рассмотрим следующий код

 
- Если строка определена

var height = "61"; совпал бы с

case 61:

Это привело бы к выводу «высота более 5 футов».Вместо этого он дает вывод «высота от 59 дюймов до 61 дюймов». Причина проста - типы не совпадают. Это происходит потому, что switch использует ==== вместо == при сравнении значений.

Вы можете попробовать этот пример онлайн здесь.

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

Способ исправить это либо изменить

var height = "61";

в

var height = "1;

или изменить

корпус 61:

в

корпус 61:

& NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & NBSP & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp & nbsp

* Перекрестная публикация с моего Медиума.
Средний: Arisa F

Привет! Это Ариса из Японии, работающая и живущая в Германии в качестве Full-Stack Developer.

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

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

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

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

Приступим к обсуждению.

Короткий ответ - ДА.

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

Вы можете использовать правильно!

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

Это звучит немного преувеличенно… для некоторых из них.
Собираетесь ли вы рисковать или нет, решать вам.
Кроме того, его можно использовать, если вы следуете синтаксису и в удобных случаях.

Тогда почему некоторые люди слишком осторожны?

Вот еще одно обсуждение.

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

Fallthrough хорош в таких ситуациях.

  • Многие случаи, например, более 10 из них, не требуют перерывов для провала
  • Многие случаи и очень простые выходы для возврата

Легче понять, увидев реальный пример.
Давайте посмотрим на этот пример.

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

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

Кроме того, ваши коллеги понимают, когда вы объединяете всех этих 7 человек в один круг и пишете один раз «Джедаи», чтобы описать их.
Fallthrough может сделать то же самое.
В этом случае провал действительно эффективен и очень полезен.

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

Давайте посмотрим правде в глаза о том, кто на самом деле ваш друг.

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

Я нашел интересное объяснение от W3schools по этому поводу.

Иногда вам может понадобиться, чтобы в разных случаях использовался один и тот же код, или чтобы использовалось общее значение по умолчанию.
Обратите внимание, что в этом примере случаи используют один и тот же блок кода, и что регистр по умолчанию не обязательно должен быть последним случаем в блоке переключения (однако, , если значение по умолчанию НЕ является последним случаем в блоке переключения, помните закончить с перерывом ).
https://www.w3schools.com/jsref/jsref_switch.asp

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

Давайте посмотрим в исходном коде, что это значит.

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

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

Тогда нам следует ожидать сообщения «Верни мои выходные».
Вот почему мы ставим случай от 1 до 3 и по умолчанию с провалом.

Что за… фу… провал!

Мы получили «Почти выходные… !! 😎 »на четверг и пятницу.
Выходные далеко впереди вторника, почему это происходит?

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

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

Вот тут-то и провалы ведут себя по-другому.
Кроме того, это сложно из-за использования провалов.
Fallthrough допускает случаи с 1 по 3, включая значения по умолчанию, вплоть до случаев 4 и 5, потому что нет разрыва, хотя есть значение по умолчанию.

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

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

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

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

«Тогда как же поступить со многими случаями, когда лучше не обрабатывать оператор if…?»

Всегда есть решение.
Вот один из них.

Могут ли предметы быть альтернативным решением, чтобы избежать ловушки падения?
ДА, и выглядит очень аккуратно.

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

Единственное, что вас раздражает, вы могли написать одно и то же значение для некоторых свойств объекта.
Вы поняли, что это основано на первом примере с персонажами «Звездных войн».
Во многих случаях люди используют fallthrough, чтобы сделать код коротким и чистым.
Но какие примеры чистые и короткие?

Безусловно, тот, кто использует предметы.

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

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