À souligner js, puis-je obtenir plusieurs colonnes avec plumer méthode après l'entrée où la méthode que linq sélectionnez projection

TL;DR Utilisation :

var results = _.chain(people)
    .where({ city: "ny" })
    .map(_.partialRight(_.pick, 'firstName', 'qty'))
    .value();

Mais s'il vous plaît lisez la suite pour des explications que je me sens le processus de trouver cette solution est plus intéressante que la réponse réelle.

---

La tendance générale serait (il fonctionne avec lodash trop) :

_.map(array, function(obj) { return _.pick(obj, 'x', 'y', 'z'); });

Compte tenu de ce général map fonction qui transforme chaque élément d'une collection, il y a de multiples façons de s'adapter à votre situation particulière (qui se portent garants de la flexibilité des map, qui est un bloc de construction de base des programmes fonctionnels).

Permettez-moi de présenter ci-dessous plusieurs façons de mettre en œuvre notre solution :

var _ = require('lodash'); //@lodash 2.4.1 at the time of writing
//use underscore if you want to, but please see http://stackoverflow.com/questions/13789618/differences-between-lodash-and-underscore
/* la data */
var people = [{
firstName: "Thein",
city: "ny",
qty: 5
}, {
firstName: "Michael",
city: "ny",
qty: 3
}, {
firstName: "Bloom",
city: "nj",
qty: 10
}];
/* OPTION1 : mixin' with _ */
_.mixin({
pluckMany: function() {
var array = arguments[0],
propertiesToPluck = _.rest(arguments, 1);
return _.map(array, function(item) {
/* Alternative implementation 1.1
* ------------------------------
* Taken from @mMcGarnagle answer
* _each is easy to understand here,
* but has to modify the variable `obj` from a closure
* I try to avoid that for trivial cases like this one.
*/
var obj = {};
_.each(propertiesToPluck, function(property) {
obj[property] = item[property];
});
return obj;
/* Alternative implementation 1.2
* ------------------------------
* Rewrite the previous code,
* by passing the accumulator (previously`obj`, but really it is an object that accumulates the result being constructed) across function calls.
* This construction is typical of the `reduce` function, closer to a functionnal programming style.
*/
return _.reduce(propertiesToPluck, function(obj, property) {
obj[property] = item[property];
return obj;
}, {});
/* Alternative implementation 1.3
* ------------------------------
* If we are already using lodash/underscore,
* then let's use the `pick` function ! I also included an example of `flatten` here
*/
return _.pick(item, _.flatten(propertiesToPluck, true));
/* Alternative implementation 1.4
* ------------------------------
* But really flatten is not needed.
*/
return _.partial(_.pick, item).apply(null, propertiesToPluck);
});
}
});
/* Let's use our mixed function !
* Since we call several _ functions on the same object
* it is more readable to chain the calls.
*/
var results = _.chain(people)
.where({
city: "ny"
})
.pluckMany('firstName', 'qty')
.value();
/* OPTION 2 : without mixing our code with lodash/underscore */
var results = _.chain(people)
.where({
city: "ny"
})
.map(_.partialRight(_.pick, 'firstName', 'qty'))
.value();
console.log(results);

Si vous aimez cette façon d'écrire le code avec underscore ou lodash, je suggère fortement que vous regardez de la programmation fonctionnelle, comme ce style de l'écriture ainsi que de nombreuses fonctions (map, reduce parmi beaucoup d'autres) viennent de là.

Remarque : C'est apparemment une question commune que dans le trait de soulignement :
https://github.com/jashkenas/underscore/issues/1104

Ce n'est apparemment pas un hasard si ceux-ci sont laissés hors de trait de soulignement/lodash : "la composabilité est mieux que les fonctionnalités". On pourrait aussi dire que do one thing and do it well. C'est aussi pourquoi _.mixin existe.

Yep, je souhaite pluck disposait d'une option de passage d'un tableau, mais en attendant, vous pouvez faire:

const pluckFields = (arr, fields) => _.map(arr, item => _.pick(item, fields))

YAAUu-Yep une Autre Réponse à l'Aide de soulignement...

JS:

//use a proper browser to run this code snippet, a browser that is es6-compliant
let people = [{
firstName: "Thein",
city: "ny",
qty: 5
},
{
firstName: "Michael",
city: "ny",
qty: 3
},
{
firstName: "Bloom",
city: "nj",
qty: 10
}
];
//either you pick the properties you want 
let picking = _.iteratee((person) => _(person).pick("firstName", "city"));
//either you omit the properties you do not want
let omitting = _.iteratee((person) => _(person).omit("qty"));
//create the filter by city
let living = (people, city) => _(people).where({
"city": city
});
//put the "filter by city" into a mixin (as I assume it would be used again & again)
_.mixin({
living: living
});
//do the thing (twice), 
//these chaining methods could be done into a mixin as well
console.log("results by picking properties:", _(people).chain().living("ny").map(picking).value());
console.log("results by omitting properties:", _(people).chain().living("ny").map(omitting).value());

HTML:

<script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore-min.js"></script>