Concatenamento dei metodi

Fa parte della sezione Programmazione orientata agli oggetti del percorso GO di Coddy. Lezione 81 di 107.

Concatenazione dei metodi è una tecnica in cui i metodi restituiscono il ricevente, consentendo di collegare più chiamate di metodo in un'unica istruzione. Hai già visto questo nel pattern Builder, ma è un concetto a sé stante, utile in molti contesti.

La chiave è restituire un puntatore alla struct da ciascun metodo:

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
}

Ora puoi concatenare queste chiamate in modo fluido:

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

Questo si legge quasi come linguaggio naturale rispetto a istruzioni separate. Il concatenamento dei metodi funziona meglio quando le operazioni configurano o modificano un oggetto senza dover restituire altri valori. È comunemente usato nei generatori di query, nelle API di configurazione e nelle librerie di asserzioni per i test.

Ricorda che ogni metodo deve usare un receiver puntatore e restituire *StructType affinché la catena funzioni correttamente.

Sfida

Facile

Costruiamo un builder fluente di elementi HTML che usa il concatenamento dei metodi per creare tag HTML con attributi e contenuto! Questa è un’applicazione pratica del concatenamento dei metodi: creerai un’API che, durante la creazione di elementi HTML, si legge quasi come un linguaggio naturale.

Organizzerai il codice in due file:

element.go: definisci il builder degli elementi HTML con metodi concatenabili.
Crea una struct Element che memorizza il nome del tag, una mappa di attributi (da stringa a stringa) e il contenuto interno. Crea questi metodi concatenabili, ciascuno dei quali restituisce *Element:
- NewElement(tag string) - costruttore che crea un nuovo Element con il nome di tag specificato e una mappa degli attributi inizializzata (vuota)
- Attr(key, value string) - aggiunge un attributo all’elemento
- ID(id string) - metodo pratico che imposta l’attributo "id"
- Class(class string) - metodo pratico che imposta l’attributo "class"
- Content(text string) - imposta il contenuto interno dell’elemento
Aggiungi un metodo Render() che restituisce la stringa HTML. Gli attributi devono apparire in ordine alfabetico in base alla chiave. Il formato è:
```
<tag attr1="value1" attr2="value2">content</tag>
```
Se non ci sono attributi, restituisci semplicemente <tag>content</tag>. Se non c’è contenuto, restituisci <tag attr="value"></tag>.
main.go: crea elementi HTML usando il concatenamento dei metodi.
Leggi il nome del tag, poi leggi il numero di operazioni da eseguire. Ogni operazione è una delle seguenti:
- id seguito dal valore dell’ID
- class seguito dal valore della classe
- attr seguito dal nome e dal valore dell’attributo (due righe)
- content seguito dal testo del contenuto
Concatena tutte le operazioni in modo fluido, quindi stampa l’HTML renderizzato.

Verranno forniti i seguenti input:

Riga 1: nome del tag
Riga 2: numero di operazioni
Righe successive: tipo di operazione e valore/i

Ad esempio, dato:

div
3
id
container
class
main-content
content
Hello World

L’output dovrebbe essere:

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

E dato:

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

L’output dovrebbe essere:

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

E dato:

input
2
attr
type
text
attr
placeholder
Enter name

L’output dovrebbe essere:

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

E dato:

p
1
content
Simple paragraph

L’output dovrebbe essere:

<p>Simple paragraph</p>

Nota come il concatenamento dei metodi ti permette di creare gli elementi passo dopo passo in modo leggibile. Ogni metodo modifica l’elemento e lo restituisce, consentendo di concatenare direttamente la chiamata al metodo successivo.

Provalo tu

package main

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

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

	// Leggi il nome del tag
	scanner.Scan()
	tagName := scanner.Text()

	// Leggi il numero di operazioni
	scanner.Scan()
	numOps, _ := strconv.Atoi(scanner.Text())

	// Crea l'elemento
	element := NewElement(tagName)

	// Elabora ogni operazione
	for i := 0; i < numOps; i++ {
		scanner.Scan()
		operation := scanner.Text()

		// TODO: In base al tipo di operazione, concatena il metodo appropriato
		// Le operazioni possono essere: "id", "class", "attr" o "content"
		// - Per "id": leggi la riga successiva come valore ID
		// - Per "class": leggi la riga successiva come valore della classe
		// - Per "attr": leggi le DUE righe successive (nome dell'attributo, poi valore)
		// - Per "content": leggi la riga successiva come testo del contenuto
		// Usa la concatenazione dei metodi per costruire l'elemento in modo fluido

		_ = operation // Rimuovi questa riga durante l'implementazione
	}

	// Stampa l'HTML generato
	fmt.Println(element.Render())
}