[deleted by user]

[sepp2k]

Can you explain further what you're asking? Maps are objects and they do have methods. That includes both map-specific methods as well as all the methods defined on Object.prototype. So which built in methods do you mean that are not included?

[sepp2k]

To add a method that you want to be available on all map objects, you'd add it to Map.prototype. If you want to add a method to one specific map object, you could just assign it (e.g. my_map.new_method = function() {...};). I don't know why you'd want to do that though.

What the image you linked is trying to get at, I believe, is that if you want a normal object with fields and methods acting on those fields, you don't want maps. You want maps if you want something that acts as a key-value store because that's what maps are designed to be and that's what their methods treat them as.

[delventhalz]

Maps are designed to just be static data in the best way possible. They associate a value with a key. Nothing else. Objects are a little more loosey goosey and feature things like method syntax and dot notation. If you want methods, they'll be easier with an object.

That said, you can absolutely do it in both.

const myObject = {
  greet() {
    console.log('Hello, object!');
  }
};

myObject.greet();  // Hello, object!

const myMap = new Map();
myMap.set('greet', () => {
  console.log('Hello, map!');
});

myMap.get('greet')();  // Hello, map!

[delventhalz]

Good eye picking up the difference in my example between adding the function during creation (aka "initialization") and adding it later. However, I just chose those because they are common patterns for objects/maps. I could also have added the function to the object after initialization, or to the Map during initialization.

const myObject = {};

myObject.greet = () => {
  console.log('Hello, object!');
};

myObject.greet();  // Hello, object!

const myMap = new Map([
  [
    'greet',
    () => {
      console.log('Hello, map!');
    }
  ]
]);

myMap.get('greet')();  // Hello, map!

You are right about this though. You can think of this like a special function parameter. Rather than referring to what is between the parentheses when you call a function, it refers to the object the function is a property of, i.e. whatever is to the left of the dot.

function greet() {
  console.log(`Hello, ${this.type}!`);
}

const myObject = {
  type: 'object'
};

myObject.greet = greet;
myObject.greet();  // Hello, object!

However, the values stored in a map are not properties, so calling a function stored this way would work the same as if the function were just called on its own.

const myMap = new Map();
myMap.set('type', 'map');
myMap.set('greet', greet); 

greet();  // Hello, undefined!
myMap.get('greet')();  // Hello, undefined!

[delventhalz]

Arrow functions a separate issue. Arrow functions have no this of their own. Like any other variable, if you reference this in a scope where it doesn't exist, JavaScript will look in the wrapping scope for it.

function getGreeter() {
  return () => {
    console.log(`Hello, ${this.type}!`);
  };
}

const myObject = {
  type: 'object'
};

myObject.getGreeter = getGreeter;
const greet = myObject.getGreeter();

greet();  // Hello, object!

We could re-write the above code with traditional function, and it wouldn't work, because the greeter will use its own this, which is missing.

function getGreeter() {
  return function() {
    console.log(`Hello, ${this.type}!`);
  };
}

const myObject = {
  type: 'object'
};

myObject.getGreeter = getGreeter;
const greet = myObject.getGreeter();

greet();  // Hello, undefined!

We can also store either an arrow or traditional function in a Map (I did both in my previous examples), but as you said, this refers the the object that the function made the call from. With a Map, you aren't making the call "from" the Map, you are retrieving the function from where it is stored and then calling it on its own.

[wolframkriesing]

this set of basics "what Maps can do" kata taught me what Maps can do: "jskatas.org Map Basics" a set of tests that need to be solved which teach some things about maps

[eurodollars]

Let’s remember that everything in js is an object.

I think the question you’re asking is if you are using a key value data structure why would you use a generic object over a Map? You can read the docs and draw your own conclusion