How to use Map/Set to improve the code to O(n)?

Maybe I should use Map/Set, but I can not work it out...

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

let items = [
  {type: 'a', name: 'a1', color: 'yellow'},
  {type: 'b', name: 'b1', color: 'orange'}
];
const excludes = [
  {k: 'color', value: 'yellow'},
  {k: 'name', value: 'x'}
];

excludes.forEach((exclude) => {
  items = items.filter((item) => item[exclude.k] !== exclude.value)
})

console.log(items)

<!-- end snippet -->

You cannot avoid to read the input at least. That already costs O(n). So you need to check if an element needs to be excluded in O(1).

The data structure that comes in mind that could do that (at least in most cases) is a Hash-Map/-Set.

P.s.
I'm not 100% sure what Alexandre Fenyo wants to point out in his comments, but I agree that a Hash-Map/-Set cannot guarantee O(1) for lookup and insert because of possible collisions.
To minimize collisions the Hash-Map/-Set needs to be of adequate size (or have a relative cheap way to grow its internal structure) and the hash-function used must not create too many collisions because of its design.
For further details wikipedia hash-table .
For good implementations you get O(1) in most cases, that is what I mean with "in most cases" in my answer above.

O(n) means linear complexity. Here is an example code that does it in a linear complexity and checks all the keys of items.

You can use a Set to index excludes for each key to reduce filtering complexity to O(1). Below is an example code for O(n) + O(m) =~ O(n)

const items = [
  { type: "a", name: "a1", color: "yellow" },
  { type: "b", name: "b1", color: "orange" },
];
const excludes = [
  { k: "color", value: "yellow" },
  { k: "name", value: "x" },
];


const excludeIndex = { type: new Set(), name: new Set(), color: new Set() };

// Populate Exclude Index: O(m)
excludes.forEach((exclude) => excludeIndex[exclude.k].add(exclude.value));

// Filter Items: O(n)
const result = items.filter(
  (item) => !excludeIndex.type.has(item.type) && !excludeIndex.name.has(item.name) && !excludeIndex.color.has(item.color),
);

console.log(result);

Normally, we should use a variable for storing index keys and iterate them to make the code more flexible. However, iterating index keys may confuse reviewers about the complexity. The number of keys is constant (or negligible) and does not affect complexity.