2 Hello, Earth! Extend your hello world

This chapter turns the classic “hello world” into a small, testable Go program. It starts by creating a module and a minimal main that prints to standard output with fmt.Println, while explaining package main, imports, exported vs. unexported identifiers (capitalization), and sensible naming and formatting conventions. The broader goal is to move beyond a one-liner by writing code that is both documented and verifiable, and by embracing Go’s Unicode support to greet users across writing systems.

Testing is introduced as a core practice. The chapter first shows how to verify standard output with Example functions (for instance, ExampleMain using // Output:), then refactors printing into a separate greet function that returns a string so it can be covered by conventional unit tests with the testing package. It models the preparation–execution–assertion–teardown flow, uses the “want/got” idiom, and reports failures via t.Errorf. To add language variations, greet is extended to accept a language parameter (a custom string-based type) and selects messages with a clear switch; the tests evolve from per-scenario functions to a concise, table-driven style that iterates named cases with t.Run.

To scale cleanly, the switch is replaced with a phrasebook map from language codes to greetings, illustrating Go’s multiple-return lookups (value, ok) and the need to check ok to detect unsupported inputs. The program becomes a simple CLI by parsing a -lang flag with the flag package (StringVar and Parse), converting the result to the language type, and printing the appropriate greeting. By the end, you have a modular, extendable greeter with deterministic tests, practical patterns for maps and table-driven tests, and a foundation for growing features such as more languages and input validation.

• go run allows you to quickly execute a Go program without creating a binary, making it useful during development.
• Writing tests alongside your code, rather than after it, ensures the mental model of expected inputs and outputs is fresh and accurate, leading to better test coverage.
• go test is used to execute tests written for your code, following Go's naming conventions for test files and functions.
• The testing package provides everything you need to write and run tests, including support for assertions and benchmarks.
• Table-Driven Tests are a Go best practice for testing functions across multiple inputs and outputs. By using slices of test cases, you can easily iterate through various scenarios in a structured way.
• Example functions are special tests used to check the output of a function by verifying what is written to the standard output. These are often used to demonstrate usage.
• Each test generally follows four phases: preparation, where you set up inputs; execution, where you run the code being tested; decision, where you compare the result with expected output; and teardown, where you clean up resources.
• The flag package allows for parsing command-line arguments, making your Go applications more flexible and interactive.
• Maps in Go are a powerful data structure for storing key-value pairs. Accessing a map returns both the value and a boolean indicating if the key was found.
• Define custom types when they provide meaningful context over built-in types. For example, a UserID type can be more descriptive than an int.
• Use if statements for simple binary conditions. For more complex cases, prefer switch statements or maps to handle multiple conditions more cleanly.

FAQ