L'interface sort.Interface

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy — leçon 74 sur 107.

Le package sort fournit un autre excellent exemple de conception basée sur les interfaces. Pour trier une collection personnalisée, votre type doit implémenter sort.Interface :

type Interface interface {
    Len() int
    Less(i, j int) bool
    Swap(i, j int)
}

Ces trois méthodes donnent à l'algorithme de tri tout ce dont il a besoin : la longueur de la collection, un moyen de comparer les éléments et un moyen de les échanger. Voici comment rendre triable une slice de structs personnalisées :

type Person struct {
    Name string
    Age  int
}

type ByAge []Person

func (a ByAge) Len() int           { return len(a) }
func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }
func (a ByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }

func main() {
    people := []Person{
        {"Alice", 30},
        {"Bob", 25},
        {"Carol", 35},
    }
    
    sort.Sort(ByAge(people))
    fmt.Println(people)
    // [{Bob 25} {Alice 30} {Carol 35}]
}

L'idée maîtresse est de créer un type nommé (ByAge) basé sur votre slice. Cela vous permet de définir différents comportements de tri pour les mêmes données. Vous pourriez créer ByName avec une implémentation de Less différente pour trier par ordre alphabétique à la place.

Une fois que votre type satisfait sort.Interface, il fonctionne automatiquement avec sort.Sort(), sort.Reverse() et sort.IsSorted().

Défi

Facile

Construisons un système d'inventaire de produits triable qui démontre la puissance de sort.Interface de Go ! Vous allez créer un type Product et implémenter plusieurs stratégies de tri, permettant à la même collection d'être triée de différentes manières.

Vous organiserez votre code sur deux fichiers :

product.go : Définissez votre type de produit et les implémentations de tri.
Créez une structure Product avec trois champs : Name (string), Price (float64), et Quantity (int).

Créez deux types nommés basés sur []Product :
- ByPrice - pour trier les produits par prix par ordre croissant
- ByQuantity - pour trier les produits par quantité par ordre décroissant (la plus grande quantité en premier)
Chaque type doit implémenter les trois méthodes requises par sort.Interface : Len(), Less(i, j int), et Swap(i, j int). La méthode Less détermine l'ordre de tri pour chaque type.
main.go : Construisez et triez votre inventaire de produits.
Lisez un mode de tri (price ou quantity), puis lisez un nombre suivi des détails du produit. Chaque produit est fourni sur trois lignes : nom, prix et quantité.

Créez une tranche (slice) de produits, triez-les en utilisant le type de tri approprié en fonction du mode, puis affichez chaque produit dans ce format :
```
[Name]: $[Price] (x[Quantity])
```
Affichez les prix avec deux décimales.

Les entrées suivantes seront fournies :

Ligne 1 : Mode de tri (price ou quantity)
Ligne 2 : Nombre de produits
Lignes suivantes : Détails du produit (nom, prix, quantité - trois lignes par produit)

Par exemple, étant donné :

price
3
Laptop
999.99
5
Mouse
29.99
50
Keyboard
79.99
25

Votre sortie devrait être :

Mouse: $29.99 (x50)
Keyboard: $79.99 (x25)
Laptop: $999.99 (x5)

Et étant donné :

quantity
3
Laptop
999.99
5
Mouse
29.99
50
Keyboard
79.99
25

Votre sortie devrait être :

Mouse: $29.99 (x50)
Keyboard: $79.99 (x25)
Laptop: $999.99 (x5)

Remarquez comment les mêmes données de produit peuvent être triées différemment en utilisant simplement un type nommé différent. Une fois que vos types satisfont sort.Interface, ils fonctionnent parfaitement avec sort.Sort() de la bibliothèque standard.

Aide-mémoire

Le package sort nécessite que les types implémentent l'interface sort.Interface pour être triables :

type Interface interface {
    Len() int
    Less(i, j int) bool
    Swap(i, j int)
}

Pour rendre une slice personnalisée triable, créez un type nommé et implémentez les trois méthodes requises :

type Person struct {
    Name string
    Age  int
}

type ByAge []Person

func (a ByAge) Len() int           { return len(a) }
func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }
func (a ByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }

// Trier la collection
sort.Sort(ByAge(people))

Vous pouvez créer plusieurs types nommés pour la même slice afin d'implémenter différents comportements de tri. Chaque type définit sa propre méthode Less pour déterminer l'ordre de tri.

Une fois qu'un type satisfait sort.Interface, il fonctionne avec sort.Sort(), sort.Reverse() et sort.IsSorted().

Essayez vous-même

package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Lire le mode de tri
	var mode string
	fmt.Fscanln(reader, &mode)

	// Lire le nombre de produits
	var count int
	fmt.Fscanln(reader, &count)

	// Lire les produits
	products := make([]Product, count)
	for i := 0; i < count; i++ {
		name, _ := reader.ReadString('\n')
		name = name[:len(name)-1] // Supprimer le saut de ligne

		priceStr, _ := reader.ReadString('\n')
		priceStr = priceStr[:len(priceStr)-1]
		price, _ := strconv.ParseFloat(priceStr, 64)

		qtyStr, _ := reader.ReadString('\n')
		qtyStr = qtyStr[:len(qtyStr)-1]
		quantity, _ := strconv.Atoi(qtyStr)

		products[i] = Product{Name: name, Price: price, Quantity: quantity}
	}

	// TODO: Trier les produits en fonction du mode
	// Si le mode est "price", utiliser le type ByPrice
	// Si le mode est "quantity", utiliser le type ByQuantity
	// Utiliser sort.Sort() avec le type approprié

	// TODO: Afficher chaque produit au format :
	// [Name]: $[Price] (x[Quantity])
	// Utiliser fmt.Printf avec %.2f pour le formatage du prix
}