Level Up Your Web Apps With Go

Distinct from Subclassing
Subclassing in most object-oriented languages means creating a class that extends
from another class and inherits all its methods and properties. The main difference
is that in these scenarios the parent class and child class share their properties
and methods; that is, access goes both ways—from child to parent and parent to
child. In Go, however, an embedded type has no awareness of the type in which
it’s embedded, so it cannot access its fields or methods; thus it only goes one way.
The 
defer
 Command
The final language feature that we’ll look at in this chapter is the
defer
command.
This command enables us to tell a function to run after we return from the current
function. By deferring a function early on, we can ensure that some functionality
runs regardless of where in the function we return, as well as grouping logic together
at the place where it makes sense.
An example of this is closing a file in a function. It makes sense to write the code
that closes the function right where we open it, and we don’t have to think about
closing it if we return from the function early:
func CopyFile(dstName, srcName string) error {
src, err := os.Open(srcName)
if err != nil {
return err
}
defer src.Close()
dst, err := os.Open(dstName)
if err != nil {
return err
}
defer dst.Close()
_, err := io.Copy(dst, src)
return err
}
In this example, we open two different files so that we can copy from one to the
other. By calling
defer src.Close()
after we open the source file, we’re saved from
having to remember calling it before we return at the end of the function, or when
Level Up Your Web Apps With Go
32

---

we return if there’s an error opening the
dst
file. This has reduced the amount of
code we have to write and made the code more stable. If the function changed and
added another block of code that may return from the function early, there’s no
need to think about closing files.