1

我有一个嵌套的 if else 结构，如下所示，我想用正确类型的编程语句替换它。

if($provider[0][0]=='A' && $provider[1][0]=='B'){
   return 'O';
}elseif($provider[0][0]=='B' && $provider[1][0]=='A'){
   return 'O';
}elseif($provider[0][0] == 'A' && $provider[1][0] == '' ){
   return 'A';
}elseif($provider[0][0] == 'B' && $provider[1][0] == '' ){
   return 'B';
} else{
   return 'Return nothing';
}
4

5 回答 5

2

并不是真正避免嵌套，而是简化阅读：

<?php

function isOprovider($provider) {
    return $provider[0][0]=='A' && $provider[1][0]=='B' 
           || $provider[0][0]=='B' && $provider[1][0]=='A';
}

function isAprovider($provider) {
    return $provider[0][0] == 'A' && $provider[1][0] == '';
}

function isBprovider($provider) {
    return $provider[0][0] == 'B' && $provider[1][0] == '';
}

if (isOprovider($provider)) {
     return '0';
} else if (isAprovider($provider)) {
     return 'A';
} else if (isBprovider($provider)) {
     return 'B';
} else {
     return 'Return nothing';
}
于 2013-04-16T10:49:01.517 回答
1

使其更具可读性的选项之一-

if($provider[0][0]=='A') {
   // other condition(s)
} else if($provider[0][0]=='B') {
   // other condition(s) 
} else {
  // return nothing
}

你也可以试试switch。无论如何，您都需要嵌套条件。

于 2013-04-16T10:46:55.933 回答
0

我会用数据替换大部分代码，然后使用循环从数据中选择正确答案。这里的想法是将政策和实施分开。政策是：给定不同的提供者组合，我应该返回什么？实施是....好吧，实施。

这个例子是用 Ruby 编写的，但这个想法适用于任何语言。

表示策略的数据可能如下所示：

PROVIDER_COMBOS = [
  ['A', 'B', 'O'],
  ['B', 'A', 'O'],
  ['A', '', 'A'],
  ['B', '', 'B'],
]

并且使用它的代码可能如下所示：

def lookup_provider_combo(provider1, provider2)
  PROVIDER_COMBOS.each do |key1, key2, result|
    if provider1[0] == key1 && provider2[0] == key2
      return result
    end
  end
  return 'Return nothing'
end
于 2013-04-16T21:52:52.640 回答
0

从技术上讲， if..else 语句不是嵌套的。它是平的。此外，它在技术上已经处于最低复杂度的状态。这是相当简单的代码。它确实“看起来”很乱。让它看起来凌乱的事情是它的冗长（不要将冗长/凌乱与复杂性混淆）。

但是你抱怨冗长是对的。冗长的代码，尤其是有很多重复位的代码，会损害可读性。对于示例中的代码，要使其更具可读性，您可以做的第一件显而易见的事情就是分解数组语法：

p1 = $provider[0][0];
p2 = $provider[1][0];

if (p1 == 'A' && p2 == 'B') {
   return 'O';
} elseif (p1 == 'B' && p2 == 'A') {
   return 'O';
} elseif (p1 == 'A' && p2 == '' ) {
   return 'A';
} elseif (p1 == 'B' && p2 == '' ) {
   return 'B';
} else {
   return 'Return nothing';
}

仅此一项就消除了代码中的杂乱无章，使逻辑更加清晰。您可以做其他事情来从上面的代码中删除更多重复的位以使其更加清晰，但它们都归结为上面的代码所做的事情：基本上是一个条件和结果表。

在switch语句接受字符串作为输入的语言中，您可以简单地将两个条件连接成一个字符串作为切换条件：

switch (join([p1,p2],',')) {
    'A,B'   : return 'O'; break;
    'B,A'   : return 'O'; break;
    'A,'    : return 'A'; break;
    'B,'    : return 'B'; break;
    default : return 'Return nothing'; break;
}

这使得您正在做的是咨询表格变得更加明显。或者，您可以使用三元运算符实现类似的布局：

cond = join([p1,p2],',');

return cond == 'A,B' ? 'O' :
       cond == 'B,A' ? 'O' :
       cond == 'A,'  ? 'A' :
       cond == 'B,'  ? 'B' :
       'Return nothing';

诚然，这仍然有cond ==重复。但与原始 if..else 语句相比，查看该表稍微容易一些。

在具有字典/关联数组/哈希的语言中，您可以简单地将逻辑编码到数据结构中并简单地读取该数据结构：

conditions = {
    'A' : {
        'B' : 'O',
        ''  : 'A'
    },
    'B' : {
        'A' : 'O',
        ''  : 'B'
    }
}

result = conditions[p1][p2];

return result ? result : 'Return nothing';

或者，您也可以使用以下数据结构：

conditions = {
    'A,B' : 'O',
    'B,A' : 'O',
    'A,'  : 'A',
    'B,'  : 'B'
}

result = conditions[join([p1,p2],',')];

return result ? result : 'Return nothing';

将条件逻辑保留为纯数据而不是代码，这使得我们正在做的是查找表变得更加明显。将条件保留为纯数据的另一个优点是，您可以在运行时通过从文件（或从 Internet 上的套接字）读取数据结构来潜在地创建数据结构。例如，逻辑可能被编码为 JSON 或 YAML 格式的文件，您可以使逻辑可编程。

如您所见，有很多方法可以做到这一点，但这取决于您的编程语言中可用的功能。它们都具有相同的复杂性（并且大多数编译成相同的东西）。唯一的区别在于可读性和可维护性。

于 2013-04-17T17:55:49.137 回答
0

我会做这样的事情：

function IsCombinationOf($first, $second, $provider) {
    return ($provider[0][0]==$first && $provider[1][0]==$second) || 
           ($provider[0][0]==$second && $provider[1][0]==$first);
}


if(IsCombinationOf('A', 'B', $provider)){
    return 'O';
}
elseif(IsCombinationOf('', '', $provider)){
    return 'Return Nothing';
}
elseif(IsCombinationOf('A', '', $provider)){
    return 'A';
}
elseif(IsCombinationOf('B', '', $provider)){
    return 'B';
}
于 2013-04-16T11:11:39.353 回答