Go by Example
Sorry, we couldn't find that! Check out the home page?
Go by Example: Arrays
|
In Go, an array is a numbered sequence of elements of a specific length. In typical Go code, slices are much more common; arrays are useful in some special scenarios. |
|
 
|
|
|
|
|
|
|
Here we create an array |
|
|
We can set a value at an index using the
|
|
|
The builtin |
|
|
Use this syntax to declare and initialize an array in one line. |
|
|
You can also have the compiler count the number of
elements for you with |
|
|
If you specify the index with |
|
|
Array types are one-dimensional, but you can compose types to build multi-dimensional data structures. |
|
|
You can create and initialize multi-dimensional arrays at once too. |
|
|
Note that arrays appear in the form |
|
Next example: Slices.
Go by Example: Atomic Counters
|
The primary mechanism for managing state in Go is
communication over channels. We saw this for example
with worker pools. There are a few other
options for managing state though. Here we’ll
look at using the |
|
|
|
|
|
|
|
|
We’ll use an atomic integer type to represent our (always-positive) counter. |
|
|
A WaitGroup will help us wait for all goroutines to finish their work. |
|
|
We’ll start 50 goroutines that each increment the counter exactly 1000 times. |
|
|
To atomically increment the counter we use |
|
|
Wait until all the goroutines are done. |
|
|
Here no goroutines are writing to ‘ops’, but using
|
|
|
We expect to get exactly 50,000 operations. Had we
used a non-atomic integer and incremented it with
|
|
|
Next we’ll look at mutexes, another tool for managing state. |
Next example: Mutexes.
Go by Example: Base64 Encoding
|
Go provides built-in support for base64 encoding/decoding. |
|
|
|
|
This syntax imports the |
|
|
|
|
Here’s the |
|
|
Go supports both standard and URL-compatible
base64. Here’s how to encode using the standard
encoder. The encoder requires a |
|
|
Decoding may return an error, which you can check if you don’t already know the input to be well-formed. |
|
|
This encodes/decodes using a URL-compatible base64 format. |
|
|
The string encodes to slightly different values with the
standard and URL base64 encoders (trailing |
|
|
Next example: Reading Files.
Go by Example: Channel Buffering
|
By default channels are unbuffered, meaning that they
will only accept sends ( |
|
|
|
|
|
|
|
|
Here we |
|
|
Because this channel is buffered, we can send these values into the channel without a corresponding concurrent receive. |
|
|
Later we can receive these two values as usual. |
|
|
Next example: Channel Synchronization.
Go by Example: Channel Directions
|
When using channels as function parameters, you can specify if a channel is meant to only send or receive values. This specificity increases the type-safety of the program. |
|
|
|
|
|
|
This |
|
|
The |
|
|
|
Next example: Select.
Go by Example: Channel Synchronization
|
We can use channels to synchronize execution across goroutines. Here’s an example of using a blocking receive to wait for a goroutine to finish. When waiting for multiple goroutines to finish, you may prefer to use a WaitGroup. |
|
|
|
|
|
|
This is the function we’ll run in a goroutine. The
|
|
|
Send a value to notify that we’re done. |
|
|
|
|
Start a worker goroutine, giving it the channel to notify on. |
|
|
Block until we receive a notification from the worker on the channel. |
|
|
|
|
If you removed the |
Next example: Channel Directions.
Go by Example: Channels
|
Channels are the pipes that connect concurrent goroutines. You can send values into channels from one goroutine and receive those values into another goroutine. |
|
|
|
|
|
|
|
|
Create a new channel with |
|
|
Send a value into a channel using the |
|
|
The |
|
|
When we run the program the |
|
|
By default sends and receives block until both the
sender and receiver are ready. This property allowed
us to wait at the end of our program for the |
Next example: Channel Buffering.
Go by Example: Closing Channels
|
Closing a channel indicates that no more values will be sent on it. This can be useful to communicate completion to the channel’s receivers. |
|
|
|
|
|
|
In this example we’ll use a |
|
|
Here’s the worker goroutine. It repeatedly receives
from |
|
|
This sends 3 jobs to the worker over the |
|
|
We await the worker using the synchronization approach we saw earlier. |
|
|
Reading from a closed channel succeeds immediately,
returning the zero value of the underlying type.
The optional second return value is |
|
|
|
|
The idea of closed channels leads naturally to our next
example: |
Next example: Range over Channels.
Go by Example: Closures
|
Go supports anonymous functions, which can form closures. Anonymous functions are useful when you want to define a function inline without having to name it. |
|
|
|
|
|
|
This function |
|
|
|
|
We call |
|
|
See the effect of the closure by calling |
|
|
To confirm that the state is unique to that particular function, create and test a new one. |
|
|
|
|
The last feature of functions we’ll look at for now is recursion. |
Next example: Recursion.
Go by Example: Command-Line Arguments
|
Command-line arguments
are a common way to parameterize execution of programs.
For example, |
|
|
|
|
|
|
|
|
|
|
|
You can get individual args with normal indexing. |
|
|
|
To experiment with command-line arguments it’s best to
build a binary with |
|
|
Next we’ll look at more advanced command-line processing with flags. |
Next example: Command-Line Flags.
Go by Example: Command-Line Flags
|
Command-line flags
are a common way to specify options for command-line
programs. For example, in |
|
|
|
|
Go provides a |
|
|
|
|
Basic flag declarations are available for string,
integer, and boolean options. Here we declare a
string flag |
|
|
This declares |
|
|
It’s also possible to declare an option that uses an existing var declared elsewhere in the program. Note that we need to pass in a pointer to the flag declaration function. |
|
|
Once all flags are declared, call |
|
|
Here we’ll just dump out the parsed options and
any trailing positional arguments. Note that we
need to dereference the pointers with e.g. |
|
|
To experiment with the command-line flags program it’s best to first compile it and then run the resulting binary directly. |
|
|
Try out the built program by first giving it values for all flags. |
|
|
Note that if you omit flags they automatically take their default values. |
|
|
Trailing positional arguments can be provided after any flags. |
|
|
Note that the |
|
|
Use |
|
|
If you provide a flag that wasn’t specified to the
|
|
Next example: Command-Line Subcommands.
Go by Example: Command-Line Subcommands
|
Some command-line tools, like the |
|
|
|
|
|
|
|
|
We declare a subcommand using the |
|
|
For a different subcommand we can define different supported flags. |
|
|
The subcommand is expected as the first argument to the program. |
|
|
Check which subcommand is invoked. |
|
|
For every subcommand, we parse its own flags and have access to trailing positional arguments. |
|
|
|
|
First invoke the foo subcommand. |
|
|
Now try bar. |
|
|
But bar won’t accept foo’s flags. |
|
|
Next we’ll look at environment variables, another common way to parameterize programs. |
Next example: Environment Variables.
Go by Example: Constants
|
Go supports constants of character, string, boolean, and numeric values. |
|
|
|
|
|
|
|
|
|
|
|
A |
|
|
Constant expressions perform arithmetic with arbitrary precision. |
|
|
A numeric constant has no type until it’s given one, such as by an explicit conversion. |
|
|
A number can be given a type by using it in a
context that requires one, such as a variable
assignment or function call. For example, here
|
|
|
Next example: For.
Go by Example: Context
|
In the previous example we looked at setting up a simple
HTTP server. HTTP servers are useful for
demonstrating the usage of |
|
|
|
|
|
|
A |
|
|
Wait for a few seconds before sending a reply to the
client. This could simulate some work the server is
doing. While working, keep an eye on the context’s
|
|
|
The context’s |
|
|
|
|
As before, we register our handler on the “/hello” route, and start serving. |
|
|
Run the server in the background. |
|
|
Simulate a client request to |
|
Next example: Spawning Processes.
Go by Example: Custom Errors
|
It’s possible to define custom error types by
implementing the |
|
|
|
|
|
|
A custom error type usually has the suffix “Error”. |
|
|
Adding this |
|
|
|
|
Return our custom error. |
|
|
|
|
|
|
|
Next example: Goroutines.
Go by Example: Defer
|
Defer is used to ensure that a function call is
performed later in a program’s execution, usually for
purposes of cleanup. |
|
|
|
|
|
|
Suppose we wanted to create a file, write to it,
and then close when we’re done. Here’s how we could
do that with |
|
|
Immediately after getting a file object with
|
|
|
|
|
|
|
It’s important to check for errors when closing a file, even in a deferred function. |
|
|
|
Running the program confirms that the file is closed after being written. |
|
Next example: Recover.
Go by Example: Directories
|
Go has several useful functions for working with directories in the file system. |
|
|
|
|
|
|
|
|
|
|
Create a new sub-directory in the current working directory. |
|
|
When creating temporary directories, it’s good
practice to |
|
|
Helper function to create a new empty file. |
|
|
|
|
We can create a hierarchy of directories, including
parents with |
|
|
|
|
|
|
|
|
|
|
|
|
Now we’ll see the contents of |
|
|
|
|
|
|
|
We can also visit a directory recursively,
including all its sub-directories. |
|
|
|
|
|
Next example: Temporary Files and Directories.
Go by Example: Embed Directive
|
|
|
|
Import the |
|
|
|
|
|
Or embed the contents of the file into a |
|
|
We can also embed multiple files or even folders with wildcards. This uses a variable of the embed.FS type, which implements a simple virtual file system. |
|
|
|
|
Print out the contents of |
|
|
Retrieve some files from the embedded folder. |
|
|
|
Use these commands to run the example. (Note: due to limitation on go playground, this example can only be run on your local machine.) |
|
|
Next example: Testing and Benchmarking.
Go by Example: Enums
|
Enumerated types (enums) are a special case of sum types. An enum is a type that has a fixed number of possible values, each with a distinct name. Go doesn’t have an enum type as a distinct language feature, but enums are simple to implement using existing language idioms. |
|
|
|
|
|
|
Our enum type |
|
|
The possible values for |
|
|
By implementing the fmt.Stringer
interface, values of This can get cumbersome if there are many possible values. In such
cases the stringer tool
can be used in conjunction with |
|
|
|
|
If we have a value of type |
|
|
|
|
transition emulates a state transition for a server; it takes the existing state and returns a new state. |
|
|
Suppose we check some predicates here to determine the next state… |
|
|
Next example: Struct Embedding.
Go by Example: Environment Variables
|
Environment variables are a universal mechanism for conveying configuration information to Unix programs. Let’s look at how to set, get, and list environment variables. |
|
|
|
|
|
|
|
|
To set a key/value pair, use |
|
|
Use |
|
|
Running the program shows that we pick up the value
for |
|
|
The list of keys in the environment will depend on your particular machine. |
|
|
If we set |
|
Next example: Logging.
Go by Example: Epoch
|
A common requirement in programs is getting the number of seconds, milliseconds, or nanoseconds since the Unix epoch. Here’s how to do it in Go. |
|
|
|
|
|
|
|
|
Use |
|
|
|
|
You can also convert integer seconds or nanoseconds
since the epoch into the corresponding |
|
|
|
|
Next we’ll look at another time-related task: time parsing and formatting. |
Next example: Time Formatting / Parsing.
Go by Example: Errors
|
In Go it’s idiomatic to communicate errors via an explicit, separate return value. This contrasts with the exceptions used in languages like Java, Python and Ruby and the overloaded single result / error value sometimes used in C. Go’s approach makes it easy to see which functions return errors and to handle them using the same language constructs employed for other, non-error tasks. See the documentation of the errors package and this blog post for additional details. |
|
|
|
|
|
|
By convention, errors are the last return value and
have type |
|
|
|
|
|
A |
|
|
A sentinel error is a predeclared variable that is used to signify a specific error condition. |
|
|
|
|
We can wrap errors with higher-level errors to add
context. The simplest way to do this is with the
|
|
|
|
|
It’s idiomatic to use an inline error check in the |
|
|
|
|
|
|
|
|
Next example: Custom Errors.
Go by Example: Exec'ing Processes
|
In the previous example we looked at
spawning external processes. We
do this when we need an external process accessible to
a running Go process. Sometimes we just want to
completely replace the current Go process with another
(perhaps non-Go) one. To do this we’ll use Go’s
implementation of the classic
|
|
|
|
|
|
|
|
|
For our example we’ll exec |
|
|
|
|
|
|
|
|
Here’s the actual |
|
|
When we run our program it is replaced by |
|
|
Note that Go does not offer a classic Unix |
Next example: Signals.
Go by Example: Exit
|
Use |
|
|
|
|
|
|
|
|
|
|
|
Exit with status 3. |
|
|
Note that unlike e.g. C, Go does not use an integer
return value from |
|
If you run |
|
|
By building and executing a binary you can see the status in the terminal. |
|
|
Note that the |
Go by Example: File Paths
|
The |
|
|
|
|
|
|
|
|
|
You should always use |
|
|
|
|
|
We can check whether a path is absolute. |
|
|
|
|
Some file names have extensions following a dot. We
can split the extension out of such names with |
|
|
To find the file’s name with the extension removed,
use |
|
|
|
|
|
|
Next example: Directories.
Go by Example: For
|
|
|
|
|
|
|
|
|
|
The most basic type, with a single condition. |
|
|
A classic initial/condition/after |
|
|
Another way of accomplishing the basic “do this
N times” iteration is |
|
|
|
|
|
You can also |
|
|
|
|
We’ll see some other |
Next example: If/Else.
Go by Example: Functions
|
Functions are central in Go. We’ll learn about functions with a few different examples. |
|
|
|
|
|
|
Here’s a function that takes two |
|
|
Go requires explicit returns, i.e. it won’t automatically return the value of the last expression. |
|
|
When you have multiple consecutive parameters of the same type, you may omit the type name for the like-typed parameters up to the final parameter that declares the type. |
|
|
|
|
Call a function just as you’d expect, with
|
|
|
|
|
|
There are several other features to Go functions. One is multiple return values, which we’ll look at next. |
Next example: Multiple Return Values.
Go by Example: Generics
|
Starting with version 1.18, Go has added support for generics, also known as type parameters. |
|
|
|
|
|
|
As an example of a generic function, |
|
|
As an example of a generic type, |
|
|
|
|
We can define methods on generic types just like we
do on regular types, but we have to keep the type
parameters in place. The type is |
|
|
AllElements returns all the List elements as a slice. In the next example we’ll see a more idiomatic way of iterating over all elements of custom types. |
|
|
|
|
When invoking generic functions, we can often rely
on type inference. Note that we don’t have to
specify the types for |
|
|
… though we could also specify them explicitly. |
|
|
|
Next example: Range over Iterators.
Go by Example: Goroutines
|
A goroutine is a lightweight thread of execution. |
|
|
|
|
|
|
|
|
|
|
Suppose we have a function call |
|
|
To invoke this function in a goroutine, use
|
|
|
You can also start a goroutine for an anonymous function call. |
|
|
Our two function calls are running asynchronously in separate goroutines now. Wait for them to finish (for a more robust approach, use a WaitGroup). |
|
|
When we run this program, we see the output of the blocking call first, then the output of the two goroutines. The goroutines’ output may be interleaved, because goroutines are being run concurrently by the Go runtime. |
|
|
Next we’ll look at a complement to goroutines in concurrent Go programs: channels. |
Next example: Channels.
Go by Example: Hello World
|
Our first program will print the classic “hello world” message. Here’s the full source code. |
|
|
|
|
|
To run the program, put the code in |
|
|
Sometimes we’ll want to build our programs into
binaries. We can do this using |
|
|
We can then execute the built binary directly. |
|
|
Now that we can run and build basic Go programs, let’s learn more about the language. |
Next example: Values.
Go by Example: HTTP Client
|
The Go standard library comes with excellent support
for HTTP clients and servers in the |
|
|
|
|
|
|
Issue an HTTP GET request to a server. |
|
|
Print the HTTP response status. |
|
|
Print the first 5 lines of the response body. |
|
|
|
Next example: HTTP Server.
Go by Example: HTTP Server
|
Writing a basic HTTP server is easy using the
|
|
|
|
|
A fundamental concept in |
|
|
Functions serving as handlers take a
|
|
|
|
|
This handler does something a little more sophisticated by reading all the HTTP request headers and echoing them into the response body. |
|
|
|
|
We register our handlers on server routes using the
|
|
|
Finally, we call the |
|
|
Run the server in the background. |
|
|
Access the |
|
Next example: TCP Server.
Go by Example: If/Else
|
Branching with |
|
|
|
|
|
|
|
|
Here’s a basic example. |
|
|
You can have an |
|
|
Logical operators like |
|
|
A statement can precede conditionals; any variables declared in this statement are available in the current and all subsequent branches. |
|
|
Note that you don’t need parentheses around conditions in Go, but that the braces are required. |
|
|
|
There is no ternary if
in Go, so you’ll need to use a full |
Next example: Switch.
Go by Example
Go is an open source programming language designed for building scalable, secure and reliable software. Please read the official documentation to learn more.
Go by Example is a hands-on introduction to Go using annotated example programs. Check out the first example or browse the full list below.
Unless stated otherwise, examples here assume the latest major release Go and may use new language features. Try to upgrade to the latest version if something isn't working.
- Hello World
- Values
- Variables
- Constants
- For
- If/Else
- Switch
- Arrays
- Slices
- Maps
- Functions
- Multiple Return Values
- Variadic Functions
- Closures
- Recursion
- Range over Built-in Types
- Pointers
- Strings and Runes
- Structs
- Methods
- Interfaces
- Enums
- Struct Embedding
- Generics
- Range over Iterators
- Errors
- Custom Errors
- Goroutines
- Channels
- Channel Buffering
- Channel Synchronization
- Channel Directions
- Select
- Timeouts
- Non-Blocking Channel Operations
- Closing Channels
- Range over Channels
- Timers
- Tickers
- Worker Pools
- WaitGroups
- Rate Limiting
- Atomic Counters
- Mutexes
- Stateful Goroutines
- Sorting
- Sorting by Functions
- Panic
- Defer
- Recover
- String Functions
- String Formatting
- Text Templates
- Regular Expressions
- JSON
- XML
- Time
- Epoch
- Time Formatting / Parsing
- Random Numbers
- Number Parsing
- URL Parsing
- SHA256 Hashes
- Base64 Encoding
- Reading Files
- Writing Files
- Line Filters
- File Paths
- Directories
- Temporary Files and Directories
- Embed Directive
- Testing and Benchmarking
- Command-Line Arguments
- Command-Line Flags
- Command-Line Subcommands
- Environment Variables
- Logging
- HTTP Client
- HTTP Server
- TCP Server
- Context
- Spawning Processes
- Exec'ing Processes
- Signals
- Exit
Go by Example: Interfaces
|
Interfaces are named collections of method signatures. |
|
|
|
|
|
|
Here’s a basic interface for geometric shapes. |
|
|
For our example we’ll implement this interface on
|
|
|
To implement an interface in Go, we just need to
implement all the methods in the interface. Here we
implement |
|
|
The implementation for |
|
|
If a variable has an interface type, then we can call
methods that are in the named interface. Here’s a
generic |
|
|
Sometimes it’s useful to know the runtime type of an
interface value. One option is using a type assertion
as shown here; another is a type |
|
|
|
|
The |
|
|
|
|
|
To understand how Go’s interfaces work under the hood, check out this blog post. |
Next example: Enums.
Go by Example: JSON
|
Go offers built-in support for JSON encoding and decoding, including to and from built-in and custom data types. |
|
|
|
|
|
|
We’ll use these two structs to demonstrate encoding and decoding of custom types below. |
|
|
Only exported fields will be encoded/decoded in JSON. Fields must start with capital letters to be exported. |
|
|
|
|
First we’ll look at encoding basic data types to JSON strings. Here are some examples for atomic values. |
|
|
|
|
|
|
|
|
And here are some for slices and maps, which encode to JSON arrays and objects as you’d expect. |
|
|
|
|
The JSON package can automatically encode your custom data types. It will only include exported fields in the encoded output and will by default use those names as the JSON keys. |
|
|
You can use tags on struct field declarations
to customize the encoded JSON key names. Check the
definition of |
|
|
Now let’s look at decoding JSON data into Go values. Here’s an example for a generic data structure. |
|
|
We need to provide a variable where the JSON
package can put the decoded data. This
|
|
|
Here’s the actual decoding, and a check for associated errors. |
|
|
In order to use the values in the decoded map,
we’ll need to convert them to their appropriate type.
For example here we convert the value in |
|
|
Accessing nested data requires a series of conversions. |
|
|
We can also decode JSON into custom data types. This has the advantages of adding additional type-safety to our programs and eliminating the need for type assertions when accessing the decoded data. |
|
|
In the examples above we always used bytes and
strings as intermediates between the data and
JSON representation on standard out. We can also
stream JSON encodings directly to |
|
|
Streaming reads from |
|
|
|
|
We’ve covered the basic of JSON in Go here, but check out the JSON and Go blog post and JSON package docs for more. |
Next example: XML.
Go by Example: Line Filters
|
A line filter is a common type of program that reads
input on stdin, processes it, and then prints some
derived result to stdout. |
|
|
Here’s an example line filter in Go that writes a capitalized version of all input text. You can use this pattern to write your own Go line filters. |
|
|
|
|
|
|
Wrapping the unbuffered |
|
|
|
|
|
|
|
Write out the uppercased line. |
|
|
Check for errors during |
|
|
To try out our line filter, first make a file with a few lowercase lines. |
|
|
Then use the line filter to get uppercase lines. |
|
Next example: File Paths.
Go by Example: Logging
|
The Go standard library provides straightforward tools for outputting logs from Go programs, with the log package for free-form output and the log/slog package for structured output. |
|
|
|
|
|
|
|
|
Simply invoking functions like |
|
|
Loggers can be configured with flags to set
their output format. By default, the standard
logger has the |
|
|
It also supports emitting the file name and
line from which the |
|
|
It may be useful to create a custom logger and pass it around. When creating a new logger, we can set a prefix to distinguish its output from other loggers. |
|
|
We can set the prefix
on existing loggers (including the standard one)
with the |
|
|
Loggers can have custom output targets;
any |
|
|
This call writes the log output into |
|
|
This will actually show it on standard output. |
|
|
The |
|
|
In addition to the message, |
|
|
Sample output; the date and time emitted will depend on when the example ran. |
|
|
These are wrapped for clarity of presentation on the website; in reality they are emitted on a single line. |
|
Next example: HTTP Client.
Go by Example: Maps
|
Maps are Go’s built-in associative data type (sometimes called hashes or dicts in other languages). |
|
|
|
|
|
|
|
|
To create an empty map, use the builtin |
|
|
Set key/value pairs using typical |
|
|
Printing a map with e.g. |
|
|
Get a value for a key with |
|
|
If the key doesn’t exist, the zero value of the value type is returned. |
|
|
The builtin |
|
|
The builtin |
|
|
To remove all key/value pairs from a map, use
the |
|
|
The optional second return value when getting a
value from a map indicates if the key was present
in the map. This can be used to disambiguate
between missing keys and keys with zero values
like |
|
|
You can also declare and initialize a new map in the same line with this syntax. |
|
|
The |
|
|
Note that maps appear in the form |
|
Next example: Functions.
Go by Example: Methods
|
Go supports methods defined on struct types. |
|
|
|
|
|
|
|
|
This |
|
|
Methods can be defined for either pointer or value receiver types. Here’s an example of a value receiver. |
|
|
|
|
Here we call the 2 methods defined for our struct. |
|
|
Go automatically handles conversion between values and pointers for method calls. You may want to use a pointer receiver type to avoid copying on method calls or to allow the method to mutate the receiving struct. |
|
|
|
|
Next we’ll look at Go’s mechanism for grouping and naming related sets of methods: interfaces. |
Next example: Interfaces.
Go by Example: Multiple Return Values
|
Go has built-in support for multiple return values. This feature is used often in idiomatic Go, for example to return both result and error values from a function. |
|
|
|
|
|
|
The |
|
|
|
|
Here we use the 2 different return values from the call with multiple assignment. |
|
|
If you only want a subset of the returned values,
use the blank identifier |
|
|
|
|
Accepting a variable number of arguments is another nice feature of Go functions; we’ll look at this next. |
Next example: Variadic Functions.
Go by Example: Mutexes
|
In the previous example we saw how to manage simple counter state using atomic operations. For more complex state we can use a mutex to safely access data across multiple goroutines. |
|
|
|
|
|
|
Container holds a map of counters; since we want to
update it concurrently from multiple goroutines, we
add a |
|
|
Lock the mutex before accessing |
|
|
|
|
Note that the zero value of a mutex is usable as-is, so no initialization is required here. |
|
|
|
|
|
|
This function increments a named counter in a loop. |
|
|
Run several goroutines concurrently; note
that they all access the same |
|
|
|
|
|
|
Wait for the goroutines to finish |
|
|
Running the program shows that the counters updated as expected. |
|
|
Next we’ll look at implementing this same state management task using only goroutines and channels. |
Next example: Stateful Goroutines.
Go by Example: Non-Blocking Channel Operations
|
Basic sends and receives on channels are blocking.
However, we can use |
|
|
|
|
|
|
|
|
Here’s a non-blocking receive. If a value is
available on |
|
|
A non-blocking send works similarly. Here |
|
|
We can use multiple |
|
|
Next example: Closing Channels.
Go by Example: Number Parsing
|
Parsing numbers from strings is a basic but common task in many programs; here’s how to do it in Go. |
|
|
|
|
The built-in package |
|
|
|
|
With |
|
|
For |
|
|
|
|
|
A |
|
|
|
|
|
Parse functions return an error on bad input. |
|
|
|
|
Next we’ll look at another common parsing task: URLs. |
Next example: URL Parsing.
Go by Example: Panic
|
A |
|
|
|
|
|
|
|
|
We’ll use panic throughout this site to check for unexpected errors. This is the only program on the site designed to panic. |
|
|
A common use of panic is to abort if a function
returns an error value that we don’t know how to
(or want to) handle. Here’s an example of
|
|
|
Running this program will cause it to panic, print an error message and goroutine traces, and exit with a non-zero status. |
|
|
When first panic in |
|
|
|
|
Note that unlike some languages which use exceptions for handling of many errors, in Go it is idiomatic to use error-indicating return values wherever possible. |
Next example: Defer.
Go by Example: Pointers
|
Go supports pointers, allowing you to pass references to values and records within your program. |
|
|
|
|
|
|
We’ll show how pointers work in contrast to values with
2 functions: |
|
|
|
|
|
|
|
|
|
The |
|
|
Pointers can be printed too. |
|
|
|
|
Next example: Strings and Runes.
Go by Example: Random Numbers
|
Go’s |
|
|
|
|
|
|
|
|
For example, |
|
|
|
|
|
This can be used to generate random floats in
other ranges, for example |
|
|
If you want a known seed, create a new
|
|
|
|
Some of the generated numbers may be different when you run the sample. |
|
|
See the |
Next example: Number Parsing.
Go by Example: Range over Built-in Types
|
range iterates over elements in a variety of
built-in data structures. Let’s see how to
use |
|
|
|
|
|
|
|
|
Here we use |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Next example: Pointers.
Go by Example: Range over Channels
|
In a previous example we saw how |
|
|
|
|
|
|
|
|
We’ll iterate over 2 values in the |
|
|
This |
|
|
|
|
This example also showed that it’s possible to close a non-empty channel but still have the remaining values be received. |
Next example: Timers.
Go by Example: Range over Iterators
|
Starting with version 1.23, Go has added support for iterators, which lets us range over pretty much anything! |
|
|
|
|
|
|
Let’s look at the |
|
|
|
|
|
|
All returns an iterator, which in Go is a function with a special signature. |
|
|
The iterator function takes another function as
a parameter, called |
|
|
Iteration doesn’t require an underlying data structure,
and doesn’t even have to be finite! Here’s a function
returning an iterator over Fibonacci numbers: it keeps
running as long as |
|
|
|
|
|
|
Since |
|
|
Packages like slices have
a number of useful functions to work with iterators.
For example, |
|
|
Standard library packages now expose iterator helpers
too. For example, |
|
|
|
|
Once the loop hits |
|
|
Next example: Errors.
Go by Example: Rate Limiting
|
Rate limiting is an important mechanism for controlling resource utilization and maintaining quality of service. Go elegantly supports rate limiting with goroutines, channels, and tickers. |
|
|
|
|
|
|
|
|
First we’ll look at basic rate limiting. Suppose we want to limit our handling of incoming requests. We’ll serve these requests off a channel of the same name. |
|
|
This |
|
|
By blocking on a receive from the |
|
|
We may want to allow short bursts of requests in
our rate limiting scheme while preserving the
overall rate limit. We can accomplish this by
buffering our limiter channel. This |
|
|
Fill up the channel to represent allowed bursting. |
|
|
Every 200 milliseconds we’ll try to add a new
value to |
|
|
Now simulate 5 more incoming requests. The first
3 of these will benefit from the burst capability
of |
|
|
Running our program we see the first batch of requests handled once every ~200 milliseconds as desired. |
|
|
For the second batch of requests we serve the first 3 immediately because of the burstable rate limiting, then serve the remaining 2 with ~200ms delays each. |
|
Next example: Atomic Counters.
Go by Example: Reading Files
|
Reading and writing files are basic tasks needed for many Go programs. First we’ll look at some examples of reading files. |
|
|
|
|
|
|
Reading files requires checking most calls for errors. This helper will streamline our error checks below. |
|
|
|
|
Perhaps the most basic file reading task is slurping a file’s entire contents into memory. |
|
|
You’ll often want more control over how and what
parts of a file are read. For these tasks, start
by |
|
|
Read some bytes from the beginning of the file. Allow up to 5 to be read but also note how many actually were read. |
|
|
You can also |
|
|
Other methods of seeking are relative to the current cursor position, |
|
|
and relative to the end of the file. |
|
|
The |
|
|
There is no built-in rewind, but
|
|
|
The |
|
|
Close the file when you’re done (usually this would
be scheduled immediately after |
|
|
|
|
Next we’ll look at writing files. |
Next example: Writing Files.
Go by Example: Recover
|
Go makes it possible to recover from a panic, by
using the |
|
|
An example of where this can be useful: a server
wouldn’t want to crash if one of the client connections
exhibits a critical error. Instead, the server would
want to close that connection and continue serving
other clients. In fact, this is what Go’s |
|
|
|
|
|
|
This function panics. |
|
|
|
|
|
The return value of |
|
|
|
|
|
|
This code will not run, because |
|
|
Next example: String Functions.
Go by Example: Recursion
|
Go supports recursive functions. Here’s a classic example. |
|
|
|
|
|
|
This |
|
|
|
|
Anonymous functions can also be recursive, but this requires
explicitly declaring a variable with |
|
|
|
|
Since |
|
|
|
Next example: Range over Built-in Types.
Go by Example: Regular Expressions
|
Go offers built-in support for regular expressions. Here are some examples of common regexp-related tasks in Go. |
|
|
|
|
|
|
|
|
This tests whether a pattern matches a string. |
|
|
Above we used a string pattern directly, but for
other regexp tasks you’ll need to |
|
|
Many methods are available on these structs. Here’s a match test like we saw earlier. |
|
|
This finds the match for the regexp. |
|
|
This also finds the first match but returns the start and end indexes for the match instead of the matching text. |
|
|
The |
|
|
Similarly this will return information about the indexes of matches and submatches. |
|
|
The |
|
|
These |
|
|
Providing a non-negative integer as the second argument to these functions will limit the number of matches. |
|
|
Our examples above had string arguments and used
names like |
|
|
When creating global variables with regular
expressions you can use the |
|
|
The |
|
|
The |
|
|
|
|
For a complete reference on Go regular expressions check
the |
Next example: JSON.
Go by Example: Select
|
Go’s select lets you wait on multiple channel operations. Combining goroutines and channels with select is a powerful feature of Go. |
|
|
|
|
|
|
|
|
For our example we’ll select across two channels. |
|
|
Each channel will receive a value after some amount of time, to simulate e.g. blocking RPC operations executing in concurrent goroutines. |
|
|
We’ll use |
|
|
We receive the values |
|
|
Note that the total execution time is only ~2 seconds
since both the 1 and 2 second |
|
Next example: Timeouts.
Go by Example: SHA256 Hashes
|
SHA256 hashes are frequently used to compute short identities for binary or text blobs. For example, TLS/SSL certificates use SHA256 to compute a certificate’s signature. Here’s how to compute SHA256 hashes in Go. |
|
|
|
|
Go implements several hash functions in various
|
|
|
|
|
Here we start with a new hash. |
|
|
|
|
|
This gets the finalized hash result as a byte
slice. The argument to |
|
|
|
Running the program computes the hash and prints it in a human-readable hex format. |
|
|
You can compute other hashes using a similar pattern to
the one shown above. For example, to compute
SHA512 hashes import |
|
|
Note that if you need cryptographically secure hashes, you should carefully research hash strength! |
Next example: Base64 Encoding.
Go by Example: Signals
|
Sometimes we’d like our Go programs to intelligently
handle Unix signals.
For example, we might want a server to gracefully
shutdown when it receives a |
|
|
|
|
|
|
|
|
|
|
|
The program will wait here until one of the configured signals is received. |
|
|
|
|
|
When we run this program it will block waiting for a
signal. By typing |
|
Next example: Exit.
Go by Example: Slices
|
Slices are an important data type in Go, giving a more powerful interface to sequences than arrays. |
|
|
|
|
|
|
|
|
Unlike arrays, slices are typed only by the elements they contain (not the number of elements). An uninitialized slice equals to nil and has length 0. |
|
|
To create a slice with non-zero length, use
the builtin |
|
|
We can set and get just like with arrays. |
|
|
|
|
|
In addition to these basic operations, slices
support several more that make them richer than
arrays. One is the builtin |
|
|
Slices can also be |
|
|
Slices support a “slice” operator with the syntax
|
|
|
This slices up to (but excluding) |
|
|
And this slices up from (and including) |
|
|
We can declare and initialize a variable for slice in a single line as well. |
|
|
The |
|
|
Slices can be composed into multi-dimensional data structures. The length of the inner slices can vary, unlike with multi-dimensional arrays. |
|
|
Note that while slices are different types than arrays,
they are rendered similarly by |
|
|
Check out this great blog post by the Go team for more details on the design and implementation of slices in Go. |
|
|
Now that we’ve seen arrays and slices we’ll look at Go’s other key builtin data structure: maps. |
Next example: Maps.
Go by Example: Sorting
|
Go’s |
|
|
|
|
|
|
|
|
Sorting functions are generic, and work for any ordered built-in type. For a list of ordered types, see cmp.Ordered. |
|
|
An example of sorting |
|
|
We can also use the |
|
|
Next example: Sorting by Functions.
Go by Example: Sorting by Functions
|
Sometimes we’ll want to sort a collection by something other than its natural order. For example, suppose we wanted to sort strings by their length instead of alphabetically. Here’s an example of custom sorts in Go. |
|
|
|
|
|
|
|
|
We implement a comparison function for string
lengths. |
|
|
Now we can call |
|
|
We can use the same technique to sort a slice of values that aren’t built-in types. |
|
|
|
|
Sort Note: if the |
|
|
Next example: Panic.
Go by Example: Spawning Processes
|
Sometimes our Go programs need to spawn other processes. |
|
|
|
|
|
|
|
|
We’ll start with a simple command that takes no
arguments or input and just prints something to
stdout. The |
|
|
The |
|
|
|
|
|
Next we’ll look at a slightly more involved case
where we pipe data to the external process on its
|
|
|
Here we explicitly grab input/output pipes, start the process, write some input to it, read the resulting output, and finally wait for the process to exit. |
|
|
We omitted error checks in the above example, but
you could use the usual |
|
|
Note that when spawning commands we need to
provide an explicitly delineated command and
argument array, vs. being able to just pass in one
command-line string. If you want to spawn a full
command with a string, you can use |
|
|
The spawned programs return output that is the same as if we had run them directly from the command-line. |
|
|
date doesn’t have a |
|
|
Next example: Exec'ing Processes.
Go by Example: Stateful Goroutines
|
In the previous example we used explicit locking with mutexes to synchronize access to shared state across multiple goroutines. Another option is to use the built-in synchronization features of goroutines and channels to achieve the same result. This channel-based approach aligns with Go’s ideas of sharing memory by communicating and having each piece of data owned by exactly one goroutine. |
|
|
|
|
|
|
In this example our state will be owned by a single
goroutine. This will guarantee that the data is never
corrupted with concurrent access. In order to read or
write that state, other goroutines will send messages
to the owning goroutine and receive corresponding
replies. These |
|
|
|
|
As before we’ll count how many operations we perform. |
|
|
The |
|
|
Here is the goroutine that owns the |
|
|
This starts 100 goroutines to issue reads to the
state-owning goroutine via the |
|
|
We start 10 writes as well, using a similar approach. |
|
|
Let the goroutines work for a second. |
|
|
Finally, capture and report the op counts. |
|
|
Running our program shows that the goroutine-based state management example completes about 80,000 total operations. |
|
|
For this particular case the goroutine-based approach was a bit more involved than the mutex-based one. It might be useful in certain cases though, for example where you have other channels involved or when managing multiple such mutexes would be error-prone. You should use whichever approach feels most natural, especially with respect to understanding the correctness of your program. |
Next example: Sorting.
Go by Example: String Formatting
|
Go offers excellent support for string formatting in
the |
|
|
|
|
|
|
|
|
|
|
Go offers several printing “verbs” designed to
format general Go values. For example, this prints
an instance of our |
|
|
If the value is a struct, the |
|
|
The |
|
|
To print the type of a value, use |
|
|
Formatting booleans is straight-forward. |
|
|
There are many options for formatting integers.
Use |
|
|
This prints a binary representation. |
|
|
This prints the character corresponding to the given integer. |
|
|
|
|
|
There are also several formatting options for
floats. For basic decimal formatting use |
|
|
|
|
|
For basic string printing use |
|
|
To double-quote strings as in Go source, use |
|
|
As with integers seen earlier, |
|
|
To print a representation of a pointer, use |
|
|
When formatting numbers you will often want to
control the width and precision of the resulting
figure. To specify the width of an integer, use a
number after the |
|
|
You can also specify the width of printed floats, though usually you’ll also want to restrict the decimal precision at the same time with the width.precision syntax. |
|
|
To left-justify, use the |
|
|
You may also want to control width when formatting strings, especially to ensure that they align in table-like output. For basic right-justified width. |
|
|
To left-justify use the |
|
|
So far we’ve seen |
|
|
You can format+print to |
|
|
Next example: Text Templates.
Go by Example: String Functions
|
The standard library’s |
|
|
|
|
|
|
We alias |
|
|
|
|
Here’s a sample of the functions available in
|
|
|
Next example: String Formatting.
Go by Example: Strings and Runes
|
A Go string is a read-only slice of bytes. The language
and the standard library treat strings specially - as
containers of text encoded in UTF-8.
In other languages, strings are made of “characters”.
In Go, the concept of a character is called a |
|
|
|
|
|
|
|
|
|
|
|
Since strings are equivalent to |
|
|
Indexing into a string produces the raw byte values at
each index. This loop generates the hex values of all
the bytes that constitute the code points in |
|
|
To count how many runes are in a string, we can use
the |
|
|
A |
|
|
We can achieve the same iteration by using the
|
|
|
This demonstrates passing a |
|
|
|
|
Values enclosed in single quotes are rune literals. We
can compare a |
|
|
|
|
Next example: Structs.
Go by Example: Struct Embedding
|
Go supports embedding of structs and interfaces
to express a more seamless composition of types.
This is not to be confused with |
|
|
|
|
|
|
|
|
|
|
A |
|
|
|
|
When creating structs with literals, we have to initialize the embedding explicitly; here the embedded type serves as the field name. |
|
|
We can access the base’s fields directly on |
|
|
Alternatively, we can spell out the full path using the embedded type name. |
|
|
Since |
|
|
|
|
Embedding structs with methods may be used to bestow
interface implementations onto other structs. Here
we see that a |
|
|
Next example: Generics.
Go by Example: Structs
|
Go’s structs are typed collections of fields. They’re useful for grouping data together to form records. |
|
|
|
|
|
|
This |
|
|
|
|
|
Go is a garbage collected language; you can safely return a pointer to a local variable - it will only be cleaned up by the garbage collector when there are no active references to it. |
|
|
|
|
This syntax creates a new struct. |
|
|
You can name the fields when initializing a struct. |
|
|
Omitted fields will be zero-valued. |
|
|
An |
|
|
It’s idiomatic to encapsulate new struct creation in constructor functions |
|
|
Access struct fields with a dot. |
|
|
You can also use dots with struct pointers - the pointers are automatically dereferenced. |
|
|
Structs are mutable. |
|
|
If a struct type is only used for a single value, we don’t have to give it a name. The value can have an anonymous struct type. This technique is commonly used for table-driven tests. |
|
|
Next example: Methods.
Go by Example: Switch
|
Switch statements express conditionals across many branches. |
|
|
|
|
|
|
|
|
Here’s a basic |
|
|
You can use commas to separate multiple expressions
in the same |
|
|
|
|
|
A type |
|
|
Next example: Arrays.
Go by Example: TCP Server
|
The |
|
|
|
|
|
|
|
|
|
Close the listener to free the port when the application exits. |
|
|
Loop indefinitely to accept new client connections. |
|
|
Wait for a connection. |
|
|
We use a goroutine here to handle the connection so that the main loop can continue accepting more connections. |
|
|
|
|
|
Closing the connection releases resources when we are finished interacting with the client. |
|
|
Use |
|
|
Create and send a response back to the client, demonstrating two-way communication. |
|
|
Run the TCP server in the background. |
|
|
Send data and capture the response using netcat. |
|
Next example: Context.
Go by Example: Temporary Files and Directories
|
Throughout program execution, we often want to create data that isn’t needed after the program exits. Temporary files and directories are useful for this purpose since they don’t pollute the file system over time. |
|
|
|
|
|
|
|
|
|
|
The easiest way to create a temporary file is by
calling |
|
|
Display the name of the temporary file. On
Unix-based OSes the directory will likely be |
|
|
Clean up the file after we’re done. The OS is likely to clean up temporary files by itself after some time, but it’s good practice to do this explicitly. |
|
|
We can write some data to the file. |
|
|
If we intend to write many temporary files, we may
prefer to create a temporary directory.
|
|
|
|
|
Now we can synthesize temporary file names by prefixing them with our temporary directory. |
|
|
Next example: Embed Directive.
Go by Example: Testing and Benchmarking
|
Unit testing is an important part of writing
principled Go programs. The |
|
|
For the sake of demonstration, this code is in package
|
|
|
|
|
We’ll be testing this simple implementation of an
integer minimum. Typically, the code we’re testing
would be in a source file named something like
|
|
|
A test is created by writing a function with a name
beginning with |
|
|
|
|
|
Writing tests can be repetitive, so it’s idiomatic to use a table-driven style, where test inputs and expected outputs are listed in a table and a single loop walks over them and performs the test logic. |
|
|
|
|
|
|
|
Benchmark tests typically go in |
|
|
The benchmark runner will automatically execute this loop body many times to determine a reasonable estimate of the run-time of a single iteration. |
|
|
Run all tests in the current project in verbose mode. |
|
|
Run all benchmarks in the current project. All tests
are run prior to benchmarks. The |
|
Next example: Command-Line Arguments.
Go by Example: Text Templates
|
Go offers built-in support for creating dynamic content or showing customized
output to the user with the |
|
|
|
|
|
|
|
|
We can create a new template and parse its body from
a string.
Templates are a mix of static text and “actions” enclosed in
|
|
|
Alternatively, we can use the |
|
|
By “executing” the template we generate its text with
specific values for its actions. The |
|
|
Helper function we’ll use below. |
|
|
If the data is a struct we can use the |
|
|
|
|
The same applies to maps; with maps there is no restriction on the case of key names. |
|
|
if/else provide conditional execution for templates. A value is considered
false if it’s the default value of a type, such as 0, an empty string,
nil pointer, etc.
This sample demonstrates another
feature of templates: using |
|
|
range blocks let us loop through slices, arrays, maps or channels. Inside
the range block |
|
|
Next example: Regular Expressions.
Go by Example: Tickers
|
Timers are for when you want to do something once in the future - tickers are for when you want to do something repeatedly at regular intervals. Here’s an example of a ticker that ticks periodically until we stop it. |
|
|
|
|
|
|
|
|
Tickers use a similar mechanism to timers: a
channel that is sent values. Here we’ll use the
|
|
|
|
|
Tickers can be stopped like timers. Once a ticker is stopped it won’t receive any more values on its channel. We’ll stop ours after 1600ms. |
|
|
When we run this program the ticker should tick 3 times before we stop it. |
|
Next example: Worker Pools.
Go by Example: Time
|
Go offers extensive support for times and durations; here are some examples. |
|
|
|
|
|
|
|
|
We’ll start by getting the current time. |
|
|
You can build a |
|
|
You can extract the various components of the time value as expected. |
|
|
The Monday-Sunday |
|
|
These methods compare two times, testing if the first occurs before, after, or at the same time as the second, respectively. |
|
|
The |
|
|
We can compute the length of the duration in various units. |
|
|
You can use |
|
|
|
|
Next we’ll look at the related idea of time relative to the Unix epoch. |
Next example: Epoch.
Go by Example: Time Formatting / Parsing
|
Go supports time formatting and parsing via pattern-based layouts. |
|
|
|
|
|
|
|
|
Here’s a basic example of formatting a time according to RFC3339, using the corresponding layout constant. |
|
|
Time parsing uses the same layout values as |
|
|
|
|
|
For purely numeric representations you can also use standard string formatting with the extracted components of the time value. |
|
|
|
|
|
Next example: Random Numbers.
Go by Example: Timeouts
|
Timeouts are important for programs that connect to
external resources or that otherwise need to bound
execution time. Implementing timeouts in Go is easy and
elegant thanks to channels and |
|
|
|
|
|
|
|
|
For our example, suppose we’re executing an external
call that returns its result on a channel |
|
|
Here’s the |
|
|
If we allow a longer timeout of 3s, then the receive
from |
|
|
Running this program shows the first operation timing out and the second succeeding. |
|
Next example: Non-Blocking Channel Operations.
Go by Example: Timers
|
We often want to execute Go code at some point in the future, or repeatedly at some interval. Go’s built-in timer and ticker features make both of these tasks easy. We’ll look first at timers and then at tickers. |
|
|
|
|
|
|
|
|
Timers represent a single event in the future. You tell the timer how long you want to wait, and it provides a channel that will be notified at that time. This timer will wait 2 seconds. |
|
|
The |
|
|
If you just wanted to wait, you could have used
|
|
|
Give the |
|
|
The first timer will fire ~2s after we start the program, but the second should be stopped before it has a chance to fire. |
|
Next example: Tickers.
Go by Example: URL Parsing
|
URLs provide a uniform way to locate resources. Here’s how to parse URLs in Go. |
|
|
|
|
|
|
|
|
We’ll parse this example URL, which includes a scheme, authentication info, host, port, path, query params, and query fragment. |
|
|
Parse the URL and ensure there are no errors. |
|
|
Accessing the scheme is straightforward. |
|
|
|
|
|
The |
|
|
Here we extract the |
|
|
To get query params in a string of |
|
|
Running our URL parsing program shows all the different pieces that we extracted. |
|
Next example: SHA256 Hashes.
Go by Example: Values
|
Go has various value types including strings, integers, floats, booleans, etc. Here are a few basic examples. |
|
|
|
|
|
|
|
|
Strings, which can be added together with |
|
|
Integers and floats. |
|
|
Booleans, with boolean operators as you’d expect. |
|
|
Next example: Variables.
Go by Example: Variables
|
In Go, variables are explicitly declared and used by the compiler to e.g. check type-correctness of function calls. |
|
|
|
|
|
|
|
|
|
|
|
You can declare multiple variables at once. |
|
|
Go will infer the type of initialized variables. |
|
|
Variables declared without a corresponding
initialization are zero-valued. For example, the
zero value for an |
|
|
The |
|
|
Next example: Constants.
Go by Example: Variadic Functions
|
Variadic functions
can be called with any number of trailing arguments.
For example, |
|
|
|
|
|
|
Here’s a function that will take an arbitrary number
of |
|
|
Within the function, the type of |
|
|
|
|
Variadic functions can be called in the usual way with individual arguments. |
|
|
If you already have multiple args in a slice,
apply them to a variadic function using
|
|
|
|
|
Another key aspect of functions in Go is their ability to form closures, which we’ll look at next. |
Next example: Closures.
Go by Example: WaitGroups
|
To wait for multiple goroutines to finish, we can use a wait group. |
|
|
|
|
|
|
This is the function we’ll run in every goroutine. |
|
|
Sleep to simulate an expensive task. |
|
|
|
|
This WaitGroup is used to wait for all the goroutines launched here to finish. Note: if a WaitGroup is explicitly passed into functions, it should be done by pointer. |
|
|
Launch several goroutines using |
|
|
Block until all the goroutines started by |
|
|
Note that this approach has no straightforward way to propagate errors from workers. For more advanced use cases, consider using the errgroup package. |
|
|
|
|
The order of workers starting up and finishing is likely to be different for each invocation. |
Next example: Rate Limiting.
Go by Example: Worker Pools
|
In this example we’ll look at how to implement a worker pool using goroutines and channels. |
|
|
|
|
|
|
Here’s the worker, of which we’ll run several
concurrent instances. These workers will receive
work on the |
|
|
|
|
In order to use our pool of workers we need to send them work and collect their results. We make 2 channels for this. |
|
|
This starts up 3 workers, initially blocked because there are no jobs yet. |
|
|
Here we send 5 |
|
|
Finally we collect all the results of the work. This also ensures that the worker goroutines have finished. An alternative way to wait for multiple goroutines is to use a WaitGroup. |
|
|
Our running program shows the 5 jobs being executed by various workers. The program only takes about 2 seconds despite doing about 5 seconds of total work because there are 3 workers operating concurrently. |
|
|
Next example: WaitGroups.
Go by Example: Writing Files
|
Writing files in Go follows similar patterns to the ones we saw earlier for reading. |
|
|
|
|
|
|
|
|
|
|
To start, here’s how to dump a string (or just bytes) into a file. |
|
|
For more granular writes, open a file for writing. |
|
|
It’s idiomatic to defer a |
|
|
You can |
|
|
A |
|
|
Issue a |
|
|
|
|
|
Use |
|
|
|
Try running the file-writing code. |
|
|
Then check the contents of the written files. |
|
|
Next we’ll look at applying some of the file I/O ideas
we’ve just seen to the |
Next example: Line Filters.
Go by Example: XML
|
Go offers built-in support for XML and XML-like
formats with the |
|
|
|
|
|
|
Plant will be mapped to XML. Similarly to the
JSON examples, field tags contain directives for the
encoder and decoder. Here we use some special features
of the XML package: the |
|
|
|
|
|
|
Emit XML representing our plant; using
|
|
|
To add a generic XML header to the output, append it explicitly. |
|
|
Use |
|
|
|
|
The |
|
|
|
|
|
Next example: Time.
Go by Example
Sorry, we couldn't find that! Check out the home page?
{{ template "footer" }}Go by Example: {{.Name}}
{{range .Segs}}| {{.DocsRendered}} |
{{if .CodeRun}}{{end}}
{{.CodeRendered}}
|
Next example: {{.NextExample.Name}}.
{{end}} {{ template "footer" }}Go by Example
Go is an open source programming language designed for building scalable, secure and reliable software. Please read the official documentation to learn more.
Go by Example is a hands-on introduction to Go using annotated example programs. Check out the first example or browse the full list below.
Unless stated otherwise, examples here assume the latest major release Go and may use new language features. Try to upgrade to the latest version if something isn't working.
-
{{range .}}
- {{.Name}} {{end}}