智能数组过滤JS

Question

我有一个非常有趣的任务要做，但最终得到了一个糟糕的代码。 它改变了我想避免的初始数组。

这是一个数组示例：

[
{
ID: "some id",
NAME: "some name",
PROPERTIES:
    [
        {
            TYPE: [{UF_NAME: "some type name"}]
        },
        {
            OTHER_TYPE:
                [
                    {UF_NAME: "some other type name"},
                    {UF_NAME: "some other type name"},
                ]
        },
        ...
    ],
...
OFFERS:
    [
        {
            ID: "some id",
            NAME: "some name",
            PROPERTIES:
                [
                    {
                        SIZE: [{UF_NAME: "some type name"}]
                    },
                    {
                        COLOR:
                            [
                                {UF_NAME: "some color 1"},
                                {UF_NAME: "some color 2"},
                            ]
                    },
                    ...
                ],
        },
        {
            ID: "some id",
            NAME: "some name",
            PROPERTIES:
                [

                ]
        },
        ...
    ]
},
...

]

这是我将要在不改变初始数组的情况下实现的结果：

[
{
ID: "some id",
NAME: "some name",
PROPERTIES:
    [
        {
            TYPE: [{UF_NAME: "some type name"}]
        },
        {
            OTHER_TYPE:
                [
                    {UF_NAME: "some other type name"},
                    {UF_NAME: "some other type name"},
                ]
        },
        ...
    ],
...
OFFERS:
    [
        {
            ID: "some id",
            NAME: "some name",
            PROPERTIES:
                [
                    {
                        SIZE: [{UF_NAME: "some type name"}]
                    },
                    {
                        COLOR:
                            [
                                {UF_NAME: "some color 1"},
                                {UF_NAME: "some color 2"},
                            ]
                    },
                    ...
                ],
        }
    ]
}

]

过滤器应该做什么：

1. 在对象属性中遍历整个数组搜索值并提供属性
2. 返回带有过滤优惠的初始数组的新副本

数组结构：

产品 1 -- 优惠 11 -- 优惠 12 -- 优惠 13

产品 2 -- 优惠 21 -- 优惠 22 -- 优惠 23

产品 3 -- 优惠 31 -- 优惠 32 -- 优惠 33

过滤后的数组结构：

产品 1 -- 报价 11

产品 2 -- 报价 23

产品 3 -- 报价 31

这是我的功能：

function filter (array, filter) {
        return array.filter(function iter(o) {
            return Object.keys(o).some(function (k) {
                if (typeof o[k] === 'string' && o[k].indexOf(filter) !== -1) {
                    return true
                }
                if (Array.isArray(o[k])) {
                    o[k] = o[k].filter(iter)
                    return o[k].length
                }
            })
        })
    }

Answer 1

您需要重写代码以避免使用嵌套过滤器和重新分配属性来进行拟合。

如果找到想要的属性，此函数会减少数组并检查属性，将新属性添加到临时对象并稍后推送到结果集。

嵌套数组也是如此，由于可能的嵌套结构，它们也会减少。

function filter(array, filter) {
    return array.reduce(function iter(r, o) {
        var temp = {};

        Object.keys(o).forEach(function (k) {
            if (typeof o[k] === 'string' && o[k].indexOf(filter) !== -1) {
                temp[k] = o[k];
            } else if (Array.isArray(o[k])) {
                var filtered = o[k].reduce(iter, []);
                if (filtered.length) temp[k] = filtered;
            }
        });

        if (Object.keys(temp).length) r.push(temp);

        return r;
    }, []);
}