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.
Ang pinakagamay na Go program kay naay package, import, ug func main():
package main
import "fmt"
func main() {
fmt.Println("Hello, Go!")
}
package main — ingna ang Go nga maghimog executable.import "fmt" — kuhaa ang formatted I/O package, para maka-print ta.func main() — diri magsugod ang program. Kung walay main, walay padaganan.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: **********.
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)
}
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 (:=).
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.
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)
}
Gamit ug var block para maghimo og daghang variables sabay:
var (
name string = "Bob"
age int = 25
height float64 = 5.9
)
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)
}
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)
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)
}
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
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.
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)
}
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.
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)
}
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"
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.
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
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)
}
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
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)
}
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
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)
}
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.
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
}
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
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)
}
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
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)
}
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)
& = "address of" (kikuha ang pointer)* = "dereference" (sunod sa address para makuha ang value)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
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))
}
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"
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)
}
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
}
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
}
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)
}
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
)
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)
}
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
)
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
}
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)
}
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
}
Ani nga chapter, nakat-on ta:
var ug :=& ug *iota