Que sont les mixins et les traits ?

Question

Accepted Answer

**Mixins** et **traits** sont des unités de *comportement réutilisable* que vous composez dans une classe sans relation d'héritage complète is-a. Ils permettent à des classes non liées de partager des fonctionnalités — comme l'héritage multiple, mais axé sur le comportement plutôt que sur la construction de hiérarchies de types profondes.

## Un mixin en Python

```python
class JsonSerializableMixin:           # reusable behavior, not a base "type"
    def to_json(self):
        import json
        return json.dumps(self.__dict__)

class TimestampMixin:
    def touch(self):
        import time
        self.updated_at = time.time()

class User(JsonSerializableMixin, TimestampMixin):   # mix in both
    def __init__(self, name): self.name = name

u = User("Mai")
u.touch()
print(u.to_json())                     # gained both behaviors via mixins
```

`User` n'*est pas* « un JsonSerializable » — il *acquiert* simplement cette capacité.

## Traits (par exemple Scala/Rust/PHP)

Les traits sont similaires mais plus formalisés : ils peuvent exiger des méthodes, fournir des valeurs par défaut et avoir un ordre de résolution défini pour les conflits.

```scala
trait Greet { def name: String; def greet = s"Hi, $name" }  // requires name
class Person(val name: String) extends Greet
```

## Mixin/trait vs. héritage vs. interface

| | Fournit le comportement | Fournit l'état | Multiples par classe |
|---|---|---|---|
| Interface | Principalement non | Non | Oui |
| Classe abstraite | Oui | Oui | Non (une) |
| Mixin/Trait | **Oui** | Parfois | **Oui** |

## Piège

L'empilement de nombreux mixins recréé la confusion diamond/MRO — collisions de noms et comportement dépendant de l'ordre. Gardez chaque mixin petit, focalisé et idéalement sans état.

## Pourquoi c'est important

Les mixins/traits sont la réponse pratique à « J'ai besoin de partager du comportement entre des classes non liées sans forcer une seule ligne d'héritage » — composition de *capacités*, pas de types.

Ils alimentent des frameworks réels (vues basées sur des classes Django, traits standard de Rust), et les comprendre clarifie comment les langages offrent les avantages de l'héritage multiple tout en évitant ses pires pièges.

	Fournit le comportement	Fournit l'état	Multiples par classe
Interface	Principalement non	Non	Oui
Classe abstraite	Oui	Oui	Non (une)
Mixin/Trait	Oui	Parfois	Oui

Un mixin en Python

Traits (par exemple Scala/Rust/PHP)

Mixin/trait vs. héritage vs. interface

Piège

Pourquoi c'est important

question.related