Chapter 3: Core Types

Introduksyon

Gamay ra ang type system ni Go pero presisyo jud — walay binuang. Anhi nga chapter atong sabton ang built-in core types: booleans, numeric types (integers, floats, big numbers), bytes, text (strings ug runes), ug ang special nil value.

True ug False

Ang bool type kay simple ra — duha ra ka values: true ug false. Resulta ni sa comparison operators:

var isDone bool = false
isValid := true

if isDone == false {
    fmt.Println("wala pa human")
}

fmt.Println(true && false)  // false
fmt.Println(true || false)  // true
fmt.Println(!true)          // false

Exercise 3.01: Password Complexity Checker

Goal: Check kung complex ba ang password (>= 8 chars, naay digit, naay uppercase).

package main

import (
    "fmt"
    "unicode"
)

func main() {
    password := "GoLang123"
    hasUpper := false
    hasDigit := false

    for _, ch := range password {
        if unicode.IsUpper(ch) { hasUpper = true }
        if unicode.IsDigit(ch) { hasDigit = true }
    }

    longEnough := len(password) >= 8
    fmt.Println("Complex:", longEnough && hasUpper && hasDigit)
}

Numbers

Ang Go kay naay integer ug floating-point types sa lain-laing sizes. Importante: lahi-lahi jud ni sila — dapat mag-explicit convert jud.

Integer

Signed: int8, int16, int32, int64, int. Unsigned: uint8, uint16, uint32, uint64, uint.

var a int8 = 127
var b uint8 = 255
var c int = 2147483647

Floating Point

float32 ug float64 (IEEE 754). Ang float64 kay default para sa float literals:

var f32 float32 = 3.1415926535   // mga 7 digits
var f64 float64 = 3.141592653589793  // 15 digits

Exercise 3.02: Floating-Point Accuracy

Goal: Ipakita ang precision loss sa float32 vs float64 — para makita ang difference.

package main

import "fmt"

func main() {
    var f32 float32 = 0
    var f64 float64 = 0
    for i := 0; i < 10; i++ {
        f32 += 0.1
        f64 += 0.1
    }
    fmt.Println("float32:", f32)  // 1.0000001
    fmt.Println("float64:", f64)  // 0.9999999999999999
}

Overflow ug Wraparound

Kung molapas ang value sa range, ang unsigned kay mag-wraparound — murag odometer sa awto:

var x uint8 = 255
x += 1
fmt.Println(x)  // 0 (wraparound)

var y int8 = 127
y += 1
fmt.Println(y)  // -128

Exercise 3.03: Number Wraparound

Goal: Sugod ug uint8 sa 250, increment ug 10 ka beses, tan-awa ang wraparound. Watch it flip.

package main

import "fmt"

func main() {
    var counter uint8 = 250
    for i := 0; i < 10; i++ {
        counter++
        fmt.Println(counter)
    }
}

Big Numbers

Para sa dagko kaayo na numbers — ingnon tag pang-astronomo — gamit ang math/big:

import "math/big"
a := big.NewInt(1)
for i := 0; i < 100; i++ {
    a.Mul(a, big.NewInt(2))
}
fmt.Println(a)

Exercise 3.04: Big Numbers

Goal: Compute ang factorial sa 50 gamit math/big. Dako jud ni.

package main

import (
    "fmt"
    "math/big"
)

func main() {
    result := big.NewInt(1)
    for i := int64(2); i <= 50; i++ {
        result.Mul(result, big.NewInt(i))
    }
    fmt.Println(result)
}

Byte

byte kay alias sa uint8. Representar sa isa ka byte (0-255):

var b byte = 'A'
fmt.Println(b)  // 65

data := []byte{72, 101, 108, 108, 111}
fmt.Println(string(data))  // "Hello"

Text

Ang Go strings kay UTF-8 ug immutable (dili mausab). Murag basahon — mabasa pero di mabag-o. Isa ka read-only slice of bytes:

s := "Hello, 世界"
fmt.Println(len(s))  // 13 bytes
fmt.Println(s[1:4])  // "ell"

Rune

rune kay alias sa int32 — representar sa Unicode code point. Ang range kay mag-iterate per rune, dili per byte:

s := "世界"
for i, r := range s {
    fmt.Printf("byte: %d, rune: %c, value: %d\n", i, r, r)
}

Exercise 3.05: Safe String Looping

Goal: I-loop ang string naay multi-byte characters gamit range ug i-count ang runes.

package main

import "fmt"

func main() {
    phrase := "Go is fun 😊"
    count := 0
    for _, r := range phrase {
        fmt.Printf("%c ", r)
        count++
    }
    fmt.Println("\nRune count:", count)
}

Ang nil Value

nil kay zero value para sa pointers, slices, maps, channels, functions, ug interfaces. Meaning "walay value" or "walay sulod" — way laman ang box.

var p *int       // nil
var s []int      // nil
var m map[int]string  // nil

Activity 3.01: Sales Tax Calculator

Goal: Calculate ang total price na apil ang sales tax (6%). Praktis pud ni.

package main

import "fmt"

func main() {
    const taxRate = 0.06
    price := 29.99
    tax := price * taxRate
    total := price + tax
    fmt.Printf("Price: $%.2f, Tax: $%.2f, Total: $%.2f\n", price, tax, total)
}

Activity 3.02: Loan Calculator

Goal: Calculate monthly payment sa loan gamit ang formula. Math time.

package main

import (
    "fmt"
    "math"
)

func main() {
    principal := 10000.0
    annualRate := 0.05
    months := 60.0
    monthlyRate := annualRate / 12
    factor := math.Pow(1+monthlyRate, months)
    payment := principal * monthlyRate * factor / (factor - 1)
    fmt.Printf("Monthly: $%.2f\n", payment)
}

Summary