blocks|key|3734066|text|首先，我删除了所有的==+true部分，这将使它缩短50%25+;)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3734067|当我有很大的条件时，我会寻找原因。有时我认为我应该使用多态性，有时我需要添加一些状态对象。基本上，这意味着需要重构(一种代码味道)。|3734068|有时我使用De-Morgan's+laws来稍微简化一下布尔表达式。|3734069|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/De_Morgan%2527s_laws^0|A|7|0|0|5|G|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|V|8|@]|D|@$9|W|A|X|1|Y]]|E|$]]|$1|J|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]]]

First, I'd remove all the <code>== true</code> parts, that would make it 50% shorter ;)

When I have big condition I search for the reasons. Sometimes I see I should use polymorphism, sometimes I need to add some state object. Basically, it implies a refactoring is needed (a code smell). 

Sometimes I use <a href="http://en.wikipedia.org/wiki/De_Morgan%27s_laws" rel="nofollow noreferrer">De-Morgan's laws</a> to simplify boolean expressions a bit.

blocks|key|702394|text|我求助于单独的布尔值：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|702395|Bool+cond1+==+(var1+&&+var2);
Bool+cond2+==+(var3+&&+var4);

if+(+cond1+&&+cond2+)+{}|code-block|syntax|javascript|702396|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I resort to separate boolean values:

<pre><code>Bool cond1 == (var1 &amp;&amp; var2);
Bool cond2 == (var3 &amp;&amp; var4);

if ( cond1 &amp;&amp; cond2 ) {}
</code></pre>

blocks|key|3734121|text|我见过很多人和编辑要么用一个制表符缩进if语句中的每个条件，要么用打开的paren来匹配它：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3734122|if+(var1+==+true
++++&&+var2+==+true
++++&&+var3+==+true
+++)+{
++++/*+do+something..+*/
}|code-block|syntax|javascript|3734123|我通常将close+paren放在与最后一个条件相同的行上：|3734124|if+(var1+==+true
++++&&+var2+==+true
++++&&+var3+==+true)+{
++++/*+do+something..+*/
}|3734125|但我不认为这是很干净的。|3734126|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I've seen a lot of people and editors either indenting each condition in your if statement with one tab, or matching it up with the open paren:

<pre><code>if (var1 == true
 &amp;&amp; var2 == true
 &amp;&amp; var3 == true
 ) {
 /* do something.. */
}
</code></pre>

I usually put the close paren on the same line as the last condition:

<pre><code>if (var1 == true
 &amp;&amp; var2 == true
 &amp;&amp; var3 == true) {
 /* do something.. */
}
</code></pre>

But I don't think this is quite as clean.

blocks|key|5145182|text|我经常会把它们分成组件布尔型变量：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5145183|bool+orderValid+=+orderDate+<+DateTime.Now+&&+orderStatus+!=+Status.Canceled;
bool+custValid+=+customerBalance+==+0+&&+customerName+!=+"Mike";
if+(orderValid+&&+custValid)
{
...|code-block|syntax|javascript|5145184|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I'll often split these up into component boolean variables:

<pre><code>bool orderValid = orderDate &lt; DateTime.Now &amp;&amp; orderStatus != Status.Canceled;
bool custValid = customerBalance == 0 &amp;&amp; customerName != "Mike";
if (orderValid &amp;&amp; custValid)
{
...
</code></pre>

blocks|key|2890321|text|将条件分成几个布尔值，然后使用主布尔值作为条件。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2890322|bool+isOpaque+=+object.Alpha+==+1.0f;
bool+isDrawable+=+object.CanDraw+&&+object.Layer+==+currentLayer;
bool+isHidden+=+hideList.Find(object);

bool+isVisible+=+isOpaque+&&+isDrawable+&&+!+isHidden;

if(isVisible)
{
++++//+...
}|code-block|syntax|javascript|2890323|更好的是：|2890324|public+bool+IsVisible+{
++++get
++++{
++++++++bool+isOpaque+=+object.Alpha+==+1.0f;
++++++++bool+isDrawable+=+object.CanDraw+&&+object.Layer+==+currentLayer;
++++++++bool+isHidden+=+hideList.Find(object);

++++++++return+isOpaque+&&+isDrawable+&&+!+isHidden;
++++}
}

void+Draw()
{
+++++if(IsVisible)
+++++{
+++++++++//+...
+++++}
}|2890325|确保你给你的变量命名实际表明意图而不是功能。这将极大地帮助开发人员维护您的代码……可能是你！|2890326|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Separate the condition in several booleans and then use a master boolean as the condition.

<pre><code>bool isOpaque = object.Alpha == 1.0f;
bool isDrawable = object.CanDraw &amp;&amp; object.Layer == currentLayer;
bool isHidden = hideList.Find(object);

bool isVisible = isOpaque &amp;&amp; isDrawable &amp;&amp; ! isHidden;

if(isVisible)
{
 // ...
}
</code></pre>

Better yet:

<pre><code>public bool IsVisible {
 get
 {
 bool isOpaque = object.Alpha == 1.0f;
 bool isDrawable = object.CanDraw &amp;&amp; object.Layer == currentLayer;
 bool isHidden = hideList.Find(object);

 return isOpaque &amp;&amp; isDrawable &amp;&amp; ! isHidden;
 }
}

void Draw()
{
 if(IsVisible)
 {
 // ...
 }
}
</code></pre>

Make sure you give your variables name that actualy indicate intention rather than function. This will greatly help the developer maintaining your code... it could be YOU!

blocks|key|2890366|text|我喜欢按级别对它们进行分解，所以我将像这样格式化您的示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2890367|if+(var1+=+true
+&&+var2+=+true
+&&+var2+=+true
+&&+var3+=+true
+&&+var4+=+true
+&&+var5+=+true
+&&+var6+=+true){|code-block|syntax|javascript|2890368|当你有更多的嵌套时，它是很方便的，就像这样(很明显真实的条件会比"=+true“更有趣)：|2890369|if+((var1+=+true+&&+var2+=+true)
+&&+((var2+=+true+&&+var3+=+true)
++&&+(var4+=+true+&&+var5+=+true))
+&&+(var6+=+true)){|2890370|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I like to break them down by level, so I'd format you example like this:

<pre><code>if (var1 = true
 &amp;&amp; var2 = true
 &amp;&amp; var2 = true
 &amp;&amp; var3 = true
 &amp;&amp; var4 = true
 &amp;&amp; var5 = true
 &amp;&amp; var6 = true){
</code></pre>

It's handy when you have more nesting, like this (obviously the real conditions would be more interesting than "= true" for everything):

<pre><code>if ((var1 = true &amp;&amp; var2 = true)
 &amp;&amp; ((var2 = true &amp;&amp; var3 = true)
 &amp;&amp; (var4 = true &amp;&amp; var5 = true))
 &amp;&amp; (var6 = true)){
</code></pre>

blocks|key|702497|text|看看Kent+Beck的Implementation+Patterns吧。我正在考虑一种特殊的模式，它可能对这种情况有所帮助……它被称为“守卫”。而不是拥有大量的条件，您可以将它们分解为一个守卫，这清楚地表明了方法中哪些是不利的条件。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|702498|例如，如果你有一个方法做了一些事情，但在某些情况下它不应该做一些事情，而不是：|702499|public+void+doSomething()+{
++++if+(condition1+&&+condition2+&&+condition3+&&+condition4)+{
++++++++//+do+something
++++}
}|code-block|syntax|javascript|702500|您可以将其更改为：|702501|public+void+doSomething()+{
++++if+(!condition1)+{
++++++++return;
++++}

++++if+(!condition2)+{
++++++++return;
++++}

++++if+(!condition3)+{
++++++++return;
++++}

++++if+(!condition4)+{
++++++++return;
++++}

++++//+do+something
}|702502|它有点冗长，但可读性更好，特别是当你开始有奇怪的嵌套时，防护可以提供帮助(结合提取方法)。|702503|顺便说一下，我强烈推荐那本书。|702504|entityMap|0|LINK|mutability|MUTABLE|url|https://rads.stackoverflow.com/amzn/click/com/0321413091^0|C|N|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|15|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|17|8|@]|9|@]|C|$I|J]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|C|$]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]]]

Check out <a href="https://rads.stackoverflow.com/amzn/click/com/0321413091" rel="nofollow noreferrer" rel="nofollow noreferrer">Implementation Patterns</a> by Kent Beck. There is a particular pattern I am thinking of that may help in this situation... it is called "Guards". Rather than having tons of conditions, you can break them out into a guard, which makes it clear which are the adverse conditions in a method.

So for example, if you have a method that does something, but there are certain conditions where it shouldn't do something, rather than:

<pre><code>public void doSomething() {
 if (condition1 &amp;&amp; condition2 &amp;&amp; condition3 &amp;&amp; condition4) {
 // do something
 }
}
</code></pre>

You could change it to:

<pre><code>public void doSomething() {
 if (!condition1) {
 return;
 }

 if (!condition2) {
 return;
 }

 if (!condition3) {
 return;
 }

 if (!condition4) {
 return;
 }

 // do something
}
</code></pre>

It's a bit more verbose, but a lot more readable, especially when you start having weird nesting, the guard can help (combined with extracting methods).

I HIGHLY recommend that book by the way.

blocks|key|5145406|text|我很惊讶还没有人收到这封信。有一个专门针对这类问题的重构：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5145407|http://www.refactoring.com/catalog/decomposeConditional.html|offset|length|5145408|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1O|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

I'm surprised no one got this one yet. There's a refactoring specifically for this type of problem:

<a href="http://www.refactoring.com/catalog/decomposeConditional.html" rel="nofollow noreferrer">http://www.refactoring.com/catalog/decomposeConditional.html</a>

blocks|key|3734429|text|这里有两个问题需要解决:可读性和可理解性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3734430|“可读性”解决方案是一个风格问题，因此是可以解释的。我的偏好是：|3734431|if+(var1+==+true+&&+//+Explanation+of+the+check
++++var2+==+true+&&+//+Explanation+of+the+check
++++var3+==+true+&&+//+Explanation+of+the+check
++++var4+==+true+&&+//+Explanation+of+the+check
++++var5+==+true+&&+//+Explanation+of+the+check
++++var6+==+true)+++//+Explanation+of+the+check
++++{+}|code-block|syntax|javascript|3734432|或者这样：|3734433|if+(var1+&&+//+Explanation+of+the+check
++++var2+&&+//+Explanation+of+the+check
++++var3+&&+//+Explanation+of+the+check
++++var4+&&+//+Explanation+of+the+check
++++var5+&&+//+Explanation+of+the+check
++++var6)+++//+Explanation+of+the+check
++++{+}|3734434|也就是说，这种复杂的检查在扫描代码时很难在心理上进行解析(特别是如果您不是原始作者的话)。考虑创建一个helper方法来抽象一些复杂性：|3734435|///+<Summary>
///+Tests+whether+all+the+conditions+are+appropriately+met
///+</Summary>
private+bool+AreAllConditionsMet+(
++++bool+var1,
++++bool+var2,
++++bool+var3,
++++bool+var4,
++++bool+var5,
++++bool+var6)
{
++++return+(
++++++++var1+&&+//+Explanation+of+the+check
++++++++var2+&&+//+Explanation+of+the+check
++++++++var3+&&+//+Explanation+of+the+check
++++++++var4+&&+//+Explanation+of+the+check
++++++++var5+&&+//+Explanation+of+the+check
++++++++var6);++//+Explanation+of+the+check
}

private+void+SomeMethod()
{
++++//+Do+some+stuff+(including+declare+the+required+variables)
++++if+(AreAllConditionsMet+(var1,+var2,+var3,+var4,+var5,+var6))
++++{
++++++++//+Do+something
++++}
}|3734436|现在，当视觉上扫描"SomeMethod“方法时，测试逻辑的实际复杂性被隐藏了，但语义含义被保留下来，以便人们在更高的层次上理解。如果开发人员确实需要了解细节，可以检查AreAllConditionsMet方法。|3734437|我认为这被正式地称为“分解条件”重构模式。像Resharper或Refactor+Pro这样的工具！可以让做这样的重构变得容易！|3734438|在所有情况下，拥有可读和可理解的代码的关键是使用真实的变量名称。虽然我理解这是一个人为的例子，但"var1“、"var2”等都是不能接受的变量名。它们应该有一个能够反映它们所表示的数据的基本性质的名称。|offset|length|style|BOLD|3734439|entityMap^0|0|0|0|0|0|0|0|0|0|1S|5|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1A|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1B|8|@$W|1C|X|1D|Y|Z]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|11|$]]

There are two issues to address here: readability and understandability

The "readability" solution is a style issue and as such is open to interpretation. My preference is this:

<pre><code>if (var1 == true &amp;&amp; // Explanation of the check
 var2 == true &amp;&amp; // Explanation of the check
 var3 == true &amp;&amp; // Explanation of the check
 var4 == true &amp;&amp; // Explanation of the check
 var5 == true &amp;&amp; // Explanation of the check
 var6 == true) // Explanation of the check
 { }
</code></pre>

or this:

<pre><code>if (var1 &amp;&amp; // Explanation of the check
 var2 &amp;&amp; // Explanation of the check
 var3 &amp;&amp; // Explanation of the check
 var4 &amp;&amp; // Explanation of the check
 var5 &amp;&amp; // Explanation of the check
 var6) // Explanation of the check
 { }
</code></pre>

That said, this kind of complex check can be quite difficult to mentally parse while scanning the code (especially if you are not the original author). Consider creating a helper method to abstract some of the complexity away:

<pre><code>/// &lt;Summary&gt;
/// Tests whether all the conditions are appropriately met
/// &lt;/Summary&gt;
private bool AreAllConditionsMet (
 bool var1,
 bool var2,
 bool var3,
 bool var4,
 bool var5,
 bool var6)
{
 return (
 var1 &amp;&amp; // Explanation of the check
 var2 &amp;&amp; // Explanation of the check
 var3 &amp;&amp; // Explanation of the check
 var4 &amp;&amp; // Explanation of the check
 var5 &amp;&amp; // Explanation of the check
 var6); // Explanation of the check
}

private void SomeMethod()
{
 // Do some stuff (including declare the required variables)
 if (AreAllConditionsMet (var1, var2, var3, var4, var5, var6))
 {
 // Do something
 }
}
</code></pre>

Now when visually scanning the "SomeMethod" method, the actual complexity of the test logic is hidden but the semantic meaning is preserved for humans to understand at a high-level. If the developer really needs to understand the details, the AreAllConditionsMet method can be examined.

This is formally known as the "Decompose Conditional" refactoring pattern I think. Tools like Resharper or Refactor Pro! can making doing this kind of refactoring easy!

In all cases, the key to having readable and understandable code is to use realistic variable names. While I understand this is a contrived example, "var1", "var2", etc are not acceptable variable names. They should have a name which reflects the underlying nature of the data they represent.

blocks|key|5145513|text|如果你碰巧用Python语言编程，在你的变量列表上应用内置的all()函数是很容易的(这里我只用布尔值)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5145514|>>>+L+=+[True,+True,+True,+False,+True]
>>>+all(L)+#+True,+only+if+all+elements+of+L+are+True.
False
>>>+any(L)+#+True,+if+any+elements+of+L+are+True.
True|code-block|syntax|javascript|5145515|在您的语言中是否有相应的函数(C#？Java?)。如果是这样的话，这可能是最干净的方法。|5145516|entityMap^0|U|5|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

If you happen to be programming in Python, it's a cinch with the built-in <code>all()</code> function applied over the list of your variables (I'll just use Boolean literals here):

<pre><code>&gt;&gt;&gt; L = [True, True, True, False, True]
&gt;&gt;&gt; all(L) # True, only if all elements of L are True.
False
&gt;&gt;&gt; any(L) # True, if any elements of L are True.
True
</code></pre>

Is there any corresponding function in your language (C#? Java?). If so, that's likely the cleanest approach.

blocks|key|2890720|text|如果您这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2890721|if+(var1+==+true)+{
++++if+(var2+==+true)+{
++++++++if+(var3+==+true)+{
++++++++++++...
++++++++}
++++}
}|code-block|syntax|javascript|2890722|然后，您还可以对某些不真实的情况做出响应。例如，如果您正在验证输入，您可以给用户一个关于如何正确格式化它的提示，等等。|2890723|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If you do this:

<pre><code>if (var1 == true) {
 if (var2 == true) {
 if (var3 == true) {
 ...
 }
 }
}
</code></pre>

Then you can also respond to cases where something isn't true. For example, if you're validating input, you could give the user a tip for how to properly format it, or whatever.

blocks|key|3734619|text|McDowell，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3734620|当使用单个'&‘运算符时，表达式的两端都会求值，这一点是正确的。但是，当使用'&&‘运算符(至少在C#中)时，第一个返回false的表达式就是最后一个被计算的表达式。这使得将计算放在FOR语句之前与使用任何其他方法一样好。|3734621|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

McDowell,

You are correct that when using the single '&amp;' operator that both sides of the expression evaluate. However, when using the '&amp;&amp;' operator (at least in C#) then the first expression to return false is the last expression evaluated. This makes putting the evaulation before the FOR statement just as good as any other way of doing it.

blocks|key|702682|text|正如其他人所提到的，我会分析您的条件句，看看是否有办法将其外包给其他方法来提高可读性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|702683|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

As others have mentioned, I would analyze your conditionals to see if there's a way you can outsource it to other methods to increase readability.

blocks|key|3734698|text|@tweakt|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3734699|3734700|这也好不到哪里去，但是我以前做过的事情：|blockquote|3734701|3734702|boolean+ok+=+cond1；ok+&=+cond2；ok+&=+cond3；ok+&=+cond4；ok+&=+cond5；ok+&=+cond6；|3734703|这与以下内容相同：|3734704|ok+=+(cond1+&&+cond2+&&+cond3+&&+cond4+&&+cond5+&&+cond6)；|3734705|3734706|实际上，这两件事在大多数语言中是不一样的。第二个表达式通常会在其中一个条件为false时立即停止计算，如果计算条件的代价很高，这将是一个很大的性能改进。|3734707|在可读性方面，我个人更喜欢Mike+Stone上面的建议。它很容易进行冗长的注释，并保留了能够提前完成的所有计算优势。如果将条件求值移到远离其他函数的位置会混淆代码的组织，您也可以在函数中使用相同的内联技术。这有点俗气，但你总是可以这样做：|3734708|do+{
++++if+(!cond1)
+++++++break;
++++if+(!cond2)
+++++++break;
++++if+(!cond3)
+++++++break;
++++...
++++DoSomething();
}+while+(false);|code-block|syntax|javascript|3734709|while+(false)有点俗气。我希望语言有一个名为"once“的作用域操作符，或者是你可以很容易突破的东西。|3734710|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|11|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|12|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|13|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|17|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|18|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|19|8|@]|9|@]|A|$]]|$1|R|3|S|5|T|7|1A|8|@]|9|@]|A|$U|V]]|$1|W|3|X|5|6|7|1B|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|Z|$]]

@tweakt

<blockquote>
 It's no better, but what I've done in the past:
 
 boolean ok = cond1;
 ok &amp;= cond2;
 ok &amp;= cond3;
 ok &amp;= cond4;
 ok &amp;= cond5;
 ok &amp;= cond6;
 
 Which is the same as:
 
 ok = (cond1 &amp;&amp; cond2 &amp;&amp; cond3 &amp;&amp; cond4 &amp;&amp; cond5 &amp;&amp; cond6);
</blockquote>

Actually, these two things are not the same in most languages. The second expression will typically stop being evaluated as soon as one of the conditions is false, which can be a big performance improvement if evaluating the conditions is expensive.

For readability, I personally prefer Mike Stone's proposal above. It's easy to verbosely comment and preserves all of the computational advantages of being able to early out. You can also do the same technique inline in a function if it'd confuse the organization of your code to move the conditional evaluation far away from your other function. It's a bit cheesy, but you can always do something like:

<pre><code>do {
 if (!cond1)
 break;
 if (!cond2)
 break;
 if (!cond3)
 break;
 ...
 DoSomething();
} while (false);
</code></pre>

the while (false) is kind of cheesy. I wish languages had a scoping operator called "once" or something that you could break out of easily.

blocks|key|5145810|text|试着看看函数式和谓词。Apache+Commons项目有一组很好的对象，允许您将条件逻辑封装到对象中。它们的用法示例可以在O‘’reilly+here上找到。代码示例摘录：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|5145811|import+org.apache.commons.collections.ClosureUtils;
import+org.apache.commons.collections.CollectionUtils;
import+org.apache.commons.collections.functors.NOPClosure;

Map+predicateMap+=+new+HashMap();

predicateMap.put(+isHonorRoll,+addToHonorRoll+);
predicateMap.put(+isProblem,+flagForAttention+);
predicateMap.put(+null,+ClosureUtils.nopClosure()+);

Closure+processStudents+=+
++++ClosureUtils.switchClosure(+predicateMap+);

CollectionUtils.forAllDo(+allStudents,+processStudents+);|code-block|syntax|javascript|5145812|现在，我们将详细介绍所有这些isHonorRoll谓词以及用于计算它们的闭包：|5145813|import+org.apache.commons.collections.Closure;
import+org.apache.commons.collections.Predicate;

//+Anonymous+Predicate+that+decides+if+a+student+
//+has+made+the+honor+roll.
Predicate+isHonorRoll+=+new+Predicate()+{
++public+boolean+evaluate(Object+object)+{
++++Student+s+=+(Student)+object;

++++return(+(+s.getGrade().equals(+"A"+)+)+%7C%7C
++++++++++++(+s.getGrade().equals(+"B"+)+&&+
++++++++++++++s.getAttendance()+==+PERFECT+)+);
++}
};

//+Anonymous+Predicate+that+decides+if+a+student
//+has+a+problem.
Predicate+isProblem+=+new+Predicate()+{
++public+boolean+evaluate(Object+object)+{
++++Student+s+=+(Student)+object;

++++return+(+(+s.getGrade().equals(+"D"+)+%7C%7C+
+++++++++++++++s.getGrade().equals(+"F"+)+)+%7C%7C
+++++++++++++s.getStatus()+==+SUSPENDED+);
++}
};

//+Anonymous+Closure+that+adds+a+student+to+the+
//+honor+roll
Closure+addToHonorRoll+=+new+Closure()+{
++public+void+execute(Object+object)+{
++++Student+s+=+(Student)+object;

++++//+Add+an+award+to+student+record
++++s.addAward(+"honor+roll",+2005+);
++++Database.saveStudent(+s+);
++}
};

//+Anonymous+Closure+flags+a+student+for+attention
Closure+flagForAttention+=+new+Closure()+{
++public+void+execute(Object+object)+{
++++Student+s+=+(Student)+object;

++++//+Flag+student+for+special+attention
++++s.addNote(+"talk+to+student",+2005+);
++++s.addNote(+"meeting+with+parents",+2005+);
++++Database.saveStudent(+s+);
++}
};|5145814|entityMap|0|LINK|mutability|MUTABLE|url|http://www.onjava.com/pub/a/onjava/2004/12/22/jakarta-gems-1.html?page=2^0|1Z|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Try looking at Functors and Predicates. The Apache Commons project has a great set of objects to allow you to encapsulate conditional logic into objects. Example of their use is available on O'reilly <a href="http://www.onjava.com/pub/a/onjava/2004/12/22/jakarta-gems-1.html?page=2" rel="nofollow noreferrer">here</a>. Excerpt of code example:

<pre><code>import org.apache.commons.collections.ClosureUtils;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.functors.NOPClosure;

Map predicateMap = new HashMap();

predicateMap.put( isHonorRoll, addToHonorRoll );
predicateMap.put( isProblem, flagForAttention );
predicateMap.put( null, ClosureUtils.nopClosure() );

Closure processStudents = 
 ClosureUtils.switchClosure( predicateMap );

CollectionUtils.forAllDo( allStudents, processStudents );
</code></pre>

Now the details of all those isHonorRoll predicates and the closures used to evaluate them:

<pre><code>import org.apache.commons.collections.Closure;
import org.apache.commons.collections.Predicate;

// Anonymous Predicate that decides if a student 
// has made the honor roll.
Predicate isHonorRoll = new Predicate() {
 public boolean evaluate(Object object) {
 Student s = (Student) object;

 return( ( s.getGrade().equals( "A" ) ) ||
 ( s.getGrade().equals( "B" ) &amp;&amp; 
 s.getAttendance() == PERFECT ) );
 }
};

// Anonymous Predicate that decides if a student
// has a problem.
Predicate isProblem = new Predicate() {
 public boolean evaluate(Object object) {
 Student s = (Student) object;

 return ( ( s.getGrade().equals( "D" ) || 
 s.getGrade().equals( "F" ) ) ||
 s.getStatus() == SUSPENDED );
 }
};

// Anonymous Closure that adds a student to the 
// honor roll
Closure addToHonorRoll = new Closure() {
 public void execute(Object object) {
 Student s = (Student) object;

 // Add an award to student record
 s.addAward( "honor roll", 2005 );
 Database.saveStudent( s );
 }
};

// Anonymous Closure flags a student for attention
Closure flagForAttention = new Closure() {
 public void execute(Object object) {
 Student s = (Student) object;

 // Flag student for special attention
 s.addNote( "talk to student", 2005 );
 s.addNote( "meeting with parents", 2005 );
 Database.saveStudent( s );
 }
};
</code></pre>

blocks|key|702777|text|我喜欢将每个条件分解为描述性变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|702778|bool+isVar1Valid,+isVar2Valid,+isVar3Valid,+isVar4Valid;
isVar1Valid+=+(+var1+==+1+)
isVar2Valid+=+(+var2.Count+>=+2+)
isVar3Valid+=+(+var3+!=+null+)
isVar4Valid+=+(+var4+!=+null+&&+var4.IsEmpty()+==+false+)
if+(+isVar1Valid+&&+isVar2Valid+&&+isVar3Valid+&&+isVar4Valid+)+{
+++++//do+code
}|code-block|syntax|javascript|702779|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I like to break each condition into descriptive variables.

<pre><code>bool isVar1Valid, isVar2Valid, isVar3Valid, isVar4Valid;
isVar1Valid = ( var1 == 1 )
isVar2Valid = ( var2.Count &gt;= 2 )
isVar3Valid = ( var3 != null )
isVar4Valid = ( var4 != null &amp;&amp; var4.IsEmpty() == false )
if ( isVar1Valid &amp;&amp; isVar2Valid &amp;&amp; isVar3Valid &amp;&amp; isVar4Valid ) {
 //do code
}
</code></pre>

blocks|key|698105|text|来自Code+Complete的史蒂夫·麦康奈尔的建议:使用多维表格。每个变量都充当表的索引，if语句转换为表查找。例如，如果(size+==+3+&&+weight+>+70)转换为表条目decisionsize|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|698106|entityMap|0|LINK|mutability|MUTABLE|url|https://rads.stackoverflow.com/amzn/click/com/0735619670^0|2|D|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Steve Mcconell's advice, from <a href="https://rads.stackoverflow.com/amzn/click/com/0735619670" rel="nofollow noreferrer" rel="nofollow noreferrer">Code Complete</a>:
Use a multi-dimensional table. Each variable serves as an index to the table,
and the if statement turns into a table lookup. For example if (size == 3 &amp;&amp; weight > 70)
translates into the table entry decision[size][weight_group]

blocks|key|3734985|text|如果我是用Perl做的，这就是我可能运行检查的方式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3734986|{
++last+unless+$var1;
++last+unless+$var2;
++last+unless+$var3;
++last+unless+$var4;
++last+unless+$var5;
++last+unless+$var6;

++...+#+Place+Code+Here
}|code-block|syntax|javascript|3734987|如果你打算在一个子程序中使用它，用return替换last的每个实例；|offset|length|style|CODE|3734988|entityMap^0|0|0|H|6|P|4|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

If I was doing it in Perl, This is how I might run the checks.

<pre><code>{
 last unless $var1;
 last unless $var2;
 last unless $var3;
 last unless $var4;
 last unless $var5;
 last unless $var6;

 ... # Place Code Here
}
</code></pre>

If you plan on using this over a subroutine replace every instance of <code>last</code> with <code>return</code>;

blocks|key|5146053|text|在像PHP这样的反射式语言中，您可以使用变量变量：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5146054|$vars+=+array('var1',+'var2',+...+etc.);
foreach+($vars+as+$v)
++++if+($$v+==+true)+{
++++++++//+do+something
++++++++break;
++++}|code-block|syntax|javascript|5146055|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In reflective languages like PHP, you can use variable-variables:

<pre><code>$vars = array('var1', 'var2', ... etc.);
foreach ($vars as $v)
 if ($$v == true) {
 // do something
 break;
 }
</code></pre>

blocks|key|702967|text|++++if+(+++(condition_A)
++++++++&&+(condition_B)
++++++++&&+(condition_C)
++++++++&&+(condition_D)
++++++++&&+(condition_E)
++++++++&&+(condition_F)
+++++++)
++++{
+++++++...
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|702968|而不是|unstyled|702969|++++if+(condition_A)+{
+++++++if+(condition_B)+{
++++++++++if+(condition_C)+{
+++++++++++++if+(condition_D)+{
++++++++++++++++if+(condition_E)+{
+++++++++++++++++++if+(condition_F)+{
++++++++++++++++++++++...
+++++++++++++++++++}
++++++++++++++++}
+++++++++++++}
++++++++++}
+++++++}
++++}|702970|和|702971|++++if+(+++(+++(condition_A)
++++++++++++&&+(condition_B)
+++++++++++)
++++++++%7C%7C+(+++(condition_C)
++++++++++++&&+(condition_D)
+++++++++++)
++++++++%7C%7C+(+++(condition_E)
++++++++++++&&+(condition_F)
+++++++++++)
+++++++)
++++{
+++++++do_this_same_thing();
++++}|702972|702973|++++if+(condition_A+&&+condition_B)+{
+++++++do_this_same_thing();
++++}
++++if+(condition_C+&&+(condition_D)+{
+++++++do_this_same_thing();
++++}
++++if+(condition_E+&&+condition_F)+{
+++++++do_this_same_thing();
++++}|702974|如果多个条件表达式没有使用显式的括号指示表达式分析，而不是依赖于运算符优先规则和较少的括号，大多数用于检查代码的静态分析工具都会报错。|702975|在左/右大括号{}、左圆括号()、左边带有圆括号和运算符的条件表达式的相同缩进级别进行垂直对齐是一种非常有用的做法，它可以极大地提高代码的可读性和清晰度，而不是阻塞可能被塞到一行上的所有内容，而不是垂直对齐、空格或括号|702976|运算符优先级规则比较复杂，例如&&的优先级高于%7C%7C，但%7C的优先级高于&&|702977|所以，..。|702978|++++if+(expr_A+&+expr_B+%7C%7C+expr_C+%7C+expr_D+&+expr_E+%7C%7C+expr_E+&&+expr_F+&+expr_G+%7C%7C+expr_H+{
++++}|702979|是一个非常简单的多条件表达式，仅供人类阅读和计算就不正确了。|702980|++++if+(+++(++(expr_A)
++++++++++++&+(expr_B)
+++++++++++)
++++++++%7C%7C+(++(expr_C)
++++++++++++%7C+(++(expr_D)
+++++++++++++++&+(expr_E)
++++++++++++++)
+++++++++++)
++++++++%7C%7C+(+++(expr_E)
++++++++++++&&+(++(expr_F)
++++++++++++++++&+(expr_G)
+++++++++++++++)
+++++++++++)
++++++++%7C%7C+(expr_H)
+++++++)
++++{
++++}|702981|水平空格(换行符)、垂直对齐或显式括号引导表达式计算没有任何问题，所有这些都增强了可读性和清晰度|702982|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|17|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|18|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|19|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|1A|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1B|8|@]|9|@]|A|$B|C]]|$1|M|3|E|5|F|7|1C|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1D|8|@]|9|@]|A|$B|C]]|$1|P|3|Q|5|F|7|1E|8|@]|9|@]|A|$]]|$1|R|3|S|5|F|7|1F|8|@]|9|@]|A|$]]|$1|T|3|U|5|F|7|1G|8|@]|9|@]|A|$]]|$1|V|3|W|5|F|7|1H|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1I|8|@]|9|@]|A|$B|C]]|$1|Z|3|10|5|F|7|1J|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|1K|8|@]|9|@]|A|$B|C]]|$1|13|3|14|5|F|7|1L|8|@]|9|@]|A|$]]|$1|15|3|-4|5|F|7|1M|8|@]|9|@]|A|$]]]|16|$]]

<pre><code> if ( (condition_A)
 &amp;&amp; (condition_B)
 &amp;&amp; (condition_C)
 &amp;&amp; (condition_D)
 &amp;&amp; (condition_E)
 &amp;&amp; (condition_F)
 )
 {
 ...
 }
</code></pre>

as opposed to

<pre><code> if (condition_A) {
 if (condition_B) {
 if (condition_C) {
 if (condition_D) {
 if (condition_E) {
 if (condition_F) {
 ...
 }
 }
 }
 }
 }
 }
</code></pre>

and

<pre><code> if ( ( (condition_A)
 &amp;&amp; (condition_B)
 )
 || ( (condition_C)
 &amp;&amp; (condition_D)
 )
 || ( (condition_E)
 &amp;&amp; (condition_F)
 )
 )
 {
 do_this_same_thing();
 }
</code></pre>

as opposed to

<pre><code> if (condition_A &amp;&amp; condition_B) {
 do_this_same_thing();
 }
 if (condition_C &amp;&amp; (condition_D) {
 do_this_same_thing();
 }
 if (condition_E &amp;&amp; condition_F) {
 do_this_same_thing();
 }
</code></pre>

Most of the static analysis tools for examining code will complain if multiple conditional expressions do not use explicit parenthesis dictating expression analysis, instead of relying on operator precedence rules and fewer parenthesis.

Vertical alignment at the same indent level of open/close braces {}, open close parenthesis (), conditional expressions with parenthesis and operators on the left is an very useful practice, which greatly ENHANCES readability and clarity of the code as opposed to jamming everything that can possibly be jammed onto a single line, sans vertical alignment, spaces or parenthesis

Operator precedence rules are tricky, e.g. &amp;&amp; has higher precedence than ||, but | has precedence than &amp;&amp;

So, ...

<pre><code> if (expr_A &amp; expr_B || expr_C | expr_D &amp; expr_E || expr_E &amp;&amp; expr_F &amp; expr_G || expr_H {
 }
</code></pre>

is a really easy multiple conditional expression for mere humans to read and evaluate improperly.

<pre><code> if ( ( (expr_A)
 &amp; (expr_B)
 )
 || ( (expr_C)
 | ( (expr_D)
 &amp; (expr_E)
 )
 )
 || ( (expr_E)
 &amp;&amp; ( (expr_F)
 &amp; (expr_G)
 )
 )
 || (expr_H)
 )
 {
 }
</code></pre>

There is nothing wrong with horizontal space (linefeeds), vertical alignment, or explicit parenthesis guiding expression evaluation, all of which ENHANCES readability and clarity

It's something that's bugged me in every language I've used, I have an if statement but the conditional part has so many checks that I have to split it over multiple lines, use a nested if statement or just accept that it's ugly and move on with my life.

Are there any other methods that you've found that might be of use to me and anybody else that's hit the same problem?

Example, all on one line:

<pre><code>if (var1 = true &amp;&amp; var2 = true &amp;&amp; var2 = true &amp;&amp; var3 = true &amp;&amp; var4 = true &amp;&amp; var5 = true &amp;&amp; var6 = true)
{
</code></pre>

Example, multi-line:

<pre><code>if (var1 = true &amp;&amp; var2 = true &amp;&amp; var2 = true
 &amp;&amp; var3 = true &amp;&amp; var4 = true &amp;&amp; var5 = true
 &amp;&amp; var6 = true)
{
</code></pre>

Example-nested:

<pre><code>if (var1 = true &amp;&amp; var2 = true &amp;&amp; var2 = true &amp;&amp; var3 = true)
{
 if (var4 = true &amp;&amp; var5 = true &amp;&amp; var6 = true)
 {
</code></pre>

How do you handle huge if-conditions?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

在我使用的每一种语言中，这都是困扰我的问题，我有一个if语句，但条件部分有太多的检查，我不得不将它分成多行，使用嵌套的if语句，或者只是接受它很丑陋，然后继续我的生活。有没有你发现的其他方法，可能对我和其他遇到同样问题的人有用？例如，所有内容都在一行上：if (var1 = true && var2 = true &&...

问你如何处理巨大的if条件？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问你如何处理巨大的if条件？EN