Mapear sobre chaves de preservação de objeto

A mapfunção em underscore.js, se chamada com um objeto javascript, retorna uma matriz de valores mapeados a partir dos valores do objeto.

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

existe uma maneira de fazê-lo preservar as chaves? ou seja, eu quero uma função que retorne

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

Com sublinhado

O sublinhado fornece uma função _.mapObjectpara mapear os valores e preservar as chaves.

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

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

DEMO

Com Lodash

O Lodash fornece uma função _.mapValuespara mapear os valores e preservar as chaves.

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

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

DEMO

Consegui encontrar a função necessária no lodash, uma biblioteca de utilidades semelhante ao sublinhado.

http://lodash.com/docs#mapValues

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

Cria um objeto com as mesmas chaves que o objeto e os valores gerados executando cada propriedade enumerável do objeto por meio do retorno de chamada. O retorno de chamada é vinculado a thisArg e invocado com três argumentos; (valor, chave, objeto).

Eu sei que isso é antigo, mas agora o Underscore tem um novo mapa para objetos:

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

Obviamente, você pode criar um mapa flexível para matrizes e objetos

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

Que tal esta versão em JS simples ( ES6 / ES2015 )?

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

jsbin

Se você deseja mapear sobre um objeto recursivamente (mapear objeto aninhado), isso pode ser feito assim:

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

Desde o ES7 / ES2016, você pode usar em Object.entriesvez de Object.keys:

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

Eu sei que já faz muito tempo, mas ainda está faltando a solução mais óbvia via fold (também conhecida como redução em js), por uma questão de integridade, deixarei aqui:

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

_.map retorna uma matriz, não um objeto.

Se você quer um objeto, é melhor usar uma função diferente, como each; se você realmente quiser usar o mapa, poderá fazer algo assim:

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

mas isso é confuso, ao ver mapum seria esperado ter uma matriz como resultado e, em seguida, fazer algo com ela.

Eu acho que você deseja uma função mapValues (para mapear uma função sobre os valores de um objeto), que é fácil o suficiente para se implementar:

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

Uma correção de mix para o bug de sublinhado do mapa : 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;
    }
}); 

Uma solução simples que mantém a tecla correta e retorna como objeto. Ainda é usada da mesma maneira que eu convidava. Você poderia usar essa função para substituir a função _.map.

ou simplesmente como eu o usei como um mixin

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

Você pode usar _.mapValues(users, function(o) { return o.age; });no Lodash e _.mapObject({ one: 1, two: 2, three: 3 }, function (v) { return v * 3; });no Underscore.

Confira a documentação cruzada aqui: http://jonathanpchen.com/underdash-api/#mapvalues-object-iteratee-identity