Variables and Data Types 🐹

package main

import "fmt"

func main() {
    // A variable is a named box that holds ONE type of value.

    // Method 1: var with an explicit type.
    //   pattern -> var  name  type  =  value
    var name string = "Alice"   // text  -> always in "double quotes"
    var age int = 28            // whole number (no decimal point)
    var height float64 = 5.7    // decimal number
    var isActive bool = true    // true or false (lowercase in Go)

    // Method 2: var with type inference — Go reads the type from the value.
    var city = "London"         // city is a string
    var score = 95              // score is an int

    // Method 3: short declaration := (most common, FUNCTIONS ONLY).
    //   No "var", no type — Go infers both. Declares AND assigns at once.
    pi := 3.14159               // pi is a float64

    fmt.Println(name, age, height, isActive) // Alice 28 5.7 true
    fmt.Println(city, score)                 // London 95
    fmt.Printf("pi = %.2f\n", pi)            // pi = 3.14
}

Alice 28 5.7 true
London 95
pi = 3.14

package main

import "fmt"

func main() {
    // 🎯 YOUR TURN — replace each ___ then run it.

    // 1) Make an int called "year" set to the current year
    var year int = ___          // 👉 a whole number, e.g. 2026

    // 2) Make a string called "city" using short declaration :=
    city := ___                 // 👉 text in "double quotes"

    // 3) Make a float64 called "price" set to 9.99
    price := ___                // 👉 a decimal number

    // These lines already work once your variables exist:
    fmt.Printf("In %d, a coffee in %s costs £%.2f\n", year, city, price)

    // ✅ Expected output (example):
    //    In 2026, a coffee in London costs £9.99
}

In 2026, a coffee in London costs £9.99

package main

import "fmt"

func main() {
    // ZERO VALUES — a var with no value is NEVER "undefined".
    // Go gives every type a sensible default.
    var i int       // 0
    var f float64   // 0
    var s string    // ""  (empty string)
    var b bool      // false
    fmt.Printf("int=%d float=%.1f str=%q bool=%t\n", i, f, s, b)

    // MULTIPLE ASSIGNMENT — declare several at once on one line.
    x, y := 10, 20
    fmt.Println("x =", x, "y =", y) // x = 10 y = 20

    // Swap two values in a single line — no temp variable needed.
    x, y = y, x
    fmt.Println("after swap:", x, y) // after swap: 20 10
}

int=0 float=0.0 str="" bool=false
x = 10 y = 20
after swap: 20 10

package main

import "fmt"

// Constants are usually declared at package level with const.
// A const NEVER changes after it's set — the compiler enforces that.
const MaxUsers = 1000
const Pi = 3.14159

func main() {
    // const also works inside a function.
    const greeting = "Hello"

    fmt.Println(greeting + ", Go!") // Hello, Go!
    fmt.Println("MaxUsers:", MaxUsers) // MaxUsers: 1000
    fmt.Printf("Pi = %.2f\n", Pi)      // Pi = 3.14

    // MaxUsers = 2000  // ❌ would NOT compile: cannot assign to const
}

Hello, Go!
MaxUsers: 1000
Pi = 3.14

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Go has NO implicit conversion. You MUST convert types yourself.

    // int -> float64, so you can divide without losing the decimals.
    total := 7
    count := 2
    average := float64(total) / float64(count)
    fmt.Printf("average = %.1f\n", average) // average = 3.5

    // float64 -> int truncates (drops the decimals, no rounding).
    price := 9.99
    whole := int(price)
    fmt.Println("whole pounds:", whole) // whole pounds: 9

    // Numbers <-> text need the strconv package.
    n := 42
    asText := strconv.Itoa(n)            // int  -> string "42"
    fmt.Printf("as text: %q\n", asText)  // as text: "42"

    back, err := strconv.Atoi("100")     // string -> int
    if err != nil {                      // Atoi returns an error if it can't
        fmt.Println("not a number")
    } else {
        fmt.Println("parsed:", back+1)   // parsed: 101
    }
}

average = 3.5
whole pounds: 9
as text: "42"
parsed: 101

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // 🎯 YOUR TURN — convert these values, then run it.
    quantityText := "3"
    var unitPrice float64 = 4.50

    // 1) Convert quantityText (a string) to an int
    quantity, _ := ___        // 👉 strconv.Atoi(quantityText)

    // 2) Convert quantity (an int) to a float64 so the maths works
    total := ___ * unitPrice  // 👉 float64(quantity)

    fmt.Printf("%d items x £%.2f = £%.2f\n", quantity, unitPrice, total)

    // ✅ Expected output:  3 items x £4.50 = £13.50
}

3 items x £4.50 = £13.50