Ich bin darauf gekommen

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

Aber ich bin mir nicht sicher, wie sich v8 damit verhalten wird, wird es zum Beispiel wirklich die anderen Schlüssel löschen oder werden nur Referenzen gelöscht und der Garbage Collector wird mich später beißen?

Außerdem habe ich erstellt diese Prüfungenich hoffe, Sie könnten Ihre Antwort dort hinzufügen, damit wir sehen können, wie sie zusammenpassen.

BEARBEITEN 1:
Anscheinend ist es den Tests zufolge schneller, wenn wir nicht prüfen, ob der Schlüssel bereits in Kleinbuchstaben geschrieben ist, aber da er schneller ist, wird er mehr Unordnung schaffen, wenn er dies ignoriert und einfach neue Kleinbuchstaben erstellt? Wird der Garbage Collector damit zufrieden sein?

Das am schnellsten Ich komme mit, wenn Sie ein neues Objekt erstellen:

var key, keys = Object.keys(obj);
var n = keys.length;
var newobj={}
while (n--) {
  key = keys[n];
  newobj[key.toLowerCase()] = obj[key];
}

Ich bin mit dem aktuellen Innenleben von v8 nicht vertraut genug, um Ihnen eine endgültige Antwort zu geben. Vor ein paar Jahren habe ich ein Video gesehen, in dem die Entwickler über Objekte gesprochen haben, und IIRC wird nur die Referenzen löschen und den Garbage Collector sich darum kümmern lassen. Aber es ist Jahre her, also selbst wenn es damals so war, muss es jetzt nicht so sein.

Wird es dich später beißen? Es hängt davon ab, was Sie tun, aber wahrscheinlich nicht. Es ist sehr üblich, kurzlebige Objekte zu erstellen, sodass der Code dafür optimiert ist, damit umzugehen. Aber jede Umgebung hat ihre Grenzen, und vielleicht beißt sie dich. Sie müssen mit tatsächlichen Daten testen.

Verwenden Object.fromEntries (ES10)

Native und unveränderliche Lösung mit dem neuen Object.fromEntries Methode:

const newObj = Object.fromEntries(
  Object.entries(obj).map(([k, v]) => [k.toLowerCase(), v])
);

Bis zu dieser Funktion wird breit verfügbar Sie könnten es selbst mit dem folgenden definieren Polyfill:

Object.fromEntries = arr => Object.assign({}, ...Array.from(arr, ([k, v]) => ({[k]: v}) ));

Eine schöne Sache ist, dass diese Methode das Gegenteil von bewirkt Object.entriessodass Sie jetzt zwischen der Objekt- und der Array-Darstellung hin und her wechseln können.

Ich würde verwenden Lo-Dash.transform so was:

var lowerObj = _.transform(obj, function (result, val, key) {
    result[key.toLowerCase()] = val;
});

Ich persönlich würde verwenden:

let objectKeysToLowerCase = function (origObj) {
    return Object.keys(origObj).reduce(function (newObj, key) {
        let val = origObj[key];
        let newVal = (typeof val === 'object') ? objectKeysToLowerCase(val) : val;
        newObj[key.toLowerCase()] = newVal;
        return newObj;
    }, {});
}

Es ist prägnant, behandelt verschachtelte Objekte wieder und gibt ein neues Objekt zurück, anstatt das Original zu ändern.

In meinen begrenzten lokalen Tests ist diese Funktion schneller als die andere derzeit aufgeführte rekursive Lösung (einmal behoben). Ich würde es gerne mit den anderen vergleichen, aber jsperf ist im Moment nicht verfügbar (???).

Es ist auch in ES5.1 geschrieben, also sollte es laut den Dokumenten auf MDN in FF 4+, Chrome 5+, IE 9.0+, Opera 12+, Safari 5+ (also so ziemlich alles) funktionieren.

• Object.keys()
• Array. Prototyp.Reduce()

Vanilla JS für den Sieg.

Ich würde mir nicht allzu viele Gedanken über den Aspekt der Garbage Collection machen. Sobald alle Verweise auf das alte Objekt zerstört sind, werden es aber die GC’s sein Neu Das Objekt wird im Grunde immer noch auf alle seine Eigenschaften verweisen, also nicht.

Alle Funktionen, Arrays oder RegExp werden durch Verweis “kopiert”. In Bezug auf den Speicher werden selbst Strings durch diesen Prozess nicht dupliziert, da die meisten (alle?) modernen JS-Engines Benutzer sind string internieren. Ich denke, das lässt nur die Zahlen, Booleans und die Objekte, die die ursprüngliche Struktur bildeten, übrig, um GC’d zu werden.

Beachten Sie, dass (alle Implementierungen) dieses Prozesses Werte verlieren, wenn das Original mehrere Eigenschaften mit derselben Darstellung in Kleinbuchstaben hat. Dh:

let myObj = { xx: 'There', xX: 'can be', Xx: 'only', XX: 'one!' };
console.log(myObj);
// { xx: 'There', xX: 'can be', Xx: 'only', XX: 'one!' }

let newObj = objectKeysToLowerCase(myObj);
console.log(newObj);
// { xx: 'one!' }

Natürlich ist das manchmal genau das, was Sie wollen.

Update 17.07.2018

Einige Leute haben bemerkt, dass die ursprüngliche Funktion mit Arrays nicht gut funktioniert. Hier ist eine erweiterte, widerstandsfähigere Version. Es wiederholt sich korrekt durch Arrays und funktioniert, wenn der Anfangswert ein Array oder ein einfacher Wert ist:

let objectKeysToLowerCase = function (input) {
    if (typeof input !== 'object') return input;
    if (Array.isArray(input)) return input.map(objectKeysToLowerCase);
    return Object.keys(input).reduce(function (newObj, key) {
        let val = input[key];
        let newVal = (typeof val === 'object') && val !== null ? objectKeysToLowerCase(val) : val;
        newObj[key.toLowerCase()] = newVal;
        return newObj;
    }, {});
};

ES6-Version:

Object.keys(source)
  .reduce((destination, key) => {
    destination[key.toLowerCase()] = source[key];
    return destination;
  }, {});

Der loDash/fp-Weg, ganz nett, da es im Wesentlichen ein Einzeiler ist

import {
mapKeys
} from 'lodash/fp'

export function lowerCaseObjectKeys (value) {
return mapKeys(k => k.toLowerCase(), value)
}

Die Verwendung von forEach scheint in meinen Tests etwas schneller zu sein – und die ursprüngliche Referenz ist weg, sodass das Löschen der neuen sie in die Reichweite des gc bringt

function keysToLowerCase(obj){
    Object.keys(obj).forEach(function (key) {
        var k = key.toLowerCase();

        if (k !== key) {
            obj[k] = obj[key];
            delete obj[key];
        }
    });
    return (obj);
}

var O={ONE:1,two:2,tThree:3,FOUR:4,Five:5,SIX:{a:1,b:2,c:3,D:4,E:5}}; TastenToLowerCase(O);

/* Rückgabewert: (Objekt) */

{
    five:5,
    four:4,
    one:1,
    six:{
        a:1,
        b:2,
        c:3,
        D:4,
        E:5
    },
    three:3,
    two:2
}