Javascript équivalent à C # LINQ Select

Oui, "1519100920 Tableau.carte () ou $.map() fait la même chose.

//array.map:
var ids = this.fruits.map(function(v){
    return v.Id;
});

//jQuery.map:
var ids2 = $.map(this.fruits, function (v){
    return v.Id;
});

console.log(ids, ids2);

http://jsfiddle.net/NsCXJ/1/

depuis array.map n'est pas pris en charge dans les navigateurs plus anciens, je suggère que vous vous en teniez à la méthode jQuery.

si vous préférez l'autre pour une raison quelconque, vous pouvez toujours ajouter un polyfill pour l'ancien support du navigateur.

vous pouvez toujours ajouter des méthodes personnalisées au prototype du tableau aussi bien:

Array.prototype.select = function(expr){
    var arr = this;
    //do custom stuff
    return arr.map(expr); //or $.map(expr);
};

var ids = this.fruits.select(function(v){
    return v.Id;
});

une version étendue qui utilise le constructeur de fonction si vous passez une chaîne. Quelque chose à jouer avec peut-être:

Array.prototype.select = function(expr){
    var arr = this;

    switch(typeof expr){

        case 'function':
            return $.map(arr, expr);
            break;

        case 'string':

            try{

                var func = new Function(expr.split('.')[0], 
                                       'return ' + expr + ';');
                return $.map(arr, func);

            }catch(e){

                return null;
            }

            break;

        default:
            throw new ReferenceError('expr not defined or not supported');
            break;
    }

};

console.log(fruits.select('x.Id'));

http://jsfiddle.net/aL85j/

mise à jour:

depuis qu'il est devenu si populaire réponse, j'ajoute similaire mon where() + firstOrDefault() . Ceux-ci pourraient également être utilisés avec l'approche du constructeur de fonctions basé sur la chaîne de caractères (qui est la plus rapide), mais voici une autre approche utilisant un objet littéral comme filtre:

Array.prototype.where = function (filter) {

    var collection = this;

    switch(typeof filter) { 

        case 'function': 
            return $.grep(collection, filter); 

        case 'object':
            for(var property in filter) {
              if(!filter.hasOwnProperty(property)) 
                  continue; // ignore inherited properties

              collection = $.grep(collection, function (item) {
                  return item[property] === filter[property];
              });
            }
            return collection.slice(0); // copy the array 
                                      // (in case of empty object filter)

        default: 
            throw new TypeError('func must be either a' +
                'function or an object of properties and values to filter by'); 
    }
};


Array.prototype.firstOrDefault = function(func){
    return this.where(func)[0] || null;
};

Utilisation:

var persons = [{ name: 'foo', age: 1 }, { name: 'bar', age: 2 }];

// returns an array with one element:
var result1 = persons.where({ age: 1, name: 'foo' });

// returns the first matching item in the array, or null if no match
var result2 = persons.firstOrDefault({ age: 1, name: 'foo' }); 

voici un test jsperf pour comparer la fonction constructeur vs objet Vitesse littérale. Si vous décidez d'utiliser l'ancien, gardez à l'esprit pour citer les chaînes correctement.

Ma préférence personnelle est d'utiliser l'objet literal based solutions lors du filtrage des propriétés 1-2, et passer une fonction de rappel pour un filtrage plus complexe.

je terminerai ceci avec 2 Conseils généraux lors de l'ajout de méthodes à des prototypes d'objets natifs:

1. vérifier l'occurrence des méthodes existantes avant d'écrire p. ex.:

   if(!Array.prototype.where) { Array.prototype.where = ...

2. si vous n'avez pas besoin de supporter IE8 et ci-dessous, définissez les méthodes en utilisant L'objet .defineProperty pour les rendre non-énumérable. Si quelqu'un a utilisé for..in sur un tableau (ce qui est faux, en premier lieu,) ils itérer les propriétés énumérables. Juste un heads-up.