Material de estudio  >  Apuntes  >  Escritura de programas  >  Sangrado

Sangrado

José A. Mañas <jmanas@dit.upm.es>
Dept. de Ingeniería de Sistemas Telemáticos
Universidad Politécnica de Madrid
8 de mayo, 2003

1. Introducción

El sangrado (cámbios de línea y espacio en blanco al principio) es un mecanismo básico para transmitir al lector lo que piensa el programador.

En principio, cualquier convenio sería bueno, con el único requisito de que se siguiere sistemáticamente.

A continuación se describe el convenio más habitual en la comunidad de programadores Java.

2. Longitud de las líneas

2.1. No escriba líneas con más de 70 caracteres.
Si una sentencia requiere más del límite, considerr partirla en varias líneas, dejando clato en todas ellas (menos la última) que se sigue a continuación. 
  String mensaje= "Este es un mensaje un poco largo que, " +
                  "claramente, requiere de más de una línea " +
                  "para atenerse a la regla.";

  int acumulado= capitulo[1] + capitulo[3] +
                 capitulo[5] + capitulo[7] +
                 capitulo[11];

  funcion(argumento1, argumento2, argumento3,
          argumento4, argumento5);

  for (int indice= 0;
       indice < tablaDeRutasDeAcceso.length;
       indice+= 2) {
    ... ... ...
  }

3. Reglas de sangrado

3.1. Utilice dos espacios en blanco como medida básica de sangrado.
Evite el uso de caracteres de tabulación (TAB). 
  int maximo= tabla[0];
  for (int i= 0; i < tabla.length; i++) {
    if (tabla[i] > maximo)
      maximo= tabla[i];
  }
Para que el código no se arrastre por la derecha.

3.2. Para sangrar clases e interfaces se usará el patrón del ejemplo. 
  class UnaClase extends OtraClase
    implements UnaInterfase, OtraInterfase {
    ... ... ...
    ... ... ...
  }

3.3. Para sangrar métodos se usará el patrón del ejemplo. 
  public void unMetodo ()
    throws UnaExcepcion {
    ... ... ...
    ... ... ...
  }

3.4. Para sangrar estructuras IF-THEN-ELSE se usará el patrón del ejemplo. 
  if (condicion) {    if (condicion) {    if (condicion) {
    ... ... ...         ... ... ...         ... ... ...
  }                   } else {            } else if (condicion) {
                        ... ... ...         ... ... ...
                      }                   } else {
                                            ... ... ...
                                          }

3.5. Para sangrar estructuras SWITCH se usará el patrón del ejemplo. 
  switch (condicion) {
  case A:
    ... ... ...
    break;
  case B:
    ... ... ...
    return zzz;
  default:
    ... ... ...
  }

3.6. Para sangrar bloques while se usará el patrón del ejemplo. 
  while (quedaPorHacer()) {    do {
    ... ... ...                  ... ... ...
    ... ... ...                  ... ... ...
  }                            } while (masQueHacer());

3.7. Para sangrar bloques for se usará el patrón del ejemplo. 
  for (inicializacion(); condicion(); siguiente()) {
    ... ... ...
    ... ... ...
  }

3.8. Una iteración sin sentencias de cuerpo será como en el ejemplo. 
  for (inicializacion(); condicion(); siguiente())
    ;

3.9. Para sangrar estructuras TRY se usará el patrón del ejemplo. 
  try {                      try {                      try {
    ... ... ...                ... ... ...                ... ... ...
  } catch (Exception e) {    } catch (Exception e) {    } finally {
    ... ... ...                ... ... ...                ... ... ...
  }                          } finally {                }
                               ... ... ...
                             }

3.10. En estructuras de bloque con solo una sentencia, se pueden obviar las llaves. 
  if (condicion)
    hazAlgo();

  while (condicion)
    hazAlgo();

  for (inicializacion; condicion, actualizacion)
    hazAlgo();

4. Referencias