Operators

1a, b := 10, 3
2
3fmt.Println(a + b)   // 13
4fmt.Println(a - b)   // 7
5fmt.Println(a * b)   // 30
6fmt.Println(a / b)   // 3   — INTEGER division truncates, it does not round
7fmt.Println(a % b)   // 1   — remainder
8
9fmt.Println(float64(a) / float64(b))   // 3.3333333333333335 — convert first if you want a decimal
10
11a++        // a statement, NOT an expression. "x := a++" does not compile.
12a--        // and there is no ++a either

1x := 10        // declare and assign (only inside a function)
2x = 20         // assign to an existing variable
3var y int = 5  // declare with an explicit type
4fmt.Println(x, y)
5
6x += 5         // x = x + 5
7x -= 5
8x *= 2
9x /= 2
10x %= 3
11x <<= 1        // the bitwise ones work too
12x &= 0xFF
13
14a, b := 1, 2
15a, b = b, a    // swap in one line, no temp variable
16fmt.Println(a, b) // 2 1

1package main
2
3import "fmt"
4
5func main() {
6	a, b := 3, 5
7	fmt.Println(a == b)             // false
8	fmt.Println(a != b)             // true
9	fmt.Println(a < b, a >= b)      // true false
10	fmt.Println(2.5 > 2.0)          // true — floats compare the same way
11	fmt.Println("apple" < "banana") // true — strings compare byte by byte
12	fmt.Println("Go" == "go")       // false — case matters
13	fmt.Println(true == !false)     // true — bools compare with == and != only
14
15	// Both sides must be the same type. This does not compile:
16	// fmt.Println(a == 2.5) // a is an int, 2.5 is not
17}

1package main
2
3import "fmt"
4
5func main() {
6	a, b := true, false
7	fmt.Println(a && b) // false — and
8	fmt.Println(a || b) // true  — or
9	fmt.Println(!a)     // false — not
10
11	// Both short-circuit: if the left side already decides the answer,
12	// the right side is never run. That is what makes this safe:
13	d := 0
14	if d != 0 && 10/d > 2 { // 10/d is never reached when d is 0
15		fmt.Println("big")
16	} else {
17		fmt.Println("d is zero, skipped the division")
18	}
19}

1a, b := 0b1100, 0b1010
2fmt.Printf("%04b\n", a&b)  // 1000  AND
3fmt.Printf("%04b\n", a|b)  // 1110  OR
4fmt.Printf("%04b\n", a^b)  // 0110  XOR
5fmt.Printf("%04b\n", a&^b) // 0100  AND NOT (bit clear) — this one is unique to Go
6fmt.Println(a<<2, a>>2)     // 48 3 — shift left (a * 4), shift right (a / 4, rounding down)
7
8// A common use: flags packed into one integer
9const (
10	CanRead  = 1 << iota   // 1
11	CanWrite               // 2
12	CanAdmin               // 4
13)
14
15perms := CanRead | CanWrite          // set two flags
16has := perms&CanWrite != 0           // test one
17perms &^= CanWrite                   // clear one
18fmt.Println(has, perms)              // true 1
19
20// Shifts as sizes: 10 << 20 is 10 * 1,048,576 bytes
21const maxUpload = 10 << 20           // 10 MB
22fmt.Println(maxUpload)               // 10485760

1p := &x   // p holds the address of x
2v := <-ch // take a value out of channel ch

1package main
2
3import "fmt"
4
5const (
6	CanRead = 1 << iota // 1
7	CanWrite            // 2
8	CanAdmin            // 4
9)
10
11func loud(name string, v bool) bool {
12	fmt.Println("  evaluated", name)
13	return v
14}
15
16func main() {
17	fmt.Println("7 / 2   =", 7/2)                        // 3, truncated
18	fmt.Println("7.0 / 2 =", float64(7)/2)               // 3.5
19
20	fmt.Println("short-circuit && :")
21	_ = loud("left", false) && loud("right", true)       // right never runs
22
23	perms := CanRead | CanWrite
24	fmt.Printf("perms      = %04b\n", perms)
25	fmt.Println("can write? ", perms&CanWrite != 0)
26	perms &^= CanWrite
27	fmt.Printf("after clear= %04b\n", perms)
28}