Quelle est la meilleure façon (la plus efficace) de convertir toutes les clés d'un objet en minuscules?

Question

Je suis arrivé à

function keysToLowerCase (obj) {
  var keys = Object.keys(obj);
  var n = keys.length;
  while (n--) {
    var key = keys[n]; // "cache" it, for less lookups to the array
    if (key !== key.toLowerCase()) { // might already be in its lower case version
        obj[key.toLowerCase()] = obj[key] // swap the value to a new lower case key
        delete obj[key] // delete the old key
    }
  }
  return (obj);
}

Mais je ne suis pas sûr du comportement de v8 à ce sujet, par exemple, va-t-il vraiment supprimer les autres clés ou va-t-il seulement supprimer les références et le garbage collector me posera-t-il un problème plus tard ?

Aussi, j'ai créé ces tests, j'espère que vous pourrez ajouter votre réponse là-bas pour voir comment elles se comparent.

ÉDIT 1: Apparemment, selon les tests, c'est plus rapide si nous ne vérifions pas si la clé est déjà en minuscules, mais mis à part le fait d'être plus rapide, est-ce que cela créera plus de désordre en ignorant cela et en créant simplement de nouvelles clés en minuscules ? Le garbage collector sera-t-il satisfait de cela ?

Answer 1

Une seule ligne de code (uniquement pour les clés de niveau supérieur) :

Object.assign(...Object.keys(obj).map(key => ({[key.toLowerCase()]: obj[key]})))

Convertit :

{ a: 1, B: 2, C: { Z: 4 } }

En :

{ a: 1, b: 2, c: { Z: 4 } }

Answer 2

Avec TypeScript

/**
 * Mettre en minuscules les clés d'un objet
 * @example
  lowercaseKeys({FOO: true, bAr: false}); // {foo: true, bar: false}
 */
export function lowercaseKeys(object: { [key: string]: T }): { [key: string]: T } {
  const result: { [key: string]: T } = {};

  for (const [key, value] of Object.entries(object)) {
    result[key.toLowerCase()] = value;
  }

  return result;
}

Utilisation

lowercaseKeys({FOO: true, bAr: false}); // {foo: true, bar: false}

Answer 3

Ce n'est pas la manière la plus propre, mais cela a fonctionné pour mon équipe, donc ça vaut la peine de partager.

J'ai créé cette méthode car notre back-end utilise un langage qui ne fait pas de distinction entre majuscules et minuscules, et la base de données et le back-end produiront des cas de clé différents. Pour nous, cela a fonctionné parfaitement. Gardez à l'esprit que nous envoyons des dates en tant que chaînes de caractères et que nous n'envoyons pas de fonctions.

Nous l'avons réduit à cette seule ligne.

const toLowerCase = (data) => JSON.parse(JSON.stringify(data).replace(/"([^"]+)":/g, ($0, key) => '"' + key.toString().toLowerCase() + '":'))

Nous clonons l'objet en utilisant la méthode JSON.parse(JSON.stringify(obj)). Cela produit une version de chaîne de caractères de l'objet au format JSON. Tant que l'objet est sous forme de chaîne, vous pouvez utiliser des expressions régulières car JSON est un format prévisible pour convertir toutes les clés.

Si on le divise, ça ressemble à ça.

const toLowerCase = function (data) {
  return JSON.parse(JSON.stringify(data)
   .replace(/"([^"]+)":/g, ($0, key) => {
     return '"' + key.toString().toLowerCase() + '":'
   }))
}

Answer 4

const keysToLowerCase = object => {
  return Object.keys(object).reduce((acc, key) => {
    let val = object[key];
    if (typeof val === 'object') {
      val = keysToLowerCase(val);
    }
    acc[key.toLowerCase()] = val;
    return acc;
  }, {});
};

Fonctionne pour les objets imbriqués.

Answer 5

Considérez baisser les majuscules une seule fois, en les stockant dans une variable lowKey :

function keysToLowerCase (obj) {
  var keys = Object.keys(obj);
  var n = keys.length;
  var lowKey;
  while (n--) {
    var key = keys[n];
    if (key === (lowKey = key.toLowerCase()))
    continue

    obj[lowKey] = obj[key]
    delete obj[key]

  }
  return (obj);
}