In JavaScript, you can convert a dictionary (object) to an array using various methods. 

Here are a few examples to map a dictionary to an array:

Using for..in Loop

const users = {
  John: {
    height: 187,
    age: 32,
  },
  Peter: {
    height: 181,
    age: 24,
  },
};

const newArray = [];
for (const key in users) {
  newArray.push({key: key, ...users[key]});
}

console.log(newArray);

outputs

[
  { key: 'John', height: 187, age: 32 },
  { key: 'Peter', height: 181, age: 24 }
]

Using Object.entries() and Array.reduce()

Use Object.entires() to return an array of object key pairs and Array.reduce() to map dictionary values to array.

let arr = Object.entries(users).reduce((acc, [key, value]) => {
    acc.push({key: key, ...value})
    return acc
}, []);

console.log(arr);

Using Object.values() 

If you are only interested in the values and don't need the keys, you can directly use the Object.values() method to map dictionary to array.

const newArray = Object.values(users);
console.log(newArray); // [ { height: 187, age: 32 }, { height: 181, age: 24 } ]

There are no dictionaries in JavaScript, only objects

JavaScript doesn't have a built-in data structure specifically called a dictionary. However, JavaScript objects behave similarly to dictionaries in other programming languages. An object in JavaScript can be used as a key-value store, where keys are unique strings, and values can be of any type.

Javascript Object data structure is different from Map

JavaScript objects and the Map data structure serves a similar purpose, which is to store key-value pairs. However, there are some differences between the two that make them suited for different scenarios:

  Object Map
Key type Keys are automatically converted to strings. This means that if you use non-string keys, they will be converted to strings. For example, 42 and true will both be converted to strings '42' and 'true'

Keys can be of any data type, including objects, functions, and primitive values. They retain their original data types as keys.
Order of Keys While modern JavaScript engines do maintain the insertion order of keys in objects, this behavior wasn't guaranteed in older versions of the language.

The Map data structure guarantees the order of keys based on their insertion sequence, making it suitable for cases where order matters.
Iterating Keys Iterating through keys in an object might not follow a specific order. In practice, most engines maintain insertion order, but this behavior wasn't standardized until ECMAScript 2015 (ES6).

The Map structure allows for easy and predictable iteration through its keys in the order they were inserted.
Size Property There is no direct way to get the number of properties in an object. You have to manually iterate through the keys to count them.

The size property of a Map allows you to directly retrieve the number of key-value pairs it contains.
Performance and Memory For small-scale key-value storage, objects are generally more memory-efficient and faster to access.

For larger-scale key-value storage or when dealing with non-string keys or maintaining order, Map can offer better performance and memory management.
Use Cases Objects are often used for simple key-value storage, especially when dealing with string keys and when the order of insertion doesn't matter.

Maps are useful when order matters, when you need to store keys of different data types, or when you want to maintain a more predictable and robust key-value storage structure.

Here is an example of using Object vs Map

// Using an object
const object = {};
object['42'] = 'value1';
object[true] = 'value2';

// Using a Map
const map = new Map();
map.set('42', 'value1');
map.set(true, 'value2');

console.log(object['42']); // 'value1'
console.log(object[true]); // 'value2'

console.log(map.get('42')); // 'value1'
console.log(map.get(true)); // 'value2'

In summary, JavaScript objects can be used as dictionaries, and the Map data structure provides more advanced key-value mapping capabilities.