Go Academy · Leçon

Ordres de tri personnalisés

Définir des fonctions de comparaison

Ordres de tri personnalisés est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Au-delà de l'ordre par défaut

Le tri par défaut s'effectue par ordre croissant. Mais les données réelles nécessitent des règles personnalisées : trier par longueur, selon plusieurs champs ou selon une valeur calculée.

La fonction de comparaison est l'endroit où vous exprimez la règle de votre choix.

La fonction de comparaison

Une fonction de comparaison pour sort.Slice a la signature func(i, j int) bool. Elle renvoie true lorsque l'élément i doit précéder l'élément j.

package main

import (
	"fmt"
	"sort"
)

func main() {
	nums := []int{4, 1, 3}
	less := func(i, j int) bool { return nums[i] < nums[j] }
	sort.Slice(nums, less)
	fmt.Println(nums)
}

Trier par longueur de chaîne

Au lieu de comparer les chaînes par ordre alphabétique, comparez le résultat de len() pour les classer selon leur longueur.

package main

import (
	"fmt"
	"sort"
)

func main() {
	words := []string{"pear", "fig", "banana"}
	sort.Slice(words, func(i, j int) bool {
		return len(words[i]) < len(words[j])
	})
	fmt.Println(words)
}

Trier des structures selon un champ

Choisissez n'importe quel champ de la structure pour la comparaison. Ici, nous trions les produits selon leur prix.

package main

import (
	"fmt"
	"sort"
)

type Product struct {
	Name  string
	Price int
}

func main() {
	items := []Product{{"Pen", 3}, {"Book", 12}, {"Cup", 7}}
	sort.Slice(items, func(i, j int) bool {
		return items[i].Price < items[j].Price
	})
	fmt.Println(items)
}

Tri selon plusieurs champs

Pour départager les égalités, comparez un second champ lorsque le premier est égal. Triez selon l'âge, puis selon le nom.

package main

import (
	"fmt"
	"sort"
)

type Person struct {
	Name string
	Age  int
}

func main() {
	p := []Person{{"Zoe", 30}, {"Ann", 30}, {"Bob", 25}}
	sort.Slice(p, func(i, j int) bool {
		if p[i].Age != p[j].Age {
			return p[i].Age < p[j].Age
		}
		return p[i].Name < p[j].Name
	})
	fmt.Println(p)
}

Inverser avec sort.Reverse

sort.Reverse enveloppe une sort.Interface pour inverser son ordre. Elle s'associe à des fonctions auxiliaires comme sort.IntSlice.

package main

import (
	"fmt"
	"sort"
)

func main() {
	nums := []int{1, 4, 2, 3}
	sort.Sort(sort.Reverse(sort.IntSlice(nums)))
	fmt.Println(nums)
}

L'interface sort.Interface

Pour un contrôle total, implémentez sort.Interface : trois méthodes Len(), Less(i, j int) bool et Swap(i, j int).

package main

import (
	"fmt"
	"sort"
)

type ByLen []string

func (s ByLen) Len() int           { return len(s) }
func (s ByLen) Less(i, j int) bool { return len(s[i]) < len(s[j]) }
func (s ByLen) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

func main() {
	w := []string{"ccc", "a", "bb"}
	sort.Sort(ByLen(w))
	fmt.Println(w)
}

Trier selon une valeur calculée

La comparaison peut utiliser n'importe quelle expression. Triez les nombres selon leur distance absolue par rapport à zéro.

package main

import (
	"fmt"
	"sort"
)

func abs(n int) int {
	if n < 0 {
		return -n
	}
	return n
}

func main() {
	nums := []int{-5, 2, -1, 3}
	sort.Slice(nums, func(i, j int) bool {
		return abs(nums[i]) < abs(nums[j])
	})
	fmt.Println(nums)
}

Tri insensible à la casse

Utilisez strings.ToLower dans la comparaison pour ignorer la casse lors du classement des chaînes.

package main

import (
	"fmt"
	"sort"
	"strings"
)

func main() {
	w := []string{"banana", "Apple", "cherry"}
	sort.Slice(w, func(i, j int) bool {
		return strings.ToLower(w[i]) < strings.ToLower(w[j])
	})
	fmt.Println(w)
}

Tranche ou interface

Deux façons de personnaliser l'ordre :

sort.Slice - fonction de comparaison rapide et intégrée directement
sort.Interface - type nommé réutilisable avec trois méthodes

Privilégiez sort.Slice pour les tris ponctuels.

Garder les comparaisons pures

Une fonction de comparaison doit seulement lire les éléments et renvoyer une valeur booléenne. Elle ne doit pas modifier la tranche ni produire d'effets secondaires, sinon le tri risque de se comporter de manière imprévisible.

Vérification rapide

Vous voulez trier des personnes selon leur âge, puis selon leur nom lorsque les âges sont égaux. Quelle technique utilisez-vous ?

Récapitulatif

Vous pouvez définir n'importe quel ordre de tri :

La fonction de comparaison exprime votre règle
Les tris selon plusieurs champs comparent un second champ en cas d'égalité
sort.Reverse inverse l'ordre ; sort.Interface fournit des types réutilisables

Questions Fréquemment Posées

La leçon « Ordres de tri personnalisés » est-elle gratuite ?

Oui — le texte complet de « Ordres de tri personnalisés » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Ordres de tri personnalisés » ?

Définir des fonctions de comparaison Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Ordres de tri personnalisés » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Go Academy