Lesson 5

Mastering Arithmetic and Logical Operations in Go

Lesson Overview

Fasten your seatbelts, coder! Today, we're immersing ourselves in Go, mastering arithmetic and logical operations on primitive types. These abilities are vital for data manipulation and decision-making during our coding adventure.

Arithmetic Operations Exposed

Remember that Go's primitive data types include int for whole numbers, float64 for decimal numbers, bool for true/false values, and string for textual content. Both int and float64 exhibit constraints in their numerical spans, which we'll explore when we discuss overflow later in this lesson.

We can perform arithmetic operations — addition (+), subtraction (-), multiplication (*), division (/), and modulus — the remainder of the division (%) — on numerical types. Here's how we do it:

1package main 2import "fmt" 3 4func main() { 5 var a int = 10 6 var b int = 2 7 fmt.Println(a + b) // Outputs: 12 8 fmt.Println(a - b) // Outputs: 8 9 fmt.Println(a * b) // Outputs: 20 10 fmt.Println(a / b) // Outputs: 5 11 fmt.Println(a % b) // Outputs: 0 12}

Go supports alteration of order using parentheses and provides the modulus (%) operation, handy for determining whether numbers are even or odd!

Logical Operations Demystified

Logical operators — && (AND), || (OR), ! (NOT) — function as decision-makers in Go, returning bool values — true or false. Here's how we can utilise them with two bool variables:

1package main 2import "fmt" 3 4func main() { 5 fmt.Println(true && true) // true 6 fmt.Println(true && false) // false 7 fmt.Println(false && true) // false 8 fmt.Println(false && false) // false 9 10 fmt.Println(true || true) // true 11 fmt.Println(true || false) // true 12 fmt.Println(false || true) // true 13 fmt.Println(false || false) // false 14 15 fmt.Println(!true) // false 16 fmt.Println(!false) // true 17}

In this case, && yields true only if both boolean inputs are true, || outputs true if either of the inputs is true, and ! reverses the boolean value.

However, the primary use of logical operations is with variables. Let's quickly illustrate the basic usage:

1package main 2import "fmt" 3 4func main() { 5 var speed int = 60 6 var minSpeed int = 30 7 var maxSpeed int = 70 8 // Check if the speed is within the accepted range. 9 fmt.Println(speed > minSpeed && speed < maxSpeed); // Prints: true 10}
Overflow Phenomenon

The concept of overflow explains what happens when we exceed the range allocation of an integer variable. It happens when we attempt to store a value that surpasses the capacity of the variable's type:

1package main 2import "fmt" 3import "math" 4 5func main() { 6 var maxInt int = math.MaxInt32 // the maximum integer, equivalent to 2^31 - 1 7 var overflow int = maxInt + 1 // causes an overflow, there's no integer after the maximal one. 8 fmt.Println(overflow) // Prints: -2147483648, which is -2^31 - the minimum integer number 9}

Here, maxInt is the largest integer value int can encapsulate. Note that we need to import "math" to use the math.MaxInt32 variable. When we increment it by one, it 'overflows' to the lowest possible integer value! This reminds us that integer values are "cyclic" in nature.

Lesson Summary

Well done! Today, we unveiled arithmetic operations, made intricate decisions using logical operators, and became familiar with the effects of overflow. Up next are some practice exercises to reinforce these crucial concepts in Go. Coders, it's time to start hacking!

Enjoy this lesson? Now it's time to practice with Cosmo!

Practice is how you turn knowledge into actual skills.