Programación sin If (básicamente sin condicionales)

Después de algunos años de programación vuelvo a mi propia pregunta, cuyo contexto ahora entiendo un poco mejor.

Hay una buena charla de Sandi Metz donde refacciona una bola realmente peluda de declaraciones if a algo menos peludo: https://www.youtube.com/watch?v=8bZh5LMaSmE

Leí el post que enlazaste y parece que en su mayoría estaban hablando de eliminar la necesidad de condicionales dentro de una clase, no debe confundirse con todo el código en general. La idea es que si necesita verificar el estado de un objeto (usando un condicional) para determinar si tiene cierta funcionalidad, entonces en realidad tiene dos objetos (uno que admite la funcionalidad y otro que no) y debe definirlos como dos clases relacionadas en su lugar.

He tenido un colega que me dijo que una vez trabajó para una empresa que tenía como política nunca tener condicionales ("if" y " switch" declaraciones) en el código y que dejan todas las decisiones en el el código debe hacerse usando polimorfismo y (supongo) algún otro OO principio.

Creo que su colega malinterpretó algo o usó las palabras equivocadas para explicarlo. Y no puedes evitar completamente las declaraciones condicionales.

Hay algo que decir: la proliferación de declaraciones if dentro de OOP puede ser un síntoma de mala programación. Un ejemplo:

No utilice if para comprobar el valor de retorno de la función como una antigua programación al estilo C:

int ret = some_func();
if (ret != null)
   //do something

Esto era típico en el código C, pero con OOP debe usar excepción:

try{
    do_something();
}catch(Exception e){
    e.printStackTrace(); //why I was not able to do something
    handle(e); //there is something else I could do to handle the occurred error
}

A veces si la proliferación de declaraciones está relacionada con un mal diseño. Considere el siguiente ejemplo en Java:

BaseClass base;
if (base instanceof DerivedClassOneFromBase){
    DerivedClassOneFromBase d = (DerivedClassOneFromBase)base;
    d.methodOne();
}else if (base instanceof DerivedClassOneFromBase){
    DerivedClassTwoFromBase d = (DerivedClassTwoFromBase)base;
    d.methodTwo();
}

Este es otro ejemplo de sentencias if malas, probablemente relacionadas con un diseño malo. Si el dos objetos derivados tendrían un método común definido en su clase base BaseClass, el podría haber llamado a ese método en lugar de verificar su tipo de concreto y fundirlos:

base.commonMethod();

A veces los condicionales dentro de los métodos son malos, ya que son una señal de que solo está realizando múltiples funciones o métodos de múltiples tipos en el único método.

Si tienes una clase llamada Automóvil y subclases como Automóvil y Bicicleta, y un método como:

drive(Automobile a)
   if (a.isCar)
      // do stuff
   else if (a.isBike)
      // do stuff

Es más probable que hagas algo mal. Incluso si no es un interruptor basado en el tipo, a menudo puede ser incorrecto. Si el método está realizando múltiples funciones dependiendo de alguna variable, a menudo está tratando de hacer más de una cosa y probablemente debería ser separado en múltiples métodos.

Por ejemplo:

save(Car c)
   if (c is new)
      // do some stuff
   else if (c is old)
      // do some stuff

Potencialmente podría dividirse en guardar y actualizar, ya que son dos funciones diferentes. Aunque depende.

Prohibir completamente si las declaraciones serían tontas, ya que tienen muchos casos de uso válidos.

Evitar condicionales no significa necesariamente que deba hacerlo por polimorfismo o herencia, tome por ejemplo :

Tienes 3 carpetas diferentes para almacenar imágenes subidas, videos subidos y pdf subidos

Puedes escribir código como:

uploadMedia(mediaType){
   if(mediaType == images){
     uploadTo("myProject/images");
   }else if(mediaType == videos){
     upoloadTo("myProject/videos);  
   }else if(mediaType == pdf){
     uploadTo("myProject/pdf");
  }
}

Otra alternativa que la gente podría usar es switch-case:

uploadMedia(mediaType){
         switch(mediaType){
         case : images
         uploadTo("myProject/images");
         break;

         case : videos
         uploadTo("myProject/videos");
         break;

         case : pdf
         uploadTo("myProject/pdf");
         break;
    }
}

Pero entonces puedes evitar totalmente la declaración condicional usando algo como dictionary / hashmap / json (Dependiendo de lo que trabajes con) :

Por ejemplo:

HashMap<String,String> mediaMap = new HashMap<>();

mediaMap.put("images","myProject/images");
mediaMap.put("videos","myProject/videos");
mediaMap.put("pdf","myProject/pdf");

//mediaType can be images/videos/pdf same as keys of mediaMap
uploadMedia(mediaType){
  uploadTo(mediaMap.get(mediaType));
}

Esto es una especie de pseudo código por lo que podría haber errores de sintaxis, pero en general este concepto también es útil para evitar condicionales. También se puede reducir la línea de código.