go-patterns
esc

ផ្លូវសិក្សា

ផែនទីផ្លូវអ្នកអភិវឌ្ឍន៍ Go

ដំណាក់កាល 3 ដំបូងដូចគ្នាសម្រាប់អ្នកសរសេរ Go ទាំងអស់ ចាប់ពី go mod init។ បន្ទាប់មកផ្លូវបែកតាមប្រភេទការងារដែលអ្នកចង់ធ្វើ។

ជ្រើសផ្លូវ

Backend និង APIs

3 ដំណាក់កាល

Services HTTP និង gRPC ដែលគេពឹងផ្អែក។

CLI និងឧបករណ៍អ្នកអភិវឌ្ឍន៍

កំពុងមើល

Binary តែមួយដែល engineer ផ្សេងដំឡើង។

Cloud-native និង Platform

គ្រោងទុក

Controllers, operators និង control plane។

AI agents ក្នុង Go

គ្រោងទុក

Tool dispatch, retrieval, memory, evals។

CLI និងឧបករណ៍អ្នកអភិវឌ្ឍន៍

សេចក្តីព្រាង 7 ដំណាក់កាល · 42 ប្រធានបទ

ជម្រករបស់ Go មួយទៀត៖ binary static តែមួយ, គ្មាន runtime ត្រូវដំឡើង និងបន្ទាត់ពាក្យបញ្ជាដែលត្រូវយល់បានសម្រាប់អ្នកមិនធ្លាប់អានកូដរបស់អ្នក។ បញ្ចប់ដោយឧបករណ៍ដែលអ្នកអាច tag និងចេញផ្សាយ។

បានធីក 0 ក្នុង 42 ប្រធានបទ

ដំណាក់កាលបីដំបូងជារួម ដូច្នេះការធីកនៅទីនេះរាប់សម្រាប់គ្រប់ផ្លូវ។

មុនដំណាក់កាល ០១

រឿងទាំងនេះមិនមែនជា Go ទេ ប៉ុន្តែវាទាំងអស់លេចឡើងក្នុងសប្តាហ៍ដំបូងរបស់អ្នកនៅក្រុម Go។

Git និងការ review កូដ

Branches, rebase, commit តូចៗ និងការអាន diff — អ្នកនឹងរៀន Go តាមរយៈ pull requests។

Terminal និងមូលដ្ឋាន Linux

ការប្រើ shell, environment variables, processes, signals, file permissions និង SSH។

HTTP និង JSON

Methods, status codes, headers, caching និងរូបរាងពិតរបស់ request នៅលើបណ្តាញ។

SQL និងការរចនាទិន្នន័យ

Joins, indexes, transactions និង normalization — Go services ភាគច្រើនជា service ទិន្នន័យ។

ផ្លូវដំណើរ

ប្រធានបទ (ចុចដើម្បីធីក) បានបញ្ចប់ ចម្ងាយដែលបានឆ្លងកាត់

ចាប់ផ្តើម
01

មូលដ្ឋានភាសា

0/6

២–៤ សប្តាហ៍

អាន និងសរសេរ Go ធម្មតាបាន ដោយមិនចាំបាច់រកមើល syntax នៅរាល់បន្ទាត់។

សាងសង់ CLI មួយដែលអាន cart ជា JSON តាម stdin ហើយបោះពុម្ពសរុបនៃ order ជាមួយពន្ធ និងថ្លៃដឹកជញ្ជូន។

បន្តពេល អ្នកអាចពន្យល់ភាពខុសគ្នារវាង nil slice និង empty slice ព្រមទាំងមូលហេតុដែល value receiver មិនអាចកែប្រែ struct របស់វា។

02

សរសេរតាមរបៀប Go

0/6

៣–៥ សប្តាហ៍

សរសេរកូដដែល reviewer មើលឃើញថាជា Go ពិត មិនមែនការបកប្រែពី Java ឬ Python។

សាងសង់ package catalog ជាមួយ repository តាម interface, fake ក្នុង memory និង table-driven tests ដែលគ្របដណ្តប់ច្បាប់ domain។

បន្តពេល អ្នកបង្កើត interface តែពេលមាន implementation ទីពីរ ឬ test double ប៉ុណ្ណោះ មិនមែនទុកជាមុនទេ។

03

Concurrency និង Context

0/6

៤–៦ សប្តាហ៍

សរសេរកូដ concurrent ដែលត្រឹមត្រូវក្រោម -race មិនត្រឹមតែលឿនប៉ុណ្ណោះទេ។

សាងសង់ price fetcher ដែលសួរ supplier ចំនួន N ដំណាលគ្នា ជាមួយ deadline សម្រាប់ request មួយៗ, បោះបង់អ្វីដែលនៅសល់ពេលទទួលបានតម្លៃគ្រប់គ្រាន់ ហើយមិនធ្វើឱ្យ goroutine លេចធ្លាយ។

បន្តពេល អ្នកអាចមើលឃើញ goroutine leak ក្នុងការ review ហើយពន្យល់បានថាហេតុអ្វី context ប្រសើរជាង done flag រួម។

04

ផ្ទៃពាក្យបញ្ជា

0/6

៣–៤ សប្តាហ៍

Design a command line someone else can learn without reading the source.

សាងសង់ A catalog CLI with add, list and export subcommands that round-trips through stdin and stdout, and exits non-zero with a message you could act on.

បន្តពេល Someone can pipe your tool into jq and script it without reading the source.

05

ឧបករណ៍ដែលគេដំឡើង

0/6

៤–៦ សប្តាហ៍

Ship a binary a stranger can install, trust, and upgrade.

សាងសង់ Tag and release the catalog CLI for three platforms with checksums, a --version that reports the real commit, and output that stays readable when piped.

បន្តពេល Your tool behaves the same in CI as in a terminal, and you never hand-build a release.

06

ជំនាញផលិតឧបករណ៍

0/6

បន្តរហូត

Make the tool safe to run on someone else's machine and easy to change.

សាងសង់ Add a golden-file suite and a --verbose debug mode to the catalog CLI, then cut startup time or binary size with before/after evidence.

បន្តពេល You can change the output format without fear, because the golden tests catch it.

07

ការរចនា និង Architecture

0/6

បន្តរហូត

ធ្វើការសម្រេចចិត្តរចនាដែលអ្នកអាចការពារបាន រួមទាំងលំនាំដែលអ្នកបានបដិសេធ។

សាងសង់ ធ្វើ refactor package ដែលរញ៉េរញ៉ៃឱ្យនៅក្រោយព្រំដែន interface ច្បាស់លាស់មួយ ដោយប្រើលំនាំក្នុងបណ្ដុំនេះ ហើយសរសេរ design doc ខ្លីដែលបញ្ជាក់ការបែងចែកនោះ។

បន្តពេល អ្នកអាចពន្យល់ថាហេតុអ្វីលំនាំមួយមិនសមស្រប បានច្បាស់ដូចការពន្យល់ថាហេតុអ្វីលំនាំមួយទៀតសមស្រប។

បញ្ចប់

បន្ទាប់ពីនេះ ផ្លូវគឺជាការសាងសង់, ការវាស់វែង និងការ review ដែលធ្វើម្តងហើយម្តងទៀត។

លំនាំសម្រាប់ផ្លូវនេះ

លំនាំមិនមែនជាដំណាក់កាលដែលអ្នកបញ្ចប់ទេ — វាជាភាសាដែលអ្នកទទួលបានពេលមានកូដដែលសមនឹងរៀបចំឡើងវិញ។ ខាងក្រោមនេះជាលំនាំដែលផ្លូវនេះជួបប្រទះច្រើនបំផុត។

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

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

Builder

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

Composite

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

Template Method

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

Memento

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

Interpreter

Define a small grammar for recurring business rules and evaluate sentences of that grammar with an expression tree.

ធនធានដែលសមនឹងពេលវេលារបស់អ្នក

បញ្ជីខ្លីមួយ ភាគច្រើនជាឯកសារផ្លូវការ។ បញ្ចប់ទាំងនេះមុននឹងទិញវគ្គសិក្សា។

A Tour of Go

សេចក្តីផ្តើមអន្តរកម្មជាផ្លូវការ។ បញ្ចប់វាមុនរឿងផ្សេងទាំងអស់។

Effective Go

របៀបដែល Go គួរត្រូវសរសេរ ដោយផ្ទាល់ពីក្រុម Go។

Go Code Review Comments

បញ្ជីត្រួតពិនិត្យដែល reviewer Go ប្រើពិតប្រាកដលើ pull requests របស់អ្នក។

Go by Example

កម្មវិធីខ្លីៗមានពន្យល់សម្រាប់លក្ខណៈពិសេសភាសាស្ទើរតែទាំងអស់។

The Go Blog

អត្ថបទស៊ីជម្រៅជាផ្លូវការស្តីពី slices, errors, context, generics និង GC។

Standard Library Reference

រក្សាទុកជា bookmark។ ការអាន source របស់ std គឺជាផ្នែកនៃការរៀនភាសា។

Learn Go with Tests

រៀនភាសាដោយចាប់ផ្តើមពី test — ផ្លូវលឿនបំផុតទៅរកវិន័យសរសេរ test។

Go Proverbs

ប្រយោគខ្លីៗរបស់ Rob Pike ដែលពន្យល់អំណះអំណាងរចនា Go ភាគច្រើន។

អន្ទាក់តាមផ្លូវ

រករើស framework មុនពេលដឹងថា net/http ធ្វើអ្វីបានរួចទៅហើយ។
បង្កើត interface សម្រាប់រាល់ struct — abstraction ដោយគ្មាន implementation ទីពីរ។
បើក goroutine ដោយគ្មាន context, គ្មានការបោះបង់ និងគ្មានអ្នកទទួលខុសត្រូវ។
បោះបង់ errors ដោយ _ ឬ log ហើយបន្តដូចគ្មានអ្វីកើតឡើង។
ប្រើ panic ជា control flow ជំនួសការ return errors ដែលបាន wrap។
បង្កើត package utils ឬ common ធំដែលអ្វីៗទាំងអស់ import។
បែងចែកទៅជា microservices មុនពេល service តែមួយចាប់ផ្តើមមានបញ្ហាបន្ទុក។
ចម្លង class hierarchies ពី Java ឬ C# មកក្នុង Go ហើយហៅវាថាលំនាំរចនា។