Renommer / re-map efficacement les clés d'objet javascript/json dans le tableau des objets

a posé cette question il y a longtemps, et depuis lors, j'ai pris l'habitude d'utiliser le tableau .prototype.map() pour faire le travail, plus pour la stabilité et la propreté du code de la performance. Bien qu'il ne soit certainement pas le plus performant, il semble grand:

var repl = orig.map(function(obj) {
    return {
        name: obj.title,
        id: obj.uid
    }
})

si vous avez besoin d'une fonction plus flexible (et compatible ES6), essayez:

let replaceKeyInObjectArray = (a, r) => a.map(o => 
    Object.keys(o).map((key) => ({ [r[key] || key] : o[key] })
).reduce((a, b) => Object.assign({}, a, b)))

p.ex.

const arr = [{ abc: 1, def: 40, xyz: 50 }, { abc: 1, def: 40, xyz: 50 }, { abc: 1, def: 40, xyz: 50 }]
const replaceMap = { "abc": "yyj" }

replaceKeyInObjectArray(arr, replaceMap)

/*
[
    {
        "yyj": 1,
        "def": 40,
        "xyz": 50
    },
    {
        "yyj": 1,
        "def": 40,
        "xyz": 50
    },
    {
        "yyj": 1,
        "def": 40,
        "xyz": 50
    }
]
*/

voici un autre point de vue sur la suggestion de L'OP d'utiliser map() par souci de clarté (et non de performance).

var newItems = items.map(item => ({
    name: item.title,
    id: item.uid
}));

utilise fonctions de flèche ES6 et les syntaxes à raccourci qui sont possibles quand il n'y a qu'un seul Parme passé à la fonction et une seule instruction dans le corps de la fonction.

selon votre histoire avec des expressions lambda dans diverses langues, cette forme peut ou non résonner avec vous.

soyez prudent en retournant un objet littéral dans la syntaxe de raccourci de la fonction de flèche comme ceci. N'oubliez pas les parens supplémentaires autour de l'objet littéral!

Si vous voulez le rendre un peu plus réutilisable. C'est peut-être un décent approche.

function rekey(arr, lookup) {
	for (var i = 0; i < arr.length; i++) {
		var obj = arr[i];
		for (var fromKey in lookup) {
			var toKey = lookup[fromKey];
			var value = obj[fromKey];
			if (value) {
				obj[toKey] = value;
				delete obj[fromKey];
			}
		}
	}
	return arr;
}

var arr = [{ apple: 'bar' }, { apple: 'foo' }];
var converted = rekey(arr, { apple: 'kung' });
console.log(converted);

var jsonObj = [/*sample array in question*/   ]

basé sur différents benchmarks discutés ci-dessous, la solution la plus rapide est native pour:

var arr = [];
for(var i = 0, len = jsonObj .length; i < len; i++) {
  arr.push( {"name": jsonObj[i].title, "id" : jsonObj[i].uid});
}

je pense alternativement sans utiliser de cadres ce sera l'option 2:

var arr = []
jsonObj.forEach(function(item) { arr.push({"name": item.title, "id" : item.uid }); });

il y a toujours un débat entre l'utilisation des fonctions navite et non-navite. Si je me souviens bien lodash ont fait valoir qu'ils étaient plus rapide que underscore parce que l'utilisation des fonctions non natives pour les opérations clés.

Toutefois différents navigateurs produisent parfois des résultats très différents. J'ai toujours cherché le meilleur moyen.

pour les benchmarks vous pouvez jeter un oeil à ceci:

http://jsperf.com/lo-dash-v1-1-1-vs-underscore-v1-4-4/8

utilisant ES6:

const renameFieldInArrayOfObjects = (arr, oldField, newField) => {
  return arr.map(s => {
    return Object.keys(s).reduce((prev, next) => {
      if(next === oldField) { 
        prev[newField] = s[next]
      } else { 
        prev[next] = s[next] 
      }
      return prev
    }, {})
  })
}

utilisant ES7:

const renameFieldInArrayOfObjects = (arr, oldField, newField) => {
  return arr.map(s => {
    return Object.keys(s).reduce((prev, next) => {
      return next === oldField
        ? {...prev, [newField]: s[next]}
        : {...prev, [next]: s[next]}
    }, {})
  })
}

Vous pouvez utiliser un mécanisme national de prévention package nommé nœud-données-transformer .

vos données:

const data = [
  {
    title: 'pineapple',
    uid: 'ab982d34c98f',
  },
  {
    title: 'carrots',
    uid: '6f12e6ba45ec',
  },
];

Votre mapping :

const map = {
  item: {
    name: 'title',
    id: 'uid',
  },
};

et utiliser le paquet:

const DataTransform = require("node-json-transform").DataTransform;
const dataTransform = DataTransform(data, map);
const result = dataTransform.transform();
console.log(result);

résultat:

[
  {
    name: 'pineapple',
    id: 'ab982d34c98f'
  },
  {
    name: 'carrots',
    id: '6f12e6ba45ec'
  }
]

ce n'est peut-être pas la meilleure façon de jouer, mais c'est assez élégant.