Dalam pengembangan perangkat lunak, bagaimana kita menyimpan dan mengelola data di memori dapat memengaruhi performa, keamanan, dan maintainability kode. Hari ini kita akan membandingkan struktur data in-memory di Go (Golang) dan PHP - dua bahasa yang memiliki filosofi berbeda dalam menangani koleksi data.

Apa yang Kita Bandingkan?

  • Go: Slices dan Maps sebagai struktur data utama
  • PHP: Array sebagai struktur data serba-bisa

1. Keamanan Tipe Data (Type Safety)

PHP: Fleksibel tapi Rentan Error

php 
<?php
// PHP mengizinkan tipe data campuran dalam array
$data = [1, "hello", 3.14, true];
$data["nama"] = "Budi";
$data[10] = "sepuluh";

// Tidak ada error pada saat penulisan kode
// Tapi bisa menyebabkan runtime error
foreach ($data as $value) {
    echo strtoupper($value); // Error saat bertemu integer!
}
?>

Go: Ketat tapi Aman

go 
package main

func main() {
    // Harus deklarasikan tipe data dari awal
    numbers := []int{1, 2, 3}
    // numbers = append(numbers, "hello") // ERROR: compile-time
    
    // Map dengan tipe yang jelas
    person := map[string]string{
        "nama": "Budi",
        "usia": "30", // Harus string semua
    }
}

Kelebihan Go: Error terdeteksi saat kompilasi, bukan saat dijalankan!

2. Performa dan Efisiensi Memori

PHP: Fleksibilitas dengan Cost

Array PHP sebenarnya adalah ordered hash maps yang canggih. Setiap elemen menyimpan:

  • Value
  • Type information
  • Key
  • Metadata lainnya

Struktur ini membuat PHP arrays sangat fleksibel tapi kurang efisien untuk data numerik dalam jumlah besar.

Go: Efisien dan Cepat

go 
// Slice of integers - hampir seperti array C
numbers := make([]int, 0, 1000) // Pre-alokasi memory
for i := 0; i < 1000; i++ {
    numbers = append(numbers, i*i)
}

// Memory layout yang padat
// [int][int][int][int]... (tanpa overhead type info)

Benchmark Simple:

  • Operasi pada 1 juta elemen integer:
    • Go: ~50ms
    • PHP: ~200ms (tergantung konfigurasi)

3. Dukungan Concurrency

PHP: Shared-Nothing Architecture

PHP dirancang untuk environment web dimana setiap request terisolasi. Array tidak perlu thread-safe karena tidak dibagi antar process.

Go: Built-in Concurrency

go 
package main

import (
    "sync"
)

func main() {
    var wg sync.WaitGroup
    var mu sync.Mutex
    data := make(map[string]int)
    
    // Multiple goroutines accessing shared map
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(index int) {
            defer wg.Done()
            
            mu.Lock()
            data[fmt.Sprintf("key%d", index)] = index
            mu.Unlock()
        }(i)
    }
    
    wg.Wait()
}

Catatan: Go maps tidak thread-safe by default, tapi mudah di-synchronize dengan sync.Mutex atau sync.Map.

4. Fungsi Bawaan dan Kemudahan Penggunaan

PHP: Kaya Fitur Built-in

php 
<?php
$numbers = [1, 2, 3, 4, 5];

// Banyak helper functions
$doubled = array_map(fn($x) => $x * 2, $numbers);
$even = array_filter($numbers, fn($x) => $x % 2 === 0);
$sum = array_sum($numbers);

// Array manipulation
$merged = array_merge($numbers, [6, 7, 8]);
$reversed = array_reverse($numbers);
?>

Go: Minimalis tapi Powerful

go 
// Tidak ada built-in map/filter
numbers := []int{1, 2, 3, 4, 5}

// Manual filtering
var even []int
for _, n := range numbers {
    if n%2 == 0 {
        even = append(even, n)
    }
}

// Manual mapping
doubled := make([]int, len(numbers))
for i, n := range numbers {
    doubled[i] = n * 2
}

Trade-off: PHP lebih cepat untuk development, Go lebih eksplisit dan terkontrol.

5. Use Cases yang Cocok

Pilih PHP Arrays ketika:

  • Development speed adalah prioritas
  • Bekerja dengan data heterogen (mixed types)
  • Membangun web applications dengan data request/response
  • Scripting dan rapid prototyping

Pilih Go Slices/Maps ketika:

  • Performance kritikal (microservices, APIs)
  • Memory efficiency penting
  • Butuh concurrent processing
  • Building CLI tools atau system utilities
  • Type safety dan reliability adalah prioritas

Studi Kasus: Processing User Data

PHP Approach

php 
<?php
// Fleksibel handling berbagai tipe data user
$users = [
    ["id" => 1, "name" => "Alice", "age" => 25],
    ["id" => 2, "name" => "Bob", "age" => "30"], // Age sebagai string? Tidak masalah!
    ["id" => 3, "name" => "Charlie", "age" => 35.5], // Float? Juga bisa
];

// Processing dengan built-in functions
$userNames = array_column($users, 'name');
$adults = array_filter($users, fn($user) => $user['age'] > 18);
?>

Go Approach

go 
type User struct {
    ID   int
    Name string
    Age  int
}

func main() {
    users := []User{
        {ID: 1, Name: "Alice", Age: 25},
        {ID: 2, Name: "Bob", Age: 30},
        {ID: 3, Name: "Charlie", Age: 35},
    }
    
    // Manual processing - lebih verbose tapi lebih aman
    var userNames []string
    var adults []User
    
    for _, user := range users {
        userNames = append(userNames, user.Name)
        if user.Age > 18 {
            adults = append(adults, user)
        }
    }
}

Kesimpulan

AspekGo (Slices/Maps)PHP Arrays
Type Safety✅ Strict, aman❌ Flexible, rentan error
Performance✅ Lebih cepat❌ Lebih lambat
Memory Usage✅ Lebih efisien❌ Lebih boros
Concurrency✅ Excellent❌ Tidak applicable
Development Speed❌ Manual✅ Cepat dengan built-in functions
Flexibility❌ Rigid✅ Sangat flexible

Pilihan tergantung kebutuhan:

  • Butuh cepat development dan fleksibilitas? → PHP
  • Butuh performansi tinggi dan reliability? → Go

Dalam praktiknya, banyak perusahaan menggunakan kedua bahasa ini bersama-sama: PHP untuk frontend/rapid prototyping, dan Go untuk backend services yang membutuhkan performansi tinggi.

Semoga artikel ini membantu Anda memilih tools yang tepat untuk project yang tepat! 🚀