linq.js 学习

linq.js中GroupBy

 

GroupBy: function (keySelector, elementSelector, resultSelector, compareSelector)
        {
            var source = this;
            keySelector = Utils.CreateLambda(keySelector);
            elementSelector = Utils.CreateLambda(elementSelector);
            if (resultSelector != null) resultSelector = Utils.CreateLambda(resultSelector);
            compareSelector = Utils.CreateLambda(compareSelector);

            return new Enumerable(function ()
            {
                var enumerator;

                return new IEnumerator(
                    function ()
                    {
                        enumerator = source.ToLookup(keySelector, elementSelector, compareSelector)
                            .ToEnumerable()
                            .GetEnumerator();
                    },
                    function ()
                    {
                        while (enumerator.MoveNext())
                        {
                            return (resultSelector == null)
                                ? this.Yield(enumerator.Current())
                                : this.Yield(resultSelector(enumerator.Current().Key(), enumerator.Current()));
                        }
                        return false;
                    },
                    function () { Utils.Dispose(enumerator); })
            });
        },

测试代码：

 

module("Grouping");

var expected, actual; // will be removed

var fileList = ["temp.xls", "temp2.xls", "temp.pdf", "temp.jpg", "temp2.pdf", "temp3.xls"];

test("groupBy", function ()
{
    actual = Enumerable.from(fileList)
        .groupBy("file=>file.match(/\\.(.+$)/)[1]") 
        .select("{key:$.key(),value:$.toArray()}")
        .toArray();
    expected = [{ key: "xls", value: ["temp.xls", "temp2.xls", "temp3.xls"] },
                { key: "pdf", value: ["temp.pdf", "temp2.pdf"] },
                { key: "jpg", value: ["temp.jpg"]}];
    deepEqual(actual, expected);

    actual = Enumerable.from(fileList)
        .groupBy("file=>file.match(/\\.(.+$)/)[1]", "file=>file.match(/(^.+)\\..+$/)[1]")
        .select("{key:$.key(),value:$.toArray()}")
        .toArray();
    expected = [{ key: "xls", value: ["temp", "temp2", "temp3"] },
                { key: "pdf", value: ["temp", "temp2"] },
                { key: "jpg", value: ["temp"]}];
    deepEqual(actual, expected);

    actual = Enumerable.from(fileList).groupBy("file=>file.match(/\\.(.+$)/)[1]",
        "file=>file",
        "ext,group => {extension:ext,count:group.count(),files:group.toArray()}")
        .toArray();
    expected = [{ extension: "xls", count: 3, files: ["temp.xls", "temp2.xls", "temp3.xls"] },
                { extension: "pdf", count: 2, files: ["temp.pdf", "temp2.pdf"] },
                { extension: "jpg", count: 1, files: ["temp.jpg"]}];
    deepEqual(actual, expected);

    var objects = [
        { Date: new Date(2000, 1, 1), Id: 1 },
        { Date: new Date(2010, 5, 5), Id: 2 },
        { Date: new Date(2000, 1, 1), Id: 3 }
    ]
    var actual = Enumerable.from(objects)
        .groupBy("$.Date", "$.Id",
            function (key, group) { return key.getFullYear() + "-" + group.toJoinedString(',') },
            function (key) { return key.toString() })
        .toArray();
    expected = ["2000-1,3", "2010-2"]
    deepEqual(actual, expected);
});

注：此处正则表达式中转义用两个斜杠 \\ 表示，用括号括起来的正则表达式匹配到的字符会单独提取出来返回。

正则中( )的作用：

(1). 在被修饰匹配次数的时候，括号中的表达式可以作为整体被修饰
(2). 取匹配结果的时候，括号中的表达式匹配到的内容可以被单独得到

 

"temp.xls".match(/\.(.+$)/) ——》结果：[".xls", "xls"]

"temp.xls".match(/(^.+)\..+$/)——》结果：["temp.xls", "temp"]

 

GroupBy四个参数的解释：

keySelector:键选择器,选出来的键作为groupby分组的依据。

elementSelector:值选择器

resultSelector:返回的结果选择器

compareSelector:比较对象选择器，定义keySelector选出来的键中groupby分组比较的方式