Encadeamento de Métodos

Parte da seção Programação Orientada a Objetos do Journey de GO da Coddy. Lição 81 de 107.

Encadeamento de métodos é uma técnica em que os métodos retornam o objeto receptor, permitindo que várias chamadas de método sejam encadeadas em uma única instrução. Você já viu isso no padrão Builder, mas é um conceito independente, útil em muitos contextos.

A chave é retornar um ponteiro para a struct de cada método:

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
}

Agora você pode encadear essas chamadas de forma fluente:

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

Isso quase parece uma linguagem natural em comparação com instruções separadas. O encadeamento de métodos funciona melhor quando as operações configuram ou modificam um objeto sem precisar retornar outros valores. Ele é comumente usado em construtores de consultas, APIs de configuração e bibliotecas de asserções para testes.

Lembre-se de que cada método deve usar um receptor de ponteiro e retornar *StructType para que a cadeia funcione corretamente.

Desafio

Fácil

Vamos criar um construtor fluente de elementos HTML que usa encadeamento de métodos para construir tags HTML com atributos e conteúdo! Esta é uma aplicação prática do encadeamento de métodos: você criará uma API que se lê quase como linguagem natural ao construir elementos HTML.

Você organizará seu código em dois arquivos:

element.go: Defina seu construtor de elementos HTML com métodos encadeáveis.
Crie uma struct Element que armazene o nome da tag, um mapa de atributos (de string para string) e o conteúdo interno. Crie estes métodos encadeáveis, cada um retornando *Element:
- NewElement(tag string) - construtor que cria um novo Element com o nome de tag fornecido e um mapa de atributos inicializado (vazio)
- Attr(key, value string) - adiciona um atributo ao elemento
- ID(id string) - método de conveniência que define o atributo "id"
- Class(class string) - método de conveniência que define o atributo "class"
- Content(text string) - define o conteúdo interno do elemento
Adicione um método Render() que retorne a string HTML. Os atributos devem aparecer em ordem alfabética por chave. O formato é:
```
<tag attr1="value1" attr2="value2">content</tag>
```
Se não houver atributos, simplesmente renderize <tag>content</tag>. Se não houver conteúdo, renderize <tag attr="value"></tag>.
main.go: Construa elementos HTML usando encadeamento de métodos.
Leia o nome da tag e, em seguida, leia uma contagem de operações a serem realizadas. Cada operação é uma destas:
- id seguido pelo valor do ID
- class seguido pelo valor da classe
- attr seguido pelo nome e pelo valor do atributo (duas linhas)
- content seguido pelo texto do conteúdo
Encadeie todas as operações de forma fluente e, então, imprima o HTML renderizado.

As seguintes entradas serão fornecidas:

Linha 1: Nome da tag
Linha 2: Número de operações
Linhas seguintes: Tipo da operação e valor(es)

Por exemplo, dada a entrada:

div
3
id
container
class
main-content
content
Hello World

Sua saída deve ser:

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

E dada a entrada:

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

Sua saída deve ser:

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

E dada a entrada:

input
2
attr
type
text
attr
placeholder
Enter name

Sua saída deve ser:

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

E dada a entrada:

p
1
content
Simple paragraph

Sua saída deve ser:

<p>Simple paragraph</p>

Observe como o encadeamento de métodos permite construir elementos passo a passo de maneira legível. Cada método modifica o elemento e o retorna, permitindo que a próxima chamada de método seja encadeada diretamente.

Experimente você mesmo

package main

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

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

	// Ler o nome da tag
	scanner.Scan()
	tagName := scanner.Text()

	// Ler o número de operações
	scanner.Scan()
	numOps, _ := strconv.Atoi(scanner.Text())

	// Criar o elemento
	element := NewElement(tagName)

	// Processar cada operação
	for i := 0; i < numOps; i++ {
		scanner.Scan()
		operation := scanner.Text()

		// TODO: Com base no tipo da operação, encadeie o método apropriado
		// As operações podem ser: "id", "class", "attr" ou "content"
		// - Para "id": leia a próxima linha como o valor do ID
		// - Para "class": leia a próxima linha como o valor da class
		// - Para "attr": leia as próximas DUAS linhas (nome do atributo, depois o valor)
		// - Para "content": leia a próxima linha como o texto do conteúdo
		// Use o encadeamento de métodos para construir o elemento de forma fluente

		_ = operation // Remova esta linha ao implementar
	}

	// Imprime o HTML renderizado
	fmt.Println(element.Render())
}