Mapper sur les clés de préservation des objets

La mapfonction dans underscore.js, si elle est appelée avec un objet javascript, retourne un tableau de valeurs mappées à partir des valeurs de l'objet.

_.map({one: 1, two: 2, three: 3}, function(num, key){ return num * 3; });
=> [3, 6, 9]

y a-t-il un moyen de lui faire conserver les clés? c'est à dire, je veux une fonction qui retourne

{one: 3, two: 6, three: 9}

Avec soulignement

Underscore fournit une fonction _.mapObjectpour mapper les valeurs et conserver les clés.

_.mapObject({ one: 1, two: 2, three: 3 }, function (v) { return v * 3; });

// => { one: 3, two: 6, three: 9 }

DEMO

Avec Lodash

Lodash fournit une fonction _.mapValuespour mapper les valeurs et conserver les clés.

_.mapValues({ one: 1, two: 2, three: 3 }, function (v) { return v * 3; });

// => { one: 3, two: 6, three: 9 }

DEMO

J'ai réussi à trouver la fonction requise dans lodash, une bibliothèque utilitaire similaire au soulignement.

http://lodash.com/docs#mapValues

_.mapValues(object, [callback=identity], [thisArg])

Crée un objet avec les mêmes clés que l'objet et les valeurs générées en exécutant chaque propre propriété énumérable d'objet via le rappel. Le rappel est lié à thisArg et appelé avec trois arguments; (valeur, clé, objet).

Je sais que c'est vieux, mais maintenant Underscore a une nouvelle carte pour les objets:

_.mapObject(object, iteratee, [context]) 

Vous pouvez bien sûr créer une carte flexible pour les tableaux et les objets

_.fmap = function(arrayOrObject, fn, context){
    if(this.isArray(arrayOrObject))
      return _.map(arrayOrObject, fn, context);
    else
      return _.mapObject(arrayOrObject, fn, context);
}

Que diriez-vous de cette version en JS ordinaire ( ES6 / ES2015 )?

let newObj = Object.assign(...Object.keys(obj).map(k => ({[k]: obj[k] * 3})));

jsbin

Si vous voulez mapper sur un objet de manière récursive (mapper obj imbriqué), cela peut être fait comme ceci:

const mapObjRecursive = (obj) => {
  Object.keys(obj).forEach(key => {
    if (typeof obj[key] === 'object') obj[key] = mapObjRecursive(obj[key]);
    else obj[key] = obj[key] * 3;
  });
  return obj;
};

jsbin

Depuis ES7 / ES2016, vous pouvez utiliser Object.entriesau lieu de Object.keysceci:

let newObj = Object.assign(...Object.entries(obj).map([k, v] => ({[k]: v * 3})));

Je sais que cela fait longtemps, mais la solution la plus évidente via le repli (aka réduire en js) est manquante, par souci d'exhaustivité, je la laisserai ici:

function mapO(f, o) {
  return Object.keys(o).reduce((acc, key) => {
    acc[key] = f(o[key])
    return acc
  }, {})
}

_.map renvoie un tableau, pas un objet.

Si vous voulez un objet, il vaut mieux utiliser une fonction différente, comme each; si vous voulez vraiment utiliser map, vous pouvez faire quelque chose comme ceci:

Object.keys(object).map(function(value, index) {
   object[value] *= 3;
})

mais c'est déroutant, quand mapon voit, on s'attendrait à avoir un tableau comme résultat et à en faire quelque chose.

Je pense que vous voulez une fonction mapValues (pour mapper une fonction sur les valeurs d'un objet), qui est assez facile à implémenter vous-même:

mapValues = function(obj, f) {
  var k, result, v;
  result = {};
  for (k in obj) {
    v = obj[k];
    result[k] = f(v);
  }
  return result;
};

const mapObject = (obj = {}, mapper) =>
  Object.entries(obj).reduce(
    (acc, [key, val]) => ({ ...acc, [key]: mapper(val) }),
    {},
  );

Un correctif de mix pour le bogue de la carte de soulignement : P

_.mixin({ 
    mapobj : function( obj, iteratee, context ) {
        if (obj == null) return [];
        iteratee = _.iteratee(iteratee, context);
        var keys = obj.length !== +obj.length && _.keys(obj),
            length = (keys || obj).length,
            results = {},
            currentKey;
        for (var index = 0; index < length; index++) {
          currentKey = keys ? keys[index] : index;
          results[currentKey] = iteratee(obj[currentKey], currentKey, obj);
        }
        if ( _.isObject( obj ) ) {
            return _.object( results ) ;
        } 
        return results;
    }
}); 

Une solution de contournement simple qui garde la bonne clé et la renvoie en tant qu'objet Elle est toujours utilisée de la même manière qu'en invité, vous pouvez utiliser cette fonction pour remplacer la fonction bugy _.map

ou tout simplement comme je l'ai utilisé comme mixin

_.mapobj ( options , function( val, key, list ) 

Vous pouvez utiliser _.mapValues(users, function(o) { return o.age; });dans Lodash et _.mapObject({ one: 1, two: 2, three: 3 }, function (v) { return v * 3; });Underscore.

Consultez la documentation croisée ici: http://jonathanpchen.com/underdash-api/#mapvalues-object-iteratee-identity