Chaînage de méthodes

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy. Leçon 81 sur 107.

Le chaînage de méthodes est une technique dans laquelle les méthodes renvoient le récepteur, ce qui permet de relier plusieurs appels de méthodes dans une seule instruction. Vous avez déjà vu cela dans le pattern Builder, mais il s’agit d’un concept autonome utile dans de nombreux contextes.

La clé consiste à renvoyer un pointeur vers la structure depuis chaque méthode :

type Query struct {
    table   string
    columns []string
    where   string
    limit   int
}

func (q *Query) Select(cols ...string) *Query {
    q.columns = cols
    return q
}

func (q *Query) From(table string) *Query {
    q.table = table
    return q
}

func (q *Query) Where(condition string) *Query {
    q.where = condition
    return q
}

func (q *Query) Limit(n int) *Query {
    q.limit = n
    return q
}

Vous pouvez maintenant enchaîner ces appels de manière fluide :

query := &Query{}
query.Select("name", "email").From("users").Where("active = true").Limit(10)

Cela se lit presque comme du langage naturel, comparé à des instructions distinctes. Le chaînage de méthodes fonctionne particulièrement bien lorsque les opérations configurent ou modifient un objet sans avoir besoin de renvoyer d’autres valeurs. Il est couramment utilisé dans les constructeurs de requêtes, les API de configuration et les bibliothèques d’assertions de tests.

N’oubliez pas que chaque méthode doit utiliser un récepteur pointeur et renvoyer *StructType pour que la chaîne fonctionne correctement.

Défi

Facile

Construisons un générateur d’éléments HTML fluide qui utilise l’enchaînement de méthodes pour construire des balises HTML avec des attributs et du contenu ! Il s’agit d’une application pratique de l’enchaînement de méthodes : tu vas créer une API qui se lit presque comme du langage naturel lors de la construction d’éléments HTML.

Tu organiseras ton code sur deux fichiers :

element.go : définis ton générateur d’éléments HTML avec des méthodes chaînables.
Crée une structure Element qui stocke le nom de la balise, une map d’attributs (de chaîne à chaîne) et le contenu interne. Construis ces méthodes chaînables, qui renvoient chacune *Element :
- NewElement(tag string) - constructeur qui crée un nouvel Element avec le nom de balise donné et une map d’attributs initialisée (vide)
- Attr(key, value string) - ajoute un attribut à l’élément
- ID(id string) - méthode pratique qui définit l’attribut "id"
- Class(class string) - méthode pratique qui définit l’attribut "class"
- Content(text string) - définit le contenu interne de l’élément
Ajoute une méthode Render() qui renvoie la chaîne HTML. Les attributs doivent apparaître dans l’ordre alphabétique de leur clé. Le format est le suivant :
```
<tag attr1="value1" attr2="value2">content</tag>
```
S’il n’y a aucun attribut, rends simplement <tag>content</tag>. S’il n’y a pas de contenu, rends <tag attr="value"></tag>.
main.go : construis des éléments HTML en utilisant l’enchaînement de méthodes.
Lis le nom de la balise, puis lis un nombre d’opérations à effectuer. Chaque opération est l’une des suivantes :
- id suivi de la valeur de l’ID
- class suivi de la valeur de la classe
- attr suivi du nom et de la valeur de l’attribut (deux lignes)
- content suivi du texte du contenu
Enchaîne toutes les opérations de manière fluide, puis affiche le HTML généré.

Les entrées suivantes seront fournies :

Ligne 1 : nom de la balise
Ligne 2 : nombre d’opérations
Lignes suivantes : type d’opération et valeur(s)

Par exemple, avec :

div
3
id
container
class
main-content
content
Hello World

Ta sortie doit être :

<div class="main-content" id="container">Hello World</div>

Et avec :

a
3
attr
href
https://example.com
attr
target
_blank
content
Click here

Ta sortie doit être :

<a href="https://example.com" target="_blank">Click here</a>

Et avec :

input
2
attr
type
text
attr
placeholder
Enter name

Ta sortie doit être :

<input placeholder="Enter name" type="text"></input>

Et avec :

p
1
content
Simple paragraph

Ta sortie doit être :

<p>Simple paragraph</p>

Remarque comment l’enchaînement de méthodes te permet de construire des éléments étape par étape de manière lisible. Chaque méthode modifie l’élément et le renvoie, ce qui permet d’enchaîner directement l’appel de la méthode suivante.

Essayez vous-même

package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)

	// Lire le nom de la balise
	scanner.Scan()
	tagName := scanner.Text()

	// Lire le nombre d'opérations
	scanner.Scan()
	numOps, _ := strconv.Atoi(scanner.Text())

	// Créer l'élément
	element := NewElement(tagName)

	// Traiter chaque opération
	for i := 0; i < numOps; i++ {
		scanner.Scan()
		operation := scanner.Text()

		// TODO: En fonction du type d'opération, enchaîner la méthode appropriée
		// Les opérations peuvent être : "id", "class", "attr", ou "content"
		// - Pour "id" : lire la ligne suivante comme valeur de l'ID
		// - Pour "class" : lire la ligne suivante comme valeur de la classe
		// - Pour "attr" : lire les DEUX lignes suivantes (nom de l'attribut, puis valeur)
		// - Pour "content" : lire la ligne suivante comme texte du contenu
		// Utiliser le chaînage de méthodes pour construire l'élément de manière fluide

		_ = operation // Supprimer cette ligne lors de l'implémentation
	}

	// Affiche le HTML rendu
	fmt.Println(element.Render())
}