Level Up Your Web Apps With Go

Exported and Unexported Code
When writing your own packages and structs, you need to decide what methods,
functions, constants, and fields will be available to code outside the package. An
exported value is available to code outside the package, unexported values are not.
If you’re unsure whether or not some code should be exported, it’s a good rule of
thumb to make it unexported, then change the name if you realize it’s required
outside the package:
// myUnexportedFunc is not available to code outside this package
func myUnexportedFunc() {
}
// MyExportedFunc is available outside this package, though
func MyExportedFunc() {
}
type MyExportedType struct{
Level Up Your Web Apps With Go
20

---

ExportedField string
unexportedField string
}
Summary
That covers our introduction to the basics of the Go syntax and types. In the next
chapter, we’ll look at creating our own types, how to create interfaces that serve as
a contract for other types to implement, and how Go handles third-party libraries.
21
Welcome New Gopher

---

---

Chapter
2
Go Types Explored
In the last chapter, we were introduced to the basic Go types and syntax. In this
chapter we’ll go a little deeper into some of the types, and how to define your own
types and interfaces. We’ll also cover how Go lets us use third-party libraries in our
software with ease.
Custom Types
While you can’t add your own methods to built-in types, you can create your own
types from other types. A common example of this is a
ByteSize
type, which extends
float64
and provides a custom formatted string to represent a size in bytes such
as 2 kilobytes or 3.14 megabytes:
const (
KB = 1024
MB = KB * 1024
GB = MB * 1024
TB = GB * 1024
PB = TB * 1024
)

---

type ByteSize float64
func (b ByteSize) String() string {
switch {
case b >= PB:
return "Very Big"
case b >= TB:
return fmt.Sprintf("%.2fTB", b/TB)
case b >= GB:
return fmt.Sprintf("%.2fGB", b/GB)
case b >= MB:
return fmt.Sprintf("%.2fMB", b/MB)
case b >= KB:
return fmt.Sprintf("%.2fKB", b/KB)
}
return fmt.Sprintf("%dB", b)
}
func main(){
fmt.Println(ByteSize(2048)) // Outputs: 2.00KB
fmt.Println(ByteSize(3292528.64)) // Outputs: 3.14MB
}
First, we’ve defined some constants that represent the various sizes of a kilobyte,
megabyte, and so on. A constant is just like a variable, except once defined it cannot
be changed.
Next up, we create a new type
Bytesize
that uses
float64
as a base. We then define
a new method
String
that returns a string, and in that method we check against
the size of the value compared to our constants. We’re using a
select
statement,
and the first
case
that matches will return a nicely formatted string that’s reduced
down to just two decimal places, plus a suffix. A select statement is just like multiple
if else
statements, but it’s a little tidier for this use case.
In our
main
function we create a couple of
ByteSize
instances and pass them to
fmt.Println
. You’ll notice that nowhere do we actually call the
String
method.
This is because the
fmt
package knows to use the
String
method if it exists on a
type. This might seem a little magical, but all will be revealed in the next section!
Level Up Your Web Apps With Go
24

---