As covered briefly by MDN, Map has a number of technical benefits — while a simple Array or an Object may suffice for simple data structures, oftentimes the increasing complexity of modern web development justifies using something else.

Let's look at a few specific examples:

The keys of a Map can be anything

In both modern libraries as well as webapps, memoization is often used to cut down performance costs of repetitive operations. Briefly, memoization is the act of storing the output of a given function for given inputs after the first run.
Maps are a great candidate for storing this data, since you can use them regardless of what you want to index by.

Show code snippet

const cache = new Map();
const input = [2, 3, 2]; // Assuming this is immutable for simplicity

function expensive(n, ...args) {
  if (!args.length) return n;
  return Math.pow(n, expensive(...args));
}

function memoExpensive(arr) {
  const memoResult = cache.get(arr);
  if (memoResult) {
    console.log('used memo', memoResult);
    return memoResult;
  }
  const result = expensive(...arr);
  console.log('calculated', result);
  cache.set(arr, result);
  return result;
}

memoExpensive(input);
memoExpensive(input);

There are cases where you could also use a Symbol and a regular Object, but a Map is more universal in this regard.

Map keys are ordered

For a regular Object, keys are partially ordered (since ECMAScript 2015, before that it was a bit iffy on different engines). Keys keep their order only for string and Symbol keys, while numerical keys are sorted.
When adding keys to an Object in the order c, b, a, 3, 2, 1, the stored order will be 1, 2, 3, c, b, a, for example.

Show code snippet

const obj = {};
obj.c = 1;
obj.b = 2;
obj.a = 3;
obj[3] = 4;
obj[2] = 5;
obj[1] = 6;
console.log(Object.keys(obj));

A Map will keep the order of the inserted keys regardless of their type.

Show code snippet

const map = new Map();
map.set('c', 1);
map.set('b', 2);
map.set('a', 3);
map.set(3, 4);
map.set(2, 5);
map.set(1, 6);
console.log(Array.from(map.keys()));

Oftentimes this won't matter, especially in casual web dev, but there are numerous notorious cases when the order of the keys does matter.

Map is iterable

While an Array, as brought up in the question, is also iterable, a Map offers a better use-case for key-value mappings than an Object would. Being iterable has a number of benefits, just-in-time execution and guaranteed order being two examples.

Show code snippet

const map = new Map()
map.set(document.body, 'blue')
map.set(document.documentElement, 'green')

for (let pair of map) {
  console.log(pair);
}

Other benefits

There are numerous other benefits why you might pick a Map over other alternatives, like performance as covered by Asthmatic, avoiding Object prototype issues, convenience etc.

Hopefully this generic overview has covered most questions you had.

Well first of all, it's not a fair comparison. As you said, the proper javascript map is able to use objects, not just arrays. So you are basically comparing two completely different functions with different algorithms/results/inner workings.

Of course the proper javascript map is slower - it is designed to work over a larger domain than a simple for over an array.

It's true that object lookup occurs in constant time - O(1) - so using object properties instead of an array is one option, but if you're just trying to check whether a value is included in a collection, it would be more appropriate to use a Set, which is a (generally unordered) collection of values, which can also be looked up in linear time. (Using a plain object instead would require you to have values in addition to your keys, which you don't care about - so, use a Set instead.)

const set = new Set(['foo', 'bar']);
console.log(set.has('foo'));
console.log(set.has('baz'));

This will be useful when you have to look up multiple values for the same Set. But, adding items to the Set (just like adding properties to an object) is O(N), so if you're just going to look up a single value, once, there's no benefit to this nor the object technique, and you may as well just use an array includes test.

Thanks to the comments I know now:

Array.find() is similar iterating/looping through an array and that means, it is slower then using get(), which is not a loop.

So if I want to search only one time in this array, find() should be enough. If I want to find multiple elements in that array. It makes sense to generate a Map from that array.

PS: The amount of 10 was an example. I just wanted to know what generally is faster.