Declaración simple si bloque - llaves o no? [cerrado]

¿Cuál es mejor / más generalmente aceptado?

Esta:

if(condition)
{
  statement;
}

O:

if(condition)
  statement;

Tiendo a preferir el primero, porque creo que hace que sea más fácil saber qué pertenece realmente en el bloque if, evita que otros agreguen las llaves más tarde (o crean un error al olvidarlo), y hace que todas sus declaraciones if uniforme en lugar de algunos con tirantes y otros sin. El segundo, sin embargo, sigue siendo sintácticamente correcto y definitivamente más compacto. Sin embargo, tengo curiosidad por ver cuál es el más preferido por otros.

El primero es mejor porque el segundo es propenso a errores. Por ejemplo, supongamos que está comentando temporalmente el código para depurar algo:

if(condition) 
//      statement;
otherStatement;

O agregando código a toda prisa:

if(condition) 
    statement;
    otherStatement;

Esto es obviamente malo. Por otro lado, el primero se siente demasiado detallado a veces. Por lo tanto, prefiero poner todo en una línea si es lo suficientemente corto y simple:

if(condition) statement;

Esto reduce el ruido sintáctico mientras hace que la construcción parezca que hace lo que realmente hace, por lo que es menos propensa a errores. Siempre que esta sintaxis solo se use para declaraciones y condiciones muy simples y cortas, me parece perfectamente legible.

Siempre uso corchetes solo para estar seguro.

Está bien cuando lo escribes, pero sabes que alguien vendrá en el futuro e insertará otra declaración sin poner corchetes.

Prefiero la versión sin llaves cuando sea posible.

La siguiente explicación es larga. Por favor, tenga paciencia conmigo. Daré una razón convincente para que prefiera este estilo. También explicaré por qué creo que el contraargumento habitual no es válido.

Las líneas (casi) vacías son un desperdicio

La razón de esto es que la llave de cierre requiere una línea adicional de código, y también la llave de apertura, según el estilo. ¹

¿Es esto un gran problema? Superficialmente, no. Después de todo, la mayoría de las personas también ponen líneas vacías en su código para separar bloques lógicamente ligeramente independientes, lo que mejora enormemente la legibilidad.

Sin embargo, detesto desperdiciar el espacio vertical. Los monitores modernos en realidad tienen un amplio espacio horizontal. Pero el espacio vertical sigue siendo muy, muy limitado (a menos que use un monitor en posición vertical, lo que no es tan raro). Este espacio vertical limitado es un problema: se reconoce ampliamente que los métodos individuales deben ser lo más cortos posible y que los corchetes correspondientes (u otros delimitadores de bloque) no deben tener más de una altura de pantalla en la diferencia para que pueda ver todo el bloque sin desplazamiento

Este es un problema fundamental : una vez que ya no puede ver todo el bloque en su pantalla, se vuelve difícil de comprender.

Como consecuencia, detesto las líneas vacías redundantes. Donde las líneas vacías individuales son cruciales para delimitar bloques independientes (solo mire la apariencia visual de este texto), las líneas vacías consecutivas son un estilo muy malo en mi libro (y en mi experiencia generalmente son un signo de programadores novatos).

Del mismo modo, las líneas que simplemente sostienen una llave, y que podrían economizarse, deberían serlo. Un bloque de una sola declaración que está delimitado por llaves desperdicia una o dos líneas. Con solo 50 líneas por altura de pantalla, esto es notable.

Omitir aparatos ortopédicos tal vez no haga daño

Solo hay un argumento en contra de omitir llaves: que alguien más tarde agregará otra declaración al bloque en cuestión y olvidará agregar las llaves, cambiando así inadvertidamente la semántica del código.

De hecho, esto sería un gran problema.

Pero en mi experiencia, no lo es. Soy un programador descuidado; y, sin embargo, en mi década de experiencia en programación, honestamente puedo decir que he no una vez olvidado de añadir las llaves cuando se añade una declaración adicional a un bloque de Singleton.

Incluso me parece inverosímil que esto sea un error común: los bloques son una parte fundamental de la programación. La resolución y el alcance del nivel de bloque es un proceso mental automático e integrado para los programadores. El cerebro simplemente lo hace (de lo contrario, razonar sobre la programación sería mucho más difícil). No se requiere un esfuerzo mental adicional para recordar poner los frenos: el programador también recuerda sangrar correctamente la declaración recién agregada, después de todo; entonces el programador ya ha procesado mentalmente que hay un bloque involucrado.

Ahora, estoy no diciendo que la omisión de los apoyos no causa errores. Lo que digo es que no tenemos evidencia de una manera u otra. Simplemente no sabemos si causa daño.

Entonces, hasta que alguien pueda mostrarme datos concretos, recopilados de experimentos científicos, que demuestren que esto es realmente un problema en la práctica, esta teoría sigue siendo una " historia justa ": una hipótesis muy convincente que nunca se ha puesto a prueba, y que debe no ser utilizado como un argumento.

¹ Este problema a veces se resuelve poniendo todo, incluidos los corchetes, en la misma línea:

if (condition)
{ do_something(); }

Sin embargo, creo que es seguro decir que la mayoría de las personas desprecian esto. Además, tendría los mismos problemas que la variante sin llaves, por lo que es el peor de ambos mundos.

Voy con el segundo. Es más sucinto y menos detallado.

Intento no escribir en el mínimo común denominador, por lo que espero que otros desarrolladores sepan cómo escribir una de las estructuras de flujo de control más comunes en la programación actual.

Usaría lo siguiente (el consenso aquí):

if (condition) {
    any_number_of_statements;
}

También es posible:

if(condition) single_compact_statement;

No tan bueno, especialmente en C / C ++ - como lenguajes:

if(condition) 
    single_compact_statement;

(No hay elección aquí en Python ;-)

En Perl , usarías:

$C = $A**3 if $A != $B;

o

$C = $A**3 unless $A == $B;

(Esto no es pseudocódigo ;-)

Utilizo el método de llaves - por todas las razones anteriores más una más.

El código se fusiona. Se sabe que sucede en proyectos en los que he trabajado en esa declaración única si se han roto por fusiones automáticas. Lo que da miedo es que la sangría se ve bien a pesar de que el código es incorrecto, por lo que este tipo de error es difícil de detectar.

Así que voy con aparatos ortopédicos, en sus propias líneas. Es más fácil detectar los niveles de esa manera. Sí, desperdicia espacio en pantalla vertical y eso es un verdadero inconveniente. Sin embargo, creo que vale la pena.

Sin frenos. Si algún otro programador agrega una segunda declaración a mi código, no es más culpa mía que si dejo que alguien conduzca mi automóvil y se caiga por un precipicio.

Hemos tenido este argumento más de una vez aquí, y el consenso general es usar siempre llaves. Las razones principales son sobre legibilidad / mantenibilidad.

Si necesita agregar código al ifbloque, no necesita recordar / buscar llaves. Cuando los futuros programadores leen el código, las llaves siempre son inequívocas.

En el lado positivo, ReSharper agregará automáticamente las llaves para programadores perezosos en Visual Studio, y supongo que hay complementos para otros IDE que también lo harán.

Yo uso la primera sintaxis, casi sin excepción. Porque no se puede malinterpretar .

"No me hagas pensar" no solo se aplica a las interfaces de usuario, ustedes ;-)

Yo personalmente prefiero el segundo. El primero se ve feo, incómodo y desperdicia espacio horizontal. Los principales problemas con el segundo son las macros y las personas que modifican su código en un momento posterior y lo interpretan mal.

A esto, digo "no use macros". También digo, "sangra tu maldito código correctamente". Teniendo en cuenta cómo cada editor de texto / IDE utilizado para la programación sangra automáticamente, esto no debería ser tan difícil de hacer. Al escribir código en Emacs, usaría la sangría automática para identificar si escribí algo incorrecto en una línea anterior. Cada vez que Emacs comienza a arruinar la sangría, generalmente sé que he hecho algo mal.

En la práctica, termino siguiendo la convención de codificación que se me ha presentado. Pero estos me molestan (y me hace mucho más feliz cuando codifico en Python y todo este desastre de soporte desaparece):

if (condition) {
    statement;
} // stupid extra brace looks ugly

Entonces

if (condition) // the brackets have now just become noise
{ statement; } // also can't see the indentation, harder to read

Aunque honestamente, dos declaraciones en una declaración if me molestan mucho más que una sola declaración. Principalmente porque entonces se requieren paréntesis y todavía se ve divertido con solo dos declaraciones en la declaración if.

Yo uso la versión de dos líneas sin llaves (la segunda forma), pero no para ahorrar espacio.

Utilizo ese formulario porque lo encuentro más legible, visualmente más atractivo y más fácil de escribir. Solo uso ese formulario si se cumplen esas condiciones; es decir, la ifcondición tiene que encajar bien en una sola línea, y la declaración correspondiente tiene que encajar bien en la siguiente línea. Si ese no es el caso, usaré llaves para mejorar la legibilidad.

Si uso este formulario, me aseguro de que haya una línea vacía (o una línea que contenga solo una llave) antes y después de la ifdeclaración (o arriba del comentario, si está presente). Si bien esto no es una regla que sigo conscientemente, lo noto ahora después de leer esta pregunta.

Conservar el espacio de la pantalla no es una prioridad para mí. Si necesitara más espacio, usaría un monitor más grande. Mi pantalla ya es lo suficientemente grande como para leer cualquier cosa en la que deba centrar mi atención. Es poco probable que necesite centrarme en tantas líneas de código a la vez que ocupen toda mi pantalla. Si hay tanto anidamiento con un fragmento de código que no puedo entenderlo sin ver más de una vez, entonces tendría que considerar si la lógica podría representarse mejor mediante la refactorización.

A continuación hay algunos ejemplos que demuestran cómo uso esta forma de la ifdeclaración.

    string GuardConditions(Plan planForWorldDomination)
    {
        if (planForWorldDomination == null)
            throw new ArgumentNullException("planForWorldDomination");

        if (!planForWorldDomination.IsComplete())
            return "Doh!";

        planForWorldDomination.Execute();
    }

    void ProcessingLogic()
    {
        OneBlankLineAbove();

        if (simpleCondition)
            simpleStatement();

        OneBlankLineBelow();
        OneBlankLineAbove();

        // optional comment on the line above an if statement
        if (simpleCondition)
            simpleStatement();

        OneBlankLineBelow();
    }

    void Assignment(string drive)
    {
        OneBlankLineAbove();

        string prompt;
        if (simpleCondition)
            prompt = "simple assignment";
        else
            prompt = null;

        OneBlankLineBelow();
    }

    string Return()
    {
        OneBlankLineAbove();

        if (simpleCondition)
            return "simple return";
        else
            return null;

        OneBlankLineBelow();
    }

Tirantes. Siempre. Soy un poco fanático de ellos, porque le da al código algo de consistencia. Y también, como escribió @dsimcha, hay menos posibilidades de errores al agregar líneas de código adicionales.

La "fealdad" de las llaves alrededor de una sola línea de código es menos dañina que el trabajo adicional que es probable en aquellos casos con depuración y / o agregando código.

Personalmente voy con corchetes.

¿Por qué?

Bueno, si alguien viene y necesita agregar código en la declaración if, está 100% claro dónde está el alcance.

Mantiene el formato de las ifdeclaraciones consistentes sin importar cuántas declaraciones haya en el bloque.

Sin embargo, si el estilo del proyecto es irse, quédese con eso.

Casi siempre uso los soportes solo para estar seguro. Sin embargo, a veces, si el contenido del bloque es realmente corto, lo dejaré y lo haré de una sola línea de esta manera:

if (x==5) Console.WriteLine("It's a five!");

Prefiero llaves para la consistencia, pero no desperdiciar demasiado espacio en blanco (por lo que el código con formato más legible está en mi campo de visión limitado). Entonces escribo esto para líneas lo suficientemente cortas:

If (cond) { statement; }

Usualmente uso llaves, pero hay algunos casos en los que no.

object GetObject() {
    // calculate obj1
    if(obj1 != null)
        return obj1;

    // calculate obj2
    if(obj2 != null)
        return obj2;

    // calculate obj3
    if(obj3 != null)
        return obj3;

    return defaultObj;
}

Para mí, sería una tontería agregarlos allí. Si alguien agrega una declaración después del return, tenemos mayores problemas que problemas de alcance.

Si el IDE tiene formato de código disponible, no uso llaves.

Por otro lado, cuando el código se puede editar en otros editores que no admite el formateo automático, es peligroso no poner llaves como se menciona en otras publicaciones. Pero aun así prefiero no usar aparatos ortopédicos, y no ha sido un problema para mí.