Ruby'de değişkenler ve temel tipler nasıl çalışır?

Question

Accepted Answer

Ruby **dinamik olarak yazılır** — değişkenler bir tür bildirmez ve herhangi bir değeri tutabilir. Ruby'nin birkaç temel tipi vardır (hepsi nesnedir) ve **adlandırma kuralları** (işaretler) kullanarak değişken kapsamını belirtir.

## Değişkenler ve dinamik yazım

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

## Temel tipler (hepsi nesnedir)

```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
```

## Değişken adlandırma kuralları kapsamı belirtir

```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 değişken kapsamını belirtmek için **işaretler** (önekler) kullanır: düz adlar yerel değişkendir, `@` örnek değişkenleri için, `@@` sınıf değişkenleri için, `$` genel değişkenler için (önerilmez) ve büyük harfler sabitler için. Bu ayırt edicidir — önek kapsamı bir bakışta söyler.

## Doğruluk değeri (Ruby'nin ilginç bir özelliği)

```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
```

**Ruby'de yalnızca `false` ve `nil` yanlıştır** — `0`, `""` ve `[]` hepsi doğrudur (birçok dilde 0/boş değerler yanlış olduğundan farklıdır). Yaygın bir tuzak.

## Neden önemli

Ruby'nin değişkenlerini ve temel tiplerini anlamak, temel günlük bilgidir.

Ruby dinamik olarak yazılır (değişkenler herhangi bir değeri tutar, tür bildirimi yoktur) ve ayırt edici bir özelliği **değişken kapsamını belirtmek için adlandırma kuralları (işaretler) kullanmasıdır** — örnek değişkenler için `@`, sınıf değişkenleri için `@@`, genel değişkenler için `$`, sabitler için büyük harfler — bu sayede değişkenin öneki kapsamını bir bakışta söyler, bu da Ruby'yi doğru şekilde okumak ve yazmak için önemlidir (özellikle sınıflarda sürekli kullanılan `@instance` değişkenleri).

Temel tipleri (Ruby'nin saf nesne yönelimli modelinde hepsi nesnedir) bilmek — ayırt edici **Symbol** tipi dahil olmak üzere — verilerle çalışmak için gereklidir.

Ruby'nin **doğruluk değeri** hakkında anlaşılması gereken özellikle önemli bir tuzak şudur: **yalnızca `false` ve `nil` yanlıştır**, oysa diğer her şey (`0`, `""` ve `[]` dahil olmak üzere) doğrudur — bu birçok dilde 0 veya boş değerlerin yanlış olduğu durumdan farklıdır ve diğer dillerden gelen geliştirici için yaygın bir hata kaynağıdır.

Dinamik yazımı, kapsam gösterme adlandırma kurallarını, temel tipleri ve özellikle yalnızca false-ve-nil doğruluk kuralını anlamak, doğru Ruby yazması ve yaygın tuzakları önlemek için temeldir ve bu da dilin için gerekli olan, kaçınılmaz bilgiyi oluşturur.