Belajar Ruby - Collections: Array, Hash, Range & Set

#Pendahuluan

Collection adalah tempat Ruby menyimpan dan memanipulasi data dalam jumlah besar. Array untuk urutan, Hash untuk pemetaan key-value, Range untuk rentang, dan Set untuk keanggotaan unik. Memahami kapan memakai yang mana — dan bagaimana iterasi bekerja di balik layar — menentukan efisiensi kode kalian.

Episode 10 ini membedah empat collection inti: operasi umum Array dan Hash beserta default value, mekanisme Enumerator dengan next dan peek, lazy evaluation untuk data besar, Enumerator.produce, serta Set yang menjadi core class sejak Ruby 4.0 dan Range#cover? yang sering dipakai validasi.

#Array dan Hash

#Operasi Umum

Array dan Hash menyediakan banyak method transformasi. Sebagian method ! mengubah data asli (seperti sort!), sisanya mengembalikan salinan:

Operasi array dan hash

angka = [3, 1, 4, 1, 5]
puts angka.sort.inspect
puts angka.first
puts angka.max
puts angka.sum
 
data = { a: 1, b: 2 }
puts data.key?(:a)
puts data.values.inspect

angka.sort mengembalikan array terurut tanpa mengubah asli, angka.first mengambil elemen pertama, angka.max nilai terbesar, dan angka.sum menjumlahkan. Di sisi hash, data.key?(:a) mengecek keberadaan key dan data.values mengambil seluruh nilai. Seluruh operasi ini berjalan berkat modul Enumerable yang di-include oleh Array.

#Default Value dan Capacity Hash

Hash bisa diberi nilai default yang dikembalikan saat key tidak ditemukan — sangat berguna untuk penghitung dan akumulator:

Default value hash

penghitung = Hash.new(0)
penghitung[:ruby] += 1
puts penghitung[:ruby]
puts penghitung[:rails]

Hash.new(0) membuat hash yang mengembalikan 0 untuk key yang belum ada. Karena itu penghitung[:ruby] += 1 aman dilakukan tanpa inisialisasi manual, dan penghitung[:rails] mengembalikan 0. Untuk data besar, Ruby juga menyediakan cara memberi capacity awal — pola yang menghemat rehash ketika jumlah key bisa diperkirakan.

#Enumerator dan Lazy

#Enumerator, next, dan peek

Sebuah method yang menerima block (seperti each) sebenarnya bisa diubah menjadi Enumerator — objek yang mengatur iterasi sebagai konsumen manual. Dengan Enumerator, kalian menarik elemen satu per satu melalui next, dan melihat elemen berikutnya tanpa mengonsumsinya lewat peek:

Enumerator dan next

enum = [10, 20, 30].each
puts enum.next
puts enum.peek
puts enum.next
puts enum.next

Block kode di atas menampilkan 10 (hasil next), lalu 20 (hasil peek yang tidak mengonsumsi), kemudian 20 dan 30 dari dua next berikutnya. Pemanggilan enum.next melempar StopIteration setelah elemen habis — perilaku yang dieksploitasi oleh loop loop untuk iterasi sampai tuntas.

#Enumerator::Lazy untuk Data Besar

Rantai map dan select biasa memproses seluruh koleksi di setiap tahap, menghasilkan array sementara. Lazy evaluation menunda pemrosesan dan menarik elemen hanya sebanyak yang diminta:

Lazy evaluation

hasil = (1..Float::INFINITY).lazy
                        .map { |n| n * n }
                        .select { |n| n.even? }
                        .first(5)
puts hasil.inspect

(1..Float::INFINITY).lazy membuat range tak hingga yang dievaluasi malas. Rantai map dan select tidak langsung diproses; hanya sampai first(5) menghentikan iterasi. Inilah cara menangani deret tanpa batas atau dataset raksasa tanpa mengalokasikan array penuh.

#Enumerator.produce

Enumerator.produce membangkitkan deret tak hingga dari sebuah nilai awal dan aturan transisi — pola elegan untuk deret fibonacci:

Enumerator.produce

fib = Enumerator.produce([0, 1]) { |a, b| [b, a + b] }
puts fib.first(7).map(&:first).inspect

Enumerator.produce([0, 1]) { |a, b| [b, a + b] } menghasilkan pasangan angka fibonacci berurutan. fib.first(7).map(&:first) mengambil tujuh pasangan pertama lalu menampilkan elemen pertamanya: [0, 1, 1, 2, 3, 5, 8].

#Set dan Range

#Set: Core Class Sejak Ruby 4.0

Set adalah koleksi unik tanpa duplikasi dengan pencarian keanggotaan O(1). Sebelumnya stdlib, Set kini menjadi core class sejak Ruby 4.0 — tidak perlu require "set" lagi:

Set core class

set = Set.new([1, 2, 3])
set.add(4)
puts set.include?(2)
puts set.include?(100)

Set.new([1, 2, 3]) membangun set, set.add(4) menambahkan elemen, dan set.include?(2) mengecek keanggotaan dengan cepat. Karena elemen wajib unik, add dengan nilai duplikat tidak mengubah set. Untuk ribuan elemen, pencarian keanggotaan jauh lebih cepat daripada array.

#Range dan cover?

Range mewakili rentang nilai — 1..10 (inklusif) dan 1...10 (eksklusif). Method cover? mengecek apakah sebuah nilai berada dalam rentang, dan sering dipakai untuk validasi:

Range dan cover?

umur = 25
if umur.between?(17, 60)
  puts "Usia produktif"
end
puts (1..10).cover?(15)

umur.between?(17, 60) — yang tersedia berkat modul Comparable — mengecek nilai dalam batas, dan (1..10).cover?(15) mengembalikan false karena 15 di luar rentang. Bedakan cover? yang membandingkan batas dengan include? yang mengiterasi elemen: untuk range, cover? jauh lebih efisien.

#Penutup

Episode 10 melengkapi arsenal collection kalian: operasi Array dan Hash dengan nilai default, mekanisme Enumerator dengan next, peek, dan Enumerator.produce, lazy evaluation untuk deret tak hingga, Set sebagai core class Ruby 4.0, serta Range#cover? untuk validasi.

Inti yang harus dibawa pulang:

• Array menyimpan urutan; Hash memetakan key ke value dengan pencarian cepat.
• Hash.new(0) memberi nilai default untuk penghitung tanpa inisialisasi manual.
• Enumerator memungkinkan iterasi manual dengan next dan peek.
• .lazy menunda pemrosesan dan hanya menarik elemen yang dibutuhkan.
• Enumerator.produce membangkitkan deret tak hingga dari nilai awal.
• Set kini core class Ruby 4.0 untuk keanggotaan unik dengan pencarian O(1).
• Range#cover? lebih efisien daripada include? untuk mengecek batas.

Di episode 11 selanjutnya kita akan membahas concurrency dan parallelism — Thread dengan Mutex dan Queue, race condition, Fiber dengan cooperative scheduling dan Fiber.scheduler, serta Ractor untuk paralelisme sejati dengan API baru Ractor::Port di Ruby 4.0. Ini materi paling menantang tapi paling berdampak pada performa aplikasi.