លំនាំ Go ទាំងអស់

អត្ថបទលំនាំ Go ដែលបានបោះពុម្ព ត្រូវបានរៀបចំតាមប្រភេទ។ ការផ្តោតសំខាន់គឺ idiomatic Go មិនមែនជាការបក class diagrams មួយទល់មួយទេ។

ប្រភេទ

ភាពស្មុគស្មាញ

30 លំនាំ

ការបង្កើត

5 បានបោះពុម្ព

លំនាំសម្រាប់ការបង្កើត objects ក្នុង Go ដែលភាគច្រើនបង្ហាញតាម constructor functions, interfaces និង functional options។

ការបង្កើត

Abstract Factory in Go

Create related objects through one factory so whole product families can change together without leaking concrete types.

ការបង្កើត

Builder in Go

Separate a multi-step construction workflow from the final representation so the same input can produce different outputs cleanly.

ការបង្កើត

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

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

ការបង្កើត

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

ចម្លង object graphs ដែលបានកំណត់រួច នៅពេលការចម្លងសាមញ្ញ ឬលឿនជាងការសាងសង់ឡើងវិញពីដើម។

ការបង្កើត

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

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

រចនាសម្ព័ន្ធ

7 បានបោះពុម្ព

លំនាំសម្រាប់ផ្សំប្រភេទទិន្នន័យ និងព្រំដែនក្នុង Go ដោយប្រើ interfaces, embedding, adapters និង packages ដែលមានតួនាទីច្បាស់។

រចនាសម្ព័ន្ធ

Adapter in Go

Wrap an incompatible API behind the interface your application already expects so the rest of the code stays unchanged.

រចនាសម្ព័ន្ធ

Bridge in Go

Separate an abstraction from its implementation so both sides can vary independently without multiplying concrete types.

រចនាសម្ព័ន្ធ

Composite in Go

Treat individual objects and object groups uniformly so recursive tree structures stay simple to traverse and aggregate.

រចនាសម្ព័ន្ធ

Decorator in Go

Add behavior around an object dynamically by wrapping it with small focused layers that share the same interface.

រចនាសម្ព័ន្ធ

Facade in Go

Provide one simplified entry point over several collaborating subsystems so callers can trigger a workflow without knowing every step.

រចនាសម្ព័ន្ធ

Flyweight in Go

Share intrinsic immutable state across many small objects so large collections stay cheaper in memory and easier to manage.

រចនាសម្ព័ន្ធ

Proxy in Go

Control access to another object by standing in front of it to add caching, authorization, rate limiting, or lazy loading.

ឥរិយាបថ

10 បានបោះពុម្ព

លំនាំសម្រាប់រៀបចំ control flow, workflows និងការសហការងារ ដោយផ្អែកលើ errors ច្បាស់លាស់, interfaces និងឯកតាអាកប្បកិរិយាតូចៗ។

ឥរិយាបថ

លំនាំ Chain of Responsibility ក្នុង Go

បង្កើត validation និង request-processing pipelines ដោយប្រើ handlers តូចៗដែលត្រូវបានផ្សំតាម interfaces។

ឥរិយាបថ

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

ខ្ចប់ operations សម្រាប់ queuing, audit history និង undo/redo ខណៈដែលរក្សា Go error handling ឱ្យច្បាស់លាស់។

ឥរិយាបថ

Iterator in Go

Traverse a collection without exposing its internal representation, keeping traversal state separate from the aggregate.

ឥរិយាបថ

Mediator in Go

Centralize communication between collaborating objects so they depend on a coordinator instead of referencing each other directly.

ឥរិយាបថ

Memento in Go

Capture and restore object state without exposing internal details so undo and rollback remain explicit and controlled.

ឥរិយាបថ

Observer in Go

Notify dependent subscribers when state changes so event-driven reactions stay decoupled from the publisher.

ឥរិយាបថ

State in Go

Change an object’s behavior when its internal state changes by delegating transitions and rules to state-specific types.

ឥរិយាបថ

Strategy in Go

Encapsulate interchangeable algorithms behind one interface so callers can swap behavior without branching on concrete rules.

ឥរិយាបថ

Template Method in Go

Define the skeleton of an algorithm once while letting concrete steps vary through narrow hook methods.

ឥរិយាបថ

Visitor in Go

Add operations across a stable object structure without changing each node type whenever a new operation is introduced.

Agentic

8 បានបោះពុម្ព

លំនាំសម្រាប់បង្កើតប្រព័ន្ធ AI agent ក្នុង Go: reasoning loops, tool dispatch, memory, retrieval និងការសម្របសម្រួលរវាង agents ច្រើន។

Agent Loop (ReAct) in Go

Drive an agent by alternating reasoning and acting steps inside a structured loop that terminates when the model signals a final answer.

Tool Use in Go

Register typed tools by name so an agent can dispatch LLM-selected function calls to the right handler without embedding dispatch logic in the agent itself.

Orchestrator-Subagent in Go

Decompose a complex task by having a root agent spawn and coordinate specialized subagents, each responsible for one concern, then aggregate their results.

Memory in Go

Give an agent a pluggable memory store — short-term context buffer, episodic session history, and optional long-term semantic store — through one interface so the storage backend can be swapped.

Retrieval-Augmented Generation in Go

Ground LLM responses in authoritative documents by retrieving relevant chunks before generation so the model can cite real data instead of hallucinating.

Human-in-the-Loop in Go

Pause agent execution at defined checkpoints to request human approval or input, then resume with the human's decision injected back into the agent's context.

Prompt Template in Go

Build prompts from versioned, parameterized templates so prompt logic stays separate from agent orchestration code and can be tested, diffed, and swapped independently.

Multi-Agent Communication in Go

Enable agents to exchange typed messages through a shared message bus so they can collaborate without direct references to each other's implementations.