¿Se deben omitir los métodos abreviados, la brevedad y la astucia rutinariamente a favor de la claridad?

Question

Esta pregunta vino a la mente después de ver este simple trozo de código: (? K & R)

if (!x%y) 
{ 
    // do something 
} 

Tal vez sea la influencia de los primeros libros de C, pero no es lo siguiente siempre se prefiere, si no tan linda ?

if (x%y != 0) 
{ 
    // do something 
} 

Answer 1

This quote responde a su pregunta.

"La depuración es dos veces más duro que escribir el código en el primer lugar. Por lo tanto, si se escribe el código como inteligente posible, usted es, por definición, no lo suficientemente inteligente para depurarlo se " - Brian W. Kernighan

Answer 2

Prefieren la claridad sobre la brevedad. El segundo ejemplo x % y != 0 es más claro.

Por supuesto, lo que constituye claridad es algo subjetivo, pero prefiero reservar el operador ! único para variables booleanas o funciones que devuelven booleano.

La forma en que generalmente trato de medir la claridad mientras escribo el código es preguntándome a mí mismo: ¿podría leer y entender fácilmente esta línea si 1) alguien más la escribió o 2) tuve que volver a leerla hace 2 años? abajo de la línea.

Answer 3

La astucia debe omitirse. No es inteligente ... o más importante es mantenible.

Los accesos directos y la brevedad pueden o no ser aceptables: todos tomamos atajos pero hay atajos casi "estándar de la industria" porque todos lo hacemos. Sin atajos inteligentes aunque

Answer 4

¿Estás seguro de ese código? !x%y significa (!x)%y porque ! se une más apretado que %.

(Sólo por esa razón, yo preferiría x % y != 0.)

Answer 5

Clarity gana sobre la brevedad todos los días, en mi opinión. A veces siento que escribir código como:

if(!(x = func(y)) && ++z == x) 

... es el equivalente a rayas más rápidas en un automóvil. Puede sentirse rápido, pero no lo es. Tampoco creo que usar nombres de variables incomprensibles (como en el ejemplo anterior) para ahorrar en tipeo sea una buena idea.

¿Cuál es mejor aquí:

for(int x(0) x < managers.size(); ++x) 
    managers[x]->initialise(); 

o:

for(int mgr(0); mgr < managers.size(); ++mgr) 
    managers[mgr]->initialise(); 

Ambos logran la misma cosa y se podría argumentar que no tiene sentido hacer mgr más clara (incluso hay otros argumentos para decir mgr debe ser más claro :)).Pero si alguna vez esta parte de la rutina se vuelve más complicado, que podría ser muy importante:

for(int mgr(0); mgr < managers.size(); ++mgr) 
{ 
    for(int dependentMgr(0); dependentMgr < managers[mgr].dependents().size(); ++dependentMgr) 
    { 
     // init these first 
    } 
} 

Obviamente, esto no es una discusión sobre la conveniencia de utilizar iteradores o no, simplemente si debemos usar nombres claros o no.

Cuando miro un código que no he visto antes, los nombres de las variables son todo. Me estremezco cuando veo tmp y tempt2 y vec2. No significan nada.

Hablando en serio, si te preocupa la cantidad que estás escribiendo, consiguen un IDE con autocompletar o ir criar pollos en Fiji :)

Answer 6

En realidad, si usted quiere que su código sea auto-documentado (Martin Fowler estilo), se puede utilizar la más prolija:

every_player_gets_equal_points = x%y; 
if (!every_player_gets_equal_points) { //Some players get more: now base on completion time 

Answer 7

el primer fragmento de código que presente, ...

if (!x%y) 
{ 
    // do something 
} 

... no tiene sentido y, por tanto, más probable es incorrecta, dado que !x%y es equivalente a !x excepto en los casos de y es igual a -1, 0 o 1, y en el y es 0 caso es Comportamiento no definido (es decir, %y generalmente no tiene sentido).

Otros ya han comentado que el primer fragmento no es equivalente al segundo más detallado. Pero entonces uno podría preguntarse qué fragmento expresa la intención. Mi punto es que el primer fragmento no es equivalente a cualquier cosa que pueda ser correcta.

Y esto ilustra muy bien que la claridad es una buena idea.

Saludos & HTH,

Answer 8

En primer lugar, los apoyos a todos notar que (!x%y) no es equivalente a (!(x%y)), pero lo más importante, ninguno de ellos es equivalente a:.

if (x % y != 0) 

que tiene una mucho más agradable forma:

if (x % y) 

Personalmente no intento escribir ==0 cuando c un sustituto por el uso de ! sin introducir paréntesis excesivos, y yo nunca uso !=0, pero esta es una discusión que iniciará flamewars. :-)