លំនាំ Prototype ក្នុង Go

The Problem

Sometimes the expensive part of object creation is not allocating one struct. It is rebuilding a whole preconfigured object graph with nested defaults, collections, and shared setup rules. When that same baseline needs to be reused repeatedly, rebuilding it by hand creates duplication and makes small variations error-prone.

The Solution

The Prototype pattern keeps a fully configured instance around and asks it to clone itself. In Go, that usually means defining a small Clone() contract and being explicit about deep-copy behavior for slices, nested structs, and recursive graphs.

The Go example on Refactoring Guru uses a recursive file-and-folder model to show this idea. This article applies the same deep-cloning approach to commerce bundle templates, where nested bundles and products need to be copied safely before customization.

Structure

Prototype interface: CatalogPrototype defines the cloning contract.
Concrete prototypes: ProductTemplate and BundleTemplate know how to copy their own state.
Registry: TemplateRegistry stores baseline templates and returns cloned copies on demand.
Client: Application code clones a stored template and customizes the copy.

Implementation

This example stores a preconfigured launch bundle in a registry, clones it, and then turns the clone into a Black Friday variant without mutating the original nested structure.

package main

// CatalogPrototype defines the common cloning contract.
type CatalogPrototype interface {
	Clone() CatalogPrototype
	Rename(name string)
	Describe(indent string) string
}

package main

import "fmt"

type ProductTemplate struct {
	name      string
	sku       string
	unitPrice float64
	tags      []string
}

func NewProductTemplate(name, sku string, unitPrice float64, tags ...string) *ProductTemplate {
	return &ProductTemplate{
		name:      name,
		sku:       sku,
		unitPrice: unitPrice,
		tags:      append([]string(nil), tags...),
	}
}

func (p *ProductTemplate) Clone() CatalogPrototype {
	return &ProductTemplate{
		name:      p.name,
		sku:       p.sku,
		unitPrice: p.unitPrice,
		tags:      append([]string(nil), p.tags...),
	}
}

func (p *ProductTemplate) Rename(name string) {
	p.name = name
}

func (p *ProductTemplate) SetSKU(sku string) {
	p.sku = sku
}

func (p *ProductTemplate) AddTag(tag string) {
	p.tags = append(p.tags, tag)
}

func (p *ProductTemplate) Describe(indent string) string {
	return fmt.Sprintf(
		"%s- Product(name=%q, sku=%q, price=%.2f, tags=%v)\n",
		indent,
		p.name,
		p.sku,
		p.unitPrice,
		p.tags,
	)
}

package main

import (
	"fmt"
	"strings"
)

type BundleTemplate struct {
	name     string
	discount float64
	items    []CatalogPrototype
}

func NewBundleTemplate(name string, discount float64, items ...CatalogPrototype) *BundleTemplate {
	clonedItems := make([]CatalogPrototype, 0, len(items))
	for _, item := range items {
		clonedItems = append(clonedItems, item)
	}

	return &BundleTemplate{
		name:     name,
		discount: discount,
		items:    clonedItems,
	}
}

func (b *BundleTemplate) Clone() CatalogPrototype {
	clonedItems := make([]CatalogPrototype, 0, len(b.items))
	for _, item := range b.items {
		clonedItems = append(clonedItems, item.Clone())
	}

	return &BundleTemplate{
		name:     b.name,
		discount: b.discount,
		items:    clonedItems,
	}
}

func (b *BundleTemplate) Rename(name string) {
	b.name = name
}

func (b *BundleTemplate) SetDiscount(discount float64) {
	b.discount = discount
}

func (b *BundleTemplate) AddItem(item CatalogPrototype) {
	b.items = append(b.items, item)
}

func (b *BundleTemplate) Describe(indent string) string {
	var builder strings.Builder
	builder.WriteString(fmt.Sprintf("%s+ Bundle(name=%q, discount=%.0f%%)\n", indent, b.name, b.discount*100))
	for _, item := range b.items {
		builder.WriteString(item.Describe(indent + "  "))
	}
	return builder.String()
}

package main

import "fmt"

type TemplateRegistry struct {
	templates map[string]CatalogPrototype
}

func NewTemplateRegistry() *TemplateRegistry {
	return &TemplateRegistry{
		templates: make(map[string]CatalogPrototype),
	}
}

func (r *TemplateRegistry) Register(key string, prototype CatalogPrototype) {
	r.templates[key] = prototype
}

func (r *TemplateRegistry) Clone(key string) (CatalogPrototype, error) {
	prototype, ok := r.templates[key]
	if !ok {
		return nil, fmt.Errorf("template %q not found", key)
	}
	return prototype.Clone(), nil
}

package main

import (
	"fmt"
	"log"
)

func main() {
	registry := NewTemplateRegistry()

	keyboard := NewProductTemplate("Mechanical Keyboard", "KEY-001", 129.99, "hardware", "desktop")
	mouse := NewProductTemplate("Ergonomic Mouse", "MSE-002", 59.99, "hardware", "desktop")
	deskPack := NewBundleTemplate("Desk Setup Pack", 0.10, keyboard, mouse)

	launchBundle := NewBundleTemplate(
		"Creator Launch Bundle",
		0.15,
		deskPack,
		NewProductTemplate("Desk Mat", "MAT-003", 24.99, "accessory"),
	)

	registry.Register("creator-launch", launchBundle)

	clone, err := registry.Clone("creator-launch")
	if err != nil {
		log.Fatal(err)
	}

	blackFridayBundle := clone.(*BundleTemplate)
	blackFridayBundle.Rename("Black Friday Creator Bundle")
	blackFridayBundle.SetDiscount(0.25)
	blackFridayBundle.AddItem(NewProductTemplate("Cable Organizer", "ORG-004", 12.99, "accessory", "bonus"))

	fmt.Println("=== Original Prototype ===")
	fmt.Print(launchBundle.Describe(""))

	fmt.Println("\n=== Cloned Variant ===")
	fmt.Print(blackFridayBundle.Describe(""))
}

Best Practices

Be explicit about deep versus shallow copies. Slices, maps, and nested references are where clone bugs usually hide.
Keep the clone contract small. A focused Clone() method is easier to reason about than generic reflection-based copying.
Use prototypes for expensive or repetitive setup, not for every ordinary constructor.
A registry is useful when the same baseline templates are reused often.
Avoid sharing mutable internals between the original and the clone unless that sharing is intentional.

When to Use

Rebuilding a baseline object graph is repetitive or expensive.
You need small variations of the same preconfigured object.
The client should not know all the construction details required to recreate the original.

When NOT to Use

A plain constructor or factory is already simpler.
The object graph is shallow enough that copying manually is clearer.
Clone semantics would be ambiguous or dangerous because the object owns external resources like file handles or network connections.

លំនាំ Factory Method ក្នុង Go

ប្រើ constructor functions និង interfaces តូចៗ ដើម្បីជ្រើស concrete implementations ដោយមិនភ្ជាប់ callers ទៅនឹងវា។

លំនាំ Singleton ក្នុង Go

ប្រើ sync.Once ដោយប្រុងប្រយ័ត្នសម្រាប់ការចាប់ផ្តើមតែម្តង ហើយយល់ថាពេលណា dependency injection ជាជម្រើសល្អជាង។