/* Answer to: "javascript map function" */
/*
<Array>.map() - One of the most useful in-built methods in JavaScript (imo).
The map() method creates a new array populated with the results of calling
a provided function on every element in the calling array.
For more information, click on the source link.
Let me make some examples of it's uses:
*/
let array = [1, 4, 9, 16];
array.map(num => num * 2); // [2, 8, 18, 32];
array.map(pounds => `£${pounds}.00`); // ["£1.00", "£4.00", "£9.00", "£16.00"];
array.map(item => Math.sqrt(item)); // [1, 2, 3, 4];
var arr = [
{ key: 'foo', val: 'bar' },
{ key: 'hello', val: 'world' }
];
var result = new Map(arr.map(i => [i.key, i.val]));
// When using TypeScript, need to specify type:
// var result = arr.map((i): [string, string] => [i.key, i.val])
// Unfortunately maps don't stringify well. This is the contents in array form.
console.log("Result is: " + JSON.stringify([...result]));
// Map {"foo" => "bar", "hello" => "world"}
Run code snippet
let numbers = [1, 2, 3, 4]
let filteredNumbers = numbers.map(function(_, index) {
if (index < 3) {
return num
}
})
// index goes from 0, so the filterNumbers are 1,2,3 and undefined.
// filteredNumbers is [1, 2, 3, undefined]
// numbers is still [1, 2, 3, 4]
// Map objects are collections of key-value pairs.
// A key in the Map may only occur once, it is unique in the Map 's collection
let map = new Map()
let keyArray = 'Array'
map.set(keyArray, [1, 2, 3, 4, 5])
map.get(keyArray) // 1, 2, 3, 4, 5
// make new array from edited items of another array
var newArray = unchangedArray.map(function(item, index){
return item; // do something to returned item
});
// same in ES6 style (IE not supported)
var newArray2 = unchangedArray.map((item, index) => item);
let arr = [1,2,3]
/*
map accepts a callback function, and each value of arr is passed to the
callback function. You define the callback function as you would a regular
function, you're just doing it inside the map function
map applies the code in the callback function to each value of arr,
and creates a new array based on your callback functions return values
*/
let mappedArr = arr.map(function(value){
return value + 1
})
// mappedArr is:
> [2,3,4]
var kvArray = [["clave1", "valor1"], ["clave2", "valor2"]];
// El constructor por defecto de Map para transforar un Array 2D (clave-valor) en un mapa
var miMapa = new Map(kvArray);
miMapa.get("clave1"); // devuelve "valor1"
// Usando la función Array.from para transformar el mapa a un Array 2D clave-valor.
console.log(Array.from(miMapa)); // Muestra exactamente el mismo Array que kvArray
// O usando los iteradores de claves o valores y convirtiendo a array.
console.log(Array.from(miMapa.keys())); // Muestra ["clave1", "clave2"]
function square(arr) {
const newArr = arr.map(x => x * x );
return newArr ;
//if you find this answer is useful ,
//upvote ⇑⇑ , so can the others benefit also . @mohammad alshraideh ( ͡~ ͜ʖ ͡°)
// use the map method on an array.
// define array
let scores = [10, 25, 30]
// use of map, we store the map method in to a variable called doubledScore
let doubledScore = scores.map(function(score) {
return score * 2 // returns every value of the array * 2
})
console.log(doubledScore) // [20, 50, 60]
//forEach vs. Map High Order Array Methods
const arr = [1,2,3]
const arr2 = [...arr,4,5]//see spread operator grepper answer for [...arr]
//the forEach doesn't return anything, it just loops through the array
arr2.forEach(function(item) {
console.log(item + ' of ' + arr2.length)
})
//map allows us to return an array and store it into a new array
const arr3 = arr2.map(function(item) {
//after performing some operation on all the objects of the array
//we can then return all those values into a new array
return item * 2
})
console.log(arr3)
const result = new Map();//create a new map
result.set('a', 1);
result.set('b', 2);
console.log(result);
const germany = {name: 'Germany' , population: 8000000};//create a new object
result.set(germany, '80m');//set the object to the map
console.log(result);
result.delete('a');//delete the key 'a'
console.log(result);
result.clear();//clear all the keys in the map
console.log(result);
let numbers = [1, 2, 3, 4]
let filteredNumbers = numbers.map(function(num, index) {
if (index < 3) {
return num
}
})
// index goes from 0, so the filterNumbers are 1,2,3 and undefined.
// filteredNumbers is [1, 2, 3, undefined]
// numbers is still [1, 2, 3, 4]