Le cas est simple - j'ai un objet suivant:
Object {1: false, 2: true, 3: false, 4: false, 5: false, 6: false, 7: false, 8: true, 12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false}
et j'ai besoin d'obtenir un tableau d'identifiants ayant une valeur vraie, en utilisant un trait de soulignement. Dans le cas ci-dessus, ce serait:
[2, 8]
J'ai essayé peu de choses mais je suis un peu coincé. Est-ce que quelqu'un a une idée?
var keys = [];
_.each( obj, function( val, key ) {
if ( val ) {
keys.Push(key);
}
});
Il y a peut-être des façons plus simples/plus courtes d'utiliser un trait de soulignement simple.
Si quelqu'un utilise Lodash au lieu de Underscore, les possibilités suivantes sont également possibles: very short et easy to read:
var keys = _.invert(obj, true)[ "true" ];
Giorgi Kandelaki a donné une bonne réponse, mais il y avait quelques problèmes potentiels (voir mon commentaire sur sa réponse).
La manière correcte est:
_(obj).pairs().filter(_.last).map(_.first)
ou
_.map(_.filter(_.pairs(obj),_.last),_.first)
var data = {1: false, 2: true, 3: false, 4: true};
var filteredIds = _.filter(_.keys(data), function (key) {
return data[key];
});
// result [2, 4]
var rejectedIds = _.reject(_.keys(data), function (key) {
return data[key];
});
// result [1, 3]
Vous pouvez utiliser _.pick
. Comme ça:
var data = {1: false, 2: true, 3: false, 4: false, 5: false, 6: false, 7: false, 8: true, 12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false}
var keys = _.keys(_.pick(data, function(value) {
return value;
}));
Vous pouvez essayer ceci:
_.pairs(obj)
.filter(function(pair) { return pair[1] })
.map(function(pair) { return pair[0] })
Ou le même mais un peu plus concis:
_.pairs(obj).filter(_.last).map(_.first)
var obj = {1: false, 2: true /*...*/};
vous pouvez utiliser réduire:
_(obj).reduce(function(memo, val, key){
if (val)
memo.Push(key);
return memo;
}, []);
ou carte en chaîne:
_(obj).chain().map(function(val, key){
if (val)
return key;
}).reject(_.isUndefined).value();
Cela pourrait être plus facile
result = _.chain(obj)
.map(function(value, key){
return value?key:false;
})
.filter(function(v){
return v
})
.value();
Ma version:
var list = {
1: false, 2: true, 3: false, 4: false,
5: false, 6: false, 7: false, 8: true,
12: false, 13: false, 14: false, 15: false,
16: false, 17: false, 18: false, 19: false
};
_.chain(list).map(function(val, key) {
return val ? parseInt(key) : undefined
}).reject(function(val) {
return _.isUndefined(val);
}).value();
// returns [2,8]
Vous pouvez le faire très facilement
var obj = { a: false, b: false, c: true, d: false, e: true, f: false };
name, names;
name = _.findKey(obj, true);
// -> 'c'
names = _.findKeys(obj, true);
// -> ['c', 'e']
Pour cela, il suffit d’allonger légèrement le soulignement:
_.mixin({
findKey: function(obj, search, context) {
var result,
isFunction = _.isFunction(search);
_.any(obj, function (value, key) {
var match = isFunction ? search.call(context, value, key, obj) : (value === search);
if (match) {
result = key;
return true;
}
});
return result;
},
findKeys: function(obj, search, context) {
var result = [],
isFunction = _.isFunction(search);
_.each(obj, function (value, key) {
var match = isFunction ? search.call(context, value, key, obj) : (value === search);
if (match) {
result.Push(key);
}
});
return result;
}
});
Et vous pouvez même utiliser une fonction comme filtre, comme ceci:
var team = {
place1: { name: 'john', age: 15 },
place2: { name: 'tim', age: 21 },
place3: { name: 'jamie', age: 31 },
place4: { name: 'dave', age: 17 }}
// Determine the places of players who are major
var placeNames = _.findKeys(team, function(value) { return value.age >= 18; });
// -> ['place2', 'place3']
Prendre plaisir ;-)
function findKey(obj, value){
var key;
_.each(_.keys(obj), function(k){
var v = obj[k];
if (v === value){
key = k;
}
});
return key;
}
Une autre solution potentielle:
// Your example data
var data = {1: false, 2: true, 3: false, 4: false, 5: false, 6: false, 7: false, 8: true, 12: false, 13: false, 14: false, 15: false, 16: false, 17: false, 18: false, 19: false};
// Outputs the keys: ["2", "8"]
_.keys(_.transform(data, function(r, v, k) { v ? r[k] = 1 : null; }));
// Outputs the keys as integers: [2, 8]
_.map(_.keys(_.transform(data, function(r, v, k) { v ? r[k] = 1 : null; })), _.parseInt)
Donc en gros:
J'utilise celui-ci: Récupère toutes les clés avec la même valeur d'un objet (pas seulement un objet avec juste des valeurs booléennes) en utilisant lodash
function allKeys(obj, value) {
_.keys(_.pick(obj, function (v, k) { return v === value; }));
}
Exemple:
var o = {a: 3, b: 5, c: 3};
var desiredKeys = allKeys(o, 3);
// => [a, c]