Labaw sa core types, ang Go kay naay composite types para mag-group ug data: arrays, slices, maps, ug structs. Importante jud ni para makahimo mog tinuod na programs — dili lang hello world.
Tulo ka built-in collection types ang Go: arrays (fixed-size — way usbans), slices (dynamic — flexible), ug maps (key-value — murag diksyonaryo).
Ang arrays kay fixed length — parte na sa type. Ang [3]int ug [4]int kay lahi na type. Dili interchangeable.
var nums [3]int
nums[0] = 1
primes := [5]int{2, 3, 5, 7, 11}
package main
import "fmt"
func main() {
days := [5]string{"Mon", "Tue", "Wed", "Thu", "Fri"}
fmt.Println(days)
}
a := [3]int{1, 2, 3}
b := [3]int{1, 2, 3}
fmt.Println(a == b) // true
package main
import "fmt"
func main() {
a := [3]int{10, 20, 30}
b := [3]int{10, 20, 30}
fmt.Println("a == b:", a == b)
}
arr := [5]int{1: 10, 3: 30}
fmt.Println(arr) // [0 10 0 30 0]
package main
import "fmt"
func main() {
vals := [7]float64{0: 1.0, 3: 2.0, 6: 3.0}
fmt.Println(vals)
}
arr := [3]string{"a", "b", "c"}
fmt.Println(arr[0])
package main
import "fmt"
func main() {
fruits := [4]string{"apple", "banana", "cherry", "date"}
fmt.Println("first:", fruits[0])
}
arr := [3]int{1, 2, 3}
arr[1] = 99
package main
import "fmt"
func main() {
temps := [3]float64{23.5, 24.0, 22.8}
temps[1] = 25.0
fmt.Println(temps)
}
arr := [3]string{"a", "b", "c"}
for i, v := range arr {
fmt.Println(i, v)
}
package main
import "fmt"
func main() {
nums := [5]int{2, 4, 6, 8, 10}
for i := 0; i < len(nums); i++ {
fmt.Println(nums[i] * 2)
}
}
arr := [3]int{1, 2, 3}
for i := range arr {
arr[i] *= 10
}
package main
import "fmt"
func main() {
vals := [4]int{5, 10, 15, 20}
for i := range vals {
vals[i] *= 2
}
fmt.Println(vals)
}
package main
import "fmt"
func main() {
var squares [10]int
for i := 0; i < len(squares); i++ {
squares[i] = (i + 1) * (i + 1)
}
fmt.Println(squares)
}
Ang slices kay dynamic-sized — flexible. Sila ang pinakagamit na collection sa Go. May three parts: pointer sa underlying array, length, ug capacity.
var s []int
s = []int{1, 2, 3}
s = make([]int, 5)
s = make([]int, 3, 5)
package main
import "fmt"
func main() {
nums := []int{10, 20, 30}
nums = append(nums, 40)
fmt.Println(nums, len(nums), cap(nums))
}
package main
import "fmt"
func main() {
name := "Alice"
fmt.Println("Hello, " + name + "!")
}
nums := []int{1, 2, 3}
nums = append(nums, 4, 5, 6)
package main
import "fmt"
func main() {
scores := []int{85, 90}
scores = append(scores, 75, 88, 92)
fmt.Println(scores)
}
package main
import "fmt"
func main() {
supported := []string{"en-US", "en-GB", "ja-JP"}
locale := "ja-JP"
found := false
for _, l := range supported {
if l == locale { found = true; break }
}
fmt.Println("Found:", found)
}
arr := [5]int{0, 1, 2, 3, 4}
s := arr[1:4] // [1 2 3]
package main
import "fmt"
func main() {
original := []int{1, 2, 3, 4, 5}
subset := original[1:4]
original[2] = 99
fmt.Println("subset:", subset)
}
Ang slice kay internally usa ka descriptor: pointer + length + capacity. Kung ma-exceed ang capacity sa append, mag-allocate ang Go og bag-o na array — murag upgrade.
package main
import "fmt"
func main() {
s := make([]int, 0, 10)
for i := 0; i < 12; i++ {
s = append(s, i)
if cap(s) != cap(s[:len(s)-1]) {
fmt.Println("realloc at", len(s)-1)
}
}
}
Gamit ug copy() para independent — di magkagubot ang original ug copy:
a := []int{1, 2, 3, 4, 5}
b := make([]int, 3)
copy(b, a[:3])
b[0] = 42
fmt.Println(a[0]) // 1 — wala naapektuhan
package main
import "fmt"
func main() {
original := []int{10, 20, 30, 40, 50}
copied := make([]int, 3)
copy(copied, original[:3])
copied[0] = 999
fmt.Println("original:", original)
fmt.Println("copied:", copied)
}
ages := map[string]int{"bob": 30}
age, ok := ages["bob"]
delete(ages, "carol")
package main
import "fmt"
func main() {
scores := make(map[string]int)
scores["Alice"] = 95
fmt.Println(scores)
}
val, ok := m["b"]
if !ok { fmt.Println("wala ang key") }
package main
import "fmt"
func main() {
phonebook := map[string]string{"Alice": "555-1234"}
num, ok := phonebook["Carol"]
if ok { fmt.Println(num) } else { fmt.Println("wala") }
}
package main
import "fmt"
func main() {
week := []string{"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}
fmt.Println(week[1:6])
}
delete(m, "a")
package main
import "fmt"
func main() {
inventory := map[string]int{"apples": 10, "bananas": 5}
delete(inventory, "bananas")
fmt.Println(inventory)
}
package main
import "fmt"
func remove(s []int, i int) []int {
return append(s[:i], s[i+1:]...)
}
func main() {
nums := []int{10, 20, 30, 40, 50}
nums = remove(nums, 2)
fmt.Println(nums)
}
type Celsius float64
type ID int
package main
import "fmt"
type Miles float64
func main() {
var d Miles = 26.2
fmt.Println(d, "miles")
}
type Person struct {
Name string
Age int
}
p := Person{"Alice", 30}
package main
import "fmt"
type Book struct {
Title, Author string
Year int
}
func main() {
b := Book{"The Go Language", "Donovan", 2015}
fmt.Println(b.Title)
}
a := Point{1, 2}
b := Point{1, 2}
fmt.Println(a == b)
package main
import "fmt"
type Rectangle struct { W, H float64 }
func main() {
r1 := Rectangle{10, 20}
r2 := Rectangle{10, 20}
fmt.Println(r1 == r2)
}
type Address struct { City string }
type Employee struct {
Name string
Address
}
e := Employee{Name: "A", Address: Address{"Tokyo"}}
fmt.Println(e.City)
package main
import "fmt"
type Address struct { City string }
type Company struct {
Name string
Address
}
func main() {
c := Company{"Acme", Address{"Manila"}}
fmt.Println(c.Name, c.City)
}
var i int = 42
var f float64 = float64(i)
package main
import "fmt"
func main() {
var pi float64 = 3.14159
var truncated int = int(pi)
fmt.Println(truncated)
}
var v any = "hello"
s := v.(string)
s, ok := v.(string)
package main
import "fmt"
func main() {
items := []any{42, "hello"}
for _, item := range items {
switch v := item.(type) {
case int: fmt.Println("int:", v*2)
case string: fmt.Println("string:", v)
}
}
}
var v any = 42
switch val := v.(type) {
case int: fmt.Println("int:", val)
default: fmt.Println("unknown")
}
package main
import "fmt"
func describe(v any) {
switch val := v.(type) {
case int: fmt.Println("integer:", val)
case string: fmt.Println("string:", val)
default: fmt.Println("unknown")
}
}
func main() {
describe(42)
describe("hello")
}
package main
import "fmt"
func main() {
data := []any{100, "Go", 3.14, true}
for _, v := range data {
switch v.(type) {
case int: fmt.Println("integer")
case float64: fmt.Println("float")
case string: fmt.Println("string")
default: fmt.Printf("other: %T\n", v)
}
}
}