Cara menggunakan javascript array map performance

Map is a collection of keyed data items, just like an

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

Methods and properties are:

• let john = { name: "John" };
  
  // for every user, let's store their visits count
  let visitsCountMap = new Map();
  
  // john is the key for the map
  visitsCountMap.set(john, 123);
  
  alert( visitsCountMap.get(john) ); // 123

  7 – creates the map.

• let john = { name: "John" };
  
  // for every user, let's store their visits count
  let visitsCountMap = new Map();
  
  // john is the key for the map
  visitsCountMap.set(john, 123);
  
  alert( visitsCountMap.get(john) ); // 123

  8 – stores the value by the key.

• let john = { name: "John" };
  
  // for every user, let's store their visits count
  let visitsCountMap = new Map();
  
  // john is the key for the map
  visitsCountMap.set(john, 123);
  
  alert( visitsCountMap.get(john) ); // 123

  9 – returns the value by the key,

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  0 if

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  1 doesn’t exist in map.

• let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  2 – returns

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  3 if the

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  1 exists,

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  5 otherwise.

• let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  6 – removes the element (the key/value pair) by the key.

• let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  7 – removes everything from the map.

• let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  8 – returns the current element count.

For instance:

let map = new Map();

map.set('1', 'str1');   // a string key
map.set(1, 'num1');     // a numeric key
map.set(true, 'bool1'); // a boolean key

// remember the regular Object? it would convert keys to string
// Map keeps the type, so these two are different:
alert( map.get(1)   ); // 'num1'
alert( map.get('1') ); // 'str1'

alert( map.size ); // 3

As we can see, unlike objects, keys are not converted to strings. Any type of key is possible.

let john = { name: "John" };
let ben = { name: "Ben" };

let visitsCountObj = {}; // try to use an object

visitsCountObj[ben] = 234; // try to use ben object as the key
visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced

// That's what got written!
alert( visitsCountObj["[object Object]"] ); // 123

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

Although

let john = { name: "John" };
let ben = { name: "Ben" };

let visitsCountObj = {}; // try to use an object

visitsCountObj[ben] = 234; // try to use ben object as the key
visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced

// That's what got written!
alert( visitsCountObj["[object Object]"] ); // 123

map.set('1', 'str1')
  .set(1, 'num1')
  .set(true, 'bool1');

map.set('1', 'str1')
  .set(1, 'num1')
  .set(true, 'bool1');

So we should use

map.set('1', 'str1')
  .set(1, 'num1')
  .set(true, 'bool1');

map.set('1', 'str1')
  .set(1, 'num1')
  .set(true, 'bool1');

map.set('1', 'str1')
  .set(1, 'num1')
  .set(true, 'bool1');

Map can also use objects as keys.

For instance:

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

Using objects as keys is one of the most notable and important

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

Let’s try:

let john = { name: "John" };
let ben = { name: "Ben" };

let visitsCountObj = {}; // try to use an object

visitsCountObj[ben] = 234; // try to use ben object as the key
visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced

// That's what got written!
alert( visitsCountObj["[object Object]"] ); // 123

As

let recipeMap = new Map([
  ['cucumber', 500],
  ['tomatoes', 350],
  ['onion',    50]
]);

// iterate over keys (vegetables)
for (let vegetable of recipeMap.keys()) {
  alert(vegetable); // cucumber, tomatoes, onion
}

// iterate over values (amounts)
for (let amount of recipeMap.values()) {
  alert(amount); // 500, 350, 50
}

// iterate over [key, value] entries
for (let entry of recipeMap) { // the same as of recipeMap.entries()
  alert(entry); // cucumber,500 (and so on)
}

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

let recipeMap = new Map([
  ['cucumber', 500],
  ['tomatoes', 350],
  ['onion',    50]
]);

// iterate over keys (vegetables)
for (let vegetable of recipeMap.keys()) {
  alert(vegetable); // cucumber, tomatoes, onion
}

// iterate over values (amounts)
for (let amount of recipeMap.values()) {
  alert(amount); // 500, 350, 50
}

// iterate over [key, value] entries
for (let entry of recipeMap) { // the same as of recipeMap.entries()
  alert(entry); // cucumber,500 (and so on)
}

let recipeMap = new Map([
  ['cucumber', 500],
  ['tomatoes', 350],
  ['onion',    50]
]);

// iterate over keys (vegetables)
for (let vegetable of recipeMap.keys()) {
  alert(vegetable); // cucumber, tomatoes, onion
}

// iterate over values (amounts)
for (let amount of recipeMap.values()) {
  alert(amount); // 500, 350, 50
}

// iterate over [key, value] entries
for (let entry of recipeMap) { // the same as of recipeMap.entries()
  alert(entry); // cucumber,500 (and so on)
}

let recipeMap = new Map([
  ['cucumber', 500],
  ['tomatoes', 350],
  ['onion',    50]
]);

// iterate over keys (vegetables)
for (let vegetable of recipeMap.keys()) {
  alert(vegetable); // cucumber, tomatoes, onion
}

// iterate over values (amounts)
for (let amount of recipeMap.values()) {
  alert(amount); // 500, 350, 50
}

// iterate over [key, value] entries
for (let entry of recipeMap) { // the same as of recipeMap.entries()
  alert(entry); // cucumber,500 (and so on)
}

How

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

To test keys for equivalence,

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

let recipeMap = new Map([
  ['cucumber', 500],
  ['tomatoes', 350],
  ['onion',    50]
]);

// iterate over keys (vegetables)
for (let vegetable of recipeMap.keys()) {
  alert(vegetable); // cucumber, tomatoes, onion
}

// iterate over values (amounts)
for (let amount of recipeMap.values()) {
  alert(amount); // 500, 350, 50
}

// iterate over [key, value] entries
for (let entry of recipeMap) { // the same as of recipeMap.entries()
  alert(entry); // cucumber,500 (and so on)
}

// runs the function for each (key, value) pair
recipeMap.forEach( (value, key, map) => {
  alert(`${key}: ${value}`); // cucumber: 500 etc
});

// runs the function for each (key, value) pair
recipeMap.forEach( (value, key, map) => {
  alert(`${key}: ${value}`); // cucumber: 500 etc
});

// runs the function for each (key, value) pair
recipeMap.forEach( (value, key, map) => {
  alert(`${key}: ${value}`); // cucumber: 500 etc
});

This algorithm can’t be changed or customized.

Chaining

Every

// runs the function for each (key, value) pair
recipeMap.forEach( (value, key, map) => {
  alert(`${key}: ${value}`); // cucumber: 500 etc
});

map.set('1', 'str1')
  .set(1, 'num1')
  .set(true, 'bool1');

For looping over a

map.set('1', 'str1')
  .set(1, 'num1')
  .set(true, 'bool1');

• // runs the function for each (key, value) pair
  recipeMap.forEach( (value, key, map) => {
    alert(`${key}: ${value}`); // cucumber: 500 etc
  });

  5 – returns an iterable for keys,

• // runs the function for each (key, value) pair
  recipeMap.forEach( (value, key, map) => {
    alert(`${key}: ${value}`); // cucumber: 500 etc
  });

  6 – returns an iterable for values,

• // runs the function for each (key, value) pair
  recipeMap.forEach( (value, key, map) => {
    alert(`${key}: ${value}`); // cucumber: 500 etc
  });

  7 – returns an iterable for entries

  // runs the function for each (key, value) pair
  recipeMap.forEach( (value, key, map) => {
    alert(`${key}: ${value}`); // cucumber: 500 etc
  });

  8, it’s used by default in

  // runs the function for each (key, value) pair
  recipeMap.forEach( (value, key, map) => {
    alert(`${key}: ${value}`); // cucumber: 500 etc
  });

  9.

For instance:

let recipeMap = new Map([
  ['cucumber', 500],
  ['tomatoes', 350],
  ['onion',    50]
]);

// iterate over keys (vegetables)
for (let vegetable of recipeMap.keys()) {
  alert(vegetable); // cucumber, tomatoes, onion
}

// iterate over values (amounts)
for (let amount of recipeMap.values()) {
  alert(amount); // 500, 350, 50
}

// iterate over [key, value] entries
for (let entry of recipeMap) { // the same as of recipeMap.entries()
  alert(entry); // cucumber,500 (and so on)
}

The insertion order is used

The iteration goes in the same order as the values were inserted.

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

Besides that,

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

// array of [key, value] pairs
let map = new Map([
  ['1',  'str1'],
  [1,    'num1'],
  [true, 'bool1']
]);

alert( map.get('1') ); // str1

// array of [key, value] pairs
let map = new Map([
  ['1',  'str1'],
  [1,    'num1'],
  [true, 'bool1']
]);

alert( map.get('1') ); // str1

// runs the function for each (key, value) pair
recipeMap.forEach( (value, key, map) => {
  alert(`${key}: ${value}`); // cucumber: 500 etc
});

When a

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

// array of [key, value] pairs
let map = new Map([
  ['1',  'str1'],
  [1,    'num1'],
  [true, 'bool1']
]);

alert( map.get('1') ); // str1

If we have a plain object, and we’d like to create a

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

So we can create a map from an object like this:

let obj = {
  name: "John",
  age: 30
};

let map = new Map(Object.entries(obj));

alert( map.get('name') ); // John

Here,

// array of [key, value] pairs
let map = new Map([
  ['1',  'str1'],
  [1,    'num1'],
  [true, 'bool1']
]);

alert( map.get('1') ); // str1

// array of [key, value] pairs
let map = new Map([
  ['1',  'str1'],
  [1,    'num1'],
  [true, 'bool1']
]);

alert( map.get('1') ); // str1

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

We’ve just seen how to create

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

let obj = {
  name: "John",
  age: 30
};

let map = new Map(Object.entries(obj));

alert( map.get('name') ); // John

There’s

let obj = {
  name: "John",
  age: 30
};

let map = new Map(Object.entries(obj));

alert( map.get('name') ); // John

// runs the function for each (key, value) pair
recipeMap.forEach( (value, key, map) => {
  alert(`${key}: ${value}`); // cucumber: 500 etc
});

let prices = Object.fromEntries([
  ['banana', 1],
  ['orange', 2],
  ['meat', 4]
]);

// now prices = { banana: 1, orange: 2, meat: 4 }

alert(prices.orange); // 2

We can use

let obj = {
  name: "John",
  age: 30
};

let map = new Map(Object.entries(obj));

alert( map.get('name') ); // John

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

E.g. we store the data in a

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

Here we go:

let map = new Map();
map.set('banana', 1);
map.set('orange', 2);
map.set('meat', 4);

let obj = Object.fromEntries(map.entries()); // make a plain object (*)

// done!
// obj = { banana: 1, orange: 2, meat: 4 }

alert(obj.orange); // 2

A call to

// runs the function for each (key, value) pair
recipeMap.forEach( (value, key, map) => {
  alert(`${key}: ${value}`); // cucumber: 500 etc
});

let obj = {
  name: "John",
  age: 30
};

let map = new Map(Object.entries(obj));

alert( map.get('name') ); // John

We could also make line

let obj = {
  name: "John",
  age: 30
};

let map = new Map(Object.entries(obj));

alert( map.get('name') ); // John

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

That’s the same, because

let obj = {
  name: "John",
  age: 30
};

let map = new Map(Object.entries(obj));

alert( map.get('name') ); // John

map.set('1', 'str1')
  .set(1, 'num1')
  .set(true, 'bool1');

// runs the function for each (key, value) pair
recipeMap.forEach( (value, key, map) => {
  alert(`${key}: ${value}`); // cucumber: 500 etc
});

map.set('1', 'str1')
  .set(1, 'num1')
  .set(true, 'bool1');

A

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

Its main methods are:

• let prices = Object.fromEntries([
    ['banana', 1],
    ['orange', 2],
    ['meat', 4]
  ]);
  
  // now prices = { banana: 1, orange: 2, meat: 4 }
  
  alert(prices.orange); // 2

  5 – creates the set, and if an

  let prices = Object.fromEntries([
    ['banana', 1],
    ['orange', 2],
    ['meat', 4]
  ]);
  
  // now prices = { banana: 1, orange: 2, meat: 4 }
  
  alert(prices.orange); // 2

  6 object is provided (usually an array), copies values from it into the set.

• let prices = Object.fromEntries([
    ['banana', 1],
    ['orange', 2],
    ['meat', 4]
  ]);
  
  // now prices = { banana: 1, orange: 2, meat: 4 }
  
  alert(prices.orange); // 2

  7 – adds a value, returns the set itself.

• let prices = Object.fromEntries([
    ['banana', 1],
    ['orange', 2],
    ['meat', 4]
  ]);
  
  // now prices = { banana: 1, orange: 2, meat: 4 }
  
  alert(prices.orange); // 2

  8 – removes the value, returns

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  3 if

  let map = new Map();
  map.set('banana', 1);
  map.set('orange', 2);
  map.set('meat', 4);
  
  let obj = Object.fromEntries(map.entries()); // make a plain object (*)
  
  // done!
  // obj = { banana: 1, orange: 2, meat: 4 }
  
  alert(obj.orange); // 2

  0 existed at the moment of the call, otherwise

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  5.

• let map = new Map();
  map.set('banana', 1);
  map.set('orange', 2);
  map.set('meat', 4);
  
  let obj = Object.fromEntries(map.entries()); // make a plain object (*)
  
  // done!
  // obj = { banana: 1, orange: 2, meat: 4 }
  
  alert(obj.orange); // 2

  2 – returns

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  3 if the value exists in the set, otherwise

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  5.

• let map = new Map();
  map.set('banana', 1);
  map.set('orange', 2);
  map.set('meat', 4);
  
  let obj = Object.fromEntries(map.entries()); // make a plain object (*)
  
  // done!
  // obj = { banana: 1, orange: 2, meat: 4 }
  
  alert(obj.orange); // 2

  5 – removes everything from the set.

• let map = new Map();
  map.set('banana', 1);
  map.set('orange', 2);
  map.set('meat', 4);
  
  let obj = Object.fromEntries(map.entries()); // make a plain object (*)
  
  // done!
  // obj = { banana: 1, orange: 2, meat: 4 }
  
  alert(obj.orange); // 2

  6 – is the elements count.

The main feature is that repeated calls of

let prices = Object.fromEntries([
  ['banana', 1],
  ['orange', 2],
  ['meat', 4]
]);

// now prices = { banana: 1, orange: 2, meat: 4 }

alert(prices.orange); // 2

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

For example, we have visitors coming, and we’d like to remember everyone. But repeated visits should not lead to duplicates. A visitor must be “counted” only once.

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

The alternative to

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

We can loop over a set either with

// runs the function for each (key, value) pair
recipeMap.forEach( (value, key, map) => {
  alert(`${key}: ${value}`); // cucumber: 500 etc
});

// array of [key, value] pairs
let map = new Map([
  ['1',  'str1'],
  [1,    'num1'],
  [true, 'bool1']
]);

alert( map.get('1') ); // str1

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

Note the funny thing. The callback function passed in

// array of [key, value] pairs
let map = new Map([
  ['1',  'str1'],
  [1,    'num1'],
  [true, 'bool1']
]);

alert( map.get('1') ); // str1

let map = new Map();
map.set('banana', 1);
map.set('orange', 2);
map.set('meat', 4);

let obj = Object.fromEntries(map.entries()); // make a plain object (*)

// done!
// obj = { banana: 1, orange: 2, meat: 4 }

alert(obj.orange); // 2

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

That’s for compatibility with

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

// array of [key, value] pairs
let map = new Map([
  ['1',  'str1'],
  [1,    'num1'],
  [true, 'bool1']
]);

alert( map.get('1') ); // str1

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

The same methods

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

• let john = { name: "John" };
  
  // for every user, let's store their visits count
  let visitsCountMap = new Map();
  
  // john is the key for the map
  visitsCountMap.set(john, 123);
  
  alert( visitsCountMap.get(john) ); // 123

  12 – returns an iterable object for values,

• let john = { name: "John" };
  
  // for every user, let's store their visits count
  let visitsCountMap = new Map();
  
  // john is the key for the map
  visitsCountMap.set(john, 123);
  
  alert( visitsCountMap.get(john) ); // 123

  13 – same as

  let john = { name: "John" };
  
  // for every user, let's store their visits count
  let visitsCountMap = new Map();
  
  // john is the key for the map
  visitsCountMap.set(john, 123);
  
  alert( visitsCountMap.get(john) ); // 123

  12, for compatibility with

  let john = { name: "John" };
  
  // for every user, let's store their visits count
  let visitsCountMap = new Map();
  
  // john is the key for the map
  visitsCountMap.set(john, 123);
  
  alert( visitsCountMap.get(john) ); // 123

  3,

• let john = { name: "John" };
  
  // for every user, let's store their visits count
  let visitsCountMap = new Map();
  
  // john is the key for the map
  visitsCountMap.set(john, 123);
  
  alert( visitsCountMap.get(john) ); // 123

  16 – returns an iterable object for entries

  let john = { name: "John" };
  
  // for every user, let's store their visits count
  let visitsCountMap = new Map();
  
  // john is the key for the map
  visitsCountMap.set(john, 123);
  
  alert( visitsCountMap.get(john) ); // 123

  17, exists for compatibility with

  let john = { name: "John" };
  
  // for every user, let's store their visits count
  let visitsCountMap = new Map();
  
  // john is the key for the map
  visitsCountMap.set(john, 123);
  
  alert( visitsCountMap.get(john) ); // 123

  3.

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

Methods and properties:

• let john = { name: "John" };
  
  // for every user, let's store their visits count
  let visitsCountMap = new Map();
  
  // john is the key for the map
  visitsCountMap.set(john, 123);
  
  alert( visitsCountMap.get(john) ); // 123

  20 – creates the map, with optional

  let prices = Object.fromEntries([
    ['banana', 1],
    ['orange', 2],
    ['meat', 4]
  ]);
  
  // now prices = { banana: 1, orange: 2, meat: 4 }
  
  alert(prices.orange); // 2

  6 (e.g. array) of

  let john = { name: "John" };
  
  // for every user, let's store their visits count
  let visitsCountMap = new Map();
  
  // john is the key for the map
  visitsCountMap.set(john, 123);
  
  alert( visitsCountMap.get(john) ); // 123

  22 pairs for initialization.

• let john = { name: "John" };
  
  // for every user, let's store their visits count
  let visitsCountMap = new Map();
  
  // john is the key for the map
  visitsCountMap.set(john, 123);
  
  alert( visitsCountMap.get(john) ); // 123

  8 – stores the value by the key, returns the map itself.

• let john = { name: "John" };
  
  // for every user, let's store their visits count
  let visitsCountMap = new Map();
  
  // john is the key for the map
  visitsCountMap.set(john, 123);
  
  alert( visitsCountMap.get(john) ); // 123

  9 – returns the value by the key,

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  0 if

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  1 doesn’t exist in map.

• let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  2 – returns

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  3 if the

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  1 exists,

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  5 otherwise.

• let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  6 – removes the element by the key, returns

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  3 if

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  1 existed at the moment of the call, otherwise

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  5.

• let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  7 – removes everything from the map.

• let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  8 – returns the current element count.

The differences from a regular

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

• Any keys, objects can be keys.
• Additional convenient methods, the

  let john = { name: "John" };
  
  // for every user, let's store their visits count
  let visitsCountMap = new Map();
  
  // john is the key for the map
  visitsCountMap.set(john, 123);
  
  alert( visitsCountMap.get(john) ); // 123

  38 property.

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

Methods and properties:

• let prices = Object.fromEntries([
    ['banana', 1],
    ['orange', 2],
    ['meat', 4]
  ]);
  
  // now prices = { banana: 1, orange: 2, meat: 4 }
  
  alert(prices.orange); // 2

  5 – creates the set, with optional

  let prices = Object.fromEntries([
    ['banana', 1],
    ['orange', 2],
    ['meat', 4]
  ]);
  
  // now prices = { banana: 1, orange: 2, meat: 4 }
  
  alert(prices.orange); // 2

  6 (e.g. array) of values for initialization.

• let prices = Object.fromEntries([
    ['banana', 1],
    ['orange', 2],
    ['meat', 4]
  ]);
  
  // now prices = { banana: 1, orange: 2, meat: 4 }
  
  alert(prices.orange); // 2

  7 – adds a value (does nothing if

  let map = new Map();
  map.set('banana', 1);
  map.set('orange', 2);
  map.set('meat', 4);
  
  let obj = Object.fromEntries(map.entries()); // make a plain object (*)
  
  // done!
  // obj = { banana: 1, orange: 2, meat: 4 }
  
  alert(obj.orange); // 2

  0 exists), returns the set itself.

• let prices = Object.fromEntries([
    ['banana', 1],
    ['orange', 2],
    ['meat', 4]
  ]);
  
  // now prices = { banana: 1, orange: 2, meat: 4 }
  
  alert(prices.orange); // 2

  8 – removes the value, returns

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  3 if

  let map = new Map();
  map.set('banana', 1);
  map.set('orange', 2);
  map.set('meat', 4);
  
  let obj = Object.fromEntries(map.entries()); // make a plain object (*)
  
  // done!
  // obj = { banana: 1, orange: 2, meat: 4 }
  
  alert(obj.orange); // 2

  0 existed at the moment of the call, otherwise

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  5.

• let map = new Map();
  map.set('banana', 1);
  map.set('orange', 2);
  map.set('meat', 4);
  
  let obj = Object.fromEntries(map.entries()); // make a plain object (*)
  
  // done!
  // obj = { banana: 1, orange: 2, meat: 4 }
  
  alert(obj.orange); // 2

  2 – returns

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  3 if the value exists in the set, otherwise

  let john = { name: "John" };
  let ben = { name: "Ben" };
  
  let visitsCountObj = {}; // try to use an object
  
  visitsCountObj[ben] = 234; // try to use ben object as the key
  visitsCountObj[john] = 123; // try to use john object as the key, ben object will get replaced
  
  // That's what got written!
  alert( visitsCountObj["[object Object]"] ); // 123

  5.

• let map = new Map();
  map.set('banana', 1);
  map.set('orange', 2);
  map.set('meat', 4);
  
  let obj = Object.fromEntries(map.entries()); // make a plain object (*)
  
  // done!
  // obj = { banana: 1, orange: 2, meat: 4 }
  
  alert(obj.orange); // 2

  5 – removes everything from the set.

• let map = new Map();
  map.set('banana', 1);
  map.set('orange', 2);
  map.set('meat', 4);
  
  let obj = Object.fromEntries(map.entries()); // make a plain object (*)
  
  // done!
  // obj = { banana: 1, orange: 2, meat: 4 }
  
  alert(obj.orange); // 2

  6 – is the elements count.

Iteration over

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123

let john = { name: "John" };

// for every user, let's store their visits count
let visitsCountMap = new Map();

// john is the key for the map
visitsCountMap.set(john, 123);

alert( visitsCountMap.get(john) ); // 123