У дел с быстрым переключением дел есть разные и общие дела

У меня есть такой код

switch thing {
  case thisThing:
     do thing #1
     do thing #2
  case thatThing:
     do thing #2
     do thing #3
  case anotherThing:
     do thing #4
  default:
     default
}

Итак, КАЖДЫЙ случай имеет то, что ТОЛЬКО ОНО делает. В некоторых случаях также выполняются те же действия, что и в одном или нескольких других случаях.

Есть ли способ сделать это, если я не хочу повторяющегося кода?

ИЛИ, есть ли намного более эффективный способ сделать это без операторов switch вообще? Я имею в виду, что я мог бы, например, использовать операторы if, но, как и операторы switch, я не могу придумать, как выполнить то, что я хочу, без использования повторяющегося кода.

Кроме того, этот пример может быть более понятным, чем выше

myFavoriteNumbers = []
myLeastFavoriteNumbers = []

switch myNumber {
case 1:
  print("my number is number 1") // do this only for case 1
  myFavoriteNumbers += [1] // do this for case 1 and case 2
case 2:
  print("this is number 2") // do this only for case 2
  myFavoriteNumbers += [2] // do this for case 1 and case 2
case 3:
  print("I don't like number 3") // do this only for case 3
  myLeastFavoriteNumbers += [3] // do this for case 3 and case 4
case 4:
  print("Number Four") // do this only for case 4
  myLeastFavoriteNumbers += [4] // do this for case 3 and case 4
default:
  print("Default")
}

3 ответа

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

Например, для вашего примера

var myFavoriteNumbers: [Int] = []
var myLeastFavoriteNumbers: [Int] = []
let myNumberDescriptions = ["my number is number 1",
    "this is number 2", "I don't like number 3", "Number Four"]

let myNumber = 1

/* unique action:
    perform a unique action (given a valid number)
    and thereafter proceed to common cases */
if 1...myNumberDescriptions.count ~= myNumber {
    print(myNumberDescriptions[myNumber-1])
}

/* common cases */
switch myNumber {

/* common case: is a favourite number */
case 1...2: myFavoriteNumbers += [myNumber]

/* common case: is a least favourite number */
case 3...4: myLeastFavoriteNumbers += [myNumber]

default:
    print("Default")
}

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

Вы можете вкладывать операторы switch, которые включают одно и то же значение, например так:

switch myNumber {
case 1...2:
    myFavoriteNumbers += [myNumber] // do this for case 1 and case 2
    switch myNumber {
    case 1:
        print("my number is number 1") // do this only for case 1
    default:
        print("this is number 2") // do this only for case 2
    }
case 3...4:
    myLeastFavoriteNumbers += [myNumber] // do this for case 3 and case 4
    switch myNumber {
    case 3:
        print("I don't like number 3") // do this only for case 3
    default:
        print("Number Four") // do this only for case 4
    }
default:
    print("Default")
}

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

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

У меня нет для тебя серебряной пули, но я думаю, что поступил бы так:

создать один оператор switch, который охватывает только отдельную логику

создать второй оператор switch, который объединяет общую логику

switch thing {
case thisThing:
   do thing #1
case thatThing:
   do thing #4
case anotherThing:
   do thing #5
default: ()
}

switch thing {
case thisThing, thatThing:
   do thing #2
default: ()
}

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

Другие вопросы по тегам