switch语句是否可以有多个变量？

Question

问题出在所有使用开关块的语言中（C++，C＃PHP，Java，Python等）。那么有可能有这样的事情吗？

switch (var1, var2) 
case var1 = a: 
    something 
    break; 
case var2 = b: 
    something 
    break; 
case var1 = 0 ,var2 = 1 
    etc... 

Answer 1

是/否。

传统语言没有“switch”语句。它存在于所谓的“模式匹配”中。 （不完全确定PHP，但我不相信它，如果我错了，请纠正错误）。

下面是Haskell中存在模式匹配的例子。模式匹配有很多功能风格的语言。

function 1 _ = "first parameter has a one" 
function _ 1 = "second parameter is a one" 
function _ _ = "I don't know what crazy number you passed in" 

当该函数被调用时，运行时/编译器/检查它的人会看看是否可以调用第一个函数。如果可以，它会返回该值。然后它继续前进，直到找到可用于给定参数的一些匹配。 “_”只是一种说法，“任何东西都可以在这里，我真的不在乎它是什么，所以不要将价值与名称绑定”。如果我关心的价值，我可以这样做：

function 1 a = "second parameter is " ++ (show a) 

现在，因为它通常会自上而下的（不像switch语句），这是更类似于一个的if/else比只是跳转到switch语句正确的位置。这只是一个很好看的if/else。另外，如果我对它进行了重新排序，所以最常见的情况是在文件的顶部，其他情况将被忽略。

你也可以做一些类似的模板，但是这只会在编译时才起作用。

Answer 2

我从来没有见过一种语言，允许那，没有。

Answer 3

当然不是在C＃中。你会使用一个if/else if模式来满足这些条件。我不能说任何其他语言的权威，但我99％肯定Java不允许它。谁知道这些疯狂的PHP和Python人允许什么，尽管...

Answer 4

不需要。您将不得不将一个变量的开关盒嵌套在另一个变量的内部。

Answer 5

我认为你可以在Haskell和ML等语言中进行任意的情况匹配。请参阅Haskell Pattern Matching。所讨论的对象仍然是单个对象，但该对象可以是包含任意数量对象的元组。

中的链接给出的一个例子是：

describeList :: [a] -> String 
describeList list = 
    case list of 
    []  -> "The list was empty" 
    (x:xs) -> "The list wasn't empty: the first element was " ++ show x ++ 
      ", and there were " ++ show (length xs) ++ 
      " more elements in the list." 

Answer 6

如果你想想看，语言不能让因为你可以有一个以上的情况下，这将是真正的结束。

Answer 7

AFAIK，python没有切换大小写。

Answer 8

Python没有switch语句。推荐的替代方案是使用链式if/else链 - 无论如何，这就是您应该使用的方法。

另一个常见的习惯用法是使用地图。在你的情况下，你可以使用（var1，var2）的元组来匹配结果。

switch = { 
    (1,2): lambda: .., 
    (3,4): lambda: ..., 
} 
switch[(var1,var2)] 

我不确定这是常用的，但至少是可以的。

Answer 9

CHILL允许它：

PROC (b board LOC,m move) EXCEPTIONS (illegal); 
DCL starting square LOC:= b (m.lin_1)(m.col_1), 
arriving square LOC:= b (m.lin_2)(m.col_2); 
DO WITH m; 
IF starting.status=free THEN CAUSE illegal; FI; 
IF arriving.status/=free THEN 
IF arriving.p.kind=king THEN CAUSE illegal; FI; 
FI; 
CASE starting.p.kind, starting.p.color OF 
    (pawn),(white): 
     IF col_1 = col_2 AND (arriving.status/=free 
     OR NOT (lin_2=lin_1+1 OR lin_2=lin_1+2 AND lin_2=2)) 
     OR (col_2=PRED (col_1) OR col_2=SUCC (col_1)) 
     AND arriving.status=free THEN CAUSE illegal; FI; 
     IF arriving.status/=free THEN 
     IF arriving.p.color=white THEN CAUSE illegal; FI; FI; 
    (pawn),(black): 
     IF col_1=col_2 AND (arriving.status/=free 
     OR NOT (lin_2=lin_11 OR lin_2=lin_12 AND lin_1=7)) 
     OR (col_2=PRED (col_1) OR col_2=SUCC (col_1)) 
     AND arriving.status=free THEN CAUSE illegal; FI; 
     IF arriving.status/=free THEN 
     IF arriving.p.color=black THEN CAUSE illegal; FI; FI; 
    (rook),(*): 
     IF NOT ok_rook (b,m) 
     THEN CAUSE illegal; 
     FI; 
    (bishop),(*): 
     IF NOT ok_bishop (b,m) 
     THEN CAUSE illegal; 
     FI; 
    (queen),(*): 
    IF NOT ok_rook (b,m) AND NOT ok_bishop (b,m) 
    THEN CAUSE illegal; 

Answer 10

你可以做一些类似你想在斯卡拉什么（以及任何其他函数式语言，具有模式匹配的机制）：

def matchTest(var1: Any, var2: Any): Any = (var1, var2) match { 
    case (a, _) => "var1 == a" 
    case (_, b) => "var2 == b" 
    case (0, 1) => "var1 == 0, var2 == 1" 
} 

Answer 11

如上所述，这种模式匹配是功能语言的典型特征。但是你可以找到一些支持它的至少“混合”功能/ OOP。

下面是F＃的例子

let fnc (var1, var2) = 
    match (var1, var2) with 
     | 2 , _ -> "something" 
     | _ , 3 -> "something else" 
     | 0, 1 -> "etc ... " 
     | a, b -> "I got " + a.ToString() + " and " + b.ToString() 

fnc(0, 1) |> printfn "%s" // prints "etc.." 

和阶相同

def fnc(var1: Int, var2: Int) : String = 
    (var1, var2) match { 
    case (2, _) => "something" 
    case (_,3) => "something else" 
    case (0, 1) => "etc..." 
    case (a, b) => "I got " + a + " and " + b 
    } 

println(fnc(0,1))