Classificar objeto JavaScript por chave

Preciso classificar objetos JavaScript por chave.

Daí o seguinte:

{ 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' }

Se tornaria:

{ 'a' : 'dsfdsfsdf', 'b' : 'asdsad', 'c' : 'masdas' }

As outras respostas a esta pergunta estão desatualizadas, nunca correspondem à realidade da implementação e ficaram oficialmente incorretas agora que as especificações do ES6 / ES2015 foram publicadas.

Consulte a seção sobre ordem de iteração de propriedade em Explorando o ES6 por Axel Rauschmayer :

Todos os métodos que iteram sobre as chaves de propriedade fazem isso na mesma ordem:

1. Primeiro todos os índices de matriz, classificados numericamente.
2. Em seguida, todas as chaves de sequência (que não são índices), na ordem em que foram criadas.
3. Em seguida, todos os símbolos, na ordem em que foram criados.

Portanto, sim, os objetos JavaScript são de fato ordenados e a ordem de suas chaves / propriedades pode ser alterada.

Veja como você pode classificar um objeto por suas chaves / propriedades em ordem alfabética:

const unordered = {
  'b': 'foo',
  'c': 'bar',
  'a': 'baz'
};

console.log(JSON.stringify(unordered));
// → '{"b":"foo","c":"bar","a":"baz"}'

const ordered = {};
Object.keys(unordered).sort().forEach(function(key) {
  ordered[key] = unordered[key];
});

console.log(JSON.stringify(ordered));
// → '{"a":"baz","b":"foo","c":"bar"}'

Use em varvez de constpara compatibilidade com os mecanismos ES5.

Os objetos JavaScript ¹ não estão ordenados. Não faz sentido tentar "classificá-las". Se você deseja iterar sobre as propriedades de um objeto, pode classificar as chaves e recuperar os valores associados:

var myObj = {
    'b': 'asdsadfd',
    'c': 'masdasaf',
    'a': 'dsfdsfsdf'
  },
  keys = [],
  k, i, len;

for (k in myObj) {
  if (myObj.hasOwnProperty(k)) {
    keys.push(k);
  }
}

keys.sort();

len = keys.length;

for (i = 0; i < len; i++) {
  k = keys[i];
  console.log(k + ':' + myObj[k]);
}

Implementação alternativa usando Object.keysfantasia:

var myObj = {
    'b': 'asdsadfd',
    'c': 'masdasaf',
    'a': 'dsfdsfsdf'
  },
  keys = Object.keys(myObj),
  i, len = keys.length;

keys.sort();

for (i = 0; i < len; i++) {
  k = keys[i];
  console.log(k + ':' + myObj[k]);
}

^{1 Não é pedante, mas não existe um objeto JSON .}

Muitas pessoas mencionaram que "os objetos não podem ser classificados" , mas depois disso eles estão fornecendo uma solução que funciona. Paradoxo, não é?

Ninguém menciona por que essas soluções estão funcionando. Eles são, porque na maioria das implementações do navegador, os valores nos objetos são armazenados na ordem em que foram adicionados. É por isso que se você criar um novo objeto a partir da lista ordenada de chaves, ele retornará um resultado esperado.

E acho que poderíamos adicionar mais uma solução - a maneira funcional do ES5:

function sortObject(obj) {
    return Object.keys(obj).sort().reduce(function (result, key) {
        result[key] = obj[key];
        return result;
    }, {});
}

Versão ES2015 acima (formatada para "uma linha"):

const sortObject = o => Object.keys(o).sort().reduce((r, k) => (r[k] = o[k], r), {})

Breve explicação dos exemplos acima (conforme solicitado nos comentários):

Object.keysestá nos dando uma lista de chaves no objeto fornecido ( objou o), depois classificamos as que usam o algoritmo de classificação padrão. Em seguida, .reduceé usado para converter essa matriz novamente em um objeto, mas desta vez com todas as chaves classificadas.

Gente, estou figurativamente chocado! Claro que todas as respostas são um pouco antigas, mas ninguém sequer mencionou a estabilidade na classificação! Então, fique comigo, vou tentar o meu melhor para responder à pergunta em si e entrar em detalhes aqui. Então, vou pedir desculpas agora, será muito para ler.

Como em 2018, usarei apenas o ES6, os Polyfills estão disponíveis nos documentos MDN, os quais vincularemos na parte especificada.

Responda a pergunta:

Se suas chaves são apenas números, então você pode usar com segurança Object.keys()juntamente com Array.prototype.reduce()a devolver o objeto ordenada:

// Only numbers to show it will be sorted.
const testObj = {
  '2000': 'Articel1',
  '4000': 'Articel2',
  '1000': 'Articel3',
  '3000': 'Articel4',
};

// I'll explain what reduces does after the answer.
console.log(Object.keys(testObj).reduce((accumulator, currentValue) => {
  accumulator[currentValue] = testObj[currentValue];
  return accumulator;
}, {}));

/**
 * expected output:
 * {
 * '1000': 'Articel3',
 * '2000': 'Articel1',
 * '3000': 'Articel4',
 * '4000': 'Articel2' 
 *  } 
 */

// if needed here is the one liner:
console.log(Object.keys(testObj).reduce((a, c) => (a[c] = testObj[c], a), {}));

No entanto, se você estiver trabalhando com strings, recomendo encadear Array.prototype.sort()tudo isso:

// String example
const testObj = {
  'a1d78eg8fdg387fg38': 'Articel1',
  'z12989dh89h31d9h39': 'Articel2',
  'f1203391dhj32189h2': 'Articel3',
  'b10939hd83f9032003': 'Articel4',
};
// Chained sort into all of this.
console.log(Object.keys(testObj).sort().reduce((accumulator, currentValue) => {
  accumulator[currentValue] = testObj[currentValue];
  return accumulator;
}, {}));

/**
 * expected output:   
 * { 
 * a1d78eg8fdg387fg38: 'Articel1',
 * b10939hd83f9032003: 'Articel4',
 * f1203391dhj32189h2: 'Articel3',
 * z12989dh89h31d9h39: 'Articel2' 
 * }
 */

// again the one liner:
console.log(Object.keys(testObj).sort().reduce((a, c) => (a[c] = testObj[c], a), {}));

Se alguém está se perguntando o que reduz:

// Will return Keys of object as an array (sorted if only numbers or single strings like a,b,c).
Object.keys(testObj)

// Chaining reduce to the returned array from Object.keys().
// Array.prototype.reduce() takes one callback 
// (and another param look at the last line) and passes 4 arguments to it: 
// accumulator, currentValue, currentIndex and array
.reduce((accumulator, currentValue) => {

  // setting the accumulator (sorted new object) with the actual property from old (unsorted) object.
  accumulator[currentValue] = testObj[currentValue];

  // returning the newly sorted object for the next element in array.
  return accumulator;

  // the empty object {} ist the initial value for  Array.prototype.reduce().
}, {});

Se necessário, aqui está a explicação para o liner:

Object.keys(testObj).reduce(

  // Arrow function as callback parameter.
  (a, c) => 

  // parenthesis return! so we can safe the return and write only (..., a);
  (a[c] = testObj[c], a)

  // initial value for reduce.
  ,{}
);

• Documentos para redução: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce
• Por que usar parênteses nas declarações de retorno do JavaScript: http://jamesknelson.com/javascript-return-parenthesis/

Por que a classificação é um pouco complicada:

Em resumo Object.keys(), retornará uma matriz com a mesma ordem que obtemos com um loop normal:

const object1 = {
  a: 'somestring',
  b: 42,
  c: false
};

console.log(Object.keys(object1));
// expected output: Array ["a", "b", "c"]

Object.keys () retorna uma matriz cujos elementos são cadeias correspondentes às propriedades enumeráveis ​​encontradas diretamente no objeto. A ordem das propriedades é a mesma que a especificada repetindo as propriedades do objeto manualmente.

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys

Sidenote - você também pode usar Object.keys()matrizes, lembre-se de que o índice será retornado:

// simple array
const arr = ['a', 'b', 'c'];
console.log(Object.keys(arr)); // console: ['0', '1', '2']

Mas não é tão fácil como mostrado nesses exemplos: objetos do mundo real podem conter números e caracteres alfabéticos ou até símbolos (por favor, não faça isso).

Aqui está um exemplo com todos eles em um objeto:

// This is just to show what happens, please don't use symbols in keys.
const testObj = {
  '1asc': '4444',
  1000: 'a',
  b: '1231',
  '#01010101010': 'asd',
  2: 'c'
};

console.log(Object.keys(testObj));
// output: [ '2', '1000', '1asc', 'b', '#01010101010' ]

Agora, se usarmos Array.prototype.sort()na matriz acima, a saída será alterada:

console.log(Object.keys(testObj).sort());
// output: [ '#01010101010', '1000', '1asc', '2', 'b' ]

Aqui está uma citação dos documentos:

O método sort () classifica os elementos de uma matriz no local e retorna a matriz. O tipo não é necessariamente estável. A ordem de classificação padrão é de acordo com os pontos de código Unicode da sequência.

A complexidade de tempo e espaço da classificação não pode ser garantida, pois depende da implementação.

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort

Você precisa garantir que um deles retorne a saída desejada para você. Nos exemplos da vida real, as pessoas tendem a misturar as coisas especialmente se você usar diferentes entradas de informações, como APIs e bancos de dados.

Então, qual é o grande problema?

Bem, existem dois artigos que todo programador deve entender:

Algoritmo no local :

Na ciência da computação, um algoritmo no local é um algoritmo que transforma a entrada usando nenhuma estrutura de dados auxiliar. No entanto, uma pequena quantidade de espaço de armazenamento extra é permitida para variáveis ​​auxiliares. A entrada geralmente é substituída pela saída à medida que o algoritmo é executado. O algoritmo in-loco atualiza a sequência de entrada apenas através da substituição ou troca de elementos. Um algoritmo que não está no local é chamado às vezes não no local ou fora do local.

Então, basicamente, nossa matriz antiga será substituída! Isso é importante se você deseja manter a matriz antiga por outros motivos. Portanto, mantenha isso em mente.

Algoritmo de classificação

Os algoritmos de classificação estável classificam elementos idênticos na mesma ordem em que aparecem na entrada. Ao classificar alguns tipos de dados, apenas parte dos dados é examinada ao determinar a ordem de classificação. Por exemplo, no exemplo de classificação de cartas à direita, as cartas estão sendo classificadas por sua classificação e seu naipe é ignorado. Isso permite a possibilidade de várias versões diferentes e ordenadas corretamente da lista original. Os algoritmos de classificação estável escolhem um destes, de acordo com a regra a seguir: se dois itens forem comparados como iguais, como os dois 5 cartões, sua ordem relativa será preservada, de modo que, se um veio antes do outro na entrada, ele também será vem antes do outro na saída.

Um exemplo de classificação estável em cartas de baralho. Quando as cartas são classificadas por classificação com uma classificação estável, os dois 5s devem permanecer na mesma ordem na saída classificada em que estavam originalmente. Quando são classificadas com uma classificação não estável, os 5s podem terminar no oposto ordem na saída classificada.

Isso mostra que a classificação está correta, mas mudou. Portanto, no mundo real, mesmo que a classificação esteja correta, temos que garantir o que esperamos! Isso é super importante, lembre-se disso também. Para obter mais exemplos de JavaScript, consulte Array.prototype.sort () - docs: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort

Isso funciona para mim

/**
 * Return an Object sorted by it's Key
 */
var sortObjectByKey = function(obj){
    var keys = [];
    var sorted_obj = {};

    for(var key in obj){
        if(obj.hasOwnProperty(key)){
            keys.push(key);
        }
    }

    // sort keys
    keys.sort();

    // create new array based on Sorted Keys
    jQuery.each(keys, function(i, key){
        sorted_obj[key] = obj[key];
    });

    return sorted_obj;
};

É 2019 e temos uma maneira 2019 de resolver isso :)

Object.fromEntries(Object.entries({b: 3, a:8, c:1}).sort())

aqui está o forro 1

var data = { zIndex:99,
             name:'sravan',
             age:25, 
             position:'architect',
             amount:'100k',
             manager:'mammu' };

console.log(Object.entries(data).sort().reduce( (o,[k,v]) => (o[k]=v,o), {} ));

Esta é uma pergunta antiga, mas seguindo a sugestão da resposta de Mathias Bynens, fiz uma versão curta para classificar o objeto atual , sem muita sobrecarga.

    Object.keys(unordered).sort().forEach(function(key) {
        var value = unordered[key];
        delete unordered[key];
        unordered[key] = value;
    });

após a execução do código, o próprio objeto "não ordenado" terá as chaves classificadas em ordem alfabética.

Usando o lodash, isso funcionará:

some_map = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' }

// perform a function in order of ascending key
_(some_map).keys().sort().each(function (key) {
  var value = some_map[key];
  // do something
});

// or alternatively to build a sorted list
sorted_list = _(some_map).keys().sort().map(function (key) {
  var value = some_map[key];
  // return something that shall become an item in the sorted list
}).value();

Apenas comida para pensar.

Suponha que possa ser útil no depurador do VisualStudio, que mostra propriedades não ordenadas do objeto.

(function(s){var t={};Object.keys(s).sort().forEach(function(k){t[k]=s[k]});return t})({b:2,a:1,c:3})

Versão sublinhada :

function order(unordered)
{
return _.object(_.sortBy(_.pairs(unordered),function(o){return o[0]}));
}

Se você não confiar no seu navegador para manter a ordem das chaves, sugiro que confie em uma matriz ordenada de matrizes emparelhadas com valor-chave.

_.sortBy(_.pairs(c),function(o){return o[0]})

function sortObjectKeys(obj){
    return Object.keys(obj).sort().reduce((acc,key)=>{
        acc[key]=obj[key];
        return acc;
    },{});
}

sortObjectKeys({
    telephone: '069911234124',
    name: 'Lola',
    access: true,
});

Talvez uma forma um pouco mais elegante:

 /**
     * Sorts a key-value object by key, maintaining key to data correlations.
     * @param {Object} src  key-value object
     * @returns {Object}
     */
var ksort = function ( src ) {
      var keys = Object.keys( src ),
          target = {};
      keys.sort();
      keys.forEach(function ( key ) {
        target[ key ] = src[ key ];
      });
      return target;
    };


// Usage
console.log(ksort({
  a:1,
  c:3,
  b:2  
}));

PS e o mesmo com a sintaxe ES6 +:

function ksort( src ) {
  const keys = Object.keys( src );
  keys.sort();
  return keys.reduce(( target, key ) => {
        target[ key ] = src[ key ];
        return target;
  }, {});
};

classificação recursiva, para objetos e matrizes aninhados

function sortObjectKeys(obj){
    return Object.keys(obj).sort().reduce((acc,key)=>{
        if (Array.isArray(obj[key])){
            acc[key]=obj[key].map(sortObjectKeys);
        }
        if (typeof obj[key] === 'object'){
            acc[key]=sortObjectKeys(obj[key]);
        }
        else{
            acc[key]=obj[key];
        }
        return acc;
    },{});
}

// test it
sortObjectKeys({
    telephone: '069911234124',
    name: 'Lola',
    access: true,
    cars: [
        {name: 'Family', brand: 'Volvo', cc:1600},
        {
            name: 'City', brand: 'VW', cc:1200, 
            interior: {
                wheel: 'plastic',
                radio: 'blaupunkt'
            }
        },
        {
            cc:2600, name: 'Killer', brand: 'Plymouth',
            interior: {
                wheel: 'wooden',
                radio: 'earache!'
            }
        },
    ]
});

Como já mencionado, os objetos não são ordenados.

Contudo...

Você pode achar útil esse idioma:

var o = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' };

var kv = [];

for (var k in o) {
  kv.push([k, o[k]]);
}

kv.sort()

Você pode iterar através de kv e fazer o que quiser.

> kv.sort()
[ [ 'a', 'dsfdsfsdf' ],
  [ 'b', 'asdsad' ],
  [ 'c', 'masdas' ] ]

Aqui está uma versão limpa baseada em lodash que funciona com objetos aninhados

/**
 * Sort of the keys of an object alphabetically
 */
const sortKeys = function(obj) {
  if(_.isArray(obj)) {
    return obj.map(sortKeys);
  }
  if(_.isObject(obj)) {
    return _.fromPairs(_.keys(obj).sort().map(key => [key, sortKeys(obj[key])]));
  }
  return obj;
};

Seria ainda mais limpo se o lodash tivesse um toObject()método ...

Basta usar o lodash para descompactar o mapa e classificar. Pelo primeiro valor do par e zip novamente, ele retornará a chave classificada.

Se você deseja classificar o valor, altere o índice do par para 1 em vez de 0

var o = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' };
console.log(_(o).toPairs().sortBy(0).fromPairs().value())

Classifica chaves recursivamente enquanto preserva as referências.

function sortKeys(o){
    if(o && o.constructor === Array)
        o.forEach(i=>sortKeys(i));
    else if(o && o.constructor === Object)
        Object.entries(o).sort((a,b)=>a[0]>b[0]?1:-1).forEach(e=>{
            sortKeys(e[1]);
            delete o[e[0]];
            o[e[0]] = e[1];
        });
}

Exemplo:

let x = {d:3, c:{g:20, a:[3,2,{s:200, a:100}]}, a:1};
let y = x.c;
let z = x.c.a[2];
sortKeys(x);
console.log(x); // {a: 1, c: {a: [3, 2, {a: 1, s: 2}], g: 2}, d: 3}
console.log(y); // {a: [3, 2, {a: 100, s: 200}}, g: 20}
console.log(z); // {a: 100, s: 200}

Object.keys(unordered).sort().reduce(
    (acc,curr) => ({...acc, [curr]:unordered[curr]})
    , {}
)

Esta é uma solução leve para tudo o que preciso para a classificação JSON.

function sortObj(obj) {
    if (typeof obj !== "object" || obj === null)
        return obj;

    if (Array.isArray(obj))
        return obj.map((e) => sortObj(e)).sort();

    return Object.keys(obj).sort().reduce((sorted, k) => {
        sorted[k] = sortObj(obj[k]);
        return sorted;
    }, {});
}

Use esse código se você tiver objetos aninhados ou se tiver objetos de matriz aninhados.

var sortObjectByKey = function(obj){
    var keys = [];
    var sorted_obj = {};
    for(var key in obj){
        if(obj.hasOwnProperty(key)){
            keys.push(key);
        }
    }
    // sort keys
    keys.sort();

    // create new array based on Sorted Keys
    jQuery.each(keys, function(i, key){
        var val = obj[key];
        if(val instanceof Array){
            //do for loop;
            var arr = [];
            jQuery.each(val,function(){
                arr.push(sortObjectByKey(this));
            }); 
            val = arr;

        }else if(val instanceof Object){
            val = sortObjectByKey(val)
        }
        sorted_obj[key] = val;
    });
    return sorted_obj;
};

Solução:

function getSortedObject(object) {
  var sortedObject = {};

  var keys = Object.keys(object);
  keys.sort();

  for (var i = 0, size = keys.length; i < size; i++) {
    key = keys[i];
    value = object[key];
    sortedObject[key] = value;
  }

  return sortedObject;
}

// Test run
getSortedObject({d: 4, a: 1, b: 2, c: 3});

Explicação:

Muitos tempos de execução do JavaScript armazenam valores dentro de um objeto na ordem em que são adicionados.

Para classificar as propriedades de um objeto por suas chaves, você pode usar a função Object.keys que retornará uma matriz de chaves. A matriz de chaves pode ser classificada pelo Array.prototype.sort () método que classifica os elementos de uma matriz no local (não é necessário atribuí-los a uma nova variável).

Depois que as chaves são classificadas, você pode começar a usá-las uma a uma para acessar o conteúdo do objeto antigo e preencher um novo objeto (que agora está classificado).

Abaixo está um exemplo do procedimento (você pode testá-lo nos navegadores de destino):

/**
 * Returns a copy of an object, which is ordered by the keys of the original object.
 *
 * @param {Object} object - The original object.
 * @returns {Object} Copy of the original object sorted by keys.
 */
function getSortedObject(object) {
  // New object which will be returned with sorted keys
  var sortedObject = {};

  // Get array of keys from the old/current object
  var keys = Object.keys(object);
  // Sort keys (in place)
  keys.sort();

  // Use sorted keys to copy values from old object to the new one
  for (var i = 0, size = keys.length; i < size; i++) {
    key = keys[i];
    value = object[key];
    sortedObject[key] = value;
  }

  // Return the new object
  return sortedObject;
}

/**
 * Test run
 */
var unsortedObject = {
  d: 4,
  a: 1,
  b: 2,
  c: 3
};

var sortedObject = getSortedObject(unsortedObject);

for (var key in sortedObject) {
  var text = "Key: " + key + ", Value: " + sortedObject[key];
  var paragraph = document.createElement('p');
  paragraph.textContent = text;
  document.body.appendChild(paragraph);
}

Nota: Object.keys é um método ECMAScript 5.1, mas aqui está um polyfill para navegadores mais antigos:

if (!Object.keys) {
  Object.keys = function (object) {
    var key = [];
    var property = undefined;
    for (property in object) {
      if (Object.prototype.hasOwnProperty.call(object, property)) {
        key.push(property);
      }
    }
    return key;
  };
}

Transferi algumas enumerações Java para objetos javascript.

Esses objetos retornaram matrizes corretas para mim. se as chaves do objeto são do tipo misto (string, int, char), há um problema.

var Helper = {
    isEmpty: function (obj) {
        return !obj || obj === null || obj === undefined || Array.isArray(obj) && obj.length === 0;
    },

    isObject: function (obj) {
        return (typeof obj === 'object');
    },

    sortObjectKeys: function (object) {
        return Object.keys(object)
            .sort(function (a, b) {
                c = a - b;
                return c
            });
    },
    containsItem: function (arr, item) {
        if (arr && Array.isArray(arr)) {
            return arr.indexOf(item) > -1;
        } else {
            return arr === item;
        }
    },

    pushArray: function (arr1, arr2) {
        if (arr1 && arr2 && Array.isArray(arr1)) {
            arr1.push.apply(arr1, Array.isArray(arr2) ? arr2 : [arr2]);
        }
    }
};

function TypeHelper() {
    var _types = arguments[0],
        _defTypeIndex = 0,
        _currentType,
        _value;

    if (arguments.length == 2) {
        _defTypeIndex = arguments[1];
    }

    Object.defineProperties(this, {
        Key: {
            get: function () {
                return _currentType;
            },
            set: function (val) {
                _currentType.setType(val, true);
            },
            enumerable: true
        },
        Value: {
            get: function () {
                return _types[_currentType];
            },
            set: function (val) {
                _value.setType(val, false);
            },
            enumerable: true
        }
    });

    this.getAsList = function (keys) {
        var list = [];
        Helper.sortObjectKeys(_types).forEach(function (key, idx, array) {
            if (key && _types[key]) {

                if (!Helper.isEmpty(keys) && Helper.containsItem(keys, key) || Helper.isEmpty(keys)) {
                    var json = {};
                    json.Key = key;
                    json.Value = _types[key];
                    Helper.pushArray(list, json);
                }
            }
        });
        return list;
    };

    this.setType = function (value, isKey) {
        if (!Helper.isEmpty(value)) {
            Object.keys(_types).forEach(function (key, idx, array) {
                if (Helper.isObject(value)) {
                    if (value && value.Key == key) {
                        _currentType = key;
                    }
                } else if (isKey) {
                    if (value && value.toString() == key.toString()) {
                        _currentType = key;
                    }
                } else if (value && value.toString() == _types[key]) {
                    _currentType = key;
                }
            });
        } else {
            this.setDefaultType();
        }
        return isKey ? _types[_currentType] : _currentType;
    };

    this.setTypeByIndex = function (index) {
        var keys = Helper.sortObjectKeys(_types);
        for (var i = 0; i < keys.length; i++) {
            if (index === i) {
                _currentType = keys[index];
                break;
            }
        }
    };

    this.setDefaultType = function () {
        this.setTypeByIndex(_defTypeIndex);
    };

    this.setDefaultType();
}


var TypeA = {
    "-1": "Any",
    "2": "2L",
    "100": "100L",
    "200": "200L",
    "1000": "1000L"
};

var TypeB = {
    "U": "Any",
    "W": "1L",
    "V": "2L",
    "A": "100L",
    "Z": "200L",
    "K": "1000L"
};
console.log('keys of TypeA', Helper.sortObjectKeys(TypeA));//keys of TypeA ["-1", "2", "100", "200", "1000"]

console.log('keys of TypeB', Helper.sortObjectKeys(TypeB));//keys of TypeB ["U", "W", "V", "A", "Z", "K"]

var objectTypeA = new TypeHelper(TypeA),
    objectTypeB = new TypeHelper(TypeB);

console.log('list of objectA = ', objectTypeA.getAsList());
console.log('list of objectB = ', objectTypeB.getAsList());

Types:

var TypeA = {
    "-1": "Any",
    "2": "2L",
    "100": "100L",
    "200": "200L",
    "1000": "1000L"
};

var TypeB = {
    "U": "Any",
    "W": "1L",
    "V": "2L",
    "A": "100L",
    "Z": "200L",
    "K": "1000L"
};


Sorted Keys(output):

Key list of TypeA -> ["-1", "2", "100", "200", "1000"]

Key list of TypeB -> ["U", "W", "V", "A", "Z", "K"]

Fragmento simples e legível, usando lodash.

Você precisa colocar a chave entre aspas apenas ao chamar sortBy. Ele não precisa estar entre aspas nos próprios dados.

_.sortBy(myObj, "key")

Além disso, seu segundo parâmetro para mapear está errado. Deve ser uma função, mas o uso de arrancar é mais fácil.

_.map( _.sortBy(myObj, "key") , "value");

Há um ótimo projeto de @sindresorhus chamado sort-keys que funciona de maneira incrível.

Você pode verificar seu código fonte aqui:

https://github.com/sindresorhus/sort-keys

Ou você pode usá-lo com o npm:

$ npm install --save sort-keys

Aqui também estão exemplos de código de seu leia-me

const sortKeys = require('sort-keys');

sortKeys({c: 0, a: 0, b: 0});
//=> {a: 0, b: 0, c: 0}

sortKeys({b: {b: 0, a: 0}, a: 0}, {deep: true});
//=> {a: 0, b: {a: 0, b: 0}}

sortKeys({c: 0, a: 0, b: 0}, {
    compare: (a, b) => -a.localeCompare(b)
});
//=> {c: 0, b: 0, a: 0}

Resposta JavaScript pura para classificar um Objeto. Esta é a única resposta que conheço que manipulará números negativos. Esta função é para classificar objetos numéricos.

Objeto de entrada = {1000: {}, -1200: {}, 10000: {}, 200: {}};

function osort(obj) {
var keys = Object.keys(obj);
var len = keys.length;
var rObj = [];
var rK = [];
var t = Object.keys(obj).length;
while(t > rK.length) {
    var l = null;
    for(var x in keys) {
        if(l && parseInt(keys[x]) < parseInt(l)) {
            l = keys[x];
            k = x;
        }
        if(!l) { // Find Lowest
            var l = keys[x];
            var k = x;
        }
    }
    delete keys[k];
    rK.push(l);
}

for (var i = 0; i < len; i++) {

    k = rK[i];
    rObj.push(obj[k]);
}
return rObj;
}

A saída será um objeto classificado por esses números com novas chaves começando em 0.

Apenas para simplificá-lo e deixar mais clara a resposta de Matt Ball

//your object
var myObj = {
    b : 'asdsadfd',
    c : 'masdasaf',
    a : 'dsfdsfsdf'
  };

//fixed code
var keys = [];
for (var k in myObj) {
  if (myObj.hasOwnProperty(k)) {
    keys.push(k);
  }
}
keys.sort();
for (var i = 0; i < keys.length; i++) {
  k = keys[i];
  alert(k + ':' + myObj[k]);
}

Não tenho certeza se isso responde à pergunta, mas é disso que eu precisava.

Maps.iterate.sorted = function (o, callback) {
    var keys = Object.keys(o), sorted = keys.sort(), k; 
    if ( callback ) {
            var i = -1;
            while( ++i < sorted.length ) {
                    callback(k = sorted[i], o[k] );
            }
    }

    return sorted;
}

Chamado como:

Maps.iterate.sorted({c:1, b:2, a:100}, function(k, v) { ... } ) 

A única linha:

Object.entries(unordered)
  .sort(([keyA], [keyB]) => keyA > keyB)
  .reduce((obj, [key,value]) => Object.assign(obj, {[key]: value}), {})

a melhor maneira de fazer isso é

 const object =  Object.keys(o).sort().reduce((r, k) => (r[k] = o[k], r), {})

 //else if its in reverse just do 

 const object = Object.keys(0).reverse ()

Você pode primeiro converter seu objeto quase do tipo matriz em uma matriz real e, em seguida, usar .reverse ():

Object.assign([], {1:'banana', 2:'apple', 
3:'orange'}).reverse();
// [ "orange", "apple", "banana", <1 empty slot> ]

O slot vazio no final se causa porque o seu primeiro índice é 1 em vez de 0. Você pode remover o slot vazio com .length-- ou .pop ().

Como alternativa, se você deseja emprestar .reverse e chamá-lo no mesmo objeto, ele deve ser um objeto totalmente do tipo matriz. Ou seja, ele precisa de uma propriedade length:

Array.prototype.reverse.call({1:'banana', 2:'apple', 
3:'orange', length:4});
// {0:"orange", 1:"apple", 3:"banana", length:4}

Observe que ele retornará o mesmo objeto de objeto totalmente de matriz, portanto não será uma matriz real. Você pode usar delete para remover a propriedade length.