Comment gérer if/else dans la transformation JavaScript fonctionnelle des objets Immutable pour le débogage

Question

var data = { 
    type: 'TEST', 
    active: true, 
    letters: Immutable.Map({ 'a': true, 'b': false }) 
}; 

var dataToLog = _.object(
    _.map(data, function(v, k) { 
    if (Immutable.Iterable.isIterable(v)) { 
     return ['*Immutable* - ' + k, v.toJS()]; 
    } else { 
     return [k, v]; 
    } 
    }) 
); 

console.log('Output: ', dataToLog); 

"Output: " 
[object Object] { 
    *Immutable* - letters: [object Object] { 
    a: true, 
    b: false 
    }, 
    active: true, 
    type: "TEST" 
} 

J'ai ceci dans un JSBin here.

En utilisant lodash et quelques-unes des méthodes de transformation pour manipuler des objets Immuable qui coule à travers mon flux Dispatcher JSON pour le débogage plus facile et indiquer aussi par préfixer « Immuable » au nom de la clé dans la sortie. Cela fonctionne bien, mais j'apprends à utiliser _.map, _.compose, _.curry, et je me demande si cela pourrait être encore plus fonctionnel.

Plus précisément, je me demande comment gérer cette if/else qui est dans ma fonction envoyée à _.map:

if (Immutable.Iterable.isIterable(v)) { 
    return ['*Immutable* - ' + k, v.toJS()]; 
} else { 
    return [k, v]; 
} 

Je ne comprends pas comment je peux le transformer en quelque chose d'autre que de faire fonctionnel la vérification pour Immutable et le retour de cela dans des fonctions séparées qui vérifient les valeurs immuables de l'objet et une autre pour le transformer en JSON (en faisant l'appel à .toJS() d'Immutable). Je suis également aux prises avec la façon d'opérer sur ceci et obtenir la sortie désirée tout en opérant sur ceci comme un objet au lieu d'avoir ma fonction de carte retournant un tableau de la clé et de la valeur.

Pour clarifier les choses, les objectifs de la transformation globale:

• itérer sur un objet avec la clé, la valeur
• Si la valeur est pas un objet Immuable, retour clé et la valeur non modifiée
• Si valeur IS un objet Immutable, modifiez la clé pour être préfixé avec 'Immutable' et appelez .toJS() sur la valeur et renvoyez ces transformations

Answer 1

Voici une version corrigée de votre code pour atteindre votre objectif de transformation. Vous étiez très proche dans le code jsbin.

(function (_) { 
    "use strict"; 

    function immutableToJS(result, v, k) { 
    if (Immutable.Iterable.isIterable(v)) {  
     result['*Immutable* - ' + k] = v.toJS(); 
    } else { 
     result[k] = v; 
    } 
    } 

    var data = {   
     type: 'TEST', 
     active: true, 
     letters: Immutable.Map({ 'a': true, 'b': false }) 
     }, 
     answer = _.transform(data, immutableToJS), 
     expectedAnswer = {type: 'TEST', active: true}; 
    expectedAnswer["*Immutable* - letters"] = {a:true,b:false}; 

    console.log('answer: ' + JSON.stringify(answer)); 
    //console.log('expectedAnswer: ' + JSON.stringify(expectedAnswer)); 
    //console.log(_.isEqual(answer,expectedAnswer));//true 
}(_)); 

http://jsbin.com/somona/edit?js,console

les points possibles de confusion dans la question:

1. _.transform contre _.reduce parce que la fonction OP immutableToJS() dans le code jsbin avaient retourner des déclarations. _.transform utilise uniquement return false; pour arrêter l'itération. En utilisant le mot "fonctionnel" pour signifier "travailler" dans cette ligne: "... transformer cela en quelque chose de fonctionnel ...". Les commentaires indiquent que les gens le lisaient comme «style de programmation fonctionnelle».
2. Phrasing de "... gérer ceci si/sinon ..." quand il s'agissait de "réparer le if/else car il ne fonctionne pas". Les commentaires indiquent que les gens lisaient la phrase comme «enlever le if/else et le remplacer par du code qui utilise plutôt une approche de programmation fonctionnelle» (aggravée par le point 2 ci-dessus).