Bagaimana pemboleh ubah dan jenis asas berfungsi dalam Ruby?

Question

IT Interview Practice · Accepted Answer

Ruby adalah **bertaip secara dinamik** — pemboleh ubah tidak mengisytiharkan jenis dan boleh menyimpan sebarang nilai. Ruby mempunyai beberapa jenis asas (semuanya objek), dan menggunakan **konvensyen penamaan** (sigil) untuk menunjukkan skop pemboleh ubah.

## Pemboleh ubah dan penaipan dinamik

```ruby
count = 42           # no type declaration — inferred
name = "Ann"
count = "now a string"   # dynamically typed — can change type
```

## Jenis asas (semuanya objek)

```ruby
42              # Integer
3.14            # Float
"hello"         # String
:symbol         # Symbol (an immutable, interned identifier)
true / false    # Boolean (TrueClass / FalseClass)
nil             # NilClass — "nothing" (Ruby's null)
[1, 2, 3]       # Array
{ a: 1 }        # Hash (key-value)
1..10           # Range
```

## Konvensyen penamaan pemboleh ubah menunjukkan skop

```ruby
name        = "local"      # local variable (lowercase)
@instance   = "instance"   # @ → INSTANCE variable (per object)
@@class_var = "class"      # @@ → CLASS variable (shared across instances)
$global     = "global"     # $ → global variable (avoid)
CONSTANT    = "constant"   # Uppercase start → CONSTANT (convention; can change with warning)
```

Ruby menggunakan **sigil** (awalan) untuk menandakan skop pemboleh ubah: nama biasa adalah tempatan, `@` untuk pemboleh ubah instance, `@@` untuk pemboleh ubah kelas, `$` untuk global (tidak digalakkan), dan huruf besar untuk pemalar. Ini adalah ciri tersendiri — awalan memberitahu anda skopnya sepintas lalu.

## Truthiness (keunikan Ruby)

```ruby
# in Ruby, ONLY false and nil are falsy — EVERYTHING else is truthy
puts "truthy" if 0        # prints — 0 is TRUTHY in Ruby! (unlike many languages)
puts "truthy" if ""        # prints — empty string is truthy too
puts "falsy" unless nil    # nil is falsy
```

**Hanya `false` dan `nil` adalah falsy** dalam Ruby — `0`, `""`, dan `[]` semuanya truthy (tidak seperti banyak bahasa di mana 0/kosong adalah falsy). Satu perangkap yang lazim.

## Mengapa ia penting

Memahami pemboleh ubah dan jenis asas Ruby adalah pengetahuan asas harian.

Ruby bertaip secara dinamik (pemboleh ubah menyimpan sebarang nilai, tiada pengisytiharan jenis), dan ciri tersendiri ialah penggunaan **konvensyen penamaan (sigil) untuk menunjukkan skop pemboleh ubah** — `@` untuk pemboleh ubah instance, `@@` untuk pemboleh ubah kelas, `$` untuk global, huruf besar untuk pemalar — supaya awalan pemboleh ubah memberitahu anda skopnya sepintas lalu, yang penting untuk membaca dan menulis Ruby dengan betul (terutamanya pemboleh ubah `@instance`, yang digunakan secara berterusan dalam kelas).

Mengetahui jenis asas (yang kesemuanya adalah objek dalam model berorientasikan objek tulen Ruby) — termasuk jenis **Symbol** yang tersendiri — adalah perlu untuk bekerja dengan data.

Satu keunikan yang amat penting untuk difahami ialah **truthiness** Ruby: **hanya `false` dan `nil` adalah falsy**, manakala segala-galanya yang lain (termasuk `0`, `""`, dan `[]`) adalah truthy — ini berbeza daripada banyak bahasa (di mana 0 atau nilai kosong adalah falsy) dan merupakan punca pepijat yang lazim bagi pembangun yang datang daripada bahasa lain.

Memahami penaipan dinamik, konvensyen penamaan yang menunjukkan skop, jenis asas, dan terutamanya peraturan truthiness false-dan-nil-sahaja adalah asas untuk menulis Ruby yang betul dan mengelakkan perangkap yang lazim, menjadikannya pengetahuan asas yang mesti diketahui untuk bahasa ini.

Pemboleh ubah dan penaipan dinamik

Jenis asas (semuanya objek)

Konvensyen penamaan pemboleh ubah menunjukkan skop

Truthiness (keunikan Ruby)

Mengapa ia penting

Soalan berkaitan