carte pour les objets (au lieu des tableaux)

Question

J'ai un objet:

 myObject = { 'a': 1, 'b': 2, 'c': 3 }
 

Je recherche une méthode native, similaire à Array.prototype.map qui serait utilisée comme suit:

 newObject = myObject.map(function (value, label) {
    return value * value;
});

// newObject is now { 'a': 1, 'b': 4, 'c': 9 }
 

Est-ce que JavaScript a une telle fonction map pour les objets? (Je veux cela pour Node.JS, donc je ne me soucie pas des problèmes entre navigateurs.)

Answer 1

Il n'y a pas de map natif à l'objet Object , mais qu'en est-il de ceci:

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

console.log(myObject);

// => { 'a': 2, 'b': 4, 'c': 6 }
 

Mais vous pouvez facilement parcourir un objet en utilisant for ... in :

 for(var key in myObject) {
    if(myObject.hasOwnProperty(key)) {
        myObject[key] *= 2;
    }
}
 

Answer 2

Aucune méthode native, mais lodash # mapValues fera le travail avec brio

 _.mapValues({ 'a': 1, 'b': 2, 'c': 3} , function(num) { return num * 3; });
// → { 'a': 3, 'b': 6, 'c': 9 }
 

Answer 3

Il est assez facile d'en écrire un et de l'ajouter à Object.prototype pour qu'il soit disponible sur tous les objets:

 Object.defineProperty(Object.prototype, 'map', {
    value: function(f, ctx) {
        ctx = ctx || this;
        var self = this, result = {};
        Object.keys(self).forEach(function(v) {
            result[v] = f.call(ctx, self[v], v, self); 
        });
        return result;
    }
});
 

L'utilisation de Object.defineProperty garantit que la nouvelle fonction ajoutée n'apparaît pas dans la liste des propriétés énumérables de chaque Object .

 > o = { a: 1, b: 2 };
> r = o.map(function(v, k, o) {
     return v * v;
  });
> r
{ a : 1, b: 4, c: 9 }
 

NB: cette version vous permet également (facultativement) de définir le contexte this pour le rappel, tout comme la méthode Array .

Answer 4

Vous pouvez utiliser Object.keys puis forEach sur le tableau renvoyé de touches:

var myObject = { 'a': 1, 'b': 2, 'c': 3 },
    newObject = {};
Object.keys(myObject).forEach(function (key) {
    var value = myObject[key];
    newObject[key] = value * value;
});

De façon modulaire:

function map(obj, callback) {
    var result = {};
    Object.keys(obj).forEach(function (key) {
        result[key] = callback.call(obj, obj[key], key, obj);
    });
    return result;
}

newObject = map(myObject, function(x) { return x * x; });

Notez que Object.keys () retourne un tableau contenant uniquement propres à l'objet énumérable propriétés, donc il se comporte comme un for..in boucle avec un hasOwnProperty vérifier.

Answer 5

Le map function n'existe pas sur le Object.prototype mais vous pouvez l'imiter comme ça

 var myMap = function ( obj, callback ) {

    var result = {};

    for ( var key in obj ) {
        if ( Object.prototype.hasOwnProperty.call( obj, key ) ) {
            if ( typeof callback === 'function' ) {
                result[ key ] = callback.call( obj, obj[ key ], key, obj );
            }
        }
    }

    return result;

};

var myObject = { 'a': 1, 'b': 2, 'c': 3 };

var newObject = myMap( myObject, function ( value, key ) {
    return value * value;
});