Refactor de la declaración If... Else en Javascript

JavaScript

La mayoría de las veces, la primera solución que aparece en nuestra mente no es la mejor solución. Es solo a través de la experiencia y la mejora del pensamiento lógico y las habilidades para la resolución de problemas que se puede llegar a un enfoque optimizado para un problema dado. Es una observación común que la mayor parte del código en JS se anida debido a las diversas condiciones que uno tiene que manejar para la solución.          

Con suerte, puede aprender algo nuevo hoy y convertirse en un mejor desarrollador escribiendo código limpio, legible y optimizado.

  1. Operador ternario
  2. Caja del interruptor
  3. Cortocircuito (usando operadores lógicos)
  4. Cláusulas de guardia
  5. Delegación de funciones

Vamos a ver  cada uno de estos métodos en detalle ahora.

1). Operador ternario
Esta es la mejor y más usual forma de reemplazar sus declaraciones "if ... else". En el campo de la IA conversacional, uno encontrará una situación en la que debe verificar la plataforma desde donde se activa el bot y dar una respuesta en consecuencia. Este es el mejor ejemplo para usar un operador ternario en lugar de usar una instrucción if para verificar la condición.

platform === "voice" ? setVoiceResponse() : setChatResponse();

 

2.) Switch
La declaración de cambio de caso no es la mejor manera posible de reemplazar declaraciones anidadas "if-else", pero se pueden utilizar para reducir el código duplicado, que es otro error común ignorado por los desarrolladores en el campo de la IA conversacional.

Muchas veces esperamos que el agente virtual dé una respuesta estática o simple para diferentes Intenciones de usuario. Cuando implementamos la lógica de cumplimiento para esto, tendemos a producir, sin saberlo, código duplicado.

Estas situaciones se pueden eliminar mediante el uso de declaraciones de cambio de caso, ya que se puede ejecutar una lógica común para varios casos y otras respuestas simples se pueden cubrir en casos separados.
    

switch(intentName) {
    case "Welcome":
    case: "Exit":
        setStaticResponse(messagePayload)
        break;
    case "Fetch Phone Number":
        getPhoneNumber();
        break;
}

 

3). Short-Circuiting

En este enfoque, emplearemos operadores lógicos como "&&" (AND) y "||" (O). El funcionamiento de estos operadores es complementario entre sí.

Por ejemplo, el lado derecho del operador "Y" se ejecuta solo si el lado izquierdo es verdadero, mientras que el lado derecho del operador "O" se ejecuta solo si el lado izquierdo es falso. Podemos usar esta lógica para eliminar fácilmente el anidamiento en nuestro código.

Esto puede resultar útil para configurar un mensaje de salida personalizado al final de una conversación.
Además, recuerde que hay pocas expresiones que siempre son falsas (convertidas a falsas),
por ejemplo: nulo, indefinido, NaN, una cadena vacía (“”)

const checkExitMessage = () => {
    return payload && payload[exitMessage] || payload && payload[defaultMessage]
}

const message = checkExitMessage()

 

4). Guard Clauses

Se emplean como estrategia de salida anticipada. Definimos nuestras condiciones de tal manera que se sale del bucle para cada verificación. Esta estrategia hace que el código sea más legible y optimizado.

Esto se puede usar en situaciones en las que verificamos si el usuario está autenticado y realizamos algunas acciones en consecuencia (por ejemplo: desencadenar un evento para la intención del usuario)

const checkAuthentication = (intentName) => {
    if(!authenticated) return setEvent('Unauthenticated')
    return setEvent(intentName)
}

 

5). Function Delegation

Esta estrategia es muy útil para comprender el concepto de cierres en JS. Dividir el caso de uso en sub-casos y crear una función para cada uno ayudará a eliminar los niveles de anidamiento. Podemos combinar todas las estrategias mencionadas anteriormente y combinarlas para lograr el mejor código posible.

Sin delegación de funciones

const checkStatus = (entry) => {
    if(!entry) {
        return false
    }
    else if(!checkAuthValue(entry)) {
        setUnauthenticatedMessage(entity)
        retryCount+1
        return errorMessage()
    }
    else {
        setAuthenticatedMessage(entity)
        return successMessage()
    }
}

 

Con delegación de funciones

const checkStatus = (entry) => {
    const unauthenticatedUser = () => {
        setUnauthenticatedMessage(entity)
        retryCount+1
        return errorMessage()
    }
    
    const authenticatedUser = () => {
        setAuthenticatedMessage(entity)
        return successMessage()
    }

    return entity && (checkAuthValue(entity) ? authenticatedUser() : unauthenticatedUser())
}

 

Puedes ver claramente el concepto de cierres implementado, ya que los parámetros de la función externa son accesibles a las funciones internas

Espero que esto haya sido útil para todos y especialmente para la gente del dominio de la IA conversacional.

Para las personas que no tienen antecedentes de IA conversacional, les recomendaría que revisen los textos con hipervínculos para cada uno de los enfoques anteriores, ya que lo ayudarán a comprender mejor los conceptos.