Acabo de comenzar a acostumbrarme a la sintaxis de ES6 y me preguntaba si era posible asignar a una variable con una función de flecha. Estoy escribiendo una biblioteca auxiliar básica AJAX ligera y en un estado de 200, quiero devolver una carga útil al usuario, que actualmente hago con:

var responseData = "";
switch (payload.returnType.toLowerCase()) {
    case "json" : responseData = JSON.parse(httpRequest.responseText); break;
    case "text" : responseData = httpRequest.responseText; break;
    default : responseData = null; break;
}
callback(null, responseData);

Esto está bien, pero no puedo evitar pensar que podría hacer este limpiador, si lo hago:

callback(null, () => { switch(payload.returnType.toLowerCase()) { ... });

Esperaría que la instrucción return envíe el resultado de la expresión como el segundo parámetro en mi devolución de llamada, sin embargo, cuando hago una consola de registro de la persona que llama, imprime la declaración del interruptor.

Alternativamente, he tratado de hacer:

var responseData = () => {
    switch (payload.returnType.toLowerCase()) {
        case "json" : return JSON.parse(httpRequest.responseText); break;
        case "text" : return httpRequest.responseText; break;
        default : return null; break;
    }
}
callback(null, responseData);

En este caso, responseData siempre está vacío. ¿Es posible tener el valor de retorno como mi segundo parámetro o vincularlo a responseData como resultado de la función de flecha?

9
Alex 14 may. 2016 a las 17:53

3 respuestas

La mejor respuesta

Crea una función anónima pero no la ejecuta.

Por ejemplo:

var getResponseData = () => {
    switch (payload.returnType.toLowerCase()) {
        case "json" : return JSON.parse(httpRequest.responseText); 
        case "text" : return httpRequest.responseText; 
        default : return null;
    }
};
callback(null, getResponseData());
9
Laurence 14 may. 2016 a las 15:12

Aún más corta con una función de ejecución automática:

let res = (() => {
    return something;
})();

O con tu código:

var getResponseData = (() => {
    switch (payload.returnType.toLowerCase()) {
        case "json" : return JSON.parse(httpRequest.responseText); 
        case "text" : return httpRequest.responseText; 
        default : return null;
    }
})();

Puedes ver claramente la diferencia en este fragmento:

let res1 = () => {
  return "something";
};

let res2 = (() => {
  return "something";
})();

console.log(res1);
console.log(res2);
4
leonheess 10 ene. 2020 a las 10:42

Creo que tu presentimiento es correcto, pero estás en el camino equivocado, en mi humilde opinión. Lo que creo que quiere hacer es crear un mapa de tipos de respuesta a devoluciones de llamada:

let parsers = new Map([
    ["json", JSON.parse], 
    ["text", (text) => text], 
    ["_", () => null]
]), t = payload.returnType.toLowerCase();

if (!parsers.has(t)) {
   t = "_";
}
callback(null, parsers.get(t)(httpRequest.responseText))

Lo que hace que esto sea subjetivamente "más limpio" es que separa la lógica de la implementación. Puede mover la definición del analizador a cualquier lugar sin afectar el código. Es por eso que las declaraciones de cambio se sienten "no funcionales" (o no declarativas).

Pero, por supuesto, todo esto sigue siendo una cuestión de gustos :)

1
Gerard van Helden 14 may. 2016 a las 15:20