Method Chaining

Termasuk bagian Pemrograman Berorientasi Objek dalam perjalanan GO di Coddy. Pelajaran 81 dari 107.

Method chaining adalah teknik ketika method mengembalikan objek penerima, sehingga beberapa pemanggilan method dapat dirangkai dalam satu pernyataan. Kamu sudah melihatnya dalam pola Builder, tetapi konsep ini juga dapat digunakan secara mandiri dalam banyak konteks.

Kuncinya adalah mengembalikan pointer ke struct dari setiap method:

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
}

Sekarang kamu dapat merangkai pemanggilan ini dengan lancar:

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

Ini terbaca hampir seperti bahasa alami dibandingkan dengan pernyataan yang terpisah. Method chaining paling cocok digunakan saat operasi mengonfigurasi atau mengubah object tanpa perlu mengembalikan nilai lain. Teknik ini umum digunakan dalam pembuat query, API konfigurasi, dan library untuk pernyataan pengujian.

Ingat, setiap method harus menggunakan receiver pointer dan mengembalikan *StructType agar rantai tersebut berfungsi dengan benar.

Tantangan

Mudah

Mari kita buat builder elemen HTML yang lancar, yang menggunakan perantaian method untuk menyusun tag HTML dengan atribut dan konten! Ini adalah penerapan praktis perantaian method: kamu akan membuat API yang hampir menyerupai bahasa alami saat menyusun elemen HTML.

Kamu akan mengatur kodemu dalam dua file:

element.go: Definisikan builder elemen HTML dengan method yang dapat dirantaikan.
Buat struct Element yang menyimpan nama tag, map atribut (string ke string), dan konten bagian dalam. Buat method-method yang dapat dirantaikan ini, yang masing-masing mengembalikan *Element:
- NewElement(tag string) - konstruktor yang membuat Element baru dengan nama tag yang diberikan dan map atribut kosong yang telah diinisialisasi
- Attr(key, value string) - menambahkan atribut ke elemen
- ID(id string) - method praktis untuk mengatur atribut "id"
- Class(class string) - method praktis untuk mengatur atribut "class"
- Content(text string) - mengatur konten bagian dalam elemen
Tambahkan method Render() yang mengembalikan string HTML. Atribut harus muncul dalam urutan alfabetis berdasarkan kunci. Formatnya adalah:
```
<tag attr1="value1" attr2="value2">content</tag>
```
Jika tidak ada atribut, cukup tampilkan <tag>content</tag>. Jika tidak ada konten, tampilkan <tag attr="value"></tag>.
main.go: Buat elemen HTML menggunakan perantaian method.
Baca nama tag, lalu baca jumlah operasi yang harus dilakukan. Setiap operasi berupa salah satu dari berikut:
- id diikuti nilai ID
- class diikuti nilai class
- attr diikuti nama dan nilai atribut (dua baris)
- content diikuti teks konten
Rantaikan semua operasi dengan lancar, lalu cetak HTML yang telah dirender.

Input berikut akan diberikan:

Baris 1: Nama tag
Baris 2: Jumlah operasi
Baris-baris berikutnya: Jenis operasi dan nilainya

Contohnya, jika diberikan:

div
3
id
container
class
main-content
content
Hello World

Output kamu seharusnya:

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

Dan jika diberikan:

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

Output kamu seharusnya:

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

Dan jika diberikan:

input
2
attr
type
text
attr
placeholder
Enter name

Output kamu seharusnya:

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

Dan jika diberikan:

p
1
content
Simple paragraph

Output kamu seharusnya:

<p>Simple paragraph</p>

Perhatikan bagaimana perantaian method memungkinkanmu menyusun elemen tahap demi tahap dengan cara yang mudah dibaca. Setiap method mengubah elemen dan mengembalikannya, sehingga pemanggilan method berikutnya dapat langsung dirantaikan.

Coba sendiri

package main

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

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

	// Baca nama tag
	scanner.Scan()
	tagName := scanner.Text()

	// Baca jumlah operasi
	scanner.Scan()
	numOps, _ := strconv.Atoi(scanner.Text())

	// Buat elemen
	element := NewElement(tagName)

	// Proses setiap operasi
	for i := 0; i < numOps; i++ {
		scanner.Scan()
		operation := scanner.Text()

		// TODO: Berdasarkan jenis operasi, rangkai method yang sesuai
		// Operasi yang tersedia: "id", "class", "attr", atau "content"
		// - Untuk "id": baca baris berikutnya sebagai nilai ID
		// - Untuk "class": baca baris berikutnya sebagai nilai class
		// - Untuk "attr": baca DUA baris berikutnya (nama atribut, lalu nilainya)
		// - Untuk "content": baca baris berikutnya sebagai teks konten
		// Gunakan perangkaian method untuk membangun elemen dengan lancar

		_ = operation // Hapus baris ini saat mengimplementasikan
	}

	// Cetak HTML yang sudah dirender
	fmt.Println(element.Render())
}