it-swarm.com.ru

функция карты для объектов (вместо массивов)

У меня есть объект:

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, поэтому меня не волнуют кросс-браузерные проблемы.)

778
Randomblue

Для объекта map нет собственного Object, но как насчет этого:

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 }

Но вы можете легко перебрать объект, используя for ... in:

var myObject = { 'a': 1, 'b': 2, 'c': 3 };

for (var key in myObject) {
  if (myObject.hasOwnProperty(key)) {
    myObject[key] *= 2;
  }
}

console.log(myObject);
// { 'a': 2, 'b': 4, 'c': 6 }

Update

Многие люди упоминают, что предыдущие методы не возвращают новый объект, а работают с самим объектом. В связи с этим я хотел добавить другое решение, которое возвращает новый объект и оставляет исходный объект как есть:

var myObject = { 'a': 1, 'b': 2, 'c': 3 };

// returns a new object with the values at each key mapped using mapFn(value)
function objectMap(object, mapFn) {
  return Object.keys(object).reduce(function(result, key) {
    result[key] = mapFn(object[key])
    return result
  }, {})
}

var newObject = objectMap(myObject, function(value) {
  return value * 2
})

console.log(newObject);
// => { 'a': 1, 'b': 4, 'c': 6 }

console.log(myObject);
// => { 'a': 1, 'b': 2, 'c': 3 }

Array.prototype.reduce уменьшает массив до единого значения, несколько объединяя предыдущее значение с текущим. Цепочка инициализируется пустым объектом {}. На каждой итерации добавляется новый ключ myObject с его квадратом в качестве значения.

1141
Amberlamps

Как насчет одного лайнера с немедленным назначением переменной в простом JS ( ES6/ES2015 )?

Использование синтаксиса оператор распространения и имя вычисляемого ключа :

let newObj = Object.assign({}, ...Object.keys(obj).map(k => ({[k]: obj[k] * obj[k]})));

jsbin

Другая версия, использующая Reduce:

let newObj = Object.keys(obj).reduce((p, c) => ({...p, [c]: obj[c] * obj[c]}), {});

jsbin

Первый пример как функция:

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);

jsbin

Если вы хотите отобразить вложенный объект рекурсивно в функциональном стиле, это можно сделать следующим образом :

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.
    ,{})       

jsbin

Или более обязательно, как это:

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;
};

jsbin

Поскольку ES7/ES2016 вы можете использовать Object.entries вместо Object.keys, например. как это:

let newObj = Object.assign(...Object.entries(obj).map(([k, v]) => ({[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'
}

jsbin

Однако, пожалуйста, сделайте мне одолжение и избегайте наследования . :-)

216
Rotareti

Нет нативных методов, но lodash # mapValues отлично справится с этой задачей

_.mapValues({ 'a': 1, 'b': 2, 'c': 3} , function(num) { return num * 3; });
// → { 'a': 3, 'b': 6, 'c': 9 }
100
Mario

Это довольно легко написать:

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 }

Примечание: эта версия также позволяет (необязательно) устанавливать контекст this для обратного вызова, точно так же, как метод Array.

EDIT - изменено, чтобы удалить использование Object.prototype, чтобы оно не конфликтовало с каким-либо существующим свойством с именем map в объекте.

55
Alnitak

Вы можете использовать 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.

22
Mattias Buelens

Это прям бразильцы, и все в сообществе 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
16
Alexander Mills

Я пришел сюда, чтобы найти и ответить для отображения объекта в массив, и в результате получил эту страницу. В случае, если вы пришли сюда в поисках того же ответа, что и я, вот как вы можете сопоставить массив и объект.

Вы можете использовать map для возврата нового массива из объекта следующим образом:

var newObject = Object.keys(myObject).map(function(key) {
   return myObject[key];
});
15
JoeTron

Принятый ответ имеет два недостатка:

  • Он неправильно использует Array.prototype.reduce, потому что сокращение означает изменение структуры составного типа, чего не происходит в этом случае.
  • Это не особо многоразового использования

Функциональный подход ES6/ES2015

Обратите внимание, что все функции определены в карри.

// 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));
  • В строке A o переназначается. Поскольку Javascript передает ссылочные значения путем совместного использования , создается неглубокая копия o. Теперь мы можем изменять o внутри omap, не изменяя o в родительской области видимости.
  • В строке B возвращаемое значение map игнорируется, поскольку map выполняет мутацию o. Поскольку этот побочный эффект остается в пределах omap и не отображается в родительской области, он полностью приемлем.

Это не самое быстрое решение, но декларативное и многоразовое. Вот та же реализация, что и в одной строке, краткая, но менее читаемая:

const omap = f => o => (o = assign(o), map(x => o[x] = f(o[x])) (keys(o)), o);

Приложение - почему объекты не повторяются по умолчанию?

ES2015 определяет итератор и итерируемые протоколы. Но объекты все еще не повторяемы и, следовательно, не отображаются. Причина заключается в смешении данных и уровня программы .

10
user6445533

Для максимальной производительности.

Если ваш объект не меняется часто, но его нужно часто повторять, я предлагаю использовать собственную карту в качестве кэша.

// 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);
});

Object.entries уже работает в Chrome, Edge, Firefox и бета-версии Opera, так что это функция будущего. Это из ES7, поэтому заполняйте его https://github.com/es-shims/Object.entries для IE там, где это не работает.

8
Pawel

Минимальная версия (es6):

Object.entries(obj).reduce((a, [k, v]) => (a[k] = v * v, a), {})
7
Yukulélé

вы можете использовать метод map и forEach для массивов, но если вы хотите использовать его для Object, вы можете использовать его с twist, как показано ниже:

Использование 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(ob,function (key, value) {
  ob[key] *= value;
});
console.log(ob) //it will also log as {a: 4, b: 16, c: 36}
5
Haritsinh Gohil

Этот ответ был переписан, чтобы продемонстрировать мощный комбинатор mapReduce, который позволяет нам думать о нашем преобразовании по-другому

  1. m, функция отображения - дает вам возможность преобразовать входящий элемент до того, как…
  2. r, редукционная функция - эта функция объединяет аккумулятор с результатом сопоставленного элемента

Интуитивно понятно, что mapReduce создает новый редуктор, который мы можем подключить непосредственно к Array.prototype.reduce. Но что еще более важно, мы можем реализовать нашу реализацию объектного функтора omap явно, используя объект monoid, Object.assign и {}.

const identity = x =>
  x
  
const first = (a, b) =>
  a
  
const mapReduce = (m = identity, r = first) =>
  (acc, x) => r (acc, m (x))
  
const omap = (o = {}, f = identity) =>
  Object.keys (o)
    .reduce ( mapReduce ( k => ({ [k]: f (o [k]) })  // Object.map
                        , Object.assign              // Object.concat
                        )
            , {}                                     // Object.empty
            )
          
const square = x =>
  x * x
  
const data =
  { a : 1, b : 2, c : 3 }
  
console.log (omap (data, square))
// { a : 1, b : 4, c : 9 }

Обратите внимание, что единственная часть программы, которую мы фактически должны были написать, - это сама реализация отображения.

k => ({ [k]: f (o [k]) }

Что говорит, учитывая известный объект o и некоторый ключ k, сконструируйте объект, и его свойство k является результатом вызова f для значения ключа o [k].

Мы получим представление о возможностях секвенирования mapReduce, если сначала абстрагируем oreduce

const oreduce = (o, f = first, acc = {}) =>
  Object.keys (o)
    .reduce ( mapReduce ( k => [ k, o[k] ]
                        , f
                        )
            , acc
            )

const omap = (o = {}, f = identity) =>
  oreduce ( o
          , mapReduce ( ([ k, v ]) => ({ [k]: f (v) })
                      , Object.assign
                      )
          , {}
          )

Все работает так же, но omap теперь можно определить на более высоком уровне. Конечно, новый Object.entries делает это глупым, но упражнение все еще важно для ученика.

Вы не увидите здесь весь потенциал mapReduce, но я поделюсь этим ответом, потому что интересно посмотреть, сколько мест его можно применить. Если вы заинтересованы в том, как это происходит и как это может быть полезно, смотрите этот ответ .

4
user633183

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;
});
3
whitneyit

JavaScript только что получил новый метод Object.fromEntries.

Пример

const myObject = { a: 1, b: 2, c: 3 }
const myNewObject = Object.fromEntries(
  Object
    .entries(myObject)
    .map(([key, value]) => ([key, value * value]))
)
console.log(myNewObject)

Объяснение

Приведенный выше код преобразует объект во вложенный массив ([[<key>,<value>], ...]), который можно отобразить. Object.fromEntries преобразует массив обратно в объект.

Крутая вещь в этом шаблоне заключается в том, что теперь вы можете легко учитывать ключи объектов при отображении.

Документация

Поддержка браузера

Object.fromEntries в настоящее время поддерживается только эти браузеры/движки , тем не менее, есть доступные полифилы (например, @ babel/polyfill ).

3
HaNdTriX

Если вас интересует mapping не только значений, но и ключей, я написал 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 }
2
MattiSG

Я натолкнулся на это как на первый элемент в поиске Google, пытаясь научиться делать это, и подумал, что поделюсь с другими людьми, которые недавно нашли это решение, которое я нашел, использующее неизменяемый пакет npm.

Я думаю, что им интересно поделиться, потому что immutable использует ситуацию EXACT OP в своей собственной документации - ниже не мой собственный код, а взятый из текущей документации 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 и может захотеть прочитать документы:

https://facebook.github.io/immutable-js/

2
alex.h

Основываясь на ответе @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}
2
yonatanmn
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 }
2
Dmitry Ragozin

Я специально хотел использовать ту же функцию, что и для массивов для одного объекта, и хотел, чтобы она была простой. Это сработало для меня:

var mapped = [item].map(myMapFunction).pop();
1
Jason Norwood-Young

Вы можете использовать простой цикл 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 array
Input: <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>
1
Victor Stoddard

Эй, написал небольшую картографическую функцию, которая может помочь.

    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];
                }
              }
            }
         }
      }
1
Zak

Сначала преобразуйте свою коллекцию HTMLCollection с помощью Object.entries (collection) Тогда это итеративно, теперь вы можете использовать метод .map для него.

Object.entries(collection).map(...)

ссылка https://medium.com/@js_tut/calling-javascript-code-on-multiple-div-elements-without-the-id-attribute-97ff6a50f31

1
Jimubao

Мне нужна была версия, которая позволяла также изменять ключи (на основе ответов @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"}
}

Правка: небольшое изменение для передачи в начальный объект {}. Позволяет ему быть [] (если ключи целые)

1
Symmetric

Мой ответ в значительной степени основан на ответе с самым высоким рейтингом, и, надеюсь, все это понимают (тоже самое объяснение на моем 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.

1
Andrew Ramshaw
settings = {
  message_notification: {
    value: true,
    is_active: true,
    slug: 'message_notification',
    title: 'Message Notification'
  },
  support_notification: {
    value: true,
    is_active: true,
    slug: 'support_notification',
    title: 'Support Notification'
  },
};

let keys = Object.keys(settings);
keys.map(key=> settings[key].value = false )
console.log(settings)
0
Akın Köker

ES6:

Object.prototype.map = function(mapFunc) {
    return Object.keys(this).map((key, index) => mapFunc(key, this[key], index));
}

ES2015:

Object.prototype.map = function (mapFunc) {
    var _this = this;

    return Object.keys(this).map(function (key, index) {
        return mapFunc(key, _this[key], index);
    });
};

тест в узле:

> a = {foo: "bar"}
{ foo: 'bar' }
> a.map((k,v,i) => v)
[ 'bar' ]
0
Malix Ren