In this chapter, we will explore the essential components of the Go programming language. You will learn how to use the keywords, operators, and delimiters that form the foundation of Go, along with the idiomatic ways to structure your code. We will also delve into data structures, including how Go handles default values (zero values) and the characteristics of structs. This chapter covers Go’s treatment of strings, UTF-8 encoding, and the different types of string literals. Finally, we will examine how to declare variables and constants, and introduce the use of the iota keyword for efficiently handling constant definitions. This chapter sets the stage for mastering Go by equipping you with the knowledge of its core language features.

There are only 25 keywords in Go. These keywords may not be used as identifiers.

break        default      func         interface    select
case         defer        go           map          struct
chan         else         goto         package      switch
const        fallthrough  if           range        type
continue     for          import       return       var

Go also has the following predeclared identifiers.

Constants

true  false  iota  nil

Types

bool      byte      rune        string       error
int       int8      int16       int32        int64
uint      uint8     uint16      uint32       uint64   uintptr
float32   float64   complex64   complex128

Functions

make      len      cap       new    append   copy
close     delete   complex   real   imag     panic
recover   print    println

The following character sequences represent operators (including assignment operators) and punctuation:

+    &     +=    &=     &&    ==    !=    (    )
-    |     -=    |=     ||    <     <=    [    ]
*    ^     *=    ^=     <-    >     >=    {    }
/    <<    /=    <<=    ++    =     :=    ,    ;
%    >>    %=    >>=    --    !     ...   .    :
     &^          &^=

In Go, there are several ways to declare a variable, and in some cases, more than one way to declare the exact same variable and value.

First, let’s declare a variable called i of data type int without initialzation. This means we will declare a space to put a value, but not give it an initial value.

var i int

You now have a variable declared as i of data type int.

You can also initialize the value by using the equal (=) operator:

var i int = 1

Both of the above forms are declaration are called long variable declarations in Go.

You can also use short variable declaration:

i := 1

In this case, you have a variable called i, and a data type of int. When you don’t specify a data type, Go will infer the data type.

With there being three ways to declare variables, the Go community has adopted the following idioms:

Only use long form when you are not initializing the variable:

var i int

Use short form when declaring and initializing:

i := 1

If you did not desire Go to infer your data type, but you still want to use short variable declaration, you can wrap your value in your desired type.

i := int64(1)

The long form is seldom used and not considered idiomatic in Go when you are also initializing the value:

var i int = 1

All builtin types have a zero value. Any allocated variable is usable even if it never has a value assigned. We can see the zero values for the following types with the following code:

package main

import "fmt"

func main() {
	var a int
	var b string
	var c float64
	var d bool

	fmt.Printf("var a %T = %d\n", a, a)
	fmt.Printf("var b %T = %q\n", b, b)
	fmt.Printf("var c %T = %f\n", c, c)
	fmt.Printf("var d %T = %t\n\n", d, d)
}

/* output
var a int = 0
var b string = ""
var c float64 = 0.000000
var d bool = false
*/

package main

import "fmt"

func main() {
	var a int
	var b string
	var c float64
	var d bool

	fmt.Printf("var a %T = %d\n", a, a)
	fmt.Printf("var b %T = %q\n", b, b)
	fmt.Printf("var c %T = %f\n", c, c)
	fmt.Printf("var d %T = %t\n\n", d, d)
}

/* output
var a int = 0
var b string = ""
var c float64 = 0.000000
var d bool = false
*/

In Go, because all values have a zero value, you can’t have undefined values like some other languages.

For instance, a boolean in some languages could be undefined, true, or false, thus allowing for three states to the variable. In Go, you can’t have more than two states for a boolean value.

Another type in Go is the nil type. This can represent many concepts.

One of the core concepts for nil is that it is the default value for many common types:

• maps
• slices
• functions
• channels
• interfaces
• errors

We’ll cover nil as it pertains to each type in later chapters.

The following types will default to the corresponding zero values. There are some types we have not covered yet, but we will cover them in detail in future chapters.

var s string    // defaults to ""
var r rune      // defaults to 0
var bt byte     // defaults to 0
var i int       // defaults to 0
var ui uint     // defaults to 0
var f float32   // defaults to 0
var c complex64 // defaults to 0
var b bool      // defaults to false
var arr [2]int  // defaults to [0 0]
var obj struct {
	b   bool
	arr [2]int
}                     // defaults to {false [0 0]}
var si []int          // defaults to empty slice of int
var ch chan string    // defaults to nil
var mp map[int]string // defaults to nil
var fn func()         // defaults to nil
var ptr *string       // defaults to nil

package main

import "fmt"

// section: var
var s string    // defaults to ""
var r rune      // defaults to 0
var bt byte     // defaults to 0
var i int       // defaults to 0
var ui uint     // defaults to 0
var f float32   // defaults to 0
var c complex64 // defaults to 0
var b bool      // defaults to false
var arr [2]int  // defaults to [0 0]
var obj struct {
	b   bool
	arr [2]int
}                     // defaults to {false [0 0]}
var si []int          // defaults to empty slice of int
var ch chan string    // defaults to nil
var mp map[int]string // defaults to nil
var fn func()         // defaults to nil
var ptr *string       // defaults to nil
// section: var

func main() {
	fmt.Println("string              :", s)
	fmt.Println("rune                :", r)
	fmt.Println("byte                :", bt)
	fmt.Println("int                 :", i)
	fmt.Println("uint                :", ui)
	fmt.Println("float32             :", f)
	fmt.Println("complex64           :", c)
	fmt.Println("bool                :", b)
	fmt.Println("array [2]int        :", arr)
	fmt.Println("struct              :", obj)
	fmt.Println("slice []int         :", si)
	fmt.Println("channel chan string :", ch)
	fmt.Println("map map[int]string  :", mp)
	fmt.Println("function func()     :", fn)
	fmt.Println("*string             :", ptr)

}

Output:

string              :
rune                : 0
byte                : 0
int                 : 0
uint                : 0
float32             : 0
complex64           : (0+0i)
bool                : false
array [2]int        : [0 0]
struct              : {false [0 0]}
slice []int         : []
channel chan string : <nil>
map map[int]string  : map[]
function func()     : <nil>
*string             : <nil>

string              :
rune                : 0
byte                : 0
int                 : 0
uint                : 0
float32             : 0
complex64           : (0+0i)
bool                : false
array [2]int        : [0 0]
struct              : {false [0 0]}
slice []int         : []
channel chan string : <nil>
map map[int]string  : map[]
function func()     : <nil>
*string             : <nil>

The naming of variables is quite flexible, but there are some rules you need to keep in mind:

• Variable names must only be one word (as in no spaces)
• Variable names must be made up of only letters, numbers, and underscore (_)
• Variable names cannot begin with a number

Following the rules above, let’s look at both valid and invalid variable names:

Something else to keep in mind when naming variables, is that they are case-sensitive, meaning that userName, USERNAME, UserName, and uSERnAME are all completely different variables. You should avoid using similar variable names within a program to ensure that both you and your current and future collaborators can keep your variables straight.

While variables are case sensitive, the case of the first letter of a variable has special meaning in Go. If a variable starts with an uppercase letter, then that variable is accessible outside the package it was declared in (or exported). If a variable starts with a lowercase letter, then it is only available within the package it is declared in.

var Email string
var password string

Email starts with a uppercase letter and can be accessed by other packages. password starts with a lowercase letter, and is only accessible inside the package it is declared in.

It is common in Go to use very terse (or short) variable names. Given the choice between using userName and user for a variable, it would be idiomatic to choose user.

Scope also plays a role in the terseness of the variable name. The rule is that the smaller the scope the variable exists in, the smaller the variable name.

names := []string{"Mary", "John", "Bob", "Anna"}
for i, n := range names {
 fmt.Printf("index: %d = %q\n", i, n)
}

The variable names is used in a larger scope, so it would be common to give it a more meaningful name to help remember what it means in the program. However, the variables i and n are used immediately in the next line of code, and never used again. Because of this, someone reading the code will not be confused about where they are used, or what they mean.

Finally, some notes about style. The style is to used MixedCaps or mixedCaps rather than underscores for multiword names.

The most important thing about style is to be consistent, and that the team you work on agrees to the style.

Beyond variable naming, Go has conventions for naming types, interfaces, and functions that make code read more naturally.

Structs should be plain nouns:

type API struct { ... }
type User struct { ... }
type Replica struct { ... }

Interfaces should be active nouns (often ending in -er):

type Reader interface { ... }
type Writer interface { ... }
type JobProcessor interface { ... }

Functions and methods should be verbs:

func Read() { ... }
func Process() { ... }
func (r *Replica) Sync() { ... }

Following these conventions makes doc comments natural and fluent:

// Sync the local replica state to the provided upstream.
func (r *Replica) Sync(u Upstream) error { ... }

// Process the next available job from the queue
// and emit results to the sink.
func Process(q JobQueuer, s Sinker) error { ... }

It also makes code read like prose - each statement becomes a sentence:

result := Process(queue, sink)
user := Fetch(userID)
data := reader.Read()

Go also allows you to assign several values to several variables within the same line. Each of these values can be of a different data type:

j, k, l := "gopher", 2.05, 15
fmt.Println(j)
fmt.Println(k)
fmt.Println(l)

/*
	output:
	gopher
	2.05
	15
*/

package main

import "fmt"

func main() {
	// section: main
	j, k, l := "gopher", 2.05, 15
	fmt.Println(j)
	fmt.Println(k)
	fmt.Println(l)

	/*
		output:
		gopher
		2.05
		15
	*/

	// section: main
}

In the example above, the variable j was assigned to the string “gopher”, the variable k was assigned to the float 2.05, and the variable l was assigned to the integer 15.

This approach to assigning multiple variables to multiple values in one line can keep your lines of code down, but make sure you are not compromising readability for fewer lines of code.

Go is a statically typed language. Statically typed means that each statement in the program is checked at compile time. It also means that the data type is bound to the variable, whereas in Dynamically linked languages, the data type is bound to the value.

For example, in Go, the type is declared when declaring a variable:

var pi float64 = 3.14
var week int = 7

As apposed to a language like PHP, where the data type is associated to the value:

$s = "gopher";        // $s is a string
$s = 123;             // $s is now an integer

Now that we know a little about a statically typed language, this will help us better understand how numbers in Go work.

Go has two types of numeric types. The first type is an architecture independent type. This means that regardless of the architecture you compile for, the type will have the correct size (bytes). The second type is a implementation specific type, and the byte size of that numeric type can vary based on the architecture the program is built for.

Go has the following architecture-independent numeric types:

uint8       unsigned  8-bit integers (0 to 255)
uint16      unsigned 16-bit integers (0 to 65535)
uint32      unsigned 32-bit integers (0 to 4294967295)
uint64      unsigned 64-bit integers (0 to 18446744073709551615)
int8        signed  8-bit integers (-128 to 127)
int16       signed 16-bit integers (-32768 to 32767)
int32       signed 32-bit integers (-2147483648 to 2147483647)
int64       signed 64-bit integers (-9223372036854775808 to 9223372036854775807)
float32     IEEE-754 32-bit floating-point numbers (+- 1O-45 -> +- 3.4 * 1038 )
float64     IEEE-754 64-bit floating-point numbers (+- 5 * 10-324 -> 1.7 * 10308 )
complex64   complex numbers with float32 real and imaginary parts
complex128  complex numbers with float64 real and imaginary parts
byte        alias for uint8
rune        alias for int32

In addition, Go has the following implementation specific types:

uint     either 32 or 64 bits
int      same size as uint
uintptr  an unsigned integer large enough to store the uninterpreted bits of a pointer value

Implementation specific types will have their size defined by the architecture the program is compiled for.

In Go, picking the correct type usually has more to do with performance for the target architecture you are programming for than the size of the data you are working with. However, without needing to know the specific ramifications of performance for your program, you can follow some of these basic guidelines when first starting out.

For integer data, it’s common in Go to use the implementation types like int or uint. This will typically result in the fastest processing speed for your target architecture.

If you know you won’t exceed a specific size range, then picking an architecture-independent type can both increase speed decrease memory usage. To understand integer ranges, we can look at the following examples:

int8 (-128 -> 127)
int16 (-32768 -> 32767)
int32 (− 2,147,483,648 -> 2,147,483,647)
int64 (− 9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807)

And for unsigned integers, we have the following ranges:

uint8 (with alias byte, 0 -> 255)
uint16 (0 -> 65,535)
uint32 (0 -> 4,294,967,295)
uint64 (0 -> 18,446,744,073,709,551,615)

For floats:

float32 (+- 1O-45 -> +- 3.4 * 1038 )
(IEEE-754) float64 (+- 5 * 10-324 -> 1.7 * 10308 )

Now that we have looked at some of the possible ranges for numeric data types, we can see how they will be affected if we exceed those ranges in our program.

Because Go is a typed language, when working with different number types, conversions may need to be made when performing calculations.

If two numbers of are the same type, no conversion is needed:

package main

import "fmt"

func main() {
	Cup := 8
	Pint := Cup * 2
	Quart := Pint * 2
	Gallon := Quart * 4

	fmt.Println("1 cup and 2 quart is", Cup+Quart*2, "ounces")
	fmt.Println("1 cup and 2 gallons is", Cup+Gallon*2, "ounces")
}

package main

import "fmt"

func main() {
	Cup := 8
	Pint := Cup * 2
	Quart := Pint * 2
	Gallon := Quart * 4

	fmt.Println("1 cup and 2 quart is", Cup+Quart*2, "ounces")
	fmt.Println("1 cup and 2 gallons is", Cup+Gallon*2, "ounces")
}

Output:

1 cup and 2 quart is 72 ounces
1 cup and 2 gallons is 264 ounces

1 cup and 2 quart is 72 ounces
1 cup and 2 gallons is 264 ounces

If two numbers are of different types, the developer will need to decide which conversion to use. Failing to do so will result in a compilation error.

Numbers can be converted by wrapping the type around the variable or value:

i := int32(42)

The type of i is now an int32.

All conversions happen at compile time. If a conversion can not be made, the compiler will throw an error:

package main

import "fmt"

func main() {
	i := 42       // int
	j := int32(i) // int32 - this is a valid conversion

	fmt.Println(i, j)

	pi := 3.14

	area := int(pi) * i

	fmt.Println(area)

	// illegal conversion:
	week := int("7")
}

package main

import "fmt"

func main() {
	i := 42       // int
	j := int32(i) // int32 - this is a valid conversion

	fmt.Println(i, j)

	pi := 3.14

	area := int(pi) * i

	fmt.Println(area)

	// illegal conversion:
	week := int("7")
}

Output:

./main.go:18:14: cannot convert "7" (untyped string constant) to type int

./main.go:18:14: cannot convert "7" (untyped string constant) to type int

In the following example, we need to convert to the correct types:

package main

import "fmt"

func main() {
	Cup := 8
	Pint := Cup * 2

	Quart := int32(Pint * 2)
	Gallon := int32(Quart * 4)

	fmt.Println("1 cup and 2 quart is", Cup+Quart*2, "ounces")
	fmt.Println("1 cup and 2 gallons is", Cup+Gallon*2, "ounces")
}

package main

import "fmt"

func main() {
	Cup := 8
	Pint := Cup * 2

	Quart := int32(Pint * 2)
	Gallon := int32(Quart * 4)

	fmt.Println("1 cup and 2 quart is", Cup+Quart*2, "ounces")
	fmt.Println("1 cup and 2 gallons is", Cup+Gallon*2, "ounces")
}

Output:

./main.go:12:41: invalid operation: Cup + Quart * 2 (mismatched types int and int32)
./main.go:13:43: invalid operation: Cup + Gallon * 2 (mismatched types int and int32)

./main.go:12:41: invalid operation: Cup + Quart * 2 (mismatched types int and int32)
./main.go:13:43: invalid operation: Cup + Gallon * 2 (mismatched types int and int32)

To allow two different numeric types to be used in a calculation, you have to explicitly convert each value as necessary:

package main

import "fmt"

func main() {
	Cup := 8
	Pint := Cup * 2

	Quart := int32(Pint * 2)
	Gallon := int32(Quart * 4)

	fmt.Println("1 cup and 2 quart is", Cup+int(Quart)*2, "ounces")
	fmt.Println("1 cup and 2 gallons is", Cup+int(Gallon)*2, "ounces")
}

package main

import "fmt"

func main() {
	Cup := 8
	Pint := Cup * 2

	Quart := int32(Pint * 2)
	Gallon := int32(Quart * 4)

	fmt.Println("1 cup and 2 quart is", Cup+int(Quart)*2, "ounces")
	fmt.Println("1 cup and 2 gallons is", Cup+int(Gallon)*2, "ounces")
}

Output:

1 cup and 2 quart is 72 ounces
1 cup and 2 gallons is 264 ounces

1 cup and 2 quart is 72 ounces
1 cup and 2 gallons is 264 ounces

Go has the potential to both overflow a number as well as wraparound a number. An overflow happens when you try to store a value larger than the data type was designed to store. When one happens vs. the other is dependent on if the value can be calculated at compile time or at runtime.

At compile time, if the compiler can determine a value will be too large to hold in the data type specified, it will throw an overflow error. This means that the value you calculated to store is too large for the data type you specified.

If we take the following example:

var maxUint8 uint8 = 255 // Max Uint8 size
fmt.Println(maxUint8)

package main

import "fmt"

func main() {
	// section: main
	var maxUint8 uint8 = 255 // Max Uint8 size
	fmt.Println(maxUint8)
	// section: main

	// section: plus
	fmt.Println(maxUint8 + 1)
	// section: plus
}

It will compile and run with the following result:

255

If we add 1 to the value at runtime, it will wraparound to 0:

fmt.Println(maxUint8 + 1)

package main

import "fmt"

func main() {
	// section: main
	var maxUint8 uint8 = 255 // Max Uint8 size
	fmt.Println(maxUint8)
	// section: main

	// section: plus
	fmt.Println(maxUint8 + 1)
	// section: plus
}

Output:

0

If we change the program to add 1 to the variable when we assign it, it will not compile:

var maxUint8 uint8 = 255 + 1
fmt.Println(maxUint8)

package main

import "fmt"

func main() {
	// section: main
	var maxUint8 uint8 = 255 + 1
	fmt.Println(maxUint8)
	// section: main
}

Because the compiler can determine it will overflow the value it will now throw an error:

constant 256 overflows uint8

Understanding the boundaries of your data will help you avoid potential bugs in your program in the future.

Go does not saturate variables during mathematical operations such as addition or multiplication. In languages that saturate, if you had a uint8 with a max value of 255, and added 1, the value would still be the max (saturated) value of 255.

In go, however, it will always wrap around. There is no saturation in Go.

var maxUint8 uint8 = 11
maxUint8 = maxUint8 * 25
fmt.Println("new value:", maxUint8)

package main

import "fmt"

func main() {
	// section: main
	var maxUint8 uint8 = 11
	maxUint8 = maxUint8 * 25
	fmt.Println("new value:", maxUint8)
	// section: main
}

/*
// section: output
new value: 19
// section: output
*/

Output:

new value: 19

package main

import "fmt"

func main() {
	// section: main
	var maxUint8 uint8 = 11
	maxUint8 = maxUint8 * 25
	fmt.Println("new value:", maxUint8)
	// section: main
}

/*
// section: output
new value: 19
// section: output
*/

The Go standard library also has support for big numbers via the math/big package.

It has support for:

Int    signed integers
Rat    rational numbers
Float  floating-point numbers

While a deep dive of big numbers it outside the scope of this training, here are some quick examples of how to convert some integer data types:

package main

import (
	"fmt"
	"math/big"
)

func main() {

	bi := big.NewInt(int64(4351454541541445))
	fmt.Println(bi)

	sn, ok := bi.SetString("999888555444777666222", 10)
	if !ok {
		fmt.Println("failed to set string")
	}
	fmt.Println(sn.Uint64())
	fmt.Println(sn)

}

package main

import (
	"fmt"
	"math/big"
)

func main() {

	bi := big.NewInt(int64(4351454541541445))
	fmt.Println(bi)

	sn, ok := bi.SetString("999888555444777666222", 10)
	if !ok {
		fmt.Println("failed to set string")
	}
	fmt.Println(sn.Uint64())
	fmt.Println(sn)

}

Output:

4351454541541445
3764375464461878958
999888555444777666222

4351454541541445
3764375464461878958
999888555444777666222

You can complete this exercise in the playground, or your local computer.

If you are completing this exercise on your local computer, copy the exercise, create a local file called main.go. Complete the solution, and then see if you have the correct results by running the following command from the same location you saved your main.go file:

go run main.go

Fix the code below by using the proper conversions so the code will compile and execute properly:

package main

import "fmt"

func main() {
	pi := 3.14
	radius := 25

	area := pi * radius * radius

	fmt.Println(area)

	day := 1
	week := uint8(7)

	year := week * day * 52

	fmt.Println(year)

}

package main

import "fmt"

func main() {
	pi := 3.14
	radius := 25

	area := pi * radius * radius

	fmt.Println(area)

	day := 1
	week := uint8(7)

	year := week * day * 52

	fmt.Println(year)

}

Currently, the code does not compile and has the following errors:

./main.go:9:10: invalid operation: pi * radius (mismatched types float64 and int)
./main.go:16:10: invalid operation: week * day (mismatched types uint8 and int)

./main.go:9:10: invalid operation: pi * radius (mismatched types float64 and int)
./main.go:16:10: invalid operation: week * day (mismatched types uint8 and int)

The following is the solution:

package main

import "fmt"

func main() {
	pi := 3.14
	radius := 25

	area := pi * float64(radius) * float64(radius)

	fmt.Println(area)

	day := 1
	week := uint8(7)

	year := int(week) * day * 52

	fmt.Println(year)

}

package main

import "fmt"

func main() {
	pi := 3.14
	radius := 25

	area := pi * float64(radius) * float64(radius)

	fmt.Println(area)

	day := 1
	week := uint8(7)

	year := int(week) * day * 52

	fmt.Println(year)

}

Running the solution should result in the following output:

1962.5
364

1962.5
364

The Boolean data type (bool) can be one of two values, either true or false. We use Booleans in programming to make comparisons and to control the flow of the program.

Many operations in math give us answers that evaluate to either True or False:

var ok bool
fmt.Println(ok)

Output:

false

In this example we defined a variable called ok with the data type of bool. When it was printed, we saw the output was false. In Go, all variables have a zero value. In the case of the bool data type, the zero value is false.

To declare a variable and initialize the value, the := operator can be used:

found := true
fmt.Println(found)

Output:

true

The bool data type is useful for making logic decisions in your code.

A string is a sequence of one or more characters (letters, numbers, symbols) that can be either a constant or a variable. Strings exist within either back quotes ` or double quotes “ in Go and have different characteristics depending on which quotes you use.

If you use the back quotes, you are creating a raw string literal. If you use the double quotes, you are creating an interpreted string literal.

Raw string literals are character sequences between back quotes, often called back ticks. Within the quotes, any character may appear except back quote.

a := `Say "hello" to Go!`

Backslashes have no special meaning inside of raw string literals. Raw string literals may also be used to create multiline strings:

a := `Go is expressive, concise, clean, and efficient.
Its concurrency mechanisms make it easy to write programs
that get the most out of multicore and networked machines,
while its novel type system enables flexible and modular
program construction. Go compiles quickly to machine code
yet has the convenience of garbage collection and the power
of run-time reflection. It's a fast, statically typed,
compiled language that feels like a dynamically typed,
interpreted language.`

Interpreted string literals are character sequences between double quotes, as in "bar". Within the quotes, any character may appear except newline and unescaped double quote.

a := "Say \"hello\" to Go!"

You will almost always use interpreted string literals because they allow for escape characters within them.

Go supports UTF-8 characters out of the box, without any special setup, libaries, or packages.

a := "Hello, 世界"

A rune is a special type in go that represents special characters.

You can define a rune using the single quote (') character:

a := 'A'
fmt.Println(a)

package main

import "fmt"

func main() {
	// section: main
	a := 'A'
	fmt.Println(a)
	// section: main
}

If you run the program, it prints out the value of 65.

The rune type in go is an alias for the int32 type. This allows for storing up to 4 bytes of data, which allows for much larger values that can map into the UTF-8 space of characters.

Why a special type and not just use an int32? The short answer is that the new type allows the programming language to distinguish between character values and integer values.

The below example shows the value of a simple character and a complex (utf-8) character, as well as the character, integer, and binary value representations.

simple := 'a'
complex := '😻'

fmt.Printf("char\tint\tlen\tbin\n")
fmt.Printf("%[1]s\t%[2]d\t%[3]d\t%[2]b\n", string(simple), simple, len(string(simple)))

package main

import (
	"fmt"
)

func main() {
	// section: main
	simple := 'a'
	complex := '😻'

	fmt.Printf("char\tint\tlen\tbin\n")
	fmt.Printf("%[1]s\t%[2]d\t%[3]d\t%[2]b\n", string(simple), simple, len(string(simple)))
	fmt.Printf("%[1]s\t%[2]d\t%[3]d\t%[2]b\n", string(complex), complex, len(string(complex))) // section: main
}

char    int     len     bin
a       97      1       1100001
😻      128571  4       11111011000111011

char    int     len     bin
a       97      1       1100001
😻      128571  4       11111011000111011

In many languages, the correct way to iterate over a string would look very much like the following code sample…

a := "Hello, 世界" // 9 characters (including the space and comma)
for i := 0; i < len(a); i++ {
	fmt.Printf("%d: %s\n", i, string(a[i]))
}

package main

import "fmt"

func main() {
	// section: main
	a := "Hello, 世界" // 9 characters (including the space and comma)
	for i := 0; i < len(a); i++ {
		fmt.Printf("%d: %s\n", i, string(a[i]))
	}

	// section: main
}

But, this will not have the output you would expect:

0: H
1: e
2: l
3: l
4: o
5: ,
6:  
7: ä
8: ¸
9: –
10: ç
11: •
12: Œ

Notice the unexpected characters that were printed out for index 7-12? This is because we were taking part of the rune as an int32, not the entire set of int32’s that make up the rune.

If you intend to walk through each character in a string, the proper way is to use the range keyword in the loop.

a := "Hello, 世界"
for i, c := range a {
	fmt.Printf("%d: %s\n", i, string(c))
}

package main

import "fmt"

func main() {
	// section: main
	a := "Hello, 世界"
	for i, c := range a {
		fmt.Printf("%d: %s\n", i, string(c))
	}
	// section: main
}

0: H
1: e
2: l
3: l
4: o
5: ,
6:
7: 世
10: 界

Range ensures that we use the proper index and length of int32’s to capture the proper rune value.

You can complete this exercise in the playground, or your local computer.

If you are completing this exercise on your local computer, copy the exercise, create a local file called main.go. Complete the solution, and then see if you have the correct results by running the following command from the same location you saved your main.go file:

go run main.go

Complete the TODO sections in the exercise below:

package main

import "fmt"

func main() {
	// TODO: Declare the following variables with zero values:
	// name: valid, type bool
	// name: command, type string

	// TODO: print the value of those variables using the `fmt.Println` function

	// TODO: using short variable declaration, declare a multi-line string variable called "template".  Hint, this will be a `raw` string literal.
	// template should have the value of `autosave=true` on the first line, `backupext=bak` on the second line, and `interval=10s` on the third line.

	// TODO: print the `template` variable

	// TODO: based on the naming styles and rules, correct the following statements
	BookId := 1
	proper_name := "Mr. Rob Pike"
	bodyHtml := `<body>This is the body of the page.  Link to <a href="https://www.gopherguides.com">Gopher Guides</a></body>`

	fmt.Println(BookId)
	fmt.Println(proper_name)
	fmt.Println(bodyHtml)
}

package main

import "fmt"

func main() {
	// TODO: Declare the following variables with zero values:
	// name: valid, type bool
	// name: command, type string

	// TODO: print the value of those variables using the `fmt.Println` function

	// TODO: using short variable declaration, declare a multi-line string variable called "template".  Hint, this will be a `raw` string literal.
	// template should have the value of `autosave=true` on the first line, `backupext=bak` on the second line, and `interval=10s` on the third line.

	// TODO: print the `template` variable

	// TODO: based on the naming styles and rules, correct the following statements
	BookId := 1
	proper_name := "Mr. Rob Pike"
	bodyHtml := `<body>This is the body of the page.  Link to <a href="https://www.gopherguides.com">Gopher Guides</a></body>`

	fmt.Println(BookId)
	fmt.Println(proper_name)
	fmt.Println(bodyHtml)
}

The following is the solution:

package main

import "fmt"

func main() {
	var valid bool
	var command string
	fmt.Println(valid)
	fmt.Println(command)

	template := `autosave=true
backupext=bak
interval=10s`

	fmt.Println(template)

	// Acronyms should be capitalized (Id -> ID)
	BookID := 1

	// Underscores are not idiomatic in Go
	properName := "Mr. Rob Pike"

	// Acronyms should be capitalized (Html -> HTML)
	bodyHTML := `<body>This is the body of the page.  Link to <a href="https://www.gopherguides.com">Gopher Guides</a></body>`

	fmt.Println(BookID)
	fmt.Println(properName)
	fmt.Println(bodyHTML)
}

package main

import "fmt"

func main() {
	var valid bool
	var command string
	fmt.Println(valid)
	fmt.Println(command)

	template := `autosave=true
backupext=bak
interval=10s`

	fmt.Println(template)

	// Acronyms should be capitalized (Id -> ID)
	BookID := 1

	// Underscores are not idiomatic in Go
	properName := "Mr. Rob Pike"

	// Acronyms should be capitalized (Html -> HTML)
	bodyHTML := `<body>This is the body of the page.  Link to <a href="https://www.gopherguides.com">Gopher Guides</a></body>`

	fmt.Println(BookID)
	fmt.Println(properName)
	fmt.Println(bodyHTML)
}

Running the solution should result in the following output:

false

autosave=true
backupext=bak
interval=10s
1
Mr. Rob Pike
<body>This is the body of the page.  Link to <a href="https://www.gopherguides.com">Gopher Guides</a></body>

false

autosave=true
backupext=bak
interval=10s
1
Mr. Rob Pike
<body>This is the body of the page.  Link to <a href="https://www.gopherguides.com">Gopher Guides</a></body>

Constants are like variables, except they can’t be modified once they have been declared.

Constants can only be a character, string, boolean, or numeric value.

const gopher = "Genny"
fmt.Println(gopher)

Output:

Genny

If you try to modify a constant after it was declared, you will get a compile time error:

const gopher = "Genny"
gopher = "george"
fmt.Println(gopher)

package main

import "fmt"

func main() {
	// section: main
	const gopher = "Genny"
	gopher = "george"
	fmt.Println(gopher)
	// section: main
}

/*
// section: output
./main.go:8:9: cannot assign to gopher
// section: output
*/

Output:

./main.go:8:9: cannot assign to gopher

package main

import "fmt"

func main() {
	// section: main
	const gopher = "Genny"
	gopher = "george"
	fmt.Println(gopher)
	// section: main
}

/*
// section: output
./main.go:8:9: cannot assign to gopher
// section: output
*/

Constants can be untypted. This can be useful when working with numbers such as integer type data. If the constant is untyped, it is explicitly converted, where typed constants are not.

package main

import "fmt"

const (
	year     = 365        // untyped
	leapYear = int32(366) // typed
)

func main() {
	hours := 24
	minutes := int32(60)
	fmt.Println(hours * year)       // multiplying an int and untyped
	fmt.Println(minutes * year)     // multiplying an int32 and untyped
	fmt.Println(minutes * leapYear) // multiplying both int32 types
}

/*
	output:
	8760
	21900
	21960
*/

package main

import "fmt"

const (
	year     = 365        // untyped
	leapYear = int32(366) // typed
)

func main() {
	hours := 24
	minutes := int32(60)
	fmt.Println(hours * year)       // multiplying an int and untyped
	fmt.Println(minutes * year)     // multiplying an int32 and untyped
	fmt.Println(minutes * leapYear) // multiplying both int32 types
}

/*
	output:
	8760
	21900
	21960
*/

If you declare a constant with a type, it will be that exact type. leapYear was defined as data type int32. This means it can only operate with int32 data types. year was declared with no type, so it is considered untyped. Because of this, you can use it with any integer data type.

package main

import "fmt"

const (
	leapYear = int32(366) // typed
)

func main() {
	hours := 24
	fmt.Println(hours * leapYear) // multiplying int and int32 types}
}

/*
	output:
	invalid operation: hours * leapYear (mismatched types int and int32)
*/