Chicos, estoy figurativamente sorprendido! ¡Seguro que todas las respuestas son algo viejas, pero nadie mencionó la estabilidad en la clasificación! Así que tengan paciencia conmigo, haré todo lo posible para responder la pregunta en sí y entrar en detalles aquí. Así que voy a disculparme ahora, será mucho para leer.
Como es 2018, solo usaré ES6, los Polyfills están disponibles en los documentos de MDN, que vincularé en la parte dada.
Respuesta a la pregunta:
Si sus claves son solo números, puede usarlas Object.keys()con seguridad Array.prototype.reduce()para devolver el objeto ordenado:
// 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), {}));
Sin embargo, si está trabajando con cadenas, le recomiendo encadenar Array.prototype.sort()todo esto:
// 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), {}));
Si alguien se pregunta qué reduce:
// 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().
}, {});
Si es necesario, aquí está la explicación del único revestimiento:
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.
,{}
);
Por qué ordenar es un poco complicado:
En resumen Object.keys(), devolverá una matriz en el mismo orden que obtenemos con un bucle normal:
const object1 = {
a: 'somestring',
b: 42,
c: false
};
console.log(Object.keys(object1));
// expected output: Array ["a", "b", "c"]
Object.keys () devuelve una matriz cuyos elementos son cadenas correspondientes a las propiedades enumerables que se encuentran directamente sobre el objeto. El orden de las propiedades es el mismo que el dado al recorrer manualmente las propiedades del objeto.
Nota al margen: también se puede usar Object.keys()en matrices, tenga en cuenta que se devolverá el índice:
// simple array
const arr = ['a', 'b', 'c'];
console.log(Object.keys(arr)); // console: ['0', '1', '2']
Pero no es tan fácil como se muestra en esos ejemplos, los objetos del mundo real pueden contener números y caracteres alfabéticos o incluso símbolos (por favor, no lo haga).
Aquí hay un ejemplo con todos ellos en un 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' ]
Ahora, si usamos Array.prototype.sort()en la matriz de arriba, la salida cambia:
console.log(Object.keys(testObj).sort());
// output: [ '#01010101010', '1000', '1asc', '2', 'b' ]
Aquí hay una cita de los documentos:
El método sort () ordena los elementos de una matriz en su lugar y devuelve la matriz. El tipo no es necesariamente estable. El orden de clasificación predeterminado es de acuerdo con los puntos de código Unicode de cadena.
La complejidad de tiempo y espacio de este tipo no se puede garantizar, ya que depende de la implementación.
Debe asegurarse de que uno de ellos le devuelva el resultado deseado. En los ejemplos de Reallife, la gente tiende a mezclar cosas especialmente si usa diferentes entradas de información como API y bases de datos juntas.
¿Así que cuál es el problema?
Bueno, hay dos artículos que todo programador debe entender:
Algoritmo en el lugar :
En informática, un algoritmo in situ es un algoritmo que transforma la entrada sin utilizar una estructura de datos auxiliar. Sin embargo, se permite una pequeña cantidad de espacio de almacenamiento adicional para las variables auxiliares. La entrada generalmente se sobrescribe con la salida a medida que se ejecuta el algoritmo. El algoritmo in situ actualiza la secuencia de entrada solo mediante el reemplazo o el intercambio de elementos. Un algoritmo que no está en el lugar a veces se llama no en el lugar o fuera de lugar.
Así que, básicamente, nuestra matriz anterior se sobrescribirá. Esto es importante si desea mantener la matriz anterior por otros motivos. Así que ten esto en cuenta.
Algoritmo de clasificación
Los algoritmos de ordenación estable ordenan elementos idénticos en el mismo orden en que aparecen en la entrada. Al ordenar algunos tipos de datos, solo se examina parte de los datos al determinar el orden de clasificación. Por ejemplo, en el ejemplo de clasificación de cartas a la derecha, las cartas se ordenan por su rango y se ignora su palo. Esto permite la posibilidad de múltiples versiones diferentes ordenadas correctamente de la lista original. Los algoritmos de clasificación estable eligen uno de estos, de acuerdo con la siguiente regla: si dos elementos se comparan como iguales, como las dos 5 cartas, entonces se mantendrá su orden relativo, de modo que si uno se antepone al otro en la entrada, también venir antes que el otro en la salida.
Un ejemplo de clasificación estable en naipes. Cuando las tarjetas se ordenan por rango con una clasificación estable, las dos 5 deben permanecer en el mismo orden en la salida ordenada en la que se encontraban originalmente. Cuando se clasifican con una clasificación no estable, las 5 pueden terminar en el lado opuesto orden en la salida ordenada.
Esto muestra que la clasificación es correcta pero cambió. Entonces, en el mundo real, incluso si la clasificación es correcta, ¡debemos asegurarnos de obtener lo que esperamos! Esto es muy importante, tenga esto en cuenta también. Para obtener más ejemplos de JavaScript, consulte Array.prototype.sort () - documentos: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort
