Mappa su chiavi di conservazione degli oggetti

La mapfunzione in underscore.js, se chiamata con un oggetto javascript, restituisce una matrice di valori mappati dai valori dell'oggetto.

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

c'è un modo per preservare le chiavi? cioè, voglio una funzione che ritorni

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

Con Underscore

Underscore fornisce una funzione _.mapObjectper mappare i valori e conservare le chiavi.

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

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

DEMO

Con Lodash

Lodash fornisce una funzione _.mapValuesper mappare i valori e conservare le chiavi.

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

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

DEMO

Sono riuscito a trovare la funzione richiesta in lodash, una libreria di utilità simile a underscore.

http://lodash.com/docs#mapValues

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

Crea un oggetto con le stesse chiavi dell'oggetto e dei valori generati eseguendo ciascuna proprietà enumerabile dell'oggetto tramite il callback. Il callback è associato a thisArg e invocato con tre argomenti; (valore, chiave, oggetto).

So che questo è vecchio, ma ora Underscore ha una nuova mappa per gli oggetti:

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

Ovviamente puoi costruire una mappa flessibile per matrici e oggetti

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

Che ne dici di questa versione in semplice JS ( ES6 / ES2015 )?

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

jsbin

Se vuoi mappare ricorsivamente un oggetto (mappa obj nidificato), puoi farlo in questo modo:

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

Da ES7 / ES2016 puoi usare Object.entriesinvece di Object.keysquesto:

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

So che è passato molto tempo, ma manca ancora la soluzione più ovvia tramite fold (ovvero ridurre in js), per completezza la lascerò qui:

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

_.map restituisce una matrice, non un oggetto.

Se vuoi un oggetto, stai meglio usando una funzione diversa, come each; se vuoi davvero usare la mappa potresti fare qualcosa del genere:

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

ma questo è confuso, quando vedendo mapuno ci si aspetterebbe di avere un array come risultato e quindi fare qualcosa con esso.

Penso che tu voglia una funzione mapValues (per mappare una funzione sui valori di un oggetto), che è abbastanza facile da implementare:

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) }),
    {},
  );

Una correzione mista per il bug della mappa di sottolineatura : 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;
    }
}); 

Una soluzione semplice che mantiene la chiave giusta e ritorna come oggetto. È ancora usata nello stesso modo in cui io ospite potresti usare questa funzione per sovrascrivere la funzione bug. _.map

o semplicemente come me l'ho usato come mixin

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

Puoi usare _.mapValues(users, function(o) { return o.age; });in Lodash e _.mapObject({ one: 1, two: 2, three: 3 }, function (v) { return v * 3; });in Underscore.

Consulta la documentazione incrociata qui: http://jonathanpchen.com/underdash-api/#mapvalues-object-iteratee-identity