как отфильтровать объект массива, используя массив объектов

Question

У меня есть группа фильтрации js объект, подобный этому:

 let filter = {
generalFilter:[
    {key: "connected", value: true},
    {key: "connected", value: false}
],
locationFilter:[
    {key: "deviceLocation", value: "def"},
     {key: "deviceLocation", value: "abc"}
],
paymentMethodsFilter:[
    {key: "devicePaymentMethods", value: "ab"}
]

}

и основной массив, подобный этому:

const devices = [{
    deviceLocation: {
      label: "abc",
      value: "abc"
    },
    deviceName: "test7",
    devicePaymentMethods: [{
      label: "ab",
      value: "ab"
    }, {
      label: "cd",
      value: "cd"
    }, {
      label: "ef",
      value: "ef"
    }],
    deviceType: "iPad",
    id: "001",
    connected: true,
    enabled: true,
  },
  {
    deviceLocation: {
      label: "def",
      value: "def"
    },
    deviceName: "test4",
    devicePaymentMethods: [{
      label: "ab",
      value: "ab"
    }, {
      label: "cd",
      value: "cd"
    }],
    deviceType: "iPad",
    id: "004",
    connected: false,
    enabled: false,
  }
];

как я могу отфильтровать этот массив устройств, используя объект фильтра ? это то, что я пытался, но это не работает

devices.filter((device) => {
    let shouldKeep = new Array(3)
    shouldKeep.fill(0) //fills the array with 0, meaning no filter groups has passed yet
    for(let filterGroupIndex in filter) {// Loop through each filter group in filter
        let filterGroup = filter[filterGroupIndex]
        for(let filterObject in filterGroup) { //Loop through
            if(filterGroup[filterObject].key in device && device[filterGroup[filterObject].key] === filterGroup[filterObject].value) {
                shouldKeep[filterGroupIndex] = 1 //Set current filterGroup to 1, meaning it has passed the filter
                break; // At least one value in that filter group is true, skip to next filter group
            }
        }
    }

    if(shouldKeep.reduce((a,b) => a + b, 0) >= filter.length) {
        return true;
    }
    return false
})

иногда этот объект фильтра может быть пустым, когда он пуст, он должен возвращать полный массив без основного фильтра. Каков наилучший подход для этого? Я не уверен в этом, может быть, есть другое решение для этого. Пожалуйста, помогите мне

объект фильтра по умолчанию выглядит следующим образом

let filter = {
    generalFilter:[],
    locationFilter:[],
    paymentMethodsFilter:[]

    }

пользователь может добавить объект в этот массив фильтров, который я использую, например, перехватчики реагирования

 let filter = {
generalFilter:[
    {key: "connected", value: true},
    {key: "connected", value: false}
],
locationFilter:[],
        paymentMethodsFilter:[]}

тогда мы должны проверить оба подключенных: ложных и подключенных: истинно совпадают данные в основном массиве (если данные подключены: истинно в основном массиве, то он будет отображаться, а также если данные подключены: ложно будет отображаться)

для этого типа фильтра

let filter = {
generalFilter:[
    {key: "connected", value: true},
    {key: "connected", value: false}
],
locationFilter:[
    {key: "deviceLocation", value: "def"},
     {key: "deviceLocation", value: "abc"}
],
paymentMethodsFilter:[
    {key: "devicePaymentMethods", value: "ab"}
]

}

результат должен быть

result =[{
    deviceLocation: {
      label: "abc",
      value: "abc"
    },
    deviceName: "test7",
    devicePaymentMethods: [{
      label: "ab",
      value: "ab"
    }, {
      label: "cd",
      value: "cd"
    }, {
      label: "ef",
      value: "ef"
    }],
    deviceType: "iPad",
    id: "001",
    connected: true,
    enabled: true,
  },
  {
    deviceLocation: {
      label: "def",
      value: "def"
    },
    deviceName: "test4",
    devicePaymentMethods: [{
      label: "ab",
      value: "ab"
    }, {
      label: "cd",
      value: "cd"
    }],
    deviceType: "iPad",
    id: "004",
    connected: false,
    enabled: false,
  }
];

, потому что вы можете видеть в фильтре подключено: true и подключено: false и deviceLocation с def и ab c, а также devicePaymentMethods - ab

это означает, что я хочу, чтобы все устройства были подключены к true и подключены к false с местоположением ab c и def и paymetmethod ab

Answer 1

Проверьте комментарии для объяснения.

const filter = {
    generalFilter: [
        {key: "connected", value: true},
        {key: "connected", value: false}
    ],
    locationFilter: [
        {key: "deviceLocation", value: "def"},
        {key: "deviceLocation", value: "abc"}
    ],
    paymentMethodsFilter: [
        {key: "devicePaymentMethods", value: "ab"}
    ]
};

const parsedFilter = {};

/**
  converting filter into a hashmap with a filter as a Key and value as an 
  array of possible values.
  
  parsedFilter looks like this
 {"connected":[true,false],"deviceLocation":["def","abc"],"paymentOption":["ab"]}

  now we can easily check if any value is present in the filter.

   **/
const filterKeys = Object.keys(filter);

filterKeys.forEach((filterKey) => {
    if (Array.isArray(filter[filterKey])) {
        filter[filterKey].forEach((filterItem) => {
            if (Object.prototype.hasOwnProperty.call(parsedFilter, filterItem.key)) {
                parsedFilter[filterItem.key].push(filterItem.value);
            } else {
                parsedFilter[filterItem.key] = [filterItem.value];
            }
        });
    }
});


const devices = [
    {
        deviceLocation: {
            label: "abc",
            value: "abc"
        },
        deviceName: "test7",
        devicePaymentMethods: [
            {
                label: "ab",
                value: "ab"
            }, {
                label: "cd",
                value: "cd"
            }, {
                label: "ef",
                value: "ef"
            }],
        deviceType: "iPad",
        id: "001",
        connected: true,
        enabled: true,
    }
];

const result = [];

/**
  Looping through each device and check if that key is present in the 
  parsedFilter.
  
  if true: check for typeof value for that device key.
           if Object: then check if it is present in the array of not for the 
                      givem deviceKey in parsedFilter.
           if Array: then loop through each item and check if it is present 
                     in the parsedFilter for the given deviceKey
           if Number, string, boolean: Check if is present in the 
                      parsedFilter for the given deviceKey

  if false: simply add it to the result.
**/
if (Array.isArray(devices)) {
    devices.forEach((device) => {
        const keys = Object.keys(device);
        const resultDeviceObj = {};

        keys.forEach((key) => {
            if (Object.prototype.hasOwnProperty.call(parsedFilter, key)) {
                if (typeof device[key] === "object" && parsedFilter[key].includes(device[key].value)) {
                    resultDeviceObj[key] = device[key];
                } else if (Array.isArray(device[key])) {
                    const arrayResult = [];

                    device[key].forEach((item) => {
                        if (parsedFilter[key].includes(item.value)) {
                            arrayResult.push(item);
                        }
                    });

                    resultDeviceObj[key] = arrayResult;
                } else if(parsedFilter[key].includes(device[key])) {
                    resultDeviceObj[key] = device[key];
                }
            } else {
                resultDeviceObj[key] = device[key];
            }
        });

        result.push(resultDeviceObj);
    });
}

console.log("result", result);

Редактировать

const filter = {
    generalFilter: [{key: "connected", value: true}],
    locationFilter: [{key: "deviceLocation", value: "abcd"}],
    paymentMethodsFilter: [{key: "devicePaymentMethods", value: "ab"}]
};

const parsedFilter = {};

const filterKeys = Object.keys(filter);

filterKeys.forEach((filterKey) => {
    if (Array.isArray(filter[filterKey])) {
        filter[filterKey].forEach((filterItem) => {
            if (Object.prototype.hasOwnProperty.call(parsedFilter, filterItem.key)) {
                parsedFilter[filterItem.key][filterItem.value] = filterItem.value;
            } else {
                parsedFilter[filterItem.key] = {
                    [filterItem.value]: filterItem.value
                }
            }
        });
    }
});

//{"connected":{"true": true,"false": "false"},"deviceLocation":{"def": "def","abc": "abc"},"paymentOption":{"ab": "ab"}}
const devices = [{
    deviceLocation: {
        label: "abc",
        value: "abc"
    },
    deviceName: "test7",
    devicePaymentMethods: [{
        label: "ab",
        value: "ab"
    }, {
        label: "cd",
        value: "cd"
    }, {
        label: "ef",
        value: "ef"
    }],
    deviceType: "iPad",
    id: "001",
    connected: true,
    enabled: true,
},
    {
        deviceLocation: {
            label: "def",
            value: "def"
        },
        deviceName: "test4",
        devicePaymentMethods: [{
            label: "ab",
            value: "ab"
        }, {
            label: "cd",
            value: "cd"
        }],
        deviceType: "iPad",
        id: "004",
        connected: false,
        enabled: false,
    }
];

const result = [];

const isObject = function (a) {
    return a.constructor.toString().indexOf("Object") !== -1;
};

if (Array.isArray(devices)) {
    devices.forEach((device) => {
            const keys = Object.keys(device);
            let isValid = true;
            for (let i = 0; i < keys.length; i++) {
                const key = keys[i];

                if (Object.prototype.hasOwnProperty.call(parsedFilter, key)) {
                    if (isObject(device[key]) &&
                        !Object.prototype.hasOwnProperty.call(parsedFilter[key], device[key].value)) {
                        isValid = false;
                        break;
                    } else if (Array.isArray(device[key])) {
                        isValid = false;
                        for (let j = 0; j < device[key].length; j++) {
                            const item = device[key][j];
                            if (Object.prototype.hasOwnProperty.call(parsedFilter[key], item.value)) {
                                isValid = true;
                                break;
                            }
                        }

                        if (!isValid) {
                            break;
                        }
                    } else if (typeof device[key] === "boolean" &&
                        !Object.prototype.hasOwnProperty.call(parsedFilter[key], device[key])) {
                        isValid = false;
                        break;
                    }
                }
            }

            if (isValid) {
                result.push(device);
            }
        }
    );
}


console.log("result", result)

Answer 2

Можете ли вы объяснить больше, что вы пытаетесь сделать. Это очень непонятно из вашего вопроса.

В общем, вы бы сделали что-то подобное, если хотите фильтровать по местоположению устройства.

devices.filter(device=>device.deviceLocation.label==="abc")

Надеюсь, этот пример поможет вам разобраться с остальными.