blocks|key|532970|text|第二个看起来像"Yoda+condition"，也就是if(2+==+x)+...，可读性差得多。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|532971|entityMap^0|R|E|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Second one looks for me like "Yoda condition", i.e. <code>if(2 == x) ...</code> and is much less readable.

blocks|key|2171008|text|没有性能差异，但我个人发现第二个令人困惑。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2171009|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|$]]

There is no performance difference but I personally find the second one being confusing.

blocks|key|1319720|text|最好的做法是避免一些基本的输入错误，这是大多数现代IDE都会发现的，因为有时你想要在更复杂的类型之间进行比较，而这些类型不是空的，最终导致意外的赋值。所以模式保持不变，但我从未见过它与性能相关，也从未见过它生成特殊的字节码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1319721|我们的想法是首先使用静态的已知值，这样在执行比较时就不会抛出任何奇怪的异常。|1319722|然而，这两种方法都不是“更正确的”，所以完全由您决定要使用哪种方法。|1319723|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

It's best practice to avoid some basic typo's that most modern IDE's will pick up, because sometimes you want to do comparisons between more complex types that are not null and end up doing accidental assignments. So the pattern remains the same, but I've never seen this linked to performance and have never seen it generate special byte code.

The idea is to have the static, known value first, so you can't throw any kind of weird exception when you perform the comparison.

Neither of the two methods are "more correct" though, so it's entirely up to you to decide what you wish to use.

blocks|key|2171056|text|没什么区别。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2171057|第二个原因仅仅是因为C/C%2B%2B程序员总是做赋值而不是比较。|2171058|例如。|2171059|//+no+compiler+complaint+at+all+for+C/C%2B%2B
//+while+in+Java,+this+is+illegal.
if(a+=+2)+{
}
//+this+is+illegal+in+C/C%2B%2B
//+and+thus+become+best+practice,+from+C/C%2B%2B+which+is+not+applicable+to+Java+at+all.
if(2+=+a)+{
}|code-block|syntax|javascript|2171060|而java编译器会产生编译错误。|2171061|所以我个人更喜欢第一个，因为可读性，人们倾向于从左到右阅读，它读成if+test+is+not+equal+to+null而不是null+is+not+equal+to+test。|offset|length|style|CODE|2171062|entityMap^0|0|0|0|0|0|X|S|1S|P|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@$O|10|P|11|Q|R]|$O|12|P|13|Q|R]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|T|$]]

No difference.

Second one is merely because C/C++ where programmers always did assignment instead of comparing.

E.g.

<pre><code>// no compiler complaint at all for C/C++
// while in Java, this is illegal.
if(a = 2) {
}
// this is illegal in C/C++
// and thus become best practice, from C/C++ which is not applicable to Java at all.
if(2 = a) {
}
</code></pre>

While java compiler will generate compilation error.

So I personally prefer first one because of readability, people tend to read from left to right, which read as <code>if test is not equal to null</code> instead of <code>null is not equal to test</code>.

blocks|key|2333883|text|它们是完全一样的。第二个在使用equals时是有意义的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2333884|if("bla".equals(test))|code-block|syntax|javascript|2333885|永远不能抛出NullPointerException，而：|offset|length|style|CODE|2333886|if(test.equals("bla"))+|2333887|能。|2333888|entityMap^0|0|0|6|K|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

They are exactly the same. The second one can make sense when using equals:

<pre><code>if("bla".equals(test))
</code></pre>

can never throw a <code>NullPointerException</code> whereas:

<pre><code>if(test.equals("bla")) 
</code></pre>

can.

blocks|key|1319760|text|这是没有区别的。但在第二种方法中，您可以避免像test+=+null那样的拼写错误。因为在第二种情况下，你会得到编译器错误。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1319761|entityMap^0|N|B|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

there is no difference. But in second way you avoid the typo like <code>test = null</code>. Beacause in second way you'll get compiler error.

blocks|key|2337668|text|使用后一种方法不是最佳实践。两者是等价的，但前者更容易阅读。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2337669|这种“最佳实践”来自于不存在布尔值的C语言。取而代之的是整数，if+(foo+=+1)不是语法错误，但与if+(foo+==+1)完全不同。|offset|length|style|CODE|2337670|在Java中，if中只能有布尔表达式，这种做法没有多大意义。|2337671|entityMap^0|0|V|C|1G|D|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]|$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|K|$]]

It's not a best practice to use the latter one. Both are equivalent, but the former is easier to read.

This "best practice" comes from C where boolean don't exist. Integers are used instead, and <code>if (foo = 1)</code> is not a syntax error, but is completely different from <code>if (foo == 1)</code>.

In Java, only boolean expressions can be inside an if, and this practice doesn't make much sense.

blocks|key|533244|text|在两种形式之间并没有真正的区别。没有性能问题，但有以下注意事项：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|533245|533246|第一种形式对于代码读者来说是可读的，因为人们通常阅读代码时Left-To-Right.|unordered-list-item|533247|Second形式更适合代码作者，因为在java中=运算符用于赋值，==运算符用于测试等价，但人们通常在if语句中使用=而不是==，由于null不能在赋值语句的Compile-Time-Error中使用，因此二次开发人员获得Left-Side。<代码>H211<代码>F212|offset|length|style|CODE|533248|533249|entityMap^0|0|0|0|O|1|X|2|1F|2|1M|1|1Q|2|27|I|33|9|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|P|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|R|8|@$H|S|I|T|J|K]|$H|U|I|V|J|K]|$H|W|I|X|J|K]|$H|Y|I|Z|J|K]|$H|10|I|11|J|K]|$H|12|I|13|J|K]|$H|14|I|15|J|K]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|16|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|N|$]]

There is no really different between two form. There is no performance issue but there are following notes:

<ul>
<li>First form is readable for code reader, because people usually read codes Left-To-Right.</li>
<li>Second form is better for code writer, because in java <code>=</code> operator is for assignment and <code>==</code> operator is for test equivalent, but people usually using in <code>if</code> statement <code>=</code> instead of <code>==</code>, by second approch developer getting <code>Compile-Time-Error</code> because null can't use in <code>Left-Side</code> of a assignment statement.</li>
</ul>

Consider the following two lines of code

<pre><code>if (test ! = null)
</code></pre>

and 

<pre><code>if (null != test)
</code></pre>

Is there is any difference in above two statements, performance wise? I have seen many people using the later and when questioned they say its a best practice with no solid reason.

Which has better performance: test != null or null != test

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

考虑以下两行代码if (test ! = null)和if (null != test)在性能方面，上面两个语句有什么不同吗？我见过许多人使用后者，当被问到时，他们说这是没有确凿理由的最佳实践。

问哪个性能更好: test != null或null != test
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问哪个性能更好: test != null或null != testEN