Primero, expandamos el código para que sea (ligeramente) más fácil de leer.

Tenga en cuenta que el ?: contiene una lógica cuestionable, el uso de === parece sugerir que está tratando de manejar la clasificación de una matriz de tipos mixtos, pero luego usa comparaciones < y > no estrictas. Entonces, para los fines del resto de esta respuesta, supondré que no está tratando de ordenar matrices de tipos mixtos o que, si lo está, ignorará las comparaciones de tipo estrictas (es decir, el === realmente debería ser == )

 function orderArr (arr: any[], key: string) { function sorter(a, b) { return ( (a[key] > b[key]) ? 1 : (a[key] === b[key]) ? ( (a[key] > b[key]) ? 1 : -1 ) : -1 ); } return arr.sort(sorter); } export orderArr;

Ahora volvamos a escribir la expresión ?: demasiado complicada (demasiado complicada no por la sintaxis ?: sino porque está haciendo más de lo necesario) y reescribiéndola como si fuera otra cosa (tenga en cuenta que este código sigue siendo incorrecto)

 function sorter(a, b) { if (a[key] > b[key]) { return 1; // return 1 if a > b } else { if (a[key] === b[key]) { // questionable logic if (a[key] > b[key]) { // questionable logic return 1; } else { return -1; // will always return -1 (wrong, a == b should return 0) } } else { return -1; // return -1 if a < b // or if type of a does not equal type of b (questionable) } } }

Ahora simplifiquemos y solucionemos el error (es decir, eliminemos la comparación estricta de tipos). Usar una técnica llamada devolución anticipada (también llamada cláusulas de guardia) y evitar usar otra cosa, ya que agrega sangría y complicaciones innecesarias.

 function sorter(a, b) { if (a[key] > b[key]) return 1; if (a[key] < b[key]) return -1; return 0; }

O si lo prefieres, usando ?: sintaxis

 function sorter(a, b) { return a[key] > b[key] ? 1 : a[key] < b[key] ? -1 : 0; }

Si está ordenando números, puede usar un pequeño truco para simplificar aún más el código. Ordenar espera un 0 si a y b son iguales, un valor negativo si a < b y un valor positivo si a > b , por lo que para la clasificación numérica simplemente podemos hacer

 function sorter(a, b) { return a[key] - b[key]; }

Ahora, volvamos a juntar todo el código simplificado en una sola línea. Primero para cualquier tipo de matriz.

 export const orderArr = (arr: any[], key: string) => arr.sort((a, b) => a[key] > b[key] ? 1 : a[key] < b[key] ? -1 : 0);

y para una matriz solo numérica

 export const orderArr = (arr: any[], key: string) => arr.sort((a, b) => a[key] - b[key]);

Editar:

De acuerdo con la respuesta de @Erich Kitzmueller, eliminé una parte [clave] === b[clave] :

 export const orderArr = (arr: any[], key: string) => arr.sort((a, b) => { if(a[key] > b[key]){ return 1; } else { return -1; } } );

Respuesta original:

No estoy seguro acerca de la estructura de la función de clasificación, pero la declaración if podría verse a continuación:

 export const orderArr = (arr: any[], key: string) => arr.sort((a, b) => { if(a[key] > b[key] || a[key] === b[key]){ return 1; } else { return -1; } } );

export const orderArr = (arr: any[], key: string) => arr.sort((a, b) => ((a[key] > b[key]) ? 1 : (a[key] === b[key]) ? ((a[key] > b[key]) ? 1 : -1) : -1));

es igual a:

 export const orderArr = (arr: any[], key: string) => { return arr.sort((a, b) => { if (a[key] > b[key]) { return 1; } else if (a[key] === b[key]) { if (a[key] > b[key]) { return 1; } else { return -1; } } else { return -1; } }) }

Creo firmemente que no es necesario usar operadores ternarios anidados de más de 3 niveles en ningún lugar porque es un gran sacrificio de legibilidad del código sin ningún motivo.

Siéntase libre de reescribir el método a if/else común o switch declaraciones para mantener su código claro.