Go Fundamentals - Table of Contents

  1. Foreword

  2. Chapter 1: Modules, Packages, and Dependencies

    1. Modules
    2. Packages
    3. Folders, Files, and Organization
    4. Importing Packages and Modules
    5. Dependencies
  3. Chapter 2: Go Language Basics

    1. Language Overview
    2. Numbers
    3. Strings
    4. UTF-8
    5. Variables
    6. Constants
    7. Naming Identifiers
    8. Printing and Formatting
  4. Chapter 3: Arrays, Slices, and Iteration

    1. List Types: Arrays and Slices
    2. How Slices Work
    3. Iteration
  5. Chapter 4: Maps and Control Structures

    1. Maps
    2. If Statements
    3. Switch Statements
  6. Chapter 5: Functions

    1. Function Definitions
    2. Variadic Arguments
    3. Deferring Function Calls
    4. Init
  7. Chapter 6: Structs, Methods, and Pointers

    1. Structs
    2. Methods
    3. Pointers
    4. Nil Receivers
  8. Chapter 7: Testing

    1. Testing Basics
    2. Code Coverage
    3. Table Drive Testing
    4. Running Tests
    5. Test Helpers
  9. Chapter 8: Interfaces

    1. Concrete Types Versus Interfaces
    2. Explicit Interface Implementation
    3. Implicit Interface Implementation
    4. Before Interfaces
    5. Using Interfaces
    6. Implementing Interfaces
    7. Multiple Interfaces
    8. Asserting Interface Implementation
    9. The Empty Interface
    10. Defining Interfaces
    11. Embedding Interfaces
    12. Type Assertions
    13. Assertions Through Switch Statements
    14. Using Assertions
  10. Chapter 9: Errors

    1. Errors as Values
    2. Panic
    3. Don't Panic
    4. Custom Errors
    5. Wrapping and Unwrapping Errors
    6. Errors As/Is
    7. Stack Traces
  11. Chapter 10: Generics

    1. What are Generics?
    2. Instantiating Generic Functions
    3. Defining Constraints
    4. Multiple Type Constraints
    5. The Constraints Package
    6. Type Assertions
    7. Mixing Method and Type Constraints
    8. Generic Types
  12. Chapter 11: Channels

    1. Concurrency and Parallelism
    2. Go's Concurrency Model
    3. Communicating with Channels
    4. Unidirectional Channels
    5. Closing Channels
    6. Buffered Channels
    7. Capturing System Signals with Channels
  13. Chapter 12: Context

    1. The Context Interface
    2. Context Rules
    3. Context Nodal Hierarchy
    4. Context Values
    5. Problems with String Keys
    6. Securing Context Keys and Values
    7. Cancellation Propagation with Contexts
    8. Timeouts and Deadlines
    9. Context Errors
    10. Listening for System Signals with Contexts
  14. Chapter 13: Synchronization

    1. Waiting for Goroutines with a WaitGroup
    2. Error Management with Error Groups
    3. Data Races
    4. Synchronizing Access with a Mutex
    5. Performing Tasks Only Once
  15. Chapter 14: Working with Files

    1. Directory Entries and File Information
    2. Walking Directories
    3. Skipping Files and Directories
    4. Creating Directories and Subdirectories
    5. File Path Helpers
    6. Creating Multiple Directories
    7. Creating Files
    8. Testing File Walking
    9. Appending to Files
    10. Reading Files
    11. The FS Package
    12. Using the FS Interface
    13. Mocking a File System
    14. Embedding Files
Subscribe to our newsletter