У меня есть объект:
myObject = { 'a': 1, 'b': 2, 'c': 3 }
Я ищу собственный метод, похожий на Array.prototype.map, который будет использоваться следующим образом:
newObject = myObject.map(function (value, label) {
return value * value;
});
// newObject is now { 'a': 1, 'b': 4, 'c': 9 }
Есть ли у JavaScript такая функция map для объектов? (Я хочу это для Node.JS, поэтому мне не нужны проблемы с перекрестным браузером.)
Для объекта Object нет нативного map, но как насчет этого:
var myObject = { 'a': 1, 'b': 2, 'c': 3 };
Object.keys(myObject).map(function(key, index) {
myObject[key] *= 2;
});
console.log(myObject);
// => { 'a': 2, 'b': 4, 'c': 6 }Как насчет одной строки с немедленным назначением переменной в простом JS (ES6/ES2015)?
Использование оператора распространения и вычисляемого имени ключа синтаксиса:
let newObj = Object.assign({}, ...Object.keys(obj).map(k => ({[k]: obj[k] * obj[k]})));
Другая версия, использующая уменьшение:
let newObj = Object.keys(obj).reduce((p, c) => ({...p, [c]: obj[c] * obj[c]}), {});
Первый пример как функция:
const oMap = (o, f) => Object.assign({}, ...Object.keys(o).map(k => ({ [k]: f(o[k]) })));
// To square each value you can call it like this:
let mappedObj = oMap(myObj, (x) => x * x);
Если вы хотите отобразить вложенный объект рекурсивно в функциональном стиле, это можно сделать так:
const sqrObjRecursive = obj =>
Object.keys(obj).reduce(
(newObj, key) =>
obj[key] && typeof obj[key] === "object"
? { ...newObj, [key]: sqrObjRecursive(obj[key]) } // recurse.
: { ...newObj, [key]: obj[key] * obj[key] }, // square val.
{}
);
Или, что более важно, вот так:
const sqrObjRecursive = obj => {
Object.keys(obj).forEach(key => {
if (typeof obj[key] === "object") obj[key] = sqrObjRecursive(obj[key]);
else obj[key] = obj[key] * obj[key];
});
return obj;
};
Начиная с ES7/ES2016 вы можете использовать Object.entries() вместо Object.keys(), например. как это:
let newObj = Object.assign(...Object.entries(obj).map(([k, v]) => ({[k]: v * v})));
ES2019 может представить Object.fromEntries(), что еще больше упрощает это:
let newObj = Object.fromEntries(Object.entries(([key, val]) => [k, v * v]));
В некоторых редких случаях вам может понадобиться отобразить объект класса, который содержит свойства унаследованного объекта в его цепочке прототипов. В таких случаях Object.keys() не будет работать, потому что Object.keys() не перечисляет унаследованные свойства. Если вам нужно отобразить унаследованные свойства, вы должны использовать for (key in myObj) {...}.
Вот пример объекта, который наследует свойства другого объекта и как Object.keys() не работает в таком сценарии.
const obj1 = { 'a': 1, 'b': 2, 'c': 3}
const obj2 = Object.create(obj1); // One of multiple ways to inherit an object in JS.
// Here you see how the properties of obj1 sit on the 'prototype' of obj2
console.log(obj2) // Prints: obj2.__proto__ = { 'a': 1, 'b': 2, 'c': 3}
console.log(Object.keys(obj2)); // Prints: an empty Array.
for (key in obj2) {
console.log(key); // Prints: 'a', 'b', 'c'
}
Однако, пожалуйста, сделайте мне одолжение и избегайте наследования. :-)
Нет встроенных методов, но lodash # mapValues будет выполнять работу блестяще
_.mapValues({ 'a': 1, 'b': 2, 'c': 3} , function(num) { return num * 3; });
// → { 'a': 3, 'b': 6, 'c': 9 }
Очень легко написать один:
Object.map = function(o, f, ctx) {
ctx = ctx || this;
var result = {};
Object.keys(o).forEach(function(k) {
result[k] = f.call(ctx, o[k], k, o);
});
return result;
}
с примером кода:
> o = { a: 1, b: 2, c: 3 };
> r = Object.map(o, function(v, k, o) {
return v * v;
});
> r
{ a : 1, b: 4, c: 9 }
NB: эта версия также позволяет (необязательно) установить контекст this для обратного вызова, как и метод Array.
EDIT - изменено, чтобы удалить использование Object.prototype, чтобы убедиться, что он не сталкивается с любым существующим свойством с именем map на объекте.
Вы можете использовать Object.keys, а затем forEach по возвращенному массиву ключей:
var myObject = { 'a': 1, 'b': 2, 'c': 3 },
newObject = {};
Object.keys(myObject).forEach(function (key) {
var value = myObject[key];
newObject[key] = value * value;
});
Или более модульным способом:
function map(obj, callback) {
var result = {};
Object.keys(obj).forEach(function (key) {
result[key] = callback.call(obj, obj[key], key, obj);
});
return result;
}
newObject = map(myObject, function(x) { return x * x; });
Обратите внимание, что Object.keys возвращает массив, содержащий только собственные свойства перечисления объекта, поэтому он ведет себя как цикл for..in с проверкой hasOwnProperty.
Это прям бразильцы, и все в сообществе JS знают это. Должна быть эта функциональность:
const obj1 = {a:4, b:7};
const obj2 = Object.map(obj1, (k,v) => v + 5);
console.log(obj1); // {a:4, b:7}
console.log(obj2); // {a:9, b:12}
вот наивная реализация:
Object.map = function(obj, fn, ctx){
const ret = {};
for(let k of Object.keys(obj)){
ret[k] = fn.call(ctx || null, k, obj[k]);
});
return ret;
};
это очень раздражает, когда приходится все время реализовывать самостоятельно;)
Если вы хотите что-то более сложное, не мешающее классу Object, попробуйте следующее:
let map = function (obj, fn, ctx) {
return Object.keys(obj).reduce((a, b) => {
a[b] = fn.call(ctx || null, b, obj[b]);
return a;
}, {});
};
const x = map({a: 2, b: 4}, (k,v) => {
return v*2;
});
но безопасно добавить эту функцию карты в Object, просто не добавляйте в Object.prototype.
Object.map = ... // fairly safe
Object.prototype.map ... // not ok
Я пришел сюда, чтобы найти и ответить за сопоставление объекта с массивом и получить эту страницу в результате. В случае, если вы пришли сюда, ища тот же ответ, что и я, вот как вы можете сопоставить и возразить массиву.
Вы можете использовать карту для возврата нового массива из объекта следующим образом:
var newObject = Object.keys(myObject).map(function(key) {
return myObject[key];
});
Принятый ответ имеет два недостатка:
Array.prototype.reduce, потому что сокращение означает изменение структуры составного типа, чего в этом случае не происходит.Обратите внимание, что все функции определены в карри.
// small, reusable auxiliary functions
const keys = o => Object.keys(o);
const assign = (...o) => Object.assign({}, ...o);
const map = f => xs => xs.map(x => f(x));
const mul = y => x => x * y;
const sqr = x => mul(x) (x);
// the actual map function
const omap = f => o => {
o = assign(o); // A
map(x => o[x] = f(o[x])) (keys(o)); // B
return o;
};
// mock data
const o = {"a":1, "b":2, "c":3};
// and run
console.log(omap(sqr) (o));
console.log(omap(mul(10)) (o)); JavaScript только что получил новый метод Object.fromEntries.
function mapObject (obj, fn) {
return Object.fromEntries(
Object
.entries(obj)
.map(fn)
)
}
const myObject = { a: 1, b: 2, c: 3 }
const myNewObject = mapObject(myObject, ([key, value]) => ([key, value * value]))
console.log(myNewObject)Для максимальной производительности.
Если ваш объект не изменяется часто, но его нужно повторять часто, я предлагаю использовать собственную карту в качестве кеша.
// example object
var obj = {a: 1, b: 2, c: 'something'};
// caching map
var objMap = new Map(Object.entries(obj));
// fast iteration on Map object
objMap.forEach((item, key) => {
// do something with an item
console.log(key, item);
});Минимальная версия (es6):
Object.entries(obj).reduce((a, [k, v]) => (a[k] = v * v, a), {})
Вы можете использовать метод map и forEach для массивов, но если вы хотите использовать его для Object вы можете использовать его с твистом, как показано ниже:
Использование Javascript (ES6)
var obj = { 'a': 2, 'b': 4, 'c': 6 };
Object.entries(obj).map( v => obj[v[0]] *= v[1] );
console.log(obj); //it will log as {a: 4, b: 16, c: 36}
var obj2 = { 'a': 4, 'b': 8, 'c': 10 };
Object.entries(obj2).forEach( v => obj2[v[0]] *= v[1] );
console.log(obj2); //it will log as {a: 16, b: 64, c: 100}
Использование jQuery
var ob = { 'a': 2, 'b': 4, 'c': 6 };
$.map(ob, function (val, key) {
ob[key] *= val;
});
console.log(ob) //it will log as {a: 4, b: 16, c: 36}
Или вы можете использовать другие циклы, такие как метод $.each как $.each ниже:
$.each(ob,function (key, value) {
ob[key] *= value;
});
console.log(ob) //it will also log as {a: 4, b: 16, c: 36}
РЕДАКТИРОВАТЬ: канонический способ использования новых функций JavaScript это -
const identity = x =>
x
const omap = (f = identity, o = {}) =>
Object.fromEntries(
Object.entries(o).map(([ k, v ]) =>
[ k, f(v) ]
)
)
Где o - некоторый объект, а f - ваша функция отображения. Или мы могли бы сказать, что, учитывая функцию из a → b и объект со значениями типа a, производим объект со значениями типа b. Как подпись псевдотипа -
// omap : (a -> b, { a }) -> { b }
Первоначальный ответ был написан для демонстрации мощного комбинатора mapReduce который позволяет нам думать о нашем преобразовании по-другому.
m, функция отображения - дает вам возможность преобразовать входящий элемент, прежде чем...r, функция сокращения - эта функция объединяет аккумулятор с результатом сопоставленного элемента Интуитивно mapReduce, что mapReduce создает новый редуктор, который мы можем подключить непосредственно к Array.prototype.reduce. Но что еще более важно, мы можем реализовать нашу реализацию объектного функтора omap просто, используя объект Object.assign, Object.assign и {}.
const identity = x =>
x
const mapReduce = (m, r) =>
(a, x) => r (a, m (x))
const omap = (f = identity, o = {}) =>
Object
.keys (o)
.reduce
( mapReduce
( k => ({ [k]: f (o[k]) })
, Object.assign
)
, {}
)
const square = x =>
x * x
const data =
{ a : 1, b : 2, c : 3 }
console .log (omap (square, data))
// { a : 1, b : 4, c : 9 } map function не существует на Object.prototype, однако вы можете эмулировать его так:
var myMap = function ( obj, callback ) {
var result = {};
for ( var key in obj ) {
if ( Object.prototype.hasOwnProperty.call( obj, key ) ) {
if ( typeof callback === 'function' ) {
result[ key ] = callback.call( obj, obj[ key ], key, obj );
}
}
}
return result;
};
var myObject = { 'a': 1, 'b': 2, 'c': 3 };
var newObject = myMap( myObject, function ( value, key ) {
return value * value;
});
На основании ответа @Amberlamps, здесь функция полезности (как комментарий выглядел уродливым)
function mapObject(obj, mapFunc){
return Object.keys(obj).reduce(function(newObj, value) {
newObj[value] = mapFunc(obj[value]);
return newObj;
}, {});
}
и используется:
var obj = {a:1, b:3, c:5}
function double(x){return x * 2}
var newObj = mapObject(obj, double);
//=> {a: 2, b: 6, c: 10}
var myObject = { 'a': 1, 'b': 2, 'c': 3 };
Object.prototype.map = function(fn){
var oReturn = {};
for (sCurObjectPropertyName in this) {
oReturn[sCurObjectPropertyName] = fn(this[sCurObjectPropertyName], sCurObjectPropertyName);
}
return oReturn;
}
Object.defineProperty(Object.prototype,'map',{enumerable:false});
newObject = myObject.map(function (value, label) {
return value * value;
});
// newObject is now { 'a': 1, 'b': 4, 'c': 9 }
Я натолкнулся на это как на первый элемент в поиске Google, пытаясь научиться делать это, и подумал, что поделюсь с другими людьми, которые недавно нашли это решение, которое я нашел, использующее неизменяемый пакет npm.
Я думаю, что им интересно поделиться, потому что immutable использует ситуацию OP EXACT в своей собственной документации - следующее не мой собственный код, а взятый из текущей документации immutable-js:
const { Seq } = require('immutable')
const myObject = { a: 1, b: 2, c: 3 }
Seq(myObject).map(x => x * x).toObject();
// { a: 1, b: 4, c: 9 }
Не то, чтобы у Seq были другие свойства ("Seq описывает ленивую операцию, позволяющую им эффективно объединять в цепочку использование всех методов сбора данных более высокого порядка (таких как map и filter), не создавая промежуточные коллекции"), и что некоторые другие данные immutable-js Структуры также могут выполнять работу достаточно эффективно.
Любой, кто использует этот метод, конечно, должен npm install immutable и может захотеть прочитать документы:
Если вас интересует map ping не только значения, но и ключи, я написал Object.map(valueMapper, keyMapper), который ведет себя таким образом
var source = { a: 1, b: 2 };
function sum(x) { return x + x }
source.map(sum); // returns { a: 2, b: 4 }
source.map(undefined, sum); // returns { aa: 1, bb: 2 }
source.map(sum, sum); // returns { aa: 2, bb: 4 }
Мне нужна была версия, которая также позволяла изменять ключи (на основе ответов @Amberlamps и @yonatanmn);
var facts = [ // can be an object or array - see jsfiddle below
{uuid:"asdfasdf",color:"red"},
{uuid:"sdfgsdfg",color:"green"},
{uuid:"dfghdfgh",color:"blue"}
];
var factObject = mapObject({}, facts, function(key, item) {
return [item.uuid, {test:item.color, oldKey:key}];
});
function mapObject(empty, obj, mapFunc){
return Object.keys(obj).reduce(function(newObj, key) {
var kvPair = mapFunc(key, obj[key]);
newObj[kvPair[0]] = kvPair[1];
return newObj;
}, empty);
}
factObject =
{
"asdfasdf": {"color":"red","oldKey":"0"},
"sdfgsdfg": {"color":"green","oldKey":"1"},
"dfghdfgh": {"color":"blue","oldKey":"2"}
}
Изменить: небольшое изменение для перехода в исходный объект {}. Позволяет ему быть [] (если ключи целые)
Вы можете использовать простой цикл for через упорядоченные пары. Я использовал hasOwnProperty() потому что вы создали три свойства (со значениями) для вашего объекта. Первый метод не создает карту. Вместо этого он просто применяет функцию к одному элементу, что может значительно ускорить выполнение во многих ситуациях.
Второй метод создает карту таким же образом, как и первый, но, вероятно, довольно медленный, чем некоторые другие ответы здесь.
var myObject = { 'a': 1, 'b': 2, 'c': 3 }
//Doesn't create a map, just applies the function to a specific element
function getValue(key) {
for (var k in myObject) {
if (myObject.hasOwnProperty(key)) {
var value = myObject[key]
return value * value; //stops iteration
}
}
}
//creates a map (answers question, but above function is better in some situations)
var newObject = {};
makeMap();
function makeMap() {
for (var k in myObject) {
var value = myObject[k];
newObject[k] = value * value;
}
}
console.log(newObject); //mapped arrayInput: <input id="input" value="" placeholder="a, b or c"><br>
Output:<input id="output"><br>
<button onclick="output.value=getValue(input.value)" >Get value</button>Сначала преобразуйте свою коллекцию HTMLCollection, используя Object.entries(collection). Тогда это итеративно, теперь вы можете использовать метод .map для него.
Object.entries(collection).map(...)
Мой ответ в значительной степени основан на ответе с самым высоким рейтингом здесь, и, надеюсь, все понимают (тоже самое объяснение на моем GitHub). Вот почему его имплементация с картой работает:
Object.keys(images).map((key) => images[key] = 'url(' + '"' + images[key] + '"' +
')');
Назначение функции - взять объект и изменить исходное содержимое объекта, используя метод, доступный для всех объектов (как объектов, так и массивов) без возврата массива. Почти все в JS является объектом, и по этой причине элементы, расположенные ниже по конвейеру наследования, могут технически использовать те, которые доступны для тех, кто находится на линии вверх (и наоборот).
Это работает из-за того, что функции .map возвращают массив, ТРЕБУЮЩИЙ, что вы предоставляете явный или неявный ВОЗВРАТ массива вместо простой модификации существующего объекта. По сути, вы заставляете программу думать, что объект является массивом, используя Object.keys, который позволит вам использовать функцию map, воздействуя на значения, с которыми связаны отдельные ключи (я фактически случайно возвратил массивы, но исправил это). Пока нет возврата в обычном смысле, не будет никакого массива, созданного с оригинальным объектом, все еще целым и измененным как запрограммированный.
Эта конкретная программа принимает объект с именем images, принимает значения его ключей и добавляет теги url для использования в другой функции. Оригинал это:
var images = {
snow: 'https://www.trbimg.com/img-5aa059f5/turbine/bs-md-weather-20180305',
sunny: 'http://www.cubaweather.org/images/weather-photos/large/Sunny-morning-east-
Matanzas-city- Cuba-20170131-1080.jpg',
rain: 'https://i.pinimg.com/originals/23/d8
/ab/23d8ab1eebc72a123cebc80ce32b43d8.jpg' };
... и модифицировано это:
var images = {
snow: url('https://www.trbimg.com/img-5aa059f5/turbine/bs-md-weather-20180305'),
sunny: url('http://www.cubaweather.org/images/weather-photos/large/Sunny-morning-
east-Matanzas-city- Cuba-20170131-1080.jpg'),
rain: url('https://i.pinimg.com/originals/23/d8
/ab/23d8ab1eebc72a123cebc80ce32b43d8.jpg')
};
Исходная структура объекта остается неизменной, что обеспечивает нормальный доступ к свойству, пока нет возврата. НЕ возвращайте массив, как обычно, и все будет хорошо. Цель - переназначить исходные значения (изображения [ключ]) на то, что нужно, а не на что-либо еще. Насколько я знаю, для предотвращения вывода массива должна быть ПЕРЕДАЧА изображений [ключ] и неявный или неявный запрос на возврат массива (назначение переменных делает это и дает сбои назад и вперед для меня).
РЕДАКТИРОВАТЬ:
Собираюсь обратиться к своему другому методу в отношении создания нового объекта, чтобы избежать изменения исходного объекта (и переназначение, по-видимому, все еще необходимо, чтобы избежать случайного создания массива в качестве вывода). Эти функции используют синтаксис стрелок и, если вы просто хотите создать новый объект для будущего использования.
const mapper = (obj, mapFn) => Object.keys(obj).reduce((result, key) => {
result[key] = mapFn(obj)[key];
return result;
}, {});
var newImages = mapper(images, (value) => value);
Принцип работы этих функций выглядит примерно так:
mapFn берет функцию, которая будет добавлена позже (в этом случае (value) => value), и просто возвращает все, что там хранится, в качестве значения для этого ключа (или умножается на два, если вы измените возвращаемое значение, как он сделал) в mapFn ( объект) [ключ],
а затем переопределяет исходное значение, связанное с ключом, в результате [ключ] = mapFn (obj) [ключ]
и возвращает операцию, выполненную с результатом (аккумулятор, расположенный в скобках, инициированный в конце функции .reduce).
Все это выполняется на выбранном объекте, и ЕЩЕ НЕ МОЖЕТ быть неявный запрос возвращаемого массива, и он работает только при переназначении значений, насколько я могу судить. Это требует некоторой умственной гимнастики, но сокращает количество необходимых строк кода, как видно выше. Вывод точно такой же, как видно ниже:
{snow: "https://www.trbimg.com/img-5aa059f5/turbine/bs-
md-weather-20180305", sunny: "http://www.cubaweather.org/images/weather-
photos/l…morning-east-Matanzas-city-Cuba-20170131-1080.jpg", rain:
"https://i.pinimg.com/originals/23/d8
/ab/23d8ab1eebc72a123cebc80ce32b43d8.jpg"}
Имейте в виду, что это работало с НОМЕРАМИ. Вы МОЖЕТЕ Дублировать ЛЮБОЙ объект, ПРОСТО ВОЗВРАЩАЯ ЗНАЧЕНИЕ в функции mapFN.
mapEntries принимает функцию обратного вызова, которая вызывается для каждой записи в объекте со значением параметра, ключом и объектом. Он должен вернуть новое значение.
mapEntries должен вернуть новый объект с новыми значениями, возвращенными из обратного вызова.
Object.prototype.mapEntries = function(mapEntriesCB) {
return Object.fromEntries(Object.entries(this).map(
([key, value]) => [key, mapEntriesCB(value, key, this)]
));
}
// Usage example:
var object = {a: 1, b: 2, c: 3}
var newObject = object.mapEntries(value => value * value)
console.log(newObject)
//> {a: 1, b: 4, c: 9}
Мне нравятся примеры, в которых используется Object.fromEntries, например этот, но, тем не менее, они не очень просты в использовании. Ответы, которые используют Object.keys, а затем ищут key, на самом деле выполняют несколько поисков, которые могут быть не нужны.
Хотелось бы, чтобы была функция Object.map, но мы можем создать свою собственную и назвать ее objectMap с возможностью модификации как key, так и value:
Использование (JavaScript):
const myObject = { 'a': 1, 'b': 2, 'c': 3 };
// keep the key and modify the value
let obj = objectMap(myObject, val => val * 2);
// obj = { a: 2, b: 4, c: 6 }
// modify both key and value
obj = objectMap(myObject,
val => val * 2 + '',
key => (key + key).toUpperCase());
// obj = { AA: '2', BB: '4', CC: '6' }
Код (TypeScript):
interface Dictionary<T> {
[key: string]: T;
}
function objectMap<TValue, TResult>(
obj: Dictionary<TValue>,
valSelector: (val: TValue, obj: Dictionary<TValue>) => TResult,
keySelector?: (key: string, obj: Dictionary<TValue>) => string,
ctx?: Dictionary<TValue>
) {
const ret = {} as Dictionary<TResult>;
for (const key of Object.keys(obj)) {
const retKey = keySelector
? keySelector.call(ctx || null, key, obj)
: key;
const retVal = valSelector.call(ctx || null, obj[key], obj);
ret[retKey] = retVal;
}
return ret;
}
Если вы не используете TypeScript, скопируйте приведенный выше код в TypeScript Playground, чтобы получить код JavaScript.
Кроме того, причина, по которой я поместил keySelector после valSelector в список параметров, заключается в том, что он является необязательным.
* Некоторая заслуга принадлежит ответу Александера Миллса.
Эй написал небольшую функцию mapper, которая могла бы помочь.
function propertyMapper(object, src){
for (var property in object) {
for (var sourceProp in src) {
if(property === sourceProp){
if(Object.prototype.toString.call( property ) === '[object Array]'){
propertyMapper(object[property], src[sourceProp]);
}else{
object[property] = src[sourceProp];
}
}
}
}
}
Я специально хотел использовать ту же функцию, которую я использовал для массивов для одного объекта, и хотел, чтобы это было просто. Это сработало для меня:
var mapped = [item].map(myMapFunction).pop();
Чтобы более точно реагировать на то, что именно запрашивал ОП, ОП хочет объект:
myObject = { 'a': 1, 'b': 2, 'c': 3 }
иметь метод карты myObject.map,
похож на Array.prototype.map, который будет использоваться следующим образом:
newObject = myObject.map(function (value, label) { return value * value; }); // newObject is now { 'a': 1, 'b': 4, 'c': 9 }
Лучший ответ imho (измеренный в терминах "близко к тому, что спрашивается" + "нет необходимости в ES {5,6,7} без необходимости") будет следующим:
myObject.map = function mapForObject(callback)
{
var result = {};
for(var property in this){
if(this.hasOwnProperty(property) && property != "map"){
result[property] = callback(this[property],property,this);
}
}
return result;
}
Приведенный выше код избегает намеренного использования каких-либо языковых функций, доступных только в последних выпусках ECMAScript. С помощью приведенного выше кода проблема может быть решена следующим образом:
myObject = { 'a': 1, 'b': 2, 'c': 3 };
myObject.map = function mapForObject(callback)
{
var result = {};
for(var property in this){
if(this.hasOwnProperty(property) && property != "map"){
result[property] = callback(this[property],property,this);
}
}
return result;
}
newObject = myObject.map(function (value, label) {
return value * value;
});
console.log("newObject is now",newObject);Вы можете использовать прототип Array и функцию call() для отображения объекта
Array.prototype.map.call(Obj, function(currentItem, index){
/** Your code... */
})
По сути, вы вызываете функцию map, которая лежит в Array.prototype, и с помощью call (Obj, fn) вы говорите javascript использовать Obj как "массив".
Вы также можете избежать "Array.prototype" и использовать вместо него пустой массив, он имеет тот же эффект
[].map.call(Obj, function(currentItem, index){
/** Your code... */
})
Сопоставляет значения массива с объектом, используя функцию, где пары ключ-значение состоят из исходного значения в качестве ключа и сопоставленного значения.
Используйте анонимную внутреннюю область функции для объявления неопределенного пространства памяти, используя замыкания для хранения возвращаемого значения. Используйте новый массив для хранения массива с картой функции над его набором данных и оператором запятой для возврата второго шага без необходимости переходить из одного контекста в другой (из-за замыканий и порядка операций).
const mapObject = (arr, fn) =>
(a => (
(a = [arr, arr.map(fn)]), a[0].reduce((acc, val, ind) => ((acc[val] = a[1][ind]), acc), {})
))();
например:
const squareIt = arr => mapObject(arr, a => a * a);
squareIt([1, 2, 3]); // { 1: 1, 2: 4, 3: 9 }
Я работаю только со строками, чтобы уменьшить количество исключений:
Object.keys(params).map(k => typeof params[k] == "string" ? params[k] = params[k].trim() : null);