Usos apropiados de las instrucciones de conmutación en caso de caída

14

¿Cuándo es apropiado usar una instrucción de conmutación directa (clásica)? ¿Se recomienda y alienta tal uso o debe evitarse a toda costa?

    
pregunta shabunc 25.10.2011 - 21:12
fuente

7 respuestas

15

Aquí hay un ejemplo en el que sería útil.

public Collection<LogItems> GetAllLogItems(Level level) {
    Collection<LogItems> result = new Collection<LogItems>();
    switch (level) {
        // Note: fall through here is INTENTIONAL
        case All:
        case Info:
             result.Add(GetItemsForLevel(Info));
        case Warning:
             result.Add(GetItemsForLevel(Warning));
        case Error:
             result.Add(GetItemsForLevel(Error));
        case Critical:
             result.Add(GetItemsForLevel(Critical));
        case None:
    }
    return result;
}

Este tipo de cosas (donde un caso incluye el otro) es bastante raro, creo, por lo que algunos lenguajes más nuevos no permiten el fallover o requieren una sintaxis especial para ello.

    
respondido por el configurator 25.10.2011 - 21:45
fuente
8

Los uso cuando hay que aplicar cierta funcionalidad para más de un valor. Por ejemplo, digamos que tenía un objeto con una propiedad llamada operationCode. Si el código es igual a 1, 2, 3 o 4, desea iniciarOperationX (). Si son 5 o 6, desea iniciar la operaciónY () y 7 iniciar la operaciónZ (). ¿Por qué tener 7 casos completos con funcionalidad y rupturas cuando puedes usar los recursos directos?

Creo que es completamente válido en ciertas situaciones, especialmente si evita 100 sentencias if-else. =)

    
respondido por el Yatrix 25.10.2011 - 21:26
fuente
8

Los he usado ocasionalmente, creo que es siempre un uso apropiado, pero solo cuando se incluye con el comentario apropiado.

    
respondido por el gbjbaanb 25.10.2011 - 21:30
fuente
7

Los casos de caída están perfectamente bien. A menudo encuentro que se usa una enumeración en muchos lugares, y que cuando no es necesario diferenciar algunos casos, es más fácil usar la lógica de acceso directo.

Por ejemplo (tenga en cuenta los comentarios explicativos):

public boolean isAvailable(Server server, HealthStatus health) {
  switch(health) {
    // Equivalent positive cases
    case HEALTHY:
    case UNDER_LOAD:
      return true;

    // Equivalent negative cases
    case FAULT_REPORTED:
    case UNKNOWN:
    case CANNOT_COMMUNICATE:
      return false;

    // Unknown enumeration!
    default:
      LOG.warn("Unknown enumeration " + health);
      return false;
  }
}

Me parece perfectamente aceptable este tipo de uso.

    
respondido por el Bringer128 26.10.2011 - 05:41
fuente
6

Depende de:

  • su preferencia personal
  • normas de codificación de su empleador
  • la cantidad de riesgo involucrado

Los dos problemas principales asociados con dejar que un caso pase al siguiente son:

  1. Hace que su código dependa del orden de las declaraciones del caso. Ese no es el caso si nunca se cumple, y agrega un grado de complejidad que a menudo no es bienvenido.

  2. No es obvio que el código para un caso incluya el código para uno o más casos subsiguientes.

Algunos lugares prohíben explícitamente caer. Si no trabajas en un lugar así, y si te sientes cómodo con la práctica, y si descifrar el código en cuestión no causará ningún sufrimiento real, entonces puede que no sea lo peor del mundo. Sin embargo, si lo haces, asegúrate de colocar un comentario que llame la atención para advertir a los que vengan más tarde (incluido el futuro).

    
respondido por el Caleb 25.10.2011 - 22:32
fuente
4

Aquí hay un ejemplo rápido (sin duda incompleto (sin manejo especial del año bisiesto)) de caída a través que me simplifica la vida:

function get_julian_day (date) {
    int utc_date = date.getUTCDate();
    int utc_month = date.getUTCMonth();

    int julian_day = 0;

    switch (utc_month) {
        case 11: julian_day += 30;
        case 10: julian_day += 31;
        case 9:  julian_day += 30;
        case 8:  julian_day += 31;
        case 7:  julian_day += 31;
        case 6:  julian_day += 30;
        case 5:  julian_day += 31;
        case 4:  julian_day += 30;
        case 3:  julian_day += 31;
        case 2:  julian_day += 28;
        case 1:  julian_day += 31;
        default: break;
    }

    return julian_day + utc_date;
}
    
respondido por el AaronDanielson 03.10.2016 - 18:57
fuente
3

Si siento la necesidad de pasar de un caso a otro (aunque sea raro), prefiero ser muy explícito y, por supuesto, goto case , que asume que su idioma lo admite.

Debido a que la caída a través es tan poco común y muy fácil de pasar por alto mientras se lee el código, creo que es apropiado ser explícito, y un goto, aunque sea en un caso, debería sobresalir como un pulgar dolorido. >

También ayuda a evitar errores que pueden ocurrir cuando se reordenan las declaraciones de casos.

    
respondido por el quentin-starin 25.10.2011 - 22:55
fuente

Lea otras preguntas en las etiquetas