objet == null ou null == objet?
J'ai entendu quelqu'un dire que null == object est mieux que object == null vérifier
par exemple :
void m1(Object obj ) {
if(null == obj) // Is this better than object == null ? Why ?
return ;
// Else blah blah
}
Y at-il des raisons ou c'est un autre mythe? Merci pour l'aide.
C’est probablement une habitude tirée de C, pour éviter ce type de faute de frappe (single = au lieu d'un double ==):
if (object = null) {
La convention de mettre la constante du côté gauche de == _ n'est pas vraiment utile dans Java puisque Java nécessite que l'expression d'un if soit _ évaluée à un boolean valeur, donc à moins que la constante ne soit boolean, vous obtiendrez une erreur de compilation dans les deux cas, en plaçant les arguments (et s'il s'agit d'un booléen, vous ne devriez pas utiliser == en tous cas...)
Comme d'autres l'ont dit, C a l'habitude d'apprendre à éviter les fautes de frappe - même si, même en C, je m'attendrais à des compilateurs décents à des niveaux d'alerte suffisamment élevés pour donner un avertissement. Comme le dit Chandru, la comparaison de null in Java de cette manière ne poserait problème que si vous utilisiez une variable de type Boolean (dont vous n'êtes pas dans l'exemple de code) Je dirais que c’est une situation assez rare et qu’il n’ya pas lieu de changer la façon dont vous écrivez du code partout ailleurs (je ne me ferais pas la peine d’inverser les opérandes, même dans ce cas; si je réfléchis assez clairement pour envisager en les inversant, je suis sûr que je peux compter les signes égaux.)
Ce que n'a pas été mentionné est que beaucoup de gens (moi-même inclus) trouvent que la forme if (variable == constant) est plus lisible - c'est une façon plus naturelle de s'exprimer. C'est une raison pas pour copier aveuglément une convention de C. Vous devez toujours remettre en question les pratiques (comme vous le faites ici :) avant de supposer que ce qui peut être utile dans un environnement est utile dans un autre.
Ceci n'a pas beaucoup de valeur dans Java (1.5+) sauf si le type d'objet est Boolean. Dans ce cas, cela peut toujours être pratique.
if (object = null) ne provoquera pas d'échec de compilation dans Java 1.5+ si l'objet est Boolean, mais lève un NullPointerException à l'exécution.
Dans Java, il n'y a pas de bonne raison.
Quelques autres réponses ont affirmé que c'est parce que vous pouvez accidentellement confier cette tâche à la place de l'égalité. Mais en Java, vous devez avoir un booléen dans un if, alors ceci:
if (o = null)
ne pas compiler.
La seule fois où cela pourrait avoir de l'importance Java est si la variable est booléenne:
int m1(boolean x)
{
if (x = true) // oops, assignment instead of equality
Cela concerne également étroitement:
if ("foo".equals(bar)) {
ce qui est pratique si vous ne voulez pas vous occuper des NPE:
if (bar!=null && bar.equals("foo")) {
Ce truc supposé éviter le genre de fautes de frappe v = null.
Mais Java n'autorise que les expressions booléennes dans les conditions if()], de sorte que cette astuce n'a pas beaucoup de sens, le compilateur trouvera quand même ces fautes de frappe.
C’est quand même un truc précieux pour le code C/C++.
C'est pour les gens qui préfèrent avoir la constante sur le côté gauche. Dans la plupart des cas, le fait d'avoir la constante du côté gauche empêchera la génération de NullPointerException (ou le fait d'avoir un autre contrôle nul). Par exemple, la méthode String est égale à une vérification nulle. Avoir la constante à gauche vous empêchera d’écrire le chèque supplémentaire. Qui, d'une autre manière est également effectuée plus tard. Avoir la valeur nulle à gauche, c'est juste être cohérent.
comme:
String b = null;
"constant".equals(b); // result to false
b.equals("constant"); // NullPointerException
b != null && b.equals("constant"); // result to false
Pour la même raison, vous le faites en C; affectation est une expression, vous devez donc placer le littéral à gauche de sorte que vous ne puissiez pas l'écraser si vous utilisez accidentellement = au lieu de ==.
Comparez avec le code suivant:
String pingResult = "asd";
long s = System.nanoTime ( );
if ( null != pingResult )
{
System.out.println ( "null != pingResult" );
}
long e = System.nanoTime ( );
System.out.println ( e - s );
long s1 = System.nanoTime ( );
if ( pingResult != null )
{
System.out.println ( "pingResult != null" );
}
long e1 = System.nanoTime ( );
System.out.println ( e1 - s1 );
Sortie (après plusieurs exécutions):
null != pingResult
325737
pingResult != null
47027
Par conséquent, pingResult != null est le gagnant.
En raison de sa propriété commutative , la seule différence entre object == null et null == object (le version de Yoda ) est de nature cognitive : comment le code est lu et digéré par le lecteur. Je ne connais pas la réponse définitive cependant, mais je sais que je préfère personnellement comparer l'objet que j'inspecte à autre chose, plutôt que de comparer autre chose à l'objet que j'inspecte, Si cela a du sens. Commencez par le sujet, puis la valeur à comparer.
Dans d'autres langues, ce style de comparaison est plus utile.
Pour protéger contre un signe "=" manquant en général cependant, je pense écrire null == object est un acte peu judicieux de programmation défensive . La meilleure façon de contourner ce code est de garantir le comportement avec un test Junit. N'oubliez pas que l'erreur possible de rater un "=" ne dépend pas des arguments d'entrée de la méthode. Vous ne dépendez pas de l'utilisation correcte de cette API par d'autres personnes. Un test Junit est donc parfait pour se protéger contre cela. Quoi qu'il en soit, vous voudrez écrire des tests junit pour vérifier le comportement; un "=" manquant entre naturellement dans le champ d'application.
C'est la condition de Yoda qui écrit de différentes manières
En java
String myString = null;
if (myString.equals("foobar")) { /* ... */ } //Will give u null pointer
condition de yoda
String myString = null;
if ("foobar".equals(myString)) { /* ... */ } // will be false