¿Se considera que salir de una declaración de cambio es una mejor práctica que usar break? [cerrado]

Opción 1 - switchusando return:

function myFunction(opt) {
  switch (opt) {
    case 1: return "One";
    case 2: return "Two";
    case 3: return "Three";

    default: return "";
  }    
}

Opción 2 - switchusando break:

function myFunction(opt) {
  let retVal = "";

  switch (opt) {
    case 1: 
      retVal = "One";
      break;
    case 2: 
      retVal = "Two";
      break;
    case 3: 
      retVal = "Three";
      break;
  }

  return retVal;
}

Sé que ambos funcionan, pero ¿es una de las mejores prácticas? Me suele gustar la opción 1: switchusar returnmejor, ya que es más limpia y sencilla.

Aquí hay un jsFiddle de mi ejemplo específico usando la técnica mencionada en los comentarios de @ic3b3rg :

let SFAIC = {};

SFAIC.common = {
  masterPages: {
    cs: "CS_",
    cp: "CP_"
  },
  contentPages: {
    cs: "CSContent_",
    cp: "CPContent_"    
  }
};

function getElementPrefix(page) {
  return (page in SFAIC.common.masterPages)
    ? SFAIC.common.masterPages[page]
    : (page in SFAIC.common.contentPages)
      ? SFAIC.common.contentPages[page]
      : undefined;
}

Para llamar a la función, lo haría de las siguientes maneras:

getElementPrefix(SFAIC.common.masterPages.cs);
getElementPrefix(SFAIC.common.masterPages.cp);
getElementPrefix(SFAIC.common.contentPages.cs);
getElementPrefix(SFAIC.common.contentPages.cp);

El problema aquí es que siempre devuelve indefinido. Supongo que se debe a que se pasa el valor real del objeto literal y no la propiedad. ¿Qué haría para solucionar este problema utilizando la técnica descrita en los comentarios de @ic3b3rg ?

May 25 '11 00:05 Code Maverick

Ninguno de los dos, porque ambos son bastante detallados para una tarea muy sencilla. Puedes simplemente hacer:

const result = ({
  1: 'One',
  2: 'Two',
  3: 'Three'
})[opt] ?? 'Default'  // opt can be 1, 2, 3 or anything (default)

Esto, por supuesto, también funciona con cadenas, una combinación de ambas o sin un caso predeterminado:

const result = ({
  first: 'One',
  'sec-ond': 'Two',
  3: 'Three'
})[opt]  // opt can be 'first', 'sec-ond' or 3

Explicación:

Funciona creando un objeto donde las opciones/casos son las claves y los resultados son los valores. Al poner la opción entre corchetes, accede al valor de la clave que coincide con la expresión a través de la notación entre corchetes.

Esto regresa undefinedsi la expresión dentro de los corchetes no es una clave válida. Podemos detectar este caso indefinido utilizando el operador coalescente nulo?? y devolver un valor predeterminado.

Ejemplo:

console.log('Using a valid case:', ({
  1: 'One',
  2: 'Two',
  3: 'Three'
})[1] ?? 'Default')

console.log('Using an invalid case/defaulting:', ({
  1: 'One',
  2: 'Two',
  3: 'Three'
})[7] ?? 'Default')

.as-console-wrapper {max-height: 100% !important;top: 0;}

Nov 25 '2020 14:11 leonheess

Depende, si su función solo consta de la declaración de cambio, entonces creo que está bien. Sin embargo, si desea realizar otras operaciones dentro de esa función, probablemente no sea una buena idea. Es posible que también deba considerar sus requisitos ahora y en el futuro. Si desea cambiar su función de la opción uno a la opción dos, será necesaria más refactorización.

Sin embargo, dado que dentro de las declaraciones if/else, la mejor práctica es hacer lo siguiente:

var foo = "bar";

if(foo == "bar") {
    return 0;
}
else {
    return 100;
}

Con base en esto, se podría argumentar que la opción uno es una mejor práctica.

En resumen, no hay una respuesta clara, por lo que siempre que su código cumpla con un estándar consistente, legible y mantenible, es decir, no mezcle ni combine las opciones uno y dos en toda su aplicación, esa es la mejor práctica que debe seguir. siguiente.

May 24 '2011 17:05 Mark Costello