Fitur Terbaru Ruby 2.3

Kemarin preview Ruby 2.3 telah dirilis. Pembaharuan ini membawa beberapa tambahan untuk kelas inti Ruby, termasuk beberapa sintaks baru. Berikut beberapa penambahan yang dilakukan oleh pengembang Ruby:

Ekstrak nilai dengan Array#dig dan Hash#dig

Instan baru dengan cara #dig menyediakan sintaks untuk mengakses data bertingkat. Contoh:

user = {
  user: {
    address: {
      street1: '123 Main street'
    }
  }
}

user.dig(:user, :address, :street1) # '123 Main street'

results = [[[1, 2, 3]]]

results.dig(0, 0, 0) # 1

Kedua cara ini akan mengembalikan nilai nil jika akses dalam struktur bertingkat mengembalikan nilai nil:

user.dig(:user, :adddresss, :street1) # nil
user.dig(:user, :address, :street2) # nil

Penangkapan pattern dengan Enumerable#grep_v

Cara ini merupakan kebalikan dari Enumerable#grep. Metode grep dan kebalikannya disediakan untuk meningkatkan penyaringan secara enumerable:

Penyaringan dengan RegEx

friends = %w[John Alain Jim Delmer]

j_friends = friends.grep(/^J/)   # ["John", "Jim"]
others    = friends.grep_v(/^J/) # ["Alain", "Delmer"]

Penyaringan dengan tipe

items = [1, 1.0, '1', nil]

nums   = items.grep(Numeric)   # [1, 1.0]
others = items.grep_v(Numeric) # ['1', nil]

Menangkap nilai jamak dengan Hash#fetch_values

Cara Hash#fetch lebih baik dibanding Hash#[] ketika ita ingin menulis kode yang terbatas. Kita juga bisa mengakses nilai jamak dari hash dengan menggunakan Hash#values_at, namun tidak ada pembatasan untuk values_at.

values = {
  foo: 1,
  bar: 2,
  baz: 3,
  qux: 4
}

values.values_at(:foo, :bar)    # [1, 2]
values.fetch_values(:foo, :bar) # [1, 2]

values.values_at(:foo, :bar, :invalid)    # [1, 2, nil]
values.fetch_values(:foo, :bar, :invalid) # KeyError: key not found: :invalid

Prediksi nilai positif dan dengan dengan Numeric#positive? dan Numeric#negative?

Nilai numerik kini bisa diprediksi dengan cara tersebut jika subyeknya positif atau negatif. Cara ini berguna jika kita ingin menyaring nilai yang sifatnya enumerable:

numbers = (-5..5)

numbers.select(&:positive?) # [1, 2, 3, 4, 5]
numbers.select(&:negative?) # [-5, -4, -3, -2, -1]

Operator superset dan subset untuk Hash dengan cara Hash#<=, Hash# dan Hash#>

Cara ini berguna ketika kita ingin membandingkan hashes untuk melihat subset maupun superset. Contoh:

small     = { a: 1                }
medium    = { a: 1, b: 2          }
large     = { a: 1, b: 2, c: 3    }
different = { totally: :different }

{ a: 1, b: 2 } > { a: 1 }             # true
{ a: 1 } > { a: 1 }                   # false
{ b: 1 } > { a: 1 }                   # false
{ a: 1, b: 2 }  true

Konversi hash ke proc dengan cara Hash#to_proc

Sekarang kita bisa menggunakan hash untuk iterasi objek yang enumerable:

hash = { a: 1, b: 2, c: 3 }
keys = %i[a c d]

keys.map(&hash) # [1, 3, nil]

Banyak fitur yang telah dikembangkan oleh pengembang Ruby pada versi Ruby 2.3. Jika pembaca ingin lebih menyederhanakan koding dengan cara ini, jangan lupa untuk mencobanya.

(yp/blockscore)