# gopl-zh/gopl-zh.github.com

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/gopl-zh-gopl-zh-github-com).**

4,958 stars · 1,060 forks · Go · BSD-3-Clause

## Links

- GitHub: https://github.com/gopl-zh/gopl-zh.github.com
- Homepage: https://gopl-zh.github.io
- awesome-repositories: https://awesome-repositories.com/repository/gopl-zh-gopl-zh-github-com.md

## Topics

`programming-language`

## Description

This project is a Chinese translation of a comprehensive guide to the Go programming language. It serves as a localized educational resource and technical manual designed to provide guidance on language syntax, design, and software development.

The resource covers a broad range of Go language education, including the implementation of programming patterns and system design. It includes translated lessons and examples that focus on core language features such as concurrency and the use of interfaces.

The content spans various capability areas, including language fundamentals, data modeling, runtime reflection, and memory management. It also provides detailed coverage of software architecture, error handling, quality assurance, and web networking.

The documentation is structured as a technical manual featuring translated content, errata, and corrections to ensure accurate learning.

## Tags

### Education & Learning Resources

- [Go Language Fundamentals](https://awesome-repositories.com/f/education-learning-resources/go-language-fundamentals.md) — Serves as a comprehensive educational resource for learning Go syntax, variables, and basic concurrency patterns.
- [Educational Programming Resources](https://awesome-repositories.com/f/education-learning-resources/educational-programming-resources.md) — Curates a structured collection of translated lessons and examples covering syntax, concurrency, and design.
- [Programming Language Guides](https://awesome-repositories.com/f/education-learning-resources/programming-language-guides.md) — Provides a comprehensive, translated guide to mastering the Go programming language syntax and specifications.
- [Technical Document Translations](https://awesome-repositories.com/f/education-learning-resources/technical-document-translations.md) — Provides a localized version of a foundational programming text to facilitate study and academic exchange.
- [Algorithmic Performance Comparison](https://awesome-repositories.com/f/education-learning-resources/algorithmic-performance-comparison.md) — Provides educational guidance on comparing the efficiency of different algorithms using benchmark functions. ([source](https://gopl-zh.github.io/ch11/ch11-04.html))

### Data & Databases

- [Fixed-Size Collections](https://awesome-repositories.com/f/data-databases/data-structures/structured-return-objects/collection-size-utilities/fixed-size-collections.md) — Covers the organization of multiple elements of the same type into fixed-size memory structures. ([source](https://gopl-zh.github.io/ch4/ch4.html))
- [Go Type Embedding](https://awesome-repositories.com/f/data-databases/data-type-mappings/type-conversion-utilities/numeric-type-promotions/go-type-embedding.md) — Provides detailed guidance on Go's struct embedding mechanism for behavior reuse and method promotion.
- [Key-Value Stores](https://awesome-repositories.com/f/data-databases/key-value-stores.md) — Teaches the use of hash tables (maps) for constant-time retrieval and updates of unique keys. ([source](https://gopl-zh.github.io/ch4/ch4-03.html))
- [Composite Literal Initializations](https://awesome-repositories.com/f/data-databases/tuple-data-structures/named-tuple-structs/named-field-initializers/composite-literal-initializations.md) — Guides the creation of data type instances using ordered and named field initializers. ([source](https://gopl-zh.github.io/ch4/ch4-04.html))
- [Comparable Type Comparisons](https://awesome-repositories.com/f/data-databases/value-comparators/epsilon-based-type-comparators/custom-data-comparators/comparable-type-comparisons.md) — Details how Go compares complex data structures and determines if they are identical. ([source](https://gopl-zh.github.io/ch4/ch4-04.html))
- [Collection Iteration](https://awesome-repositories.com/f/data-databases/collection-iterators/collection-iteration.md) — Explains how to traverse maps and slices using loop constructs to access all elements. ([source](https://gopl-zh.github.io/ch4/ch4-03.html))
- [Data Type Serialization](https://awesome-repositories.com/f/data-databases/data-type-managers/dynamic-type-managers/custom-type-serializers/data-type-serialization.md) — Covers the process of encoding and decoding structured data into formats like JSON and XML using runtime introspection. ([source](https://gopl-zh.github.io/ch12/ch12.html))
- [JSON Body Decoders](https://awesome-repositories.com/f/data-databases/json-handling-utilities/primitive-json-body-handlings/json-body-decoders.md) — Describes how to parse JSON data into Go structures with selective field decoding. ([source](https://gopl-zh.github.io/ch4/ch4-05.html))
- [Key Existence Verifiers](https://awesome-repositories.com/f/data-databases/key-value-stores/key-listing/key-existence-verifiers.md) — Covers the mechanism for distinguishing between missing map keys and zero values using the comma-ok idiom. ([source](https://gopl-zh.github.io/ch4/ch4-03.html))

### Development Tools & Productivity

- [Exported Identifier Visibility](https://awesome-repositories.com/f/development-tools-productivity/package-managers/package-exports/exported-identifier-visibility.md) — Explains Go's unique system of using capitalization to control identifier visibility across packages. ([source](https://gopl-zh.github.io/ch2/ch2-01.html))
- [Remote Dependency Integration](https://awesome-repositories.com/f/development-tools-productivity/source-code-management/remote-dependency-integration.md) — Describes retrieving source code and dependencies from remote repositories via import paths. ([source](https://gopl-zh.github.io/ch10/ch10-07.html))
- [Quoted and Raw Literals](https://awesome-repositories.com/f/development-tools-productivity/string-literal-handling/raw-string-literals/quoted-and-raw-literals.md) — Covers the definition of string literals using both double quotes and backticks. ([source](https://gopl-zh.github.io/ch3/ch3-05.html))
- [Standalone Binary Compilation](https://awesome-repositories.com/f/development-tools-productivity/build-tooling/build-orchestration-logic/build-orchestration-configuration/build-automation-systems/build-systems/binary-compilation-toolchains/server-binary-compilers/hardware-specific-binaries/custom-system-executable-building/standalone-binary-compilation.md) — Provides instructions on compiling source code into standalone executable binaries. ([source](https://gopl-zh.github.io/ch1/ch1-01.html))
- [Runtime Call-Stack Capturers](https://awesome-repositories.com/f/development-tools-productivity/call-stack-navigators/runtime-call-stack-capturers.md) — Explains how to capture the current function call hierarchy to diagnose runtime failures. ([source](https://gopl-zh.github.io/ch5/ch5-09.html))
- [Heap and CPU Profilers](https://awesome-repositories.com/f/development-tools-productivity/debugging-profiling-testing/debugging-diagnostics/performance-resource-profilers/heap-and-cpu-profilers.md) — Describes identifying bottlenecks by sampling CPU usage and memory allocations during execution. ([source](https://gopl-zh.github.io/ch11/ch11-05.html))
- [Workspace Management](https://awesome-repositories.com/f/development-tools-productivity/development-environment-management/development-environments/workspace-management.md) — Describes tools for provisioning, configuring, and managing the file operations of development workspaces. ([source](https://gopl-zh.github.io/ch10/ch10.html))

### Operating Systems & Systems Programming

- [Bitwise Manipulation Primitives](https://awesome-repositories.com/f/operating-systems-systems-programming/bitwise-manipulation-primitives.md) — Covers low-level bitwise AND, OR, XOR, and shifting operations for binary data management. ([source](https://gopl-zh.github.io/ch3/ch3-01.html))
- [Automatic Garbage Collection](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/automated-reclamation-systems/garbage-collection/precise-garbage-collectors/automatic-garbage-collection.md) — Describes the automatic allocation and reclamation of memory for variables via the Go garbage collector. ([source](https://gopl-zh.github.io/ch2/ch2-03.html))
- [Direct Memory Access](https://awesome-repositories.com/f/operating-systems-systems-programming/direct-memory-access.md) — Explains the use of pointers to store and retrieve variable memory addresses. ([source](https://gopl-zh.github.io/ch1/ch1-08.html))
- [Memory Address Identification](https://awesome-repositories.com/f/operating-systems-systems-programming/direct-memory-access/memory-address-identification.md) — Details the use of pointers to reference variable addresses for direct value updates. ([source](https://gopl-zh.github.io/ch2/ch2-03.html))
- [Immutable Byte Sequences](https://awesome-repositories.com/f/operating-systems-systems-programming/immutable-byte-sequences.md) — Explains Go's management of strings as immutable byte sequences for efficiency and memory sharing. ([source](https://gopl-zh.github.io/ch3/ch3-05.html))
- [Allocation Profiling](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/custom-memory-allocators/managed-memory-allocators/memory-allocation-management/allocation-profiling.md) — Go tracks the number of bytes allocated and the number of allocation calls per operation during execution. ([source](https://gopl-zh.github.io/ch11/ch11-04.html))
- [Low-Level Memory IO](https://awesome-repositories.com/f/operating-systems-systems-programming/low-level-memory-io.md) — Details techniques for direct memory address manipulation to achieve performance gains or hardware interaction. ([source](https://gopl-zh.github.io/ch13/ch13-05.html))

### Programming Languages & Runtimes

- [Anonymous Functions](https://awesome-repositories.com/f/programming-languages-runtimes/anonymous-functions.md) — Teaches the definition and use of anonymous function literals for flexible logic encapsulation. ([source](https://gopl-zh.github.io/ch5/ch5-06.html))
- [Associative Arrays](https://awesome-repositories.com/f/programming-languages-runtimes/associative-arrays.md) — Explains the use of Go maps as associative arrays for linking unique keys to values. ([source](https://gopl-zh.github.io/ch4/ch4.html))
- [Basic Data Type Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/basic-data-type-definitions.md) — Explains the fundamental numeric, string, and boolean types used in Go. ([source](https://gopl-zh.github.io/ch3/ch3.html))
- [Basic Type Comparisons](https://awesome-repositories.com/f/programming-languages-runtimes/basic-type-comparisons.md) — Describes how Go evaluates equality and ordering for integers, floats, and strings. ([source](https://gopl-zh.github.io/ch3/ch3-01.html))
- [Error](https://awesome-repositories.com/f/programming-languages-runtimes/block-value-returns/method-return-values/return-value-transformers/return-values/error.md) — Teaches the idiomatic Go pattern of returning errors as explicit values to handle expected failures. ([source](https://gopl-zh.github.io/ch5/ch5-04.html))
- [Boolean Logic Types](https://awesome-repositories.com/f/programming-languages-runtimes/boolean-logic-types.md) — Explains the use of boolean primitive types for conditional control flow and logical operations. ([source](https://gopl-zh.github.io/ch3/ch3-04.html))
- [Composite Types](https://awesome-repositories.com/f/programming-languages-runtimes/composite-types.md) — Describes how to group multiple values of different types into single entities like structs. ([source](https://gopl-zh.github.io/ch4/ch4-04.html))
- [Conditional Logic](https://awesome-repositories.com/f/programming-languages-runtimes/conditional-logic.md) — Describes the implementation of conditional logic using switch statements and fallthrough control. ([source](https://gopl-zh.github.io/ch1/ch1-08.html))
- [Custom String Representations](https://awesome-repositories.com/f/programming-languages-runtimes/custom-string-representations.md) — Describes how to implement custom string-returning methods to control type formatting during printing. ([source](https://gopl-zh.github.io/ch7/ch7-01.html))
- [Custom Type Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/custom-type-definitions.md) — Details the creation of new named types to prevent incompatible values from being mixed. ([source](https://gopl-zh.github.io/ch2/ch2-05.html))
- [Deferred Execution](https://awesome-repositories.com/f/programming-languages-runtimes/deferred-execution.md) — Explains the use of the defer keyword for scheduling cleanup functions and resource reclamation.
- [Deferred Function Executions](https://awesome-repositories.com/f/programming-languages-runtimes/deferred-function-executions.md) — Covers the use of the defer keyword to ensure cleanup tasks are executed before function return. ([source](https://gopl-zh.github.io/ch5/ch5-08.html))
- [Dynamic Sequence Management](https://awesome-repositories.com/f/programming-languages-runtimes/dynamic-sequence-management.md) — Covers the implementation and management of Go slices as variable-length sequences. ([source](https://gopl-zh.github.io/ch4/ch4-02.html))
- [Dynamic Slice Management](https://awesome-repositories.com/f/programming-languages-runtimes/dynamic-strings/string-slices/indexing-and-slicing/dynamic-slice-management.md) — Details the use of slices to manage dynamic sequences of elements. ([source](https://gopl-zh.github.io/ch4/ch4.html))
- [Explicit Type Conversions](https://awesome-repositories.com/f/programming-languages-runtimes/explicit-type-conversions.md) — Describes the syntax and logic for transforming values between compatible types. ([source](https://gopl-zh.github.io/ch2/ch2-05.html))
- [External Module Imports](https://awesome-repositories.com/f/programming-languages-runtimes/external-module-imports.md) — Details the mechanism for including external modules into source files to use exported identifiers. ([source](https://gopl-zh.github.io/ch10/ch10-04.html))
- [First-Class Functions](https://awesome-repositories.com/f/programming-languages-runtimes/first-class-functions.md) — Describes the ability to assign functions to variables and pass them as arguments to parameterize behavior. ([source](https://gopl-zh.github.io/ch5/ch5-05.html))
- [Fixed-Length Sequences](https://awesome-repositories.com/f/programming-languages-runtimes/fixed-length-sequences.md) — Describes the properties and use of fixed-length arrays in Go. ([source](https://gopl-zh.github.io/ch4/ch4-01.html))
- [Function Declarations](https://awesome-repositories.com/f/programming-languages-runtimes/function-declarations.md) — Provides the fundamental syntax for declaring reusable functions in Go. ([source](https://gopl-zh.github.io/ch5/ch5-01.html))
- [Function Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/function-definitions.md) — Provides comprehensive guidance on defining reusable logic through functions with parameters and return values. ([source](https://gopl-zh.github.io/ch2/ch2-02.html))
- [Go Idioms & Patterns](https://awesome-repositories.com/f/programming-languages-runtimes/go-idioms-patterns.md) — Explains idiomatic Go patterns for implementing concurrency, interfaces, and reflection to build robust software.
- [Immutable Constant Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/immutable-constant-definitions.md) — Explains how to declare compile-time constants that cannot be changed during program execution. ([source](https://gopl-zh.github.io/ch3/ch3-06.html))
- [Implicit Interface Implementations](https://awesome-repositories.com/f/programming-languages-runtimes/implicit-interface-implementations.md) — Explains the core Go concept of implicit interface satisfaction. ([source](https://gopl-zh.github.io/ch7/ch7-03.html))
- [Interface-Based Substitutability](https://awesome-repositories.com/f/programming-languages-runtimes/interface-and-any-types/interface-based-substitutability.md) — Go allows functions to accept any concrete type that satisfies a specific interface for interchangeable behavior. ([source](https://gopl-zh.github.io/ch7/ch7-01.html))
- [Interface Composition Mechanics](https://awesome-repositories.com/f/programming-languages-runtimes/interface-composition-mechanics.md) — Go creates new interface types by embedding existing interfaces to combine their required method sets. ([source](https://gopl-zh.github.io/ch7/ch7-02.html))
- [Interface Type Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/interface-type-definitions.md) — Go specifies a set of required methods that a concrete type must implement. ([source](https://gopl-zh.github.io/ch7/ch7-02.html))
- [Variable Type Declarations](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/variable-type-declarations.md) — Covers the explicit declaration of variables and their types within the language. ([source](https://gopl-zh.github.io/ch2/ch2-03.html))
- [Closure Captures](https://awesome-repositories.com/f/programming-languages-runtimes/local-variable-captures/closure-captures.md) — Explains how anonymous functions capture and maintain state from their surrounding lexical environment.
- [Loop Control Flow](https://awesome-repositories.com/f/programming-languages-runtimes/loop-control-flow.md) — Explains loop execution control using break and continue statements with labels. ([source](https://gopl-zh.github.io/ch1/ch1-08.html))
- [Multiple Return Values](https://awesome-repositories.com/f/programming-languages-runtimes/multiple-return-values.md) — Explains how Go functions can return multiple values, a key pattern for error handling. ([source](https://gopl-zh.github.io/ch5/ch5-03.html))
- [Package-Based Namespace Isolation](https://awesome-repositories.com/f/programming-languages-runtimes/package-based-namespace-isolation.md) — Describes how Go uses packages to isolate namespaces and control the visibility of identifiers.
- [Object Introspection](https://awesome-repositories.com/f/programming-languages-runtimes/reflection-based-object-manipulation/object-introspection.md) — Provides instructions on using the reflect package for runtime type inspection and dynamic value assignment.
- [Side-Effect Imports](https://awesome-repositories.com/f/programming-languages-runtimes/side-effect-imports.md) — Details how to trigger package initialization via side-effect imports. ([source](https://gopl-zh.github.io/ch10/ch10-05.html))
- [Struct Embedding](https://awesome-repositories.com/f/programming-languages-runtimes/struct-embedding.md) — Explains how to use struct embedding to simplify field and method access. ([source](https://gopl-zh.github.io/ch6/ch6-03.html))
- [Type Methods](https://awesome-repositories.com/f/programming-languages-runtimes/type-methods.md) — Explains how to associate functions with specific data types to create custom behaviors. ([source](https://gopl-zh.github.io/ch2/ch2-05.html))
- [Unicode Identifiers](https://awesome-repositories.com/f/programming-languages-runtimes/unicode-management/unicode-identifiers.md) — Describes the rules for defining names for functions, variables, and types using Unicode. ([source](https://gopl-zh.github.io/ch2/ch2-01.html))
- [Untyped Constants](https://awesome-repositories.com/f/programming-languages-runtimes/untyped-constants.md) — Discusses the utilization of untyped constants for high-precision arithmetic. ([source](https://gopl-zh.github.io/ch3/ch3-06.html))
- [Variable Assignments](https://awesome-repositories.com/f/programming-languages-runtimes/variable-assignments.md) — Describes the primitives for binding and updating values to identifiers in a program. ([source](https://gopl-zh.github.io/ch2/ch2-04.html))
- [Variable Scope Management](https://awesome-repositories.com/f/programming-languages-runtimes/variable-scope-management.md) — Explains the control of variable visibility and the use of lexical blocks for shadowing. ([source](https://gopl-zh.github.io/ch2/ch2-07.html))
- [Variadic Functions](https://awesome-repositories.com/f/programming-languages-runtimes/variadic-functions.md) — Explains how to define functions that accept an arbitrary number of arguments. ([source](https://gopl-zh.github.io/ch5/ch5-07.html))
- [Build and Run Tooling](https://awesome-repositories.com/f/programming-languages-runtimes/build-and-run-tooling.md) — Guidance on the standard build-run cycle, from compiling source code to executing the resulting binary. ([source](https://gopl-zh.github.io/ch1/ch1-01.html))
- [Documentation Comment Generators](https://awesome-repositories.com/f/programming-languages-runtimes/code-commenting/documentation-comment-generators.md) — Describes the generation of searchable guides by extracting structured comments from source files. ([source](https://gopl-zh.github.io/ch1/ch1-08.html))
- [Cross-Platform Compilers](https://awesome-repositories.com/f/programming-languages-runtimes/cross-platform-compilers.md) — Explains how to use compilers to target multiple operating systems and processor architectures from Go source. ([source](https://gopl-zh.github.io/ch10/ch10-07.html))
- [Documentation Generation](https://awesome-repositories.com/f/programming-languages-runtimes/documentation-generation.md) — Describes the use of live code snippets within documentation that are verified by the compiler. ([source](https://gopl-zh.github.io/ch11/ch11-06.html))
- [Dynamic Memory Allocation](https://awesome-repositories.com/f/programming-languages-runtimes/dynamic-memory-allocation.md) — Covers the creation of anonymous variables of specified types and returning pointers to their zero values. ([source](https://gopl-zh.github.io/ch2/ch2-03.html))
- [Indexing and Slicing](https://awesome-repositories.com/f/programming-languages-runtimes/dynamic-strings/string-slices/indexing-and-slicing.md) — Describes the process of generating a new slice subsequence from an existing one using index ranges. ([source](https://gopl-zh.github.io/ch4/ch4-02.html))
- [Dynamic Value Access](https://awesome-repositories.com/f/programming-languages-runtimes/dynamic-value-access.md) — Explains how to wrap and examine arbitrary values using reflection. ([source](https://gopl-zh.github.io/ch12/ch12-02.html))
- [Execution Flow Control](https://awesome-repositories.com/f/programming-languages-runtimes/execution-flow-control.md) — Provides guidance on using conditionals, loops, and other control statements to organize program logic. ([source](https://gopl-zh.github.io/ch2/ch2.html))
- [Go Development Workflows](https://awesome-repositories.com/f/programming-languages-runtimes/go-development-workflows.md) — Covers the complete development lifecycle, including compilation, dependency management, and project organization.
- [Import Aliasing](https://awesome-repositories.com/f/programming-languages-runtimes/import-aliasing.md) — Explains how to assign alternative names to imported packages to avoid naming conflicts. ([source](https://gopl-zh.github.io/ch10/ch10-04.html))
- [JSON Serializers](https://awesome-repositories.com/f/programming-languages-runtimes/json-serializers.md) — Describes how to convert data structures into JSON byte sequences with custom field naming. ([source](https://gopl-zh.github.io/ch4/ch4-05.html))
- [Module Organization](https://awesome-repositories.com/f/programming-languages-runtimes/module-organization.md) — Go groups related features into independent units to simplify design and enable code reuse across projects. ([source](https://gopl-zh.github.io/ch10/ch10-01.html))
- [Package Reuse](https://awesome-repositories.com/f/programming-languages-runtimes/package-reuse.md) — Guides the use of standard and third-party libraries to reuse functionality. ([source](https://gopl-zh.github.io/ch10/ch10.html))
- [Pointer Casts](https://awesome-repositories.com/f/programming-languages-runtimes/pointer-casts.md) — Covers converting pointers between specific and generic types to inspect memory patterns or write values. ([source](https://gopl-zh.github.io/ch13/ch13-02.html))
- [Program Panic Triggering](https://awesome-repositories.com/f/programming-languages-runtimes/program-panic-triggering.md) — Explains the use of panics to signal critical, unrecoverable failures and trigger program exits. ([source](https://gopl-zh.github.io/ch5/ch5-09.html))
- [Method Metadata Retrievals](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/data-structure-type-helpers/data-structures/dictionaries/inspection-methods/method-metadata-retrievals.md) — Provides methods for retrieving metadata and signatures of functions associated with a type. ([source](https://gopl-zh.github.io/ch12/ch12-08.html))
- [Array Access and Modification](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/data-structure-type-helpers/data-type-utilities/array-element-finding/array-modification-utilities/array-access-and-modification.md) — Describes the use of slices to directly modify elements within an underlying array. ([source](https://gopl-zh.github.io/ch4/ch4-02.html))
- [Memory Layout Inspectors](https://awesome-repositories.com/f/programming-languages-runtimes/reflection-based-state-inspection/memory-layout-inspectors.md) — Explains how to analyze physical memory offsets and alignment of data structures using reflection. ([source](https://gopl-zh.github.io/ch13/ch13-01.html))
- [Runtime Type Inspection](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-type-inspection.md) — Guides the use of runtime reflection to determine the underlying type of a variable. ([source](https://gopl-zh.github.io/ch12/ch12-01.html))
- [Runtime Type Introspection](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-type-introspection.md) — Provides guidance on identifying basic type categories like slices and maps at runtime for uniform data handling. ([source](https://gopl-zh.github.io/ch12/ch12-02.html))
- [String to Byte Conversions](https://awesome-repositories.com/f/programming-languages-runtimes/string-to-byte-conversions.md) — Explains the process of converting immutable strings to mutable byte slices for data manipulation. ([source](https://gopl-zh.github.io/ch3/ch3-05.html))
- [Custom Data Type Declarations](https://awesome-repositories.com/f/programming-languages-runtimes/type-name-assignment/unique-type-identifiers/custom-data-type-declarations.md) — Explains how to define custom named types and structured types to improve code readability and type safety. ([source](https://gopl-zh.github.io/ch1/ch1-08.html))
- [Unsafe Memory Access](https://awesome-repositories.com/f/programming-languages-runtimes/unsafe-memory-access.md) — Explains how to access internal memory layouts and ignore strict type conversion rules via unsafe operations. ([source](https://gopl-zh.github.io/ch13/ch13.html))

### Security & Cryptography

- [Member Visibility Control](https://awesome-repositories.com/f/security-cryptography/identity-access-management/access-control/encapsulation-modifiers/member-visibility-control.md) — Go hides internal details by controlling member visibility to enforce data consistency through access functions. ([source](https://gopl-zh.github.io/ch10/ch10-01.html))

### Software Engineering & Architecture

- [Interface Definitions](https://awesome-repositories.com/f/software-engineering-architecture/abstract-data-types/interface-definitions.md) — Teaches the use of interfaces to implement abstraction and polymorphism in Go. ([source](https://gopl-zh.github.io/ch1/ch1-08.html))
- [Short-Circuit Operators](https://awesome-repositories.com/f/software-engineering-architecture/boolean-logic-extractors/truthiness-evaluators/short-circuit-operators.md) — Explains the use of logical operators that conditionally evaluate expressions to optimize performance. ([source](https://gopl-zh.github.io/ch3/ch3-04.html))
- [Concurrency Synchronization Primitives](https://awesome-repositories.com/f/software-engineering-architecture/concurrency-synchronization-primitives.md) — Teaches the use of synchronization primitives to manage shared state across concurrent network operations.
- [Package Dependency Resolution](https://awesome-repositories.com/f/software-engineering-architecture/dependency-graph-resolution/package-dependency-resolution.md) — Covers the process of downloading and integrating external code packages from remote repositories. ([source](https://gopl-zh.github.io/ch1/ch1-01.html))
- [Struct Data Groupings](https://awesome-repositories.com/f/software-engineering-architecture/dependency-parameter-grouping/style-parameter-struct-grouping/struct-data-groupings.md) — Explains the use of structs to group multiple fields of different types into a single memory block. ([source](https://gopl-zh.github.io/ch4/ch4.html))
- [Interface-Based Polymorphism](https://awesome-repositories.com/f/software-engineering-architecture/interface-based-polymorphism.md) — Guides the implementation of interface-based polymorphism to treat different concrete types uniformly.
- [Technical Manual Translations](https://awesome-repositories.com/f/software-engineering-architecture/localization/language-translations/technical-manual-translations.md) — Offers a professional translation of a technical manual with a focus on preserving specialized terminology.
- [Composite Data Types](https://awesome-repositories.com/f/software-engineering-architecture/type-safe-development/smart-contract-type-safety/custom-data-structures/composite-data-types.md) — Explains how basic types are aggregated into complex structures such as arrays and structs. ([source](https://gopl-zh.github.io/ch2/ch2.html))
- [Implicit Interface Implementations](https://awesome-repositories.com/f/software-engineering-architecture/type-satisfaction-checks/implicit-interface-implementations.md) — Covers Go's unique approach to implicit interface satisfaction through method set implementation.
- [Deep Equality Comparison](https://awesome-repositories.com/f/software-engineering-architecture/deep-equality-comparison.md) — Covers recursive comparison of nested data structures by value using reflection. ([source](https://gopl-zh.github.io/ch13/ch13-03.html))
- [Error Propagation Systems](https://awesome-repositories.com/f/software-engineering-architecture/error-propagation-systems.md) — Details how to wrap errors with descriptive text to maintain a causal chain of failures. ([source](https://gopl-zh.github.io/ch5/ch5-04.html))
- [Pointer Arithmetic](https://awesome-repositories.com/f/software-engineering-architecture/integer-arithmetic/pointer-arithmetic.md) — Describes operations for adjusting memory addresses using offsets and pointer-to-integer conversions. ([source](https://gopl-zh.github.io/ch13/ch13-02.html))
- [Internal Package Encapsulation](https://awesome-repositories.com/f/software-engineering-architecture/module-encapsulation-patterns/logic-encapsulation-interfaces/internal-package-encapsulation.md) — Go limits the importability of internal packages to sibling directories within the same parent directory. ([source](https://gopl-zh.github.io/ch10/ch10-07.html))
- [Package Namespacing](https://awesome-repositories.com/f/software-engineering-architecture/namespace-management/package-namespacing.md) — Go assigns distinct namespaces to packages to allow clear naming without causing conflicts. ([source](https://gopl-zh.github.io/ch10/ch10-01.html))
- [Package-Based Code Organization](https://awesome-repositories.com/f/software-engineering-architecture/package-based-code-organization.md) — Go groups source files using declarations and imports to manage visibility and reuse across projects. ([source](https://gopl-zh.github.io/ch1/ch1-08.html))
- [Reflection-Based Unmarshallers](https://awesome-repositories.com/f/software-engineering-architecture/reflection-based-unmarshallers.md) — Explains how to use reflection to dynamically assign values from byte slices to struct fields. ([source](https://gopl-zh.github.io/ch12/ch12-06.html))
- [Runtime Error Management](https://awesome-repositories.com/f/software-engineering-architecture/runtime-error-management.md) — Describes the management of unrecoverable runtime errors and the execution of deferred cleanup functions. ([source](https://gopl-zh.github.io/ch5/ch5-09.html))
- [Source Code Formatting](https://awesome-repositories.com/f/software-engineering-architecture/source-code-formatting.md) — Guidance on applying standardized rules for the visual layout of source code to ensure consistency. ([source](https://gopl-zh.github.io/ch1/ch1-01.html))

### Testing & Quality Assurance

- [Performance Measurement](https://awesome-repositories.com/f/testing-quality-assurance/performance-testing-analysis/performance-diagnostics/performance-measurement.md) — Details how to calculate the average time taken per operation by executing functions under fixed workloads. ([source](https://gopl-zh.github.io/ch11/ch11-04.html))
- [Test and Benchmark Execution](https://awesome-repositories.com/f/testing-quality-assurance/test-and-benchmark-execution.md) — Describes the execution of specialized benchmark tests to measure code performance and efficiency. ([source](https://gopl-zh.github.io/ch11/ch11.html))
- [Behavior Verification](https://awesome-repositories.com/f/testing-quality-assurance/behavior-verification.md) — Go writes automated programs to check that product code behaves as expected by testing boundary conditions. ([source](https://gopl-zh.github.io/ch11/ch11.html))
- [Code Coverage Analysis](https://awesome-repositories.com/f/testing-quality-assurance/code-coverage-analysis.md) — Explains how to generate reports highlighting executed and unexecuted code blocks to find testing gaps. ([source](https://gopl-zh.github.io/ch11/ch11-03.html))
- [Execution Hotspot Analysis](https://awesome-repositories.com/f/testing-quality-assurance/execution-hotspot-analysis.md) — Details tracking the number of times each code block is executed to identify frequently used paths. ([source](https://gopl-zh.github.io/ch11/ch11-03.html))
- [Execution Time Benchmarks](https://awesome-repositories.com/f/testing-quality-assurance/function-calling-benchmarks/execution-time-benchmarks.md) — Go executes benchmark functions multiple times to calculate and report the average execution time. ([source](https://gopl-zh.github.io/ch11/ch11-01.html))
- [Go Runtime Profilers](https://awesome-repositories.com/f/testing-quality-assurance/performance-testing-analysis/performance-diagnostics/execution-profilers/flame-graph-visualizers/go-runtime-profilers.md) — Shows how to process sampled execution data to generate call graphs and pinpoint resource-heavy functions. ([source](https://gopl-zh.github.io/ch11/ch11-05.html))
- [Dependency Mocking](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/dependency-mocking.md) — Go replaces production functions with fake implementations to isolate logic and avoid side effects during testing. ([source](https://gopl-zh.github.io/ch11/ch11-02.html))

### Part of an Awesome List

- [Slice Length and Capacity Initialization](https://awesome-repositories.com/f/awesome-lists/devtools/memory-allocation/slab-based-pre-allocation/slice-capacity-pre-allocation/slice-length-and-capacity-initialization.md) — Explains how to initialize slices with specific length and capacity for optimal memory allocation. ([source](https://gopl-zh.github.io/ch4/ch4-02.html))
- [Variable Value Modifications](https://awesome-repositories.com/f/awesome-lists/devtools/reflection/variable-value-modifications.md) — Details how to update variable values at runtime by checking addressability and settability. ([source](https://gopl-zh.github.io/ch12/ch12-05.html))
- [Go Development](https://awesome-repositories.com/f/awesome-lists/devtools/go-development.md) — Chinese translation of the standard Go programming language book.

### Networking & Communication

- [Concurrent HTTP Clients](https://awesome-repositories.com/f/networking-communication/concurrent-http-clients.md) — Demonstrates how to execute multiple HTTP requests in parallel to optimize network data retrieval. ([source](https://gopl-zh.github.io/ch1/ch1-06.html))

### Scientific & Mathematical Computing

- [Floating-Point Types](https://awesome-repositories.com/f/scientific-mathematical-computing/floating-point-arithmetic/floating-point-types.md) — Describes the 32-bit and 64-bit floating-point types used for decimal values. ([source](https://gopl-zh.github.io/ch3/ch3-02.html))
- [Floating-Point Value Validation](https://awesome-repositories.com/f/scientific-mathematical-computing/floating-point-value-validation.md) — Explains how to handle special floating-point values such as NaN and infinity using library functions. ([source](https://gopl-zh.github.io/ch3/ch3-02.html))

### User Interface & Experience

- [Go Template Renderers](https://awesome-repositories.com/f/user-interface-experience/layout-utilities/presentation-engines/template-engines/server-side-rendering-engines/html-template-renderers/go-template-renderers.md) — Guides the use of html/template for generating HTML pages from data structures. ([source](https://gopl-zh.github.io/ch4/ch4.html))

### Web Development

- [Panic Recovery](https://awesome-repositories.com/f/web-development/error-handling/panic-recovery.md) — Demonstrates how to intercept runtime panics within deferred functions to prevent application crashes. ([source](https://gopl-zh.github.io/ch5/ch5-10.html))
- [Go Web Applications](https://awesome-repositories.com/f/web-development/go-web-applications.md) — Describes the implementation of backend services, HTTP servers, and dynamic HTML generation using templates.
- [JSON Encoding](https://awesome-repositories.com/f/web-development/json-encoding.md) — Explains how to encode and decode data structures between memory formats and JSON strings. ([source](https://gopl-zh.github.io/ch4/ch4.html))