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.
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
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)
}
Ang Go kay naay integer ug floating-point types sa lain-laing sizes. Importante: lahi-lahi jud ni sila — dapat mag-explicit convert jud.
Signed: int8, int16, int32, int64, int. Unsigned: uint8, uint16, uint32, uint64, uint.
var a int8 = 127
var b uint8 = 255
var c int = 2147483647
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
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
}
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
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)
}
}
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)
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 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"
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 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)
}
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)
}
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
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)
}
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)
}