Chapter 1: Variables ug Operators

Introduksyon

Ang Go (o Golang) kay gimake sa Google. Dali ra sabton, paspas mag-compile, ug built-in na ang concurrency — sulit jud. Anhi nga chapter, atong tan-awon ang pundasyon: variables, basic types, operators, pointers, ug constants. Tanan nimong kelangan para di ka ma-OP pag-sugod nimo.

Unsa'y Hitsura sa Go?

Ang pinakagamay na Go program kay naay package, import, ug func main():

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go!")
}

Exercise 1.01: Gamit ang Variables, Packages, ug Functions para Mag-imprinta og Stars

Goal: Sulat og program nga mag-print ug stars gamit ang variable ug strings.Repeat.

package main

import (
    "fmt"
    "strings"
)

func main() {
    count := 10
    line := strings.Repeat("*", count)
    fmt.Println(line)
}

Padagana sa go run main.go. Makita ninyo: **********.

Activity 1.01: Pagdeklara ug Pag-imprinta

Goal: Maghimo tulo ka variables na lain-laing type (string, int, bool) ug i-print matag usa. Simple ra.

package main

import "fmt"

func main() {
    var name string = "Go"
    var year int = 2009
    var isFun bool = true

    fmt.Println(name)
    fmt.Println(year)
    fmt.Println(isFun)
}

Pagdeklara ug Variables

Ang variable kay murag lunchbox — nag-hold og value na naay specific type. Ang Go kay statically typed, meaning sa compile time pa lang, checked na kung type safe ba. Duha ka pamaagi: var ug short declaration (:=).

Pagdeklara ug Variable Gamit ang var

Ang var kay nagdeklara og variable na naay explicit type:

var name string = "Alice"
var age int = 30
var temperature float64 = 36.6

Kung wala kay gihatag na value, automatic naay zero value (0 sa numbers, "" sa strings, false sa booleans, nil sa uban). Di na ka mag-worry.

Exercise 1.02: Pagdeklara ug Variable Gamit ang var

Goal: Gamit ug var para maghimo og upat ka variables — string, int, float64, ug bool. I-print matag usa.

package main

import "fmt"

func main() {
    var city string = "Manila"
    var population int = 14000000
    var area float64 = 619.57
    var isCapital bool = true

    fmt.Println(city)
    fmt.Println(population)
    fmt.Println(area)
    fmt.Println(isCapital)
}

Pagdeklara ug Daghang Variables Gamit ang var

Gamit ug var block para maghimo og daghang variables sabay:

var (
    name   string = "Bob"
    age    int    = 25
    height float64 = 5.9
)

Exercise 1.03: Pagdeklara ug Daghang Variables Gamit ang var

Goal: Gamit ug var block para mag-store ug i-print ang product name, price, ug stock.

package main

import "fmt"

func main() {
    var (
        product string = "Laptop"
        price   int    = 45000
        inStock bool   = true
    )

    fmt.Println(product, price, inStock)
}

Gawas ang Type o Value Pagdeklara ug Variables

Pwede ra nimo tangtangon ang type kung nagprovide kag value (type inference tawag ana), o tangtangon ang value para makuha ang zero value:

var name = "Alice"   // type inferred as string
var score int        // score = 0 (zero value)

Exercise 1.04: Gawas ang Type o Value Pagdeklara ug Variables

Goal: Maghimo og variable na type inference ug isa ka variable na type lang (zero value). I-print pareha.

package main

import "fmt"

func main() {
    var message = "Hello"  // type inferred
    var count int          // zero value

    fmt.Println(message)
    fmt.Println(count)
}

Type Inference Na Sayop

Ang type inference kay base sa value sa right side. Pero pagbantay ha — ang literals like 3.14 kay float64 jud na. Kung gusto kag specific size like int8, ispecify jud nimo.

var x = 42           // x is int, dili int8
var y int8 = 42      // y is int8

Short Variable Declaration

Sa sulod sa functions, gamit ug := para isa-rat-shot ang deklara ug initialize sa variable. Ang type kay inferred sa value:

name := "Alice"
age := 30
score := 95.5

Ang := kay sa sulod ra na sa functions ha. Package level? Dapat var jud.

Exercise 1.05: Pag-implementar ug Short Variable Declaration

Goal: Ilisan ang var ug := sa imo variables.

package main

import "fmt"

func main() {
    city := "Manila"
    population := 14000000
    area := 619.57

    fmt.Println(city, population, area)
}

Pagdeklara ug Daghang Variables Gamit ang Short Variable Declaration

Magdeklara ug daghang variables sa isa ka linya gamit ang :=:

a, b, c := 1, 2, 3
name, age := "Alice", 30

Makatabang jud ni labi nag daghan ang return values sa function.

Exercise 1.06: Pagdeklara ug Daghang Variables Gikan sa Function

Goal: Gamit ug function na magbalik og duha ka values ug kuhaa pareha gamit ang :=.

package main

import (
    "fmt"
    "strconv"
)

func main() {
    n, err := strconv.Atoi("42")
    fmt.Println(n, err)
}

Gamit ang var Para Magdeklara ug Daghang Variables sa Isa ka Linya

Pwede sad magdeklara ug daghang variables gamit ang var sa isa ka linya:

var a, b, c int = 1, 2, 3
var name, city string = "Alice", "Tokyo"

Dili English na Variable Names

Ang Go kay UTF-8. Pwede ka mogamit ug dili English na letters sa variable names:

姓名 := "张伟"
età := 30
παίκτης := "Mario"
название := "Привет"

Pero para klaro sa imong ka-team, English na lang. Ayaw palahi.

Pag-ilis sa Value sa Variable

Gamit ug = para mag-ilis og value sa existing variable. Dapat parehas ang type — ayaw pugsa.

x := 10
x = 20    // ok

name := "Alice"
name = "Bob"   // ok
// name = 42   // compile error: dili pwede int imbes string

Exercise 1.07: Pag-ilis sa Value sa Variable

Goal: Magdeklara ug variable, i-print, ilisi, ug i-print balik.

package main

import "fmt"

func main() {
    color := "red"
    fmt.Println(color)

    color = "blue"
    fmt.Println(color)

    color = "green"
    fmt.Println(color)
}

Pag-ilis ug Daghang Values Sabay

Pwede mag-swap ug daghang variables sabay — wala nay sakit sa ulo na temp variable:

a, b := 1, 2
a, b = 10, 20

x, y := 5, 10
x, y = y, x
fmt.Println(x, y) // 10, 5

Exercise 1.08: Pag-ilis ug Daghang Values Sabay

Goal: I-swap ang duha ka variables gamit ang Go's multi-assignment.

package main

import "fmt"

func main() {
    a, b := "first", "second"
    fmt.Println("before:", a, b)

    a, b = b, a
    fmt.Println("after:", a, b)
}

Mga Operator

Standard arithmetic operators sa Go para sa numeric types:

+   addition
-   subtraction
*   multiplication
/   division (integer division kay truncated)
%   modulus (remainder)

Pananglitan:

a := 10
b := 3
fmt.Println(a + b)  // 13
fmt.Println(a - b)  // 7
fmt.Println(a * b)  // 30
fmt.Println(a / b)  // 3 (integer division)
fmt.Println(a % b)  // 1

Exercise 1.09: Gamit ang Operators sa Numbers

Goal: Maghimo ug duha ka integers, gamitan ang lima ka arithmetic operations, ug i-print ang resulta.

package main

import "fmt"

func main() {
    x := 20
    y := 7

    fmt.Println("sum:", x+y)
    fmt.Println("diff:", x-y)
    fmt.Println("prod:", x*y)
    fmt.Println("quot:", x/y)
    fmt.Println("rem:", x%y)
}

Shorthand Operator

Ang shorthand assignment operators kay nag-combine ug operation ug assignment:

x := 10
x += 5   // x = x + 5   -> 15
x -= 3   // x = x - 3   -> 12
x *= 2   // x = x * 2   -> 24
x /= 4   // x = x / 4   -> 6
x %= 3   // x = x % 3   -> 0

Naay ++ ug -- si Go para sa increment ug decrement:

i := 0
i++   // i = 1
i--   // i = 0

Bantay: ang i++ ug i-- kay statements, dili expressions. Busa ang j = i++ kay compile error na.

Exercise 1.10: Pag-implementar ug Shorthand Operators

Goal: Sugod sa count := 1, gamit ug shorthand para idoble tulo ka beses.

package main

import "fmt"

func main() {
    count := 1
    count *= 2
    count *= 2
    count *= 2
    fmt.Println(count) // 8
}

Pag-compara ug Values

Ang comparison operators kay mobalik og bool (true or false):

==  equal to
!=  not equal to
<   less than
>   greater than
<=  less than or equal
>=  greater than or equal
a, b := 5, 10
fmt.Println(a == b)   // false
fmt.Println(a != b)   // true
fmt.Println(a < b)    // true
fmt.Println(a >= b)   // false

Exercise 1.11: Pag-compara ug Values

Goal: I-compare ang duha ka numbers ug i-print kung equal ba, kinsa dako, ug kung positive ba pareha.

package main

import "fmt"

func main() {
    x, y := 15, 20

    fmt.Println("x == y:", x == y)
    fmt.Println("x < y:", x < y)
    fmt.Println("x > 0 && y > 0:", x > 0 && y > 0)
}

Zero Values

Ang mga variables na walay initial value kay mag-default sa ilang zero value:

var i int       // 0
var f float64   // 0.0
var b bool      // false
var s string    // ""
var p *int      // nil

Exercise 1.12: Zero Values

Goal: Magdeklara ug variables na int, float64, bool, ug string na walay values ug i-print para makita ang zero values.

package main

import "fmt"

func main() {
    var i int
    var f float64
    var b bool
    var s string

    fmt.Printf("int: %d\n", i)
    fmt.Printf("float64: %f\n", f)
    fmt.Printf("bool: %t\n", b)
    fmt.Printf("string: %q\n", s)
}

Value versus Pointer

Ang matag variable sa Go kay naay memory address — murag house number. Ang pointer kay nag-store atong address imbes ang value mismo:

x := 42
p := &x   // p is a pointer to x (type *int)

Pagkuha ug Pointer

Gamit ug & sa wala sa variable para makuha ang pointer:

name := "Alice"
ptr := &name

fmt.Println(ptr)   // output: 0xc000010250 (memory address)
fmt.Printf("%T", ptr)  // *string

Exercise 1.13: Pagkuha ug Pointer

Goal: Magdeklara ug int variable, kuhaa ang pointer, ug i-print pareha ang value ug ang pointer.

package main

import "fmt"

func main() {
    number := 100
    ptr := &number

    fmt.Println("value:", number)
    fmt.Println("pointer:", ptr)
    fmt.Println("type of ptr:", fmt.Sprintf("%T", ptr))
}

Pagkuha ug Value Gikan sa Pointer

Gamit ug * sa wala sa pointer para ma-dereference ug makuha ang value:

name := "Alice"
ptr := &name
fmt.Println(*ptr)   // "Alice"

*ptr = "Bob"        // change ang name through the pointer
fmt.Println(name)   // "Bob"

Exercise 1.14: Pagkuha ug Value Gikan sa Pointer

Goal: Gamit ug pointer para mag-ilis ug variable value na wala gamita ang variable name diretso.

package main

import "fmt"

func main() {
    temperature := 25
    ptr := &temperature

    fmt.Println("before:", temperature)
    *ptr = 30
    fmt.Println("after:", temperature)
}

Function Design Gamit ang Pointers

Ang Go kay pass by value — ang function makakuha ra ug kopya, dili ang original. Kung gusto nimo ma-modify ang original, i-pass ang pointer:

func increment(x *int) {
    *x = *x + 1
}

func main() {
    n := 10
    increment(&n)
    fmt.Println(n) // 11
}

Exercise 1.15: Function Design Gamit ang Pointers

Goal: Sulat ug function na double na magkuha ug *int ug i-double ang value sa pointer.

package main

import "fmt"

func double(x *int) {
    *x = *x * 2
}

func main() {
    value := 7
    double(&value)
    fmt.Println(value) // 14
}

Activity 1.02: Pointer Value Swap

Goal: Sulat ug function na swap na magkuha ug duha ka *int pointers ug i-swap ang values. Skills test ni.

package main

import "fmt"

func swap(a, b *int) {
    *a, *b = *b, *a
}

func main() {
    x, y := 10, 20
    fmt.Println("before:", x, y)

    swap(&x, &y)
    fmt.Println("after:", x, y)
}

Constants

Ang constants kay fixed — dili na mausab. const ang keyword, known na sa compile time:

const Pi = 3.14159
const AppName string = "MyApp"
const (
    StatusOK = 200
    StatusNotFound = 404
)

Exercise 1.16: Constants

Goal: Maghimo ug constant para sa speed of light (299792458 m/s) ug compute ang distance sa isa ka adlaw.

package main

import "fmt"

func main() {
    const speedOfLight = 299792458
    const secondsPerDay = 86400

    distance := speedOfLight * secondsPerDay
    fmt.Println("distance (meters):", distance)
}

Enums

Wala ray dedicated enum ang Go. Gamit na lang tag const + iota:

const (
    Monday = iota     // 0
    Tuesday           // 1
    Wednesday         // 2
    Thursday          // 3
    Friday            // 4
    Saturday          // 5
    Sunday            // 6
)

Scope

Ang scope kay magdetermine kung asa ka pwede mugamit ug variable. Go kay block scope — sulod sa curly braces ra na.

package main

import "fmt"

var global = "package scope"   // accessible sa tibuok package

func main() {
    x := 10                    // function scope
    if true {
        y := 20                // block scope — sa sulod ra sa if
        fmt.Println(x, y)      // ok
    }
    // fmt.Println(y)          // error: undefined y
    fmt.Println(global)        // ok
}

Activity 1.03: Message Bug

Goal: Pangitaa ug ayoha ang bug. Ang dapat i-print kay "Hello, Go!". Debugging time.

// Buggy version:
package main

import "fmt"

func main() {
    greeting := "Hello"
    greeting := "Hello, Go!"  // error: no new variables on left side of :=
    fmt.Println(greeting)
}

Ayos: Gamit ug = imbes := sa ikaduhang linya:

package main

import "fmt"

func main() {
    greeting := "Hello"
    greeting = "Hello, Go!"
    fmt.Println(greeting)
}

Activity 1.04: Bad Count Bug

Goal: Ang program kay dapat mag-count 0 to 4, pero naay bug. Pangitaa ug ayoha. Mangita tang typo.

// Buggy version:
package main

import "fmt"

func main() {
    count := 0
    count =+ 1   // typo: dapat += dili =+
    fmt.Println(count)
}

Ayos: =+ kay dili operator — Go nag-parse as = (+1). Gamit ug +=:

package main

import "fmt"

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

Summary

Ani nga chapter, nakat-on ta: