Sign up with your email address to be the first to know about new products, VIP offers, blog features & more.

¿Y tú cómo pones las llaves cuando programas?

Cuando aprendes a programar en lenguajes con una sintaxis similar a C, uno de los aspectos más insignificantes desde el punto de vista práctico pero más relevantes desde el estético, es la situación de las llaves en los bloques de control, para los ejemplos usaremos la sentencia if. En esta entrada vamos a mostraros los estilos más populares.

Forma básica

Estilo Whitesmith (uno de los primeros compiladores de C)

Estilo GNU

Estilo BSD/Allman

Estilo Kernighan&Ritchie/Kernel

¿Y tú qué estilo usas?

  • Soy de BSD, limpieza y facilidad de lectura

  • @Alt+126 Para casos “directos” como el ejemplo que pones if (x<20) x++ yo siempre recomiendo NO OMITIR LAS LLAVES. Puedes encontrar a algún compañero que se encuentre un código como éste

    if (x<20)
    x++;

    y añada una línea al if de la siguiente forma:

    if (x<20)
    y++;
    x++;

    Y se queda tan pancho. Problema: tu variable x no se incrementa porque ya no forma parte del if, pero la identación hace difícil localizar el problema.

    Así que aunque el if sólo tenga una instrucción, yo siempre pongo llaves. Te aseguro que te evitas un montón de problemas cuando el código lo toca mucha gente.

  • Nacho

    Kernighan&Ritchie/Kernel

  • ludovico

    Yo cuando programo en lenguajes que usan llaves, y si soy yo el que decide, uso K&R porque la llave que cierra queda en la misma identación que la instrucción cerrada y es más rápido identificarla sobre todo con muchas llaves anidadas.

    en definitiva: limpieza y facilidad de lectura (como decimos todos, claro)

  • Pues antes era del tipo BSD, pero últimamente me he acostumbrado al estilo K&R/Kernel 😛 Todo por salvar algunas líneas jejeje XD

    Igual, en ocasiones hago mis excepciones y escribo en un estilo que no a muchos les gusta en sentencias pequeñas:

    if(condicion){ /*sentencia cortta;*/ }
    else { /*Otra sentencia corta; */ }

    Soy un poco obsesionado con las llaves y aunque haya sentencias en las condiciones de una sola línea prefiero usar las llaves XD

    Tampoco me gusta dejar espacio entre las llaves y los paréntesis, siento más claro no hacerlo así. XD Bueno, creo que ya es mi estilo (yeye-estilo XD) basado en el de K&R 😛

    Saludos.

  • pWeak

    Yo creo que el mejor es un híbrido entre Whitesmith y Kernighan&Ritchie/Kernel:

    if( expresion ) {
    sentencia1();
    sentencia2();
    sentencia3();
    }
    else {
    sentencia4();
    sentencia5();
    sentencia6();
    }

    También es aplicable a XML/HTML y creo que es muy socorrido visualmente cuando hay llaves anidadas.

  • pWeak

    Carai, no salieron los espacios…no vale para nada el comentario anterior…

    if( expresion ) {
    ···sentencia1();
    ···sentencia2();
    ···sentencia3();
    ···}
    else {
    ···sentencia4();
    ···sentencia5();
    ···sentencia6();
    ···}

    A ver ahora…

  • jorge

    yo raro, para definición de funciones BSD/alman
    para el resto que cae en el interior KR/Kernel 😀
    A mi me queda todo mas clarito

  • funkadelic

    KR/Kernel++;

  • martin

    BSD!

  • Pr0met30

    Siempre y para todo Kernighan&Ritchie/Kernel, aunque solo sea una sentencia. Que Dios bendiga a los developers que tabulan, XD

    if(condicion){
    sentencia1;
    sentencia2;
    }

  • Javier

    Kernighan&Ritchie/Kernel, está definido en el “Java Code Conventions”.

  • Isaac

    Yo uso BSD aunque si solo tengo una linea de codigo despues del if muchas veces ni pongo las llaves

  • vampirnet

    +650 frikipoints

  • Ignacio

    BSD

  • yo no programo nada, pero cuando diseño en CSS uso el estilo Kernighan&Ritchie/Kernel (sin siquiera saber que era un estilo, con nombre y todo). Curioso.

  • Jose

    Kernighan&Ritchie/Kernel ¡¡Sin duda!!

  • Braben

    K&R, aunque no me importa siempre que si un programador se ve obligado a meter las zarpas en el código de otro, respete las de éste, siendo consistente cada fichero.

  • JuP

    Siempre BSD/Allman

  • curtis

    Yo abro con KRK y cierro con Whitesmith.

    Por supuesto mi código tambien es el más legible y limpio. Y más original, nadie lo hace así.

  • Luisma Alonso

    Kernighan&Ritchie/Kernel.

    Comparto la opinión de Nacho Plaza, siempre hay alguno que pone una instrucción debajo esperando que esté dentro del if, y con las prisas no se dan ni cuenta, y luego vienen los lloros con los bug.

    Yo las pongo siempre.

    Saludos, y ¡enhorabuena por el blog, os sigo desde hace varios años!

  • miguel

    bsd

  • David

    Kernighan&Ritchie/Kernel

    Una vez hice un lenguaje de progrmación (para unas prácticas de ‘Compiladores’), y en mi lenguaje…. las llaves eran obligatorias!!!, aunque sólo fuera una sentencia dentro!! si no, no compilaba (lo hice así a propósito, que quede claro :P)

  • Alex Borras

    Estilo Kernighan&Ritchie/Kernel. Ahora creo en la economía de líneas. Cuando llegue la singularidad y las máquinas dominen el mundo los programadores más eficientes, que menos obligaron a trabajar inútilmente a los procesadores y discos duros menos líneas generaron serán promovidos a los puestos de gobierno.

  • Angel

    (Java)

    1. Para sentencias simples, no incluyo llaves. No pienso que se disminuye la claridad pues siempre escribo la sentencia en la misma línea:

    if(condition) sentence();

    2. Para sentencias múltiples, uso K&R/K. Si sé que otros han de leer el código, incluyo un comentario.

    if(condition) {
    ...sentence_1();
    ...
    ...sentence_n();
    ...} //end if

  • Mad

    BSD limpieza, claridad y en todo momento se ven los pares de llaves.

  • Kernighan&Ritchie/Kernel

    Y nunca omito las llaves cuando se trata de una sola instrucción dentro del “if”: es una forma segura de introducir un error.

  • Neochange
  • La verdad es que estoy sorprendido y a la vez encantado por la aceptación que ha tenido esta entrada. Cuando la redacte nunca supuse que iba a ser la entrada récord de Linux Hispano y eso que llevamos ya muchos años en la red (desde 2004…).

    Gracias a todos y desde aquí seguiremos generando contenido, que esperemos, os guste.

  • Blasito

    Hola a todos. Os sigo desde hace mucho tiempo y es la primera vez que me dejo ver. Me resultó muy curioso este post. Llevé años con k&R/K porque era el que por defecto traían los depuradores que usaba. En unos proyectos me pasé a BSD/Allman, pero volví a programar con K&R/K. Hay veces que me tiro HORAS enteras retocando el estilo de las llaves 😛 (es una obsesión que tengo). Y ahora, desde no hace mucho vengo usando el estilo GNU (que por lo que veo por aquí apenas nadie lo menciona), es el que hasta ahora me está convenciendo más. Pero no sé… creo que todavía no he encontrado un estilo que me haga sentir cómodo.

  • Augusto Lugo

    Primero, me da gusto ver no soy el único ‘geek’ que pone atención y discute sobre esto.

    Y soy alguien más en el grueso número de personas que usamos el estilo K&R/Kernel, además de ahorrar bastantes líneas, resulta más rápido localizar la función origen pues utilizo IDEs o editores de texto con colores y cada que me posiciono sobre una llave colorea la que abre/cierra también, con este estilo ahorro tiempo y esfuerzo, además de que el código queda limpio y cualquiera lo entiende. Comparto lo de usar comentarios para todo el que lea mi código.

    Sin embargo, debo reconocer que en mi opinión, el estilo GNU es más elegante y más claro, quizás lo empiece a usar; mas lo que mencionó Alex Borras me hace pensarlo dos veces.

    También me alegro al ver algunos tampoco sabíais los nombres de los estilos, es una grata sorpresa saber que se ha formalizado esto de los estilos de escribir software. 🙂

  • ParSalian

    Yo como pWeak, pero con dos espacios, y JAMAS tabuladores… los odio….

  • b4nd0ler0

    (Kernighan&Ritchie/Kernel)++

    Yo, como supongo que mucha gente por aquí aprendí primero en C, luego C++ pero por suerte teníamos un profe tipo sabio barbudo que era pro-linux y pro-java así que rápidamente nos metió en Java allá por 1998 y nos machacó mucho el tema del estilo estándar del código. Con el tiempo tiendo a la economía de líneas cuando se puede y confieso que a veces hago
    if(condicion) var=1; si la sentencia es sencilla.

  • BSD me parece la más clara 😉

  • Saul

    Siempre Kernighan&Ritchie/Kernel. Facilita la lectura y sobretodo el mantenimiento del código. Eso de ahorrarse las llaves para sentencias cortas sirve si sólo tú mantienes ese código. Cuando va otro detrás a tocar… zás cagada en el if … y eso pasa muuucho.
    Las java code convention por algo existen 😉
    Pero como siempre.. para gustos, colores. Aunque siempre abogo por facilitar el mantenimiento!

    Buen post.

  • Kernighan&Ritchie/Kernel
    me parece que el codigo se ve mas ordenado asi:

    function name_1 (value1, value2) {
    # 2 espacios desde la columna padre
    if (value1 < value2) {
    # separacion de los extremos de los parenteris,
    # de las variables y valores de los signos
    # y todas las referentes a asignacion de valores terminados en puntocoma
    x = (value2 + value1 * ((a ^ 3) + (g / h)) + 1;
    if (value1 < value2) {
    x = (value2 + value1 * ((a ^ name_2 (value_2)) + (g / h)) + 1;
    }
    }
    else
    x = value2++;
    }
    return x;
    }
    echo name_1 ();

  • se supone q coloq entre code eso

  • Ahora que estoy con jQuery, me resulta curioso y a la vez un tanto molesto la mezcla de paréntesis y llaves. En esos casos siempre tengo que usar Kernighan&Ritchie/Kernel.

  • aaa

    Siempre K&R, es el más claro, cada nivel de anidación en su indentación correspondiente.

  • el Estilo Kernighan&Ritchie/Kernel, es quizas para mi el mas comodo y legible de leer, y como dice el amigo Nacho Plaza “yo siempre recomiendo NO OMITIR LAS LLAVES”
    salu2

  • Juan

    Yo uso Kernighan&Ritchie/Kernel y si hay sólo una instrucción en el IF también las pongo. Recuerdo en un fragmento de código kilométrico no pusieron las llavecitas y la lié parda jaja. Jamás la falta de unas llaves me hicieron tanto daño.

    Saludos.

  • Kernighan&Ritchie/Kernel, sin duda, ordenado, legible, simple…

  • Inmi

    Yo siempre uso el estilo BSD/Allman, me parece el de mayor legibilidad

  • Dennis Castro

    If(condition){
    sentence_1;
    sentence_2;
    }else{
    sentence_3;
    sentence_4;
    }

  • Dennis Castro

    asi es mejor

    if ( condicion){
    ….sentencia;
    ….sentencia;
    }else{
    ….sentencia;
    …. y mas sentencias;
    }

  • ArKano

    BSD, sin lugar a dudas

  • BSD a saco, elegancia extrema, lo demás caca. Lo del comentario al cierre.. si lo van a leer mas gente a veces ayuda si son funciones o condiciones muy largas.

    Qué esté en las convenciones de java las forma KRGROMENAR, me la trae al pairo en concorde. ( Siento el trollismo pero me saltó una java fanboy exception y mi manejador de tiene pocos mensajes de error y todos hostiles 😛 ).

    Un saludo.

  • Kernighan&Ritchie/Kernel desde que tiré la primera línea de código con 12 años.

  • Fercho

    Kernighan&Ritchie/Kernel desde siempre, aunque con modificaciones comolas que plantea Dennis Castro

  • piri

    Kernighan&Ritchie/Kernel

Leer entrada anterior
Sobremesa

Cerrar