آموزش LINQ برای جاوا اسکریپت

فاطمه زکایی فروردین ۱۰, ۱۳۹۶ نظری ثبت کنید

با آموزش LINQ برای جاوا اسکریپت با شما هستیم،این مقاله قابلیت های اولیه LINQ اعمال شده روی آرایه های جاوا اسکریپت را مرور می کند.LINQ کامپوننتی از Microsoft .NET Framework است که با اضافه کردن عبارات کوئری زبان را توسعه می دهد، که به دستورات SQL وابسته است، و می تواند به راحتی داده ها را از آرایه ها گرفته و پردازش نماید. API تعبیه شده جاوا اسکریپت از ویرایش ECMAScript 5^thبا مجموعه بسیار محدودی از متدهای تکرار: forEach، some، filter، map، reduce و reduceRight می آید.

این متدها قابل پشتیبانی در همه مرورگرها نیستند، متفاوت از LINQ API بوده و بسیاری از قابلیت هایی که با LINQ می آید را پوشش نمی دهند. این مقاله پیاده سازی بیش از ۳۰ متد Enumerable از .NET 4.0 در جاوا اسکریپت شامل Aggregations، Iterations، Predicators و Selectors را برای افزودن قدرت و انعطاف پذیری کوئری های سبک LINQ به کد جاوا اسکریپت قدیمی را پوشش می دهد.

پیش زمینه

جاوا اسکریپت به طور ذاتی از وراثت کلاس پشتیبانی نمی کند و از طریق prototype به طور نامرتبی آن را پشتیبانی می کند. امکان شبیه سازی بسیاری از ویژگی های مبتنی بر کلاس در جاوا اسکریپت وجود دارد. Prototypeها ویژگی های رایج شی گرایی را برای زبان برنامه نویسی شی گرا فراهم می نماید. به این معنی که برای اضافه کردن قابلیت های بیشتر به API تعبیه شده، می توان prototype کلاس را توسعه داد.

همه آرایه ها در جاوا اسکریپت از شی Array ارث بری می کنند و متدها و property ها را از Array.prototype به ارث می برند. تغییرات روی شی Array prototype به همه آرایه ها منتشر می شود مگر اینکه propertyها و متدهای مربوط به این تغییرات در این زنجیره prototype، override شده باشند.

برای اضافه کردن قابلیت LINQ به جاوا اسکریپت، تمام کاری که ما باید انجام دهیم اضافه کردن این متدها به شی Array.prototype است.

برای مثال، API جاوا اسکریپت متد union ندارد، اگرچه متد concat را تقریبا با همان قابلیت دارد. با قرار دادن Array.prototype.union در متد تعبیه شده concat، همه آرایه ها جاوا اسکریپت می توانند متد union هم داشته باشند.

(متد صحیح union از المنت های گسسته از اجتماع دو دنباله استفاده می کند.)

Array.prototype.union = Array.prototype.concat;

۱	Array.prototype.union = Array.prototype.concat;

قبل از شروع

بیشتر متدهای LINQ، به توابع EqualityComparer، SortComparer، Predicate یا Selector برای اعمال هر المنتی درون یک آرایه نیاز دارند. در .NET این کار با ارسال Delegate به متد انجام می شود. به عنوان مثال این مدلی است که متد Select باید در C# ظاهر شود.

var someArray = new int[] { 1, 2, 3, 4 };
var otherArray = someArray.Select(t => t * 2);

۱ ۲	var someArray = new int[] { ۱, ۲, ۳, ۴ }; var otherArray = someArray.Select(t => t * ۲);

در مثال بالا t => t *2 یک Lambda expression است که برای ضرب هریک از المنت های آرایه در ۲ به عنوان یک تابع بی نام (delegate) رفتار می کند. اگرچه، از آن جایی که جاوا اسکریپت با عبارات Lambda نمی آید، توابع بی نام در جاوا اسکریپت با استفاده از function(){ … } تعریف می شوند.

این مدلی است که متد select در جاوا اسکریپت ظاهر می شود:

var someArray = [1, 2, 3, 4];
var otherArray = someArray.select(function (t) { return t * 2 });

۱ ۲	var someArray = [۱, ۲, ۳, ۴]; var otherArray = someArray.select(function (t) { return t * ۲ });

اینجا توابع پیش فرض EqualityComparer، SortComparer، Predicate یا Selector را داریم:

function DefaultEqualityComparer(a, b) {
    return a === b || a.valueOf() === b.valueOf();
};
 
function DefaultSortComparer(a, b) {
    if (a === b) return 0;
    if (a == null) return -1;
    if (b == null) return 1;
    if (typeof a == "string") return a.toString().localeCompare(b.toString());
    return a.valueOf() - b.valueOf();
};
 
function DefaultPredicate() {
    return true;
};

function DefaultSelector(t) {
    return t;
};

۱۰

۱۱

۱۲

۱۳

۱۴

۱۵

۱۶

۱۷

۱۸

۱۹

function DefaultEqualityComparer(a, b) {

return a === b || a.valueOf() === b.valueOf();

};

function DefaultSortComparer(a, b) {

if (a === b) return ۰;

if (a == null) return -۱;

if (b == null) return ۱;

if (typeof a == "string") return a.toString().localeCompare(b.toString());

return a.valueOf() - b.valueOf();

};

function DefaultPredicate() {

return true;

};

function DefaultSelector(t) {

return t;

};

LINQ Selector های جاوا اسکریپت

Select

هر یک از المنت های یک دنباله را به شکل جدیدی project می کند.

Array.prototype.select = Array.prototype.map || function (selector, context) {
    context = context || window;
    var arr = [];
    var l = this.length;
    for (var i = 0; i < l; i++)
        arr.push(selector.call(context, this[i], i, this));
    return arr;
};

Array.prototype.select = Array.prototype.map || function (selector, context) {

context = context || window;

var arr = [];

var l = this.length;

for (var i = ۰; i < l; i++)

arr.push(selector.call(context, this[i], i, this));

return arr;

};

مثال:

var arr = [1, 2, 3, 4, 5];
var doubled = arr.select(function(t){ return t * 2 });  // [2, 4, 6, 8, 10]

۱ ۲	var arr = [۱, ۲, ۳, ۴, ۵]; var doubled = arr.select(function(t){ return t * ۲ }); // [۲, ۴, ۶, ۸, ۱۰]

SelectMany

هر یک از المنت های یک دنباله را به یک آرایه project کرده و دنباله های نتیجه را در آخر به شکل یک آرایه درمی آورد:

Array.prototype.selectMany = function (selector, resSelector) {
    resSelector = resSelector || function (i, res) { return res; };
    return this.aggregate(function (a, b, i) {
        return a.concat(selector(b, i).select(function (res) { return resSelector(b, res) }));
    }, []);
};

Array.prototype.selectMany = function (selector, resSelector) {

resSelector = resSelector || function (i, res) { return res; };

return this.aggregate(function (a, b, i) {

return a.concat(selector(b, i).select(function (res) { return resSelector(b, res) }));

}, []);

};

مثال:

var arr = [{Name:"A", Values:[1, 2, 3, 4]}, {Name:"B", Values:[5, 6, 7, 8]}];  
var res1 = arr.selectMany(function(t){ return t.Values });  // using default result selector
var res2 = arr.selectMany(function(t){ return t.Values }, function(t, u){ return {Name:t.Name, Val:u}});  // using custom result selector

var arr = [{Name:"A", Values:[۱, ۲, ۳, ۴]}, {Name:"B", Values:[۵, ۶, ۷, ۸]}];

var res1 = arr.selectMany(function(t){ return t.Values }); // using default result selector

var res2 = arr.selectMany(function(t){ return t.Values }, function(t, u){ return {Name:t.Name, Val:u}}); // using custom result selector

Take

تعداد مشخصی از المنت های پیوسته را از آغاز یک دنباله برمی گرداند.

Array.prototype.take = function (c) {
    return this.slice(0, c);
};

Array.prototype.take = function (c) {

return this.slice(۰, c);

};

مثال:

var arr = [1, 2, 3, 4, 5]; 
var res = arr.take(2);  //  [1, 2]

۱ ۲	var arr = [۱, ۲, ۳, ۴, ۵]; var res = arr.take(۲); // [1, 2]

Skip

از روی تعداد مشخصی از المنت های دنباله گذشته و آن ها را نادیده گرفته و المنت های باقیمانده را برمی گرداند.

Array.prototype.skip = function (c) {
    return this.slice(c);
};

Array.prototype.skip = function (c) {

return this.slice(c);

};

مثال:

var arr = [1, 2, 3, 4, 5]; 
var res = arr.skip(2);  //  [3, 4, 5]

۱ ۲	var arr = [۱, ۲, ۳, ۴, ۵]; var res = arr.skip(۲); // [3, 4, 5]

First

اولین المنت دنباله را برمی گرداند:

Array.prototype.first = function (predicate, def) {
    var l = this.length;
    if (!predicate) return l ? this[0] : def == null ? null : def;
    for (var i = 0; i < l; i++)
        if (predicate(this[i], i, this))
            return this[i];
    return def == null ? null : def;
};

Array.prototype.first = function (predicate, def) {

var l = this.length;

if (!predicate) return l ? this[۰] : def == null ? null : def;

for (var i = ۰; i < l; i++)

if (predicate(this[i], i, this))

return this[i];

return def == null ? null : def;

};

مثال:

var arr = [1, 2, 3, 4, 5];
var t1 = arr.first(); // 1 
var t2 = arr.first(function(t){ return t > 2 });  // using comparer: 3 
var t3 = arr.first(function(t){ return t > 10 }, 10);  // using comparer and default value: 10

var arr = [۱, ۲, ۳, ۴, ۵];

var t1 = arr.first(); // ۱

var t2 = arr.first(function(t){ return t > ۲ }); // using comparer: 3

var t3 = arr.first(function(t){ return t > ۱۰ }, ۱۰); // using comparer and default value: 10

Last

آخرین المنت دنباله را برمی گرداند.

Array.prototype.last = function (predicate, def) {
    var l = this.length;
    if (!predicate) return l ? this[l - 1] : def == null ? null : def;
    while (l-- > 0)
        if (predicate(this[l], l, this))
            return this[l];
    return def == null ? null : def;
};

Array.prototype.last = function (predicate, def) {

var l = this.length;

if (!predicate) return l ? this[l - ۱] : def == null ? null : def;

while (l-- > ۰)

if (predicate(this[l], l, this))

return this[l];

return def == null ? null : def;

};

مثال:

var arr = [1, 2, 3, 4, 5];
var t1 = arr.last(); // 5 
var t2 = arr.last(function(t){ return t > 2 });  // using comparer: 5 
var t3 = arr.last(function(t){ return t > 10 }, 10);  // using comparer and default value: 10

var arr = [۱, ۲, ۳, ۴, ۵];

var t1 = arr.last(); // ۵

var t2 = arr.last(function(t){ return t > ۲ }); // using comparer: 5

var t3 = arr.last(function(t){ return t > ۱۰ }, ۱۰); // using comparer and default value: 10

Union

اجتماع دو دنباله را با استفاده از equality comparer پیش فرض تولید می کند.

Array.prototype.union = function (arr) {
    return this.concat(arr).distinct();
};

Array.prototype.union = function (arr) {

return this.concat(arr).distinct();

};

مثال:

var arr1 = [1, 2, 3, 4, 5]; 
var arr2 = [5, 6, 7, 8, 9];
var res = arr1.union(arr2);  // [1, 2, 3, 4, 5, 6, 7, 8, 9]

var arr1 = [۱, ۲, ۳, ۴, ۵];

var arr2 = [۵, ۶, ۷, ۸, ۹];

var res = arr1.union(arr2); // [۱, ۲, ۳, ۴, ۵, ۶, ۷, ۸, ۹]

Intersect

اشتراک دو دنباله را تولید می نماید.

Array.prototype.intersect = function (arr, comparer) {
    comparer = comparer || DefaultEqualityComparer;
    return this.distinct(comparer).where(function (t) {
        return arr.contains(t, comparer);
    });
};

Array.prototype.intersect = function (arr, comparer) {

comparer = comparer || DefaultEqualityComparer;

return this.distinct(comparer).where(function (t) {

return arr.contains(t, comparer);

});

};

مثال:

var arr1 = [1, 2, 3, 4, 5]; 
var arr2 = [1, 2, 3]; 
var res = arr1.intersect(arr2);  // [1, 2, 3]

var arr1 = [۱, ۲, ۳, ۴, ۵];

var arr2 = [۱, ۲, ۳];

var res = arr1.intersect(arr2); // [۱, ۲, ۳]

Except

تفاضل دو دنباله را محاسبه می نماید.

Array.prototype.except = function (arr, comparer) {
    if (!(arr instanceof Array)) arr = [arr];
    comparer = comparer || DefaultEqualityComparer;
    var l = this.length;
    var res = [];
    for (var i = 0; i < l; i++) { var k = arr.length; var t = false; while (k-- > 0) {
            if (comparer(this[i], arr[k]) === true) {
                t = true;
                break;
            }
        }
        if (!t) res.push(this[i]);
    }
    return res;
};

۱۰

۱۱

۱۲

۱۳

۱۴

۱۵

Array.prototype.except = function (arr, comparer) {

if (!(arr instanceof Array)) arr = [arr];

comparer = comparer || DefaultEqualityComparer;

var l = this.length;

var res = [];

for (var i = ۰; i < l; i++) { var k = arr.length; var t = false; while (k-- > ۰) {

if (comparer(this[i], arr[k]) === true) {

t = true;

break;

}

if (!t) res.push(this[i]);

}

return res;

};

مثال:

var arr1 = [1, 2, 3, 4, 5]; 
var arr2 = [2, 3, 4];
var res = arr1.except(arr2);  // [1, 5]

var arr1 = [۱, ۲, ۳, ۴, ۵];

var arr2 = [۲, ۳, ۴];

var res = arr1.except(arr2); // [۱, ۵]

Distinct

المنت های غیرتکراری از یک دنباله را با استفاده از equality comparer پیش فرض جهت مقایسه مقادیر برمی گرداند.

Array.prototype.distinct = function (comparer) {
    var arr = [];
    var l = this.length;
    for (var i = 0; i < l; i++) {
        if (!arr.contains(this[i], comparer))
            arr.push(this[i]);
    }
    return arr;
};

Array.prototype.distinct = function (comparer) {

var arr = [];

var l = this.length;

for (var i = ۰; i < l; i++) {

if (!arr.contains(this[i], comparer))

arr.push(this[i]);

}

return arr;

};

مثال:

var arr1 = [1, 2, 2, 3, 3, 4, 5, 5];   
var res1 = arr.distinct();  // [1, 2, 3, 4, 5]

var arr2 = [{Name:"A", Val:1}, {Name:"B", Val:1}];
var res2 = arr2.distinct(function(a, b){ return a.Val == b.Val });  // [{Name:"A", Val:1}] ;

var arr1 = [۱, ۲, ۲, ۳, ۳, ۴, ۵, ۵];

var res1 = arr.distinct(); // [۱, ۲, ۳, ۴, ۵]

var arr2 = [{Name:"A", Val:۱}, {Name:"B", Val:۱}];

var res2 = arr2.distinct(function(a, b){ return a.Val == b.Val }); // [{Name:"A", Val:1}] ;

Zip

یک تابع به خصوص را روی المنت های مربوط به هر دو دنباله اعمال می کند که یک دنباله به عنوان نتیجه تولید می کند.

Array.prototype.zip = function (arr, selector) {
    return this
        .take(Math.min(this.length, arr.length))
        .select(function (t, i) {
            return selector(t, arr[i]);
        });
};

Array.prototype.zip = function (arr, selector) {

return this

.take(Math.min(this.length, arr.length))

.select(function (t, i) {

return selector(t, arr[i]);

});

};

مثال:

var arr1 = [1, 2, 3, 4]; 
var arr2 = ["A", "B", "C", "D"];
var res = arr1.zip(arr2, function(a, b){ return {Num:a, Letter:b} });   
// [{Num:1, Letter: "A"},{Num:2, Letter: "B"}, {Num:3, Letter: "C"}, {Num:4, Letter: "D"}]

var arr1 = [۱, ۲, ۳, ۴];

var arr2 = ["A", "B", "C", "D"];

var res = arr1.zip(arr2, function(a, b){ return {Num:a, Letter:b} });

// [{Num:1, Letter: "A"},{Num:2, Letter: "B"}, {Num:3, Letter: "C"}, {Num:4, Letter: "D"}]

IndexOf

اندیس اولین جایی که یک مقدار آمده است را در یک آرایه یک بعدی به ما می دهد.

Array.prototype.indexOf = Array.prototype.indexOf || function (o, index) {
    var l = this.length;
    for (var i = Math.max(Math.min(index, l), 0) || 0; i < l; i++)
        if (this[i] === o) return i;
    return -1;
};

Array.prototype.indexOf = Array.prototype.indexOf || function (o, index) {

var l = this.length;

for (var i = Math.max(Math.min(index, l), ۰) || ۰; i < l; i++)

if (this[i] === o) return i;

return -۱;

};

مثال:

var arr = [1, 2, 3, 4, 5];
var index = arr.indexOf(2);  // 1

۱ ۲	var arr = [۱, ۲, ۳, ۴, ۵]; var index = arr.indexOf(۲); // ۱

LastIndexOf

اندیس آخرین جایی که یک مقدار در یک آرایه یک بعدی آمده است را به ما می دهد.

Array.prototype.lastIndexOf = Array.prototype.lastIndexOf || function (o, index) {
    var l = Math.max(Math.min(index || this.length, this.length), 0);
    while (l-- > 0)
        if (this[l] === o) return l;
    return -1;
};

Array.prototype.lastIndexOf = Array.prototype.lastIndexOf || function (o, index) {

var l = Math.max(Math.min(index || this.length, this.length), ۰);

while (l-- > ۰)

if (this[l] === o) return l;

return -۱;

};

مثال:

var arr = [1, 2, 3, 4, 5, 3, 4, 5];
var index = arr.lastIndexOf(3);  // 5

۱ ۲	var arr = [۱, ۲, ۳, ۴, ۵, ۳, ۴, ۵]; var index = arr.lastIndexOf(۳); // ۵

Remove

یک شی مشخصی از آرایه را در اولین جایی که آمده است، حذف می کند.

Array.prototype.remove = function (item) {
    var i = this.indexOf(item);
    if (i != -1)
        this.splice(i, 1);
};

Array.prototype.remove = function (item) {

var i = this.indexOf(item);

if (i != -۱)

this.splice(i, ۱);

};

مثال:

var arr = [1, 2, 3, 4, 5];
arr.remove(2);   // [1, 3, 4, 5]

۱ ۲	var arr = [۱, ۲, ۳, ۴, ۵]; arr.remove(۲); // [۱, ۳, ۴, ۵]

RemoveAll

تمام المنت هایی که با شرطی که توسط predicate مشخص شده مطابقت دارند، حذف می کند.

Array.prototype.removeAll = function (predicate) {
    var item;
    var i = 0;
    while (item = this.first(predicate)) {
        i++;
        this.remove(item);
    }
    return i;
};

Array.prototype.removeAll = function (predicate) {

var item;

var i = ۰;

while (item = this.first(predicate)) {

i++;

this.remove(item);

}

return i;

};

مثال:

var arr = [1, 2, 3, 4, 5];
arr.removeAll(function(t){ return t % 2 == 0 });  // [1, 3, 5]

۱ ۲	var arr = [۱, ۲, ۳, ۴, ۵]; arr.removeAll(function(t){ return t % ۲ == ۰ }); // [۱, ۳, ۵]

OrderBy

المنت های یک دنباله را در جهت صعودی براساس یک کلید مرتب می کند.

Array.prototype.orderBy = function (selector, comparer) {
    comparer = comparer || DefaultSortComparer;
    var arr = this.slice(0);
    var fn = function (a, b) {
        return comparer(selector(a), selector(b));
    };

    arr.thenBy = function (selector, comparer) {
        comparer = comparer || DefaultSortComparer;
        return arr.orderBy(DefaultSelector, function (a, b) {
            var res = fn(a, b);
            return res === 0 ? comparer(selector(a), selector(b)) : res;
        });
    };

    arr.thenByDescending = function (selector, comparer) {
        comparer = comparer || DefaultSortComparer;
        return arr.orderBy(DefaultSelector, function (a, b) {
            var res = fn(a, b);
            return res === 0 ? -comparer(selector(a), selector(b)) : res;
        });
    };

    return arr.sort(fn);
};

۱۰

۱۱

۱۲

۱۳

۱۴

۱۵

۱۶

۱۷

۱۸

۱۹

۲۰

۲۱

۲۲

۲۳

۲۴

۲۵

Array.prototype.orderBy = function (selector, comparer) {

comparer = comparer || DefaultSortComparer;

var arr = this.slice(۰);

var fn = function (a, b) {

return comparer(selector(a), selector(b));

};

arr.thenBy = function (selector, comparer) {

comparer = comparer || DefaultSortComparer;

return arr.orderBy(DefaultSelector, function (a, b) {

var res = fn(a, b);

return res === ۰ ? comparer(selector(a), selector(b)) : res;

});

};

arr.thenByDescending = function (selector, comparer) {

comparer = comparer || DefaultSortComparer;

return arr.orderBy(DefaultSelector, function (a, b) {

var res = fn(a, b);

return res === ۰ ? -comparer(selector(a), selector(b)) : res;

});

};

return arr.sort(fn);

};

مثال:

var arr = [{Name:"A", Val:1}, {Name:"a", Val:2}, {Name:"B", Val:1}, {Name:"C", Val:2}];

var res1 = arr.orderBy(function(t){ return t.Name });   

var res2 = arr.orderBy(function(t){ return t.Name }, function(a, b){
    if(a.toUpperCase() > b.toUpperCase()) return 1;
    if(a.toUpperCase() < b.toUpperCase()) return -1;
    return 0;
});

var arr = [{Name:"A", Val:۱}, {Name:"a", Val:۲}, {Name:"B", Val:۱}, {Name:"C", Val:۲}];

var res1 = arr.orderBy(function(t){ return t.Name });

var res2 = arr.orderBy(function(t){ return t.Name }, function(a, b){

if(a.toUpperCase() > b.toUpperCase()) return ۱;

if(a.toUpperCase() < b.toUpperCase()) return -۱;

return ۰;

});

OrderByDescending

المنت های یک دنباله را در جهت نزولی مرتب می کند.

Array.prototype.orderByDescending = function (selector, comparer) {
    comparer = comparer || DefaultSortComparer;
    return this.orderBy(selector, function (a, b) { return -comparer(a, b) });
};

Array.prototype.orderByDescending = function (selector, comparer) {

comparer = comparer || DefaultSortComparer;

return this.orderBy(selector, function (a, b) { return -comparer(a, b) });

};

مثال:

var arr = [{Name:"A", Val:1}, {Name:"a", Val:2}, {Name:"B", Val:1}, {Name:"C", Val:2}];
var res = arr.orderByDescending(function(t){ return t.Name });

۱ ۲	var arr = [{Name:"A", Val:۱}, {Name:"a", Val:۲}, {Name:"B", Val:۱}, {Name:"C", Val:۲}]; var res = arr.orderByDescending(function(t){ return t.Name });

ThenBy/ThenByDescending

یک مرتب سازی با تاخیر روی المنت های یک دنباله را با استفاده از یک مقایسه گر مشخص در جهت صعودی/نزولی انجام می دهد. ThenBy و ThenByDescending برای توسعه نوع خروجی OrderBy و OrderByDescending تعریف می شوند که نوع این متدها را برمی گردانند. این طراحی ما را قادر می سازد که چندین معیار مرتب سازی را با اعمال هر تعداد از متدهای ThenBy و ThenByDescending مشخص کنیم.

مثال:

var arr = [{Name:"A", Val:1}, {Name:"a", Val:2}, {Name:"B", Val:1}, {Name:"C", Val:2}];

var res1 = arr.orderBy(function(t){ return t.Val })
          .thenBy(function(t){ return t.Name });   

var res2 = arr.orderBy(function(t){ return t.Val })
          .thenByDescending(function(t){ return t.Name }); 
 
var res3 = arr.orderByDescending(function(t){ return t.Val })
          .thenBy(function(t){ return t.Name });

۱۰

var arr = [{Name:"A", Val:۱}, {Name:"a", Val:۲}, {Name:"B", Val:۱}, {Name:"C", Val:۲}];

var res1 = arr.orderBy(function(t){ return t.Val })

.thenBy(function(t){ return t.Name });

var res2 = arr.orderBy(function(t){ return t.Val })

.thenByDescending(function(t){ return t.Name });

var res3 = arr.orderByDescending(function(t){ return t.Val })

.thenBy(function(t){ return t.Name });

InnerJoin

المنت های دو دنباله را براساس کلیدهای مطابقت به هم مرتبط می کند.

Array.prototype.innerJoin = function (arr, outer, inner, result, comparer) {
    comparer = comparer || DefaultEqualityComparer;
    var res = [];

    this.forEach(function (t) {
        arr.where(function (u) {
            return comparer(outer(t), inner(u));
        })
        .forEach(function (u) {
            res.push(result(t, u));
        });
    });

    return res;
};

۱۰

۱۱

۱۲

۱۳

۱۴

۱۵

Array.prototype.innerJoin = function (arr, outer, inner, result, comparer) {

comparer = comparer || DefaultEqualityComparer;

var res = [];

this.forEach(function (t) {

arr.where(function (u) {

return comparer(outer(t), inner(u));

})

.forEach(function (u) {

res.push(result(t, u));

});

return res;

};

مثال:

var arr1 = [{Name:"A", Val:1}, {Name:"B", Val:2}, {Name:"C", Val:3}];

var arr2 = [{Code:"A"}, {Code:"B"}, {Name:"C", Code:"C"}]; 

var res1 = arr1.innerJoin(arr2,
    function (t) { return t.Name },                                      // arr1 selector
    function (u) { return u.Code },                                      // arr2 selector
    function (t, u) { return { Name: t.Name, Val: t.Val, Code: u.Code } });  // result selector

// using custom comparer
var res2 = arr1.innerJoin(arr2,
    function (t) { return t.Name },                                    // arr1 selector
    function (u) { return u.Code },                                    // arr2 selector
    function (t, u) { return { Name: t.Name, Val: t.Val, Code: u.Code } },  // result selector
    function (a, b) { return a.toUpperCase() == b.toUpperCase() });         // comparer

۱۰

۱۱

۱۲

۱۳

۱۴

۱۵

var arr1 = [{Name:"A", Val:۱}, {Name:"B", Val:۲}, {Name:"C", Val:۳}];

var arr2 = [{Code:"A"}, {Code:"B"}, {Name:"C", Code:"C"}];

var res1 = arr1.innerJoin(arr2,

function (t) { return t.Name }, // arr1 selector

function (u) { return u.Code }, // arr2 selector

function (t, u) { return { Name: t.Name, Val: t.Val, Code: u.Code } }); // result selector

// using custom comparer

var res2 = arr1.innerJoin(arr2,

function (t) { return t.Name }, // arr1 selector

function (u) { return u.Code }, // arr2 selector

function (t, u) { return { Name: t.Name, Val: t.Val, Code: u.Code } }, // result selector

function (a, b) { return a.toUpperCase() == b.toUpperCase() }); // comparer

GroupJoin

المنت های دو دنباله را براساس شباهت کلیدها و گروه بندی نتایج به هم مرتبط می کند. Equality comparer پیش فرض برای مقایسه کلیدها استفاده می شود.

Array.prototype.groupJoin = function (arr, outer, inner, result, comparer) {
    comparer = comparer || DefaultEqualityComparer;
    return this
        .select(function (t) {
            var key = outer(t);
            return {
                outer: t,
                inner: arr.where(function (u) { return comparer(key, inner(u)); }),
                key: key
            };
        })
        .select(function (t) {
            t.inner.key = t.key;
            return result(t.outer, t.inner);
        });
};

۱۰

۱۱

۱۲

۱۳

۱۴

۱۵

۱۶

Array.prototype.groupJoin = function (arr, outer, inner, result, comparer) {

comparer = comparer || DefaultEqualityComparer;

return this

.select(function (t) {

var key = outer(t);

return {

outer: t,

inner: arr.where(function (u) { return comparer(key, inner(u)); }),

key: key

};

})

.select(function (t) {

t.inner.key = t.key;

return result(t.outer, t.inner);

});

};

مثال:

var arr1 = [{Name:"A", Val:1}, {Name:"B", Val:2}, {Name:"C", Val:3}];
var arr2 = [{Code:"A"}, {Code:"A"}, {Code:"B"}, {Code:"B"}, {Code:"C"}];  

var res1 = arr1.groupJoin(arr2, 
    function(t){ return t.Name },                     // arr1 selector
    function(u){ return u.Code },                     // arr2 selector
    function(t, u){ return {Item:t, Group:u} }) ;         // result selector  
  
// using custom comparer  
var res2 = arr1.groupJoin(arr2, 
    function(t){ return t.Name },                             // arr1 selector
    function(u){ return u.Code },                             // arr2 selector
    function(t, u){ return {Item:t, Group:u} },                 // result selector 
    function(a, b){ return a.toUpperCase() == b.toUpperCase() });     // comparer

۱۰

۱۱

۱۲

۱۳

۱۴

var arr1 = [{Name:"A", Val:۱}, {Name:"B", Val:۲}, {Name:"C", Val:۳}];

var arr2 = [{Code:"A"}, {Code:"A"}, {Code:"B"}, {Code:"B"}, {Code:"C"}];

var res1 = arr1.groupJoin(arr2,

function(t){ return t.Name }, // arr1 selector

function(u){ return u.Code }, // arr2 selector

function(t, u){ return {Item:t, Group:u} }) ; // result selector

// using custom comparer

var res2 = arr1.groupJoin(arr2,

function(t){ return t.Name }, // arr1 selector

function(u){ return u.Code }, // arr2 selector

function(t, u){ return {Item:t, Group:u} }, // result selector

function(a, b){ return a.toUpperCase() == b.toUpperCase() }); // comparer

GroupBy

المنت های یک دنباله را براساس یک تابع انتخاب گر کلید مشخص گروه بندی می نماید.

Array.prototype.groupBy = function (selector, comparer) {
    var grp = [];
    var l = this.length;
    comparer = comparer || DefaultEqualityComparer;
    selector = selector || DefaultSelector;

    for (var i = 0; i < l; i++) {
        var k = selector(this[i]);
        var g = grp.first(function (u) { return comparer(u.key, k); });

        if (!g) {
            g = [];
            g.key = k;
            grp.push(g);
        }

        g.push(this[i]);
    }
    return grp;
};

۱۰

۱۱

۱۲

۱۳

۱۴

۱۵

۱۶

۱۷

۱۸

۱۹

۲۰

Array.prototype.groupBy = function (selector, comparer) {

var grp = [];

var l = this.length;

comparer = comparer || DefaultEqualityComparer;

selector = selector || DefaultSelector;

for (var i = ۰; i < l; i++) {

var k = selector(this[i]);

var g = grp.first(function (u) { return comparer(u.key, k); });

if (!g) {

g = [];

g.key = k;

grp.push(g);

}

g.push(this[i]);

}

return grp;

};

مثال:

var arr = [{Name:"A", Val:1}, {Name:"B", Val:1}, {Name:"C", Val:2}, {Name:"D", Val:2}]; 
var res = arr.groupBy(function(t){ return t.Val }); 
// [[{Name:"A", Val:1}, {Name:"B", Val:1}], [{Name:"C", Val:2}, {Name:"D", Val:2}]] 

res.forEach(function(t){ 
    console.log("Key: " + t.key, "Length: " + t.length); 
});   
// Key: 1 Length: 2  
// Key: 2 Length: 2

var arr = [{Name:"A", Val:۱}, {Name:"B", Val:۱}, {Name:"C", Val:۲}, {Name:"D", Val:۲}];

var res = arr.groupBy(function(t){ return t.Val });

// [[{Name:"A", Val:1}, {Name:"B", Val:1}], [{Name:"C", Val:2}, {Name:"D", Val:2}]]

res.forEach(function(t){

console.log("Key: " + t.key, "Length: " + t.length);

});

// Key: 1 Length: 2

// Key: 2 Length: 2

ToDictionary

یک شی از یک آرایه را براساس یک تابع انتخاب گر کلیدی مشخصی ایجاد می کند.

Array.prototype.toDictionary = function (keySelector, valueSelector) {
    var o = {};
    var l = this.length;
    while (l-- > 0) {
        var key = keySelector(this[l]);
        if (key == null || key == "") continue;
        o[key] = valueSelector(this[l]);
    }
    return o;
};

۱۰

Array.prototype.toDictionary = function (keySelector, valueSelector) {

var o = {};

var l = this.length;

while (l-- > ۰) {

var key = keySelector(this[l]);

if (key == null || key == "") continue;

o[key] = valueSelector(this[l]);

}

return o;

};

مثال:

var arr = [1, 2, 3, 4, 5]; 
var dic = arr.toDictionary(function(t){ return "Num" + t }, function(u){ return u });   
// dic = {Num5: 5, Num4: 4, Num3: 3, Num2: 2, Num1: 1}

var arr = [۱, ۲, ۳, ۴, ۵];

var dic = arr.toDictionary(function(t){ return "Num" + t }, function(u){ return u });

// dic = {Num5: 5, Num4: 4, Num3: 3, Num2: 2, Num1: 1}

توابع جمعی LINQ جاوا اسکریپت

Aggregate

یک تابع جمع کننده را روی یک دنباله اعمال می نماید.

Array.prototype.aggregate = Array.prototype.reduce || function (func, seed) {
    var arr = this.slice(0);
    var l = this.length;
    if (seed == null) seed = arr.shift();

    for (var i = 0; i < l; i++)
        seed = func(seed, arr[i], i, this);

    return seed;
};

۱۰

Array.prototype.aggregate = Array.prototype.reduce || function (func, seed) {

var arr = this.slice(۰);

var l = this.length;

if (seed == null) seed = arr.shift();

for (var i = ۰; i < l; i++)

seed = func(seed, arr[i], i, this);

return seed;

};

مثال:

var arr = [1, 2, 3, 4, 5];
var sum = arr.aggregate(function(a, b){ return a + b }, 0);  // 15

۱ ۲	var arr = [۱, ۲, ۳, ۴, ۵]; var sum = arr.aggregate(function(a, b){ return a + b }, ۰); // ۱۵

Min

کمترین مقدار بین مقادیر دنباله را برمی گرداند.

Array.prototype.min = function (s) {
    s = s || DefaultSelector;
    var l = this.length;
    var min = s(this[0]);
    while (l-- > 0)
        if (s(this[l]) < min) min = s(this[l]);
    return min;
};

Array.prototype.min = function (s) {

s = s || DefaultSelector;

var l = this.length;

var min = s(this[۰]);

while (l-- > ۰)

if (s(this[l]) < min) min = s(this[l]);

return min;

};

مثال:

var arr1 = [1, 2, 3, 4, 5, 6, 7, 8];
var min1 = arr.min();  // 1 

var arr2 = [{Name:"A", Val:1}, {Name:"B", Val:2}];
var min2 = arr2.min(function(t){ return t.Val });   // 1

var arr1 = [۱, ۲, ۳, ۴, ۵, ۶, ۷, ۸];

var min1 = arr.min(); // ۱

var arr2 = [{Name:"A", Val:۱}, {Name:"B", Val:۲}];

var min2 = arr2.min(function(t){ return t.Val }); // ۱

Max

بیشترین مقدار بین مقادیر یک دنباله را برمی گرداند.

Array.prototype.max = function (s) {
    s = s || DefaultSelector;
    var l = this.length;
    var max = s(this[0]);
    while (l-- > 0)
        if (s(this[l]) > max) max = s(this[l]);
    return max;
};

Array.prototype.max = function (s) {

s = s || DefaultSelector;

var l = this.length;

var max = s(this[۰]);

while (l-- > ۰)

if (s(this[l]) > max) max = s(this[l]);

return max;

};

مثال:

var arr1 = [1, 2, 3, 4, 5, 6, 7, 8];
var max1 = arr.max();  // 8 

var arr2 = [{Name:"A", Val:1}, {Name:"B", Val:2}];
var max2 = arr2.max(function(t){ return t.Val });   // 2

var arr1 = [۱, ۲, ۳, ۴, ۵, ۶, ۷, ۸];

var max1 = arr.max(); // ۸

var arr2 = [{Name:"A", Val:۱}, {Name:"B", Val:۲}];

var max2 = arr2.max(function(t){ return t.Val }); // ۲

Sum

مجموع مقادیر یک دنباله عددی را محاسبه می کند.

Array.prototype.sum = function (s) {
    s = s || DefaultSelector;
    var l = this.length;
    var sum = 0;
    while (l-- > 0) sum += s(this[l]);
    return sum;
};

Array.prototype.sum = function (s) {

s = s || DefaultSelector;

var l = this.length;

var sum = ۰;

while (l-- > ۰) sum += s(this[l]);

return sum;

};

مثال:

var arr1 = [1, 2, 3, 4, 5, 6, 7, 8];
var sum1 = arr.sum();  // 36 

var arr2 = [{Name:"A", Val:1}, {Name:"B", Val:2}];
var sum2 = arr2.sum(function(t){ return t.Val });   // 3

var arr1 = [۱, ۲, ۳, ۴, ۵, ۶, ۷, ۸];

var sum1 = arr.sum(); // ۳۶

var arr2 = [{Name:"A", Val:۱}, {Name:"B", Val:۲}];

var sum2 = arr2.sum(function(t){ return t.Val }); // ۳

گزاره های LINQ جاوا اسکریپت

Where

مقادیر دنباله را براساس یک گزاره فیلتر می کند.

Array.prototype.where = Array.prototype.filter || function (predicate, context) {
    context = context || window;
    var arr = [];
    var l = this.length;
    for (var i = 0; i < l; i++)
        if (predicate.call(context, this[i], i, this) === true) arr.push(this[i]);
    return arr;
};

Array.prototype.where = Array.prototype.filter || function (predicate, context) {

context = context || window;

var arr = [];

var l = this.length;

for (var i = ۰; i < l; i++)

if (predicate.call(context, this[i], i, this) === true) arr.push(this[i]);

return arr;

};

مثال:

var arr = [1, 2, 3, 4, 5];
var res = arr.where(function(t){ return t > 2 }) ;  // [3, 4, 5]

۱ ۲	var arr = [۱, ۲, ۳, ۴, ۵]; var res = arr.where(function(t){ return t > ۲ }) ; // [۳, ۴, ۵]

Any

مشخص می کند که آیا المنتی از دنباله وجود دارد یا یک شرط را برقرار می نماید.

Array.prototype.any = function (predicate, context) {
    context = context || window;
    var f = this.some || function (p, c) {
        var l = this.length;
        if (!p) return l > 0;
        while (l-- > 0)
            if (p.call(c, this[l], l, this) === true) return true;
        return false;
    };
    return f.apply(this, [predicate, context]);
};

۱۰

۱۱

Array.prototype.any = function (predicate, context) {

context = context || window;

var f = this.some || function (p, c) {

var l = this.length;

if (!p) return l > ۰;

while (l-- > ۰)

if (p.call(c, this[l], l, this) === true) return true;

return false;

};

return f.apply(this, [predicate, context]);

};

مثال:

var arr = [1, 2, 3, 4, 5];
var res1 = arr.any();  // true
var res2 = arr.any(function(t){ return t > 5 });  // false

var arr = [۱, ۲, ۳, ۴, ۵];

var res1 = arr.any(); // true

var res2 = arr.any(function(t){ return t > ۵ }); // false

All

مشخص می کند که آیا همه المنت های یک دنباله در شرطی صدق می کنند.

Array.prototype.all = function (predicate, context) {
    context = context || window;
    predicate = predicate || DefaultPredicate;
    var f = this.every || function (p, c) {
        return this.length == this.where(p, c).length;
    };
    return f.apply(this, [predicate, context]);
};

Array.prototype.all = function (predicate, context) {

context = context || window;

predicate = predicate || DefaultPredicate;

var f = this.every || function (p, c) {

return this.length == this.where(p, c).length;

};

return f.apply(this, [predicate, context]);

};

مثال:

var arr = [1, 2, 3, 4, 5];
var res = arr.all(function(t){ return t < 6 });  // true

۱ ۲	var arr = [۱, ۲, ۳, ۴, ۵]; var res = arr.all(function(t){ return t < ۶ }); // true

TakeWhile

المنت هایی از دنباله را تا زمانی که یک شرط خاصی درست باشد برمی گرداند و سپس بقیه المنت ها را نادیده می گیرد.

Array.prototype.takeWhile = function (predicate) {
    predicate = predicate || DefaultPredicate;
    var l = this.length;
    var arr = [];
    for (var i = 0; i < l && predicate(this[i], i) === true ; i++)
        arr.push(this[i]);

    return arr;
};

Array.prototype.takeWhile = function (predicate) {

predicate = predicate || DefaultPredicate;

var l = this.length;

var arr = [];

for (var i = ۰; i < l && predicate(this[i], i) === true ; i++)

arr.push(this[i]);

return arr;

};

مثال:

var arr = [1, 2, 3, 4, 5, 6, 7, 8];
var res = arr.takeWhile(function(t){ return t % 4 != 0 });  // [1, 2, 3]

۱ ۲	var arr = [۱, ۲, ۳, ۴, ۵, ۶, ۷, ۸]; var res = arr.takeWhile(function(t){ return t % ۴ != ۰ }); // [۱, ۲, ۳]

SkipWhile

المنت های یک دنباله را تا زمانی که شرط به خصوصی صدق کند نادیده می گیرد و سپس باقیمانده المنت ها را برمی گرداند.

Array.prototype.skipWhile = function (predicate) {
    predicate = predicate || DefaultPredicate;
    var l = this.length;
    var i = 0;
    for (i = 0; i < l; i++)
        if (predicate(this[i], i) === false) break;

    return this.skip(i);
};

Array.prototype.skipWhile = function (predicate) {

predicate = predicate || DefaultPredicate;

var l = this.length;

var i = ۰;

for (i = ۰; i < l; i++)

if (predicate(this[i], i) === false) break;

return this.skip(i);

};

مثال:

var arr = [1, 2, 3, 4, 5, 6, 7, 8];
var res = arr.skipWhile(function(t){ return t & 4 != 0 }) ;   // [ 4, 5, 6, 7, 8]

۱ ۲	var arr = [۱, ۲, ۳, ۴, ۵, ۶, ۷, ۸]; var res = arr.skipWhile(function(t){ return t & ۴ != ۰ }) ; // [ ۴, ۵, ۶, ۷, ۸]

Contains

مشخص می کند که آیا یک دنباله شامل یک المنت خاص می باشد یا خیر.

Array.prototype.contains = function (o, comparer) {
    comparer = comparer || DefaultEqualityComparer;
    var l = this.length;
    while (l-- > 0)
        if (comparer(this[l], o) === true) return true;
    return false;
};

Array.prototype.contains = function (o, comparer) {

comparer = comparer || DefaultEqualityComparer;

var l = this.length;

while (l-- > ۰)

if (comparer(this[l], o) === true) return true;

return false;

};

مثال:

var arr1 = [1, 2, 3, 4, 5]; 
var res1 = arr.contains(2);  // true 

var arr2 = [{Name:"A", Val:1}, {Name:"B", Val:1}]; 
var res2 = arr2.contains({Name:"C", Val:1}, function(a, b){ return a.Val == b.Val }) ;  // true

var arr1 = [۱, ۲, ۳, ۴, ۵];

var res1 = arr.contains(۲); // true

var arr2 = [{Name:"A", Val:۱}, {Name:"B", Val:۱}];

var res2 = arr2.contains({Name:"C", Val:۱}, function(a, b){ return a.Val == b.Val }) ; // true

توابع تکرار LINQ جاوا اسکریپت

ForEach

یک عمل خاصی را روی هر یک از المنت های آرایه اجرا می کند.

Array.prototype.forEach = Array.prototype.forEach || function (callback, context) {
    context = context || window;
    var l = this.length;
    for (var i = 0; i < l; i++)
        callback.call(context, this[i], i, this);
};

Array.prototype.forEach = Array.prototype.forEach || function (callback, context) {

context = context || window;

var l = this.length;

for (var i = ۰; i < l; i++)

callback.call(context, this[i], i, this);

};

مثال:

var arr = [1, 2, 3, 4, 5];
arr.forEach(function(t){ if(t % 2 ==0) console.log(t); });

۱ ۲	var arr = [۱, ۲, ۳, ۴, ۵]; arr.forEach(function(t){ if(t % ۲ ==۰) console.log(t); });

DefaultIfEmpty

المنت هایی از یک دنباله مشخص یا یک مقدار مشخص در مجموعه singleton را برمی گرداند اگر که دنباله خالی باشد.

Array.prototype.defaultIfEmpty = function (val) {
    return this.length == 0 ? [val == null ? null : val] : this;
};

Array.prototype.defaultIfEmpty = function (val) {

return this.length == ۰ ? [val == null ? null : val] : this;

};

مثال:

var arr = [1, 2, 3, 4, 5];
var res = arr.where(function(t){ return t > 5 }).defaultIfEmpty(5);  // [5]

۱ ۲	var arr = [۱, ۲, ۳, ۴, ۵]; var res = arr.where(function(t){ return t > ۵ }).defaultIfEmpty(۵); // [۵]

رمز فایل : www.mspsoft.ir , www.mspsoft.com

دوره طراحی و برنامه نویسی سیستم مدیریت مشتریان CRM

دوره طراحی و برنامه نویسی فروشگاه اینترنتی

دوره آموزشی طراحی و برنامه نویسی پورتال خبری در ASP.NET

آموزش تصویری ساخت پروژه سیستم ثبت سفارش آنلاین به زبان ASP.NET و #C

دوره آموزشی طراحی نرم افزار مدیریت فروشگاه + صدور فاکتور در سی شارپ

دوره آموزشی برنامه نویسی ساخت پروژه سیستم صدور مجوز به زبان سی شارپ

آموزشگاه تحلیل داده

آموزش LINQ برای جاوا اسکریپت

مطالب مرتبط

پاسخ دهید لغو پاسخ

سورس پروژه اضافه ، ویرایش و حذف در MVC توسط AngularJS

سورس پروژه مدیریت پادگان سربازی به زبان سی شارپ و بانک اطلاعاتی SQL Server

سورس پروژه تبدیل تاریخ شمسی به میلادی به زبان سی شارپ

پروژه نمایش اطلاعات توسط SignalR از SQL Server با نمایش تغییرات به صورت Ajax

پروژه ورود دو مرحله ای با اپلیکیشن Google Authenticator در ASP.NET

سورس پروژه سیستم مدیریت محتوا با ASP.NET MVC

سورس پروژه تبدیل Decimal به Binary در سی پلاس پلاس

چگونه میتوانیم یک برنامه نویس خوب شویم؟

دوره طراحی و برنامه نویسی فروشگاه اینترنتی

دانلود سورس پروژه فروشگاه به زبان asp.net و سی شارپ به همراه سبدخرید

آموزش تصویری MVC درASP.NET به زبان فارسی

سورس نرم افزار پیدا کردن پسورد ویندوز ۱۰۰% تست شده

دانلود پروژه اماده ارسال اس ام اس به زبان C#

دانلود مجموعه کامل آموزش تصویری سی شارپ به زبان شیرین فارسی

دوره های آنلاین ام اس پی سافت

آموزش طراحی فروشگاه اینترنتی

طراحی سیستم مدیریت مشتریان

دوره طراحی وب سایت پورتال خبری

دوره طراحی حسابداری فروشگاه