[javascript] C # LINQ Select와 동일한 Javascript

예. Array.map () 또는 $ .map () 은 동일한 작업을 수행합니다.

//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/

구형 브라우저에서는 array.map이 지원되지 않으므로 jQuery 메소드를 사용하는 것이 좋습니다.

어떤 이유로 다른 것을 선호하는 경우 이전 브라우저 지원을 위해 항상 폴리 필을 추가 ​​할 수 있습니다.

언제든지 배열 프로토 타입에 사용자 정의 메소드를 추가 할 수 있습니다.

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

문자열을 전달하면 함수 생성자를 사용하는 확장 버전입니다. 아마도 놀아야 할 것 :

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/

최신 정보:

이것이 인기있는 답변이되었으므로 비슷한 my where()+를 추가하고 firstOrDefault()있습니다. 이것들은 문자열 기반 함수 생성자 접근법 (가장 빠름)과 함께 사용될 수도 있지만 필터로 객체 리터럴을 사용하는 또 다른 접근법입니다.

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;
};

용법:

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' }); 

다음은 함수 생성자와 객체 리터럴 속도를 비교 하는 jsperf 테스트 입니다. 전자를 사용하기로 결정한 경우 문자열을 올바르게 인용하십시오.

개인적으로 선호하는 것은 1-2 속성을 필터링 할 때 객체 리터럴 기반 솔루션을 사용하고 더 복잡한 필터링을 위해 콜백 함수를 전달하는 것입니다.

네이티브 객체 프로토 타입에 메소드를 추가 할 때 2 가지 일반적인 팁으로이 작업을 끝내겠습니다.

1. 덮어 쓰기 전에 기존 방법이 있는지 확인하십시오. 예 :

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

2. IE8 이하를 지원할 필요가없는 경우, Object.defineProperty 를 사용하여 메소드를 열거 할 수 없도록 정의하십시오 . 누군가 for..in가 배열에서 사용하면 (처음에는 잘못됨) 열거 가능한 속성도 반복합니다. 그냥 머리 위로.

답변

var maleNames = people
.Where(p => p.Sex == "M")
.Select(p => p.Name)

// replace where  with $.grep
//         select with $.map
var maleNames = $.grep(people, function (p) { return p.Sex == 'M'; })
            .map(function (p) { return p.Name; });

arrayFilter() -> Where()
arrayFirst() -> First()
arrayForEach() -> (no direct equivalent)
arrayGetDistictValues() -> Distinct()
arrayIndexOf() -> IndexOf()
arrayMap() -> Select()
arrayPushAll() -> (no direct equivalent)
arrayRemoveItem() -> (no direct equivalent)
compareArrays() -> (no direct equivalent)

var mapped = ko.utils.arrayMap(selectedFruits, function (fruit) {
    return fruit.id;
});

var mapped = Enumerable.From(selectedFruits)
    .Select("$.id") // 1 of 3 different ways to specify a selector function
    .ToArray();

let people = [{firstName:'Alice',lastName:'Cooper'},{firstName:'Bob',age:'Dylan'}];
let names = Array.from(people, p => p.firstName);
for (let name of names) {
  console.log(name);
}

selectedFruits.select(fruit=>fruit.id);

Enumerable.From(selectedFruits).Select(function (fruit) { return fruit.id;  });