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

Voici ma version récursive basée sur l'un des exemples ci-dessus.

//updated function
var lowerObjKeys = function(obj) {
  Object.keys(obj).forEach(function(key) {
    var k = key.toLowerCase();
    if (k != key) {
      var v = obj[key]
      obj[k] = v;
      delete obj[key];

      if (typeof v == 'object') {
        lowerObjKeys(v);
      }
    }
  });

  return obj;
}

//plumbing
console = {
  _createConsole: function() {
    var pre = document.createElement('pre');
    pre.setAttribute('id', 'console');
    document.body.insertBefore(pre, document.body.firstChild);
    return pre;
  },
  info: function(message) {
    var pre = document.getElementById("console") || console._createConsole();
    pre.textContent += ['>', message, '\n'].join(' ');
  }
};

//test case
console.info(JSON.stringify(lowerObjKeys({
  "StackOverflow": "blah",
  "Test": {
    "LULZ": "MEH"
  }
}), true));

Attention, il ne suit pas les références circulaires, donc vous pouvez vous retrouver dans une boucle infinie aboutissant à un dépassement de pile.

Answer 2

Pour toutes les valeurs :

to_lower_case = function(obj) {
    for (var k in obj){
        if (typeof obj[k] == "object" && obj[k] !== null)
            to_lower_case(obj[k]);
        else if(typeof obj[k] == "string") {
            obj[k] = obj[k].toLowerCase();
        }
    }
    return obj;
}

La même fonction peut être utilisée pour les clés avec quelques ajustements mineurs.

Answer 3

C'est ainsi que je le fais. Mon entrée peut être n'importe quoi et elle se récuse à travers des objets imbriqués ainsi que des tableaux d'objets.

const fixKeys = input => Array.isArray(input)
  ? input.map(fixKeys)
  : typeof input === 'object'
  ? Object.keys(input).reduce((acc, elem) => {
      acc[elem.toLowerCase()] = fixKeys(input[elem])
      return acc
    }, {})
  : input

testé en utilisant mocha

const { expect } = require('chai')

const fixKeys = require('../../../src/utils/fixKeys')

describe('utils/fixKeys', () => {
  const original = {
    Some: 'data',
    With: {
      Nested: 'data'
    },
    And: [
      'an',
      'array',
      'of',
      'strings'
    ],
    AsWellAs: [
      { An: 'array of objects' }
    ]
  }

  const expected = {
    some: 'data',
    with: {
      nested: 'data'
    },
    and: [
      'an',
      'array',
      'of',
      'strings'
    ],
    aswellas: [{ an: 'array of objects' }]
  }

  let result

  before(() => {
    result = fixKeys(original)
  })

  it('left the original untouched', () => {
    expect(original).not.to.deep.equal(expected)
  })

  it('fixed the keys', () => {
    expect(result).to.deep.equal(expected)
  })
})

Answer 4

var aa = {ID:1,NOM:'Guvaliour'};
var bb= {};
var cc = Object.keys(aa);
cc.forEach(element=>{
 bb[element.toLowerCase()]=aa[element];
});
cosole.log(bb)

Answer 5

Le code ci-dessous pour convertir toutes les clés en minuscules

array.forEach(item=>{

          let data = Object.keys(item).reduce((result, p) => (result[p.toLowerCase().trim()] = item[p], result), {})

          if(data.hasOwnProperty(fieldname)){
              if(data[fieldname]){
                if(!response['data'].includes(data[fieldname].toLowerCase()))
                    response['data'].push(data[fieldname]) 

             }
           }

        })