J'ai essayé de comprendre un problème très étrange que j'ai rencontré avec le tapuscrit. Il traitait une expression booléenne en ligne comme quel que soit le type de la première valeur au lieu de l'expression complète.

Donc, si vous essayez quelque chose de simple comme celui-ci:

var numericArray:Array<number> = [2,3,4,1,5,8,11];

var sorrtedArray:Array<number> = numericArray.sort((n1,n2)=> n1 > n2);

TryIt

Vous obtiendrez une erreur sur votre méthode de tri indiquant que les paramètres ne correspondent à aucune signature de la cible de l'appel, car votre résultat est numérique et non booléen. Je suppose que je manque quelque chose car je suis presque sûr que n1> n2 est une instruction booléenne.

L'erreur est tout à fait correcte.

Comme il essaie de vous le dire, .sort()prend une fonction qui renvoie un nombre, pas un booléen.

Vous devez renvoyer négatif si le premier élément est plus petit; positive si elle est plus grande, ou zéro si elles sont égales.

Nombres

Lors du tri des nombres, vous pouvez utiliser la comparaison compacte:

var numericArray: number[] = [2, 3, 4, 1, 5, 8, 11];

var sortedArray: number[] = numericArray.sort((n1,n2) => n1 - n2);

c'est à dire -plutôt que <.

Autres types

Si vous comparez autre chose, vous devrez convertir la comparaison en un nombre.

var stringArray: string[] = ['AB', 'Z', 'A', 'AC'];

var sortedArray: string[] = stringArray.sort((n1,n2) => {
    if (n1 > n2) {
        return 1;
    }

    if (n1 < n2) {
        return -1;
    }

    return 0;
});

Objets

Pour les objets, vous pouvez trier en fonction d'une propriété, gardez à l'esprit les informations ci-dessus sur la possibilité de raccourcir les types de nombres. L'exemple ci-dessous fonctionne quel que soit le type.

var objectArray: { age: number; }[] = [{ age: 10}, { age: 1 }, {age: 5}];

var sortedArray: { age: number; }[] = objectArray.sort((n1,n2) => {
    if (n1.age > n2.age) {
        return 1;
    }

    if (n1.age < n2.age) {
        return -1;
    }

    return 0;
});

Excellente réponse Sohnee. Je voudrais ajouter que si vous avez un tableau d'objets et que vous souhaitez trier par clé, c'est presque la même chose, voici un exemple qui peut trier à la fois par date (numéro) ou par titre (chaîne):

    if (sortBy === 'date') {
        return n1.date - n2.date
    } else {
        if (n1.title > n2.title) {
           return 1;
        }
        if (n1.title < n2.title) {
            return -1;
        }
        return 0;
    }

Pourrait également rendre les valeurs à l'intérieur comme des variables n1 [champ] vs n2 [champ] si c'est plus dynamique, gardez simplement la différence entre les chaînes et les nombres.

let numericArray: number[] = [2, 3, 4, 1, 5, 8, 11];

let sortFn = (n1 , n2) => number { return n1 - n2; }

const sortedArray: number[] = numericArray.sort(sortFn);

Trier par un champ:

let arr:{key:number}[] = [{key : 2}, {key : 3}, {key : 4}, {key : 1}, {key : 5}, {key : 8}, {key : 11}];

let sortFn2 = (obj1 , obj2) => {key:number} { return obj1.key - obj2.key; }

const sortedArray2:{key:number}[] = arr.sort(sortFn2);

Trier les tableaux mixtes (alphabets et nombres)

function naturalCompare(a, b) {
   var ax = [], bx = [];

   a.replace(/(\d+)|(\D+)/g, function (_, $1, $2) { ax.push([$1 || Infinity, $2 || ""]) });
   b.replace(/(\d+)|(\D+)/g, function (_, $1, $2) { bx.push([$1 || Infinity, $2 || ""]) });

   while (ax.length && bx.length) {
     var an = ax.shift();
     var bn = bx.shift();
     var nn = (an[0] - bn[0]) || an[1].localeCompare(bn[1]);
     if (nn) return nn;
   }

   return ax.length - bx.length;
}

let builds = [ 
    { id: 1, name: 'Build 91'}, 
    { id: 2, name: 'Build 32' }, 
    { id: 3, name: 'Build 13' }, 
    { id: 4, name: 'Build 24' },
    { id: 5, name: 'Build 5' },
    { id: 6, name: 'Build 56' }
]

let sortedBuilds = builds.sort((n1, n2) => {
  return naturalCompare(n1.name, n2.name)
})

console.log('Sorted by name property')
console.log(sortedBuilds)

Le moyen le plus simple semble être de soustraire le deuxième nombre du premier:

var numericArray:Array<number> = [2,3,4,1,5,8,11];

var sorrtedArray:Array<number> = numericArray.sort((n1,n2) => n1 - n2);

https://alligator.io/js/array-sort-numbers/

J'ai écrit celui-ci aujourd'hui en essayant de le recréer _.sortByen TypeScript, et j'ai pensé que je le laisserais à quiconque en aurait besoin.

// ** Credits for getKeyValue at the bottom **
export const getKeyValue = <T extends {}, U extends keyof T>(key: U) => (obj: T) => obj[key] 

export const sortBy = <T extends {}>(index: string, list: T[]): T[] => {
    return list.sort((a, b): number => {
        const _a = getKeyValue<keyof T, T>(index)(a)
        const _b = getKeyValue<keyof T, T>(index)(b)
        if (_a < _b) return -1
        if (_a > _b) return 1
        return 0
    })
}

Usage:

Il attend un tableau de type générique T, d'où le cast pour <T extends {}>, ainsi que la saisie du paramètre et du type de retour de fonction avecT[]

const x = [{ label: 'anything' }, { label: 'goes'}]
const sorted = sortBy('label', x)

** getByKeyfn trouvé ici