guides - java code conventions en español
¿Es malo comparar explícitamente contra constantes booleanas, por ejemplo, si(b== falso) en Java? (14)
¿Es malo escribir?
if (b == false) //...
while (b != true) //...
Siempre es mejor escribir en su lugar:
if (!b) //...
while (!b) //...
Es de suponer que no hay diferencia en el rendimiento (¿o existe?), Pero ¿cómo ponderas la explicitud, la concisión, la claridad, la legibilidad, etc. entre los dos?
Actualizar
Para limitar la subjetividad, también agradecería cualquier cita de las pautas de estilo de codificación autorizadas sobre cuál es siempre preferible o cuál usar cuándo.
Nota : el nombre de la variable b solo se usa como ejemplo, ala foo y bar .
En mi humilde opinión, creo que si hace que los nombres de las variables bool aparezcan precedidos de "Is" , será evidente y más significativo y, a continuación, puede eliminar la comparación explícita con true o false
Ejemplo:
isEdited // use IsEdited in case of property names
isAuthorized // use IsAuthorized in case of property names
etc
En mi opinión, es simplemente molesto. Sin embargo, no es algo por lo que pueda causar un alboroto.
Esta es mi primera respuesta en , así que se agradable ... Recientemente, mientras refactorizaba, noté que 2 bloques de código tenían casi el mismo código, pero uno tenía
for (Alert alert : alerts) {
Long currentId = alert.getUserId();
if (vipList.contains(currentId)) {
customersToNotify.add(alert);
if (customersToNotify.size() == maxAlerts) {
break;
}
}
}
y el otro tenía
for (Alert alert : alerts) {
Long currentId = alert.getUserId();
if (!vipList.contains(currentId)) {
customersToNotify.add(alert);
if (customersToNotify.size() == maxAlerts) {
break;
}
}
}
Entonces, en este caso, tenía sentido crear un método que funcionara para ambas condiciones, como esta, usando una boolean == condition para voltear el significado.
private void appendCustomersToNotify(List<Alert> alerts
List<Alert> customersToNotify, List<Long> vipList, boolean vip){
for (Alert alert : alerts) {
Long currentId = alertItem.getUserId();
if (vip == vipList.contains(currentId)) {
customersToNotify.add(alertItem);
if (customersToNotify.size() == maxAlerts) {
break;
}
}
}
}
Esto es fuertemente una cuestión de gusto.
Personalmente, he encontrado que if (!a) { es mucho menos legible (EDITAR: para mí) que if (a == false) { y, por lo tanto, es más propenso a errores al mantener el código más tarde, y he convertido para usar la última forma.
Básicamente no me gusta la elección de símbolos para operaciones lógicas en lugar de palabras (C frente a Pascal), porque para mí a = 10 and not b = 20 es más fácil que a == 10 && !(b==20) , pero ese es el como está en Java.
Cualquiera que ponga el enfoque "== falso" a favor de "!" Claramente, nunca se había fijado en el código por mucho tiempo y había perdido ese signo de exclamación. Sí, puedes obtener código ciego.
La pauta normal es nunca probar contra booleano. Algunos argumentan que la verbosidad adicional se agrega a la claridad. El código agregado puede ayudar a algunas personas, pero cada lector deberá leer más código.
Esta mañana, he perdido 1/2 hora para encontrar un error. El código era
if ( !strcmp(runway_in_use,"CLOSED") == IPAS_FALSE)
printf(" ACTIVE FALSE /n"); else
printf(" ACTIVE TRUE /n");
Si estuviera codificado con la convención normal, habría visto mucho más rápido que estaba equivocado:
if (strcmp(runway_in_use, "CLOSED"))
printf(" ACTIVE FALSE /n"); else
printf(" ACTIVE TRUE /n");
La razón principal por la que no debe usar el primer estilo es porque ambos son válidos:
if (b = false) //...
while (b = true) //...
Es decir, si omites accidentalmente un personaje, creas una tarea en lugar de una comparación. Una expresión de asignación evalúa el valor que se asignó, por lo que la primera instrucción anterior asigna el valor false a b evalúa a false . El segundo asigna true a b , por lo que siempre se evalúa como true , sin importar lo que haga con b dentro del ciclo.
No deberías usar el primer estilo. He visto que la gente usa:
-
if ( b == true ) -
if ( b == false )
Personalmente, me resulta difícil de leer, pero es pasable. Sin embargo, un gran problema que tengo con ese estilo es que conduce a los ejemplos increíblemente contra-intuitivos que mostró:
-
if ( b != true ) -
if ( b != false )
Eso requiere más esfuerzo por parte del lector para determinar la intención del autor. Personalmente, encuentro que incluir una comparación explícita a verdadero o falso es redundante y, por lo tanto, más difícil de leer, pero ese soy yo.
No es necesariamente malo, es superfluo. Además, el nombre de la variable real pesa mucho. Preferiría, por ejemplo, if (userIsAllowedToLogin) arriba if (b) o incluso peor if (flag) .
En cuanto a la preocupación por el rendimiento, el compilador lo optimiza de cualquier forma.
Actualización : en cuanto a las fuentes autorizadas, no puedo encontrar algo explícitamente en las Convenciones de codificación de Sun , pero al menos Checkstyle tiene un módulo SimplifyBooleanExpression que advertiría al respecto.
Nunca he visto el primero excepto en el código escrito por principiantes; siempre es lo último, y no creo que nadie esté realmente confundido por eso. Por otro lado, creo
int x;
...
if(x) //...
vs
if(x != 0) //...
es mucho más discutible, y en ese caso prefiero el segundo
Personalmente, refactorizaría el código, así que no estoy usando una prueba negativa. por ejemplo.
if (b == false) {
// false
} else {
// true
}
o
boolean b = false;
while(b == false) {
if (condition)
b = true;
}
En mi humilde opinión, en el 90% de los casos, el código se puede refactorizar por lo que la prueba negativa no es necesaria.
Prefiero el enfoque largo, pero comparo el uso de == vez de != 99% del tiempo.
Sé que esta pregunta es sobre Java, pero a menudo cambio entre idiomas, y en C# , por ejemplo, comparar con (para isntance) == false puede ayudar cuando se trata de tipos de bool nullable. Así que tengo este hábito de comparar con true o false pero usando el operador == .
Yo hago esto:
if(isSomething == false) o if(isSomething == true)
pero odio estos:
if(isSomething != false) o if(isSomething != true)
por razones obvias de legibilidad!
Mientras mantenga su código legible, no importará.
Prefiero el primero, porque es más claro. La máquina puede leer igualmente bien, pero trato de escribir código para que otras personas lo lean, no solo la máquina.
Una de las razones por las que la primera (b == falsa) está mal vista es que los principiantes a menudo no se dan cuenta de que la segunda alternativa (! B) es posible en absoluto. Así que usar la primera forma puede apuntar a un concepto erróneo con expresiones booleanas y variables booleanas. De esta forma, usar la segunda forma se ha convertido en una especie de sjiboleth: cuando alguien escribe esto, probablemente entienda lo que está sucediendo.
Creo que esto ha causado que la diferencia se considere más importante de lo que realmente es.
Yo diría que es malo.
while (!b) {
// do something
}
lee mucho mejor que
while (b != true) {
// do something
}