Operators, precedence and bit manipulation

1 + 2<<1 is 5 in Go, not 6: a shift binds as tightly as a multiplication, so it runs before the addition. Go has only five precedenceoperator precedence: The rule that decides which operator of an expression is grouped first. Go has five levels for binary operators, from * / % << >> & &^ down to ||, and operators on one level group from left to right. levels for its binary operators, few enough to know by heart, and with them most expressions need no parentheses.

You will use Go’s operators, group an expression by precedence, see why Go has no ?: and no x++ inside an expression, and read the bitwise operators on real bits.

Operators need one type, and the logical ones stop early

Arithmetic takes two operands of the same type and gives a result of that type, so 499 / 3 between ints is 166 and % gives the remainder, 1. + also joins strings. Comparisons give a bool, and strings compare byte by byte, which puts “Zoo” before “apple”: ‘Z’ is the byte 90 and ‘a’ the byte 97. The logical operators && and || use short-circuit evaluationshort-circuit evaluation: The way && and || work: the right operand is evaluated only when the left one does not decide the result, so a check on the left can protect the expression on the right.: they evaluate their right side only when the left side does not settle the answer:

// operators_basics.go: arithmetic, comparison and logical operators.
package main

import "fmt"

func main() {
	price, qty := 499, 3
	fmt.Println(price*qty, price/qty, price%qty, -price)
	fmt.Println("total" + " " + "due") // + also joins strings

	fmt.Println(price > 400, price == 499, "apple" < "banana", "Zoo" < "apple")

	codes := []string{"B2", "S4"}
	i := 5
	ok := i < len(codes) && codes[i] == "B2" // && stops before codes[5] could run
	fmt.Println("in range and B2:", ok)
}

1497 166 1 -499
total due
true true true true
in range and B2: false

i < len(codes) is false, so codes[i] never runs, and the program does not panic on index 5. Put the cheap or protecting test on the left of &&: a length check before an index, a nil check before a field.

Five precedence levels decide where the parentheses go

Every binary operator belongs to one of five levels, and the higher level is grouped first:

Unary operators, such as -x, !ok and ^x, bind more tightly than any of them, and operators of one level group from left to right, so 10-4-3 is 3. The shifts and & sit with multiplication, and | with addition:

// precedence.go: the same operators, grouped by Go's five levels.
package main

import "fmt"

func main() {
	a, b := 1, 2
	fmt.Println(a + b<<1)     // 5: << binds like *, so it runs before +
	fmt.Println((a + b) << 1) // 6

	flags, mask := 6, 4
	fmt.Println(flags&mask == 0) // false: & runs before ==

	fmt.Println(10-4-3, 100/10*2) // one level: left to right

	n, ok := 7, true
	fmt.Println(n+2<<1 > 9 && ok) // ((n + (2<<1)) > 9) && ok
}

5
6
false
3 20
true

Step through the last line, which needs no parentheses at all:

flags&mask == 0 is read as (flags & mask) == 0, because & is on level 5 and == on level 3, so the bit test needs no parentheses. Where a reader could still hesitate, add them anyway: they cost nothing.

Go has no conditional operator, and increments are statements

Two familiar operators are missing on purpose. There is no conditional operator ?::

// ternary.go: Go has no ?: operator.
package main

import "fmt"

func main() {
	paid := true
	label := paid ? "paid" : "due"
	fmt.Println(label)
}

# command-line-arguments
./ternary.go:8:16: invalid character U+003F '?'
./ternary.go:8:18: syntax error: unexpected literal "paid" at end of statement

And ++ and -- are statements, not expressions, so they cannot give a value:

// plusplus.go: ++ is a statement, so it cannot give a value.
package main

import "fmt"

func main() {
	count := 1
	next := count++
	fmt.Println(next)
}

# command-line-arguments
./plusplus.go:8:15: syntax error: unexpected ++ at end of statement

Go’s FAQ gives the reasons. The designers had seen ?: used to build expressions that were hard to read, and an if-else is clearer; making ++ a statement removes the questions about evaluation order that f(i++) raises. Write label := "due" and then if paid { label = "paid" }, and write count++ on a line of its own.

Assignment is a statement as well, so it cannot stand where a value is needed. That makes the classic slip of = for == in a condition a compile error instead of a bug:

// assign_if.go: an assignment where a condition belongs.
package main

import "fmt"

func main() {
	x := 3
	if x = 5 {
		fmt.Println(x)
	}
}

# command-line-arguments
./assign_if.go:8:7: syntax error: cannot use assignment x = 5 as value

The compiler stopped with cannot use assignment x = 5 as value, before the program could run.

Bitwise operators work on the bits of integers

Bit manipulation means working on the single bits of an integer, which is how flags, masks and compact encodings are built. Go has six bitwise operators for it, shown here on 12 and 10, which are 1100 and 1010 in binary:

// bitwise.go: the bit operators on 12 (1100) and 10 (1010).
package main

import "fmt"

func main() {
	x, y := 12, 10
	fmt.Printf("x      %04b = %d\n", x, x)
	fmt.Printf("y      %04b = %d\n", y, y)
	fmt.Printf("x & y  %04b = %d\n", x&y, x&y)
	fmt.Printf("x | y  %04b = %d\n", x|y, x|y)
	fmt.Printf("x ^ y  %04b = %d\n", x^y, x^y)
	fmt.Printf("x &^ y %04b = %d\n", x&^y, x&^y)
	fmt.Printf("x << 1 %b = %d\n", x<<1, x<<1)
	fmt.Printf("x >> 2 %04b = %d\n", x>>2, x>>2)

	var u uint8 = 12
	fmt.Printf("^u     %08b = %d, for a uint8\n", ^u, ^u)
	fmt.Println("^x =", ^x, "for an int, which is -x - 1")
}

x      1100 = 12
y      1010 = 10
x & y  1000 = 8
x | y  1110 = 14
x ^ y  0110 = 6
x &^ y 0100 = 4
x << 1 11000 = 24
x >> 2 0011 = 3
^u     11110011 = 243, for a uint8
^x = -13 for an int, which is -x - 1

^ has a second job: in front of one value it flips every bit, so ^12 is 243 for a uint8 and -13 for an int. Bit manipulation needs integer operands, and it reads best with %b and %08b in a print. &^ clears bits, masksmask: A value whose set bits pick out which bits of another value an operation keeps, clears or tests. keep the bits you name, shifts move them, and math/bits counts them.

Flags, masks and shifts: set, clear, toggle and test, reproduced Pro: opens with a Pro, Premium or Ultimate pass

Comparisons and math/bits, measured Pro: opens with a Pro, Premium or Ultimate pass

Practise

Practise on operators, precedence, the missing ?: and the bitwise operators. Your shakiest idea is asked about first, and the feedback on each choice says why it is right or where it goes wrong:

Interview questions

Warm-up (fresher): How do you write a conditional value in Go, which has no ?: operator?

With an if. Give the variable its default first, then change it when the condition holds: label := "due", then if paid { label = "paid" }. When both branches compute something, declare the variable with var and assign it in an if-else. For a value used in many places, a small function returns it.

Three longer questions of the module bank build on this lesson:

Key takeaways

• Arithmetic needs operands of one type, comparisons give a bool, and && and || skip their right side when the left decides.
• Five precedence levels group binary operators: * and the shifts and & first, then + and |, then comparisons, then &&, then ||.
• Go has no ?:, so a conditional value is an if, and ++ is a statement on a line of its own.
• The bitwise operators &, |, ^, &^, << and >> work on the bits of integers, and ^x flips every bit.