Table of Contents (the real thing)
Your brain on Go.
Here you are trying to learn something, while here your brain is, doing you a favor by making sure the learning doesn’t stick. Your brain’s thinking, “Better leave room for more important things, like which wild animals to avoid and whether naked snowboarding is a bad idea.” So how do you trick your brain into thinking that your life depends on knowing how to program in Go?
Are you ready to turbo-charge your software?
Do you want a simple programming language that compiles fast? That runs fast? That makes it easy to distribute your work to users? Then you’re ready for Go!
Go is a programming language that focuses on simplicity and speed. It’s simpler than other languages, so it’s quicker to learn. And it lets you harness the power of today’s multicore computer processors, so your programs run faster. This chapter will show you all the Go features that will make your life as a developer easier, and make your users happier.
Every program has parts that apply only in certain situations.
“This code should run if there’s an error. Otherwise, that other code should run.” Almost every program contains code that should be run only when a certain condition is true. So almost every programming language provides conditional statements that let you determine whether to run segments of code. Go is no exception.
You may also need some parts of your code to run repeatedly. Like most languages, Go provides loops that run sections of code more than once. We’ll learn to use both conditionals and loops in this chapter!
You’ve been missing out.
You’ve been calling functions like a pro. But the only functions you could call were the ones Go defined for you. Now, it’s your turn. We’re going to show you how to create your own functions. We’ll learn how to declare functions with and without parameters. We’ll declare functions that return a single value, and we’ll learn how to return multiple values so that we can indicate when there’s been an error. And we’ll learn about pointers, which allow us to make more memory-efficient function calls.
It’s time to get organized.
So far, we’ve been throwing all our code together in a single file. As our programs grow bigger and more complex, that’s going to quickly become a mess.
In this chapter, we’ll show you how to create your own packages to help keep related code together in one place. But packages are good for more than just organization. Packages are an easy way to share code between your programs. And they’re an easy way to share code with other developers.
A whole lot of programs deal with lists of things.
Lists of addresses. Lists of phone numbers. Lists of products. Go has two built-in ways of storing lists. This chapter will introduce the first: arrays. You’ll learn about how to create arrays, how to fill them with data, and how to get that data back out again. Then you’ll learn about processing all the elements in array, first the hard way with
forloops, and then the easy way with
We’ve learned we can’t add more elements to an array.
That’s a real problem for our program, because we don’t know in advance how many pieces of data our file contains. But that’s where Go slices come in. Slices are a collection type that can grow to hold additional items—just the thing to fix our current program! We’ll also see how slices give users an easier way to provide data to all your programs, and how they can help you write functions that are more convenient to call.
Throwing things in piles is fine, until you need to find something again.
You’ve already seen how to create lists of values using arrays and slices. You’ve seen how to apply the same operation to every value in an array or slice. But what if you need to work with a particular value? To find it, you’ll have to start at the beginning of the array or slice, and look through Every. Single. Value.
What if there were a kind of collection where every value had a label on it? You could quickly find just the value you needed! In this chapter, we’ll look at maps, which do just that.
Sometimes you need to store more than one type of data.
We learned about slices, which store a list of values. Then we learned about maps, which map a list of keys to a list of values. But both of these data structures can only hold values of one type. Sometimes, you need to group together values of several types. Think of billing receipts, where you have to mix item names (strings) with quantities (integers). Or student records, where you have to mix student names (strings) with grade point averages (floating-point numbers). You can’t mix value types in slices or maps. But you can if you use another type called a struct. We’ll learn all about structs in this chapter!
There’s more to learn about defined types.
In the previous chapter, we showed you how to define a type with a struct underlying type. What we didn’t show you was that you can use any type as an underlying type.
And do you remember methods—the special kind of function that’s associated with values of a particular type? We’ve been calling methods on various values throughout the book, but we haven’t shown you how to define your own methods. In this chapter, we’re going to fix all of that. Let’s get started!
Sometimes, your program will receive invalid data from user input, a file you’re reading in, or elsewhere. In this chapter, you’ll learn about encapsulation: a way to protect your struct type’s fields from that invalid data. That way, you’ll know your field data is safe to work with!
We’ll also show you how to embed other types within your struct type. If your struct type needs methods that already exist on another type, you don’t have to copy and paste the method code. You can embed the other type within your struct type, and then use the embedded type’s methods just as if they were defined on your own type!
Sometimes you don’t care about the particular type of a value.
You don’t care about what it is. You just need to know that it will be able to do certain things. That you’ll be able to call certain methods on it. You don’t care whether you have a
Pencil, you just need something with a
Drawmethod. You don’t care whether you have a
Boat, you just need something with a
That’s what Go interfaces accomplish. They let you define variables and function parameters that will hold any type, as long as that type defines certain methods.
Every program encounters errors. You should plan for them.
Sometimes handling an error can be as simple as reporting it and exiting the program. But other errors may require additional action. You may need to close opened files or network connections, or otherwise clean up, so your program doesn’t leave a mess behind. In this chapter, we’ll show you how to defer cleanup actions so they happen even when there’s an error. We’ll also show you how to make your program panic in those (rare) situations where it’s appropriate, and how to recover afterward.
Working on one thing at a time isn’t always the fastest way to finish a task.
Some big problems can be broken into smaller tasks. Goroutines let your program work on several different tasks at once. Your goroutines can coordinate their work using channels, which let them send data to each other and synchronize so that one goroutine doesn’t get ahead of another. Goroutines let you take full advantage of computers with multiple processors, so that your programs run as fast as possible!
Are you sure your software is working right now? Really sure?
Before you sent that new version to your users, you presumably tried out the new features to ensure they all worked. But did you try the old features to ensure you didn’t break any of them? All the old features? If that question makes you worry, your program needs automated testing. Automated tests ensure your program’s components work correctly, even after you change your code. Go’s
go testtool make it easy to write automated tests, using the skills that you’ve already learned!
This is the 21st century. Users want web apps.
Go’s got you covered there, too! The Go standard library includes packages to help you host your own web applications and make them accessible from any web browser. So we’re going to spend the final two chapters of the book showing you how to build web apps.
The first thing your web app needs is the ability to respond when a browser sends it a request. In this chapter, we’ll learn to use the
net/httppackage to do just that.
Your web app needs to respond with HTML, not plain text.
Plain text is fine for emails and social media posts. But your pages need to be formatted. They need headings and paragraphs. They need forms where your users can submit data to your app. To do any of that, you need HTML code.
And eventually, you’ll need to insert data into that HTML code. That’s why Go offers the
html/templatepackage, a powerful way to include data in your app’s HTML responses. Templates are key to building bigger, better web apps, and in this final chapter, we’ll show you how to use them!
Some programs need to write data to files, not just read data.
Throughout the book, when we’ve wanted to work with files, you had to create them in your text editor for your programs to read. But some programs generate data, and when they do, they need to be able to write data to a file.
We used the
os.OpenFilefunction to open a file for writing earlier in the book. But we didn’t have space then to fully explore how it worked. In this appendix, we’ll show you everything you need to know in order to use
We’ve covered a lot of ground, and you’re almost finished with this book.
We’ll miss you, but before we let you go, we wouldn’t feel right about sending you out into the world without a little more preparation. We’ve saved six important topics for this appendix.