Yararlı String yöntemleri ve bang (!) varyantları nelerdir?

Question

Accepted Answer

Ruby dizelerine (string) zengin bir yöntem seti sahiptir ve birçoğu iki formda gelir: normal versiyon (**yeni** bir dize döndürür) ve **bang (`!`)** versiyonu (dizeyi **yerinde** değiştirir, orijinali mutasyona uğratır). Bu ayrımı anlamak doğruluk ve hataları önlemek açısından önemlidir.

## Yaygın string yöntemleri

```ruby
"hello".upcase           # "HELLO"
"HELLO".downcase          # "hello"
"  hi  ".strip             # "hi" — remove surrounding whitespace
"hello".reverse           # "olleh"
"hello".length            # 5
"hello world".split(" ")  # ["hello", "world"]
["a", "b"].join("-")       # "a-b"
"hello".sub("l", "L")      # "heLlo" — replace FIRST
"hello".gsub("l", "L")     # "heLLo" — replace ALL (global)
"hello".include?("ell")    # true
"hello".start_with?("he")  # true
"hello".chars             # ["h", "e", "l", "l", "o"]
"42".to_i; "3.14".to_f      # convert to number
"Hi #{name}"               # interpolation
```

## Kritik bang (!) ayrımı: yerinde mutasyon

```ruby
str = "hello"

# normal version — returns a NEW string, original UNCHANGED
upper = str.upcase        # upper = "HELLO", but str is STILL "hello"
puts str                  # "hello" — unchanged

# BANG version — modifies the original IN PLACE (mutates it)
str.upcase!               # str is NOW "HELLO" — the original changed!
puts str                  # "HELLO"
```

**`!` (bang) versiyonları orijinal dizeyi yerinde mutasyona uğratırken**, bang olmayan versiyonlar yeni bir dize döndürür ve orijinali değişmeden bırakır. Bu kritik bir ayrımdır — `upcase!` kullanmak istediğinizde `upcase` kullanmak (veya bunun tersi) orijinalin değişip değişmediğini değiştirir ve bu da ince hataları ortaya çıkarabilir.

## Bir bang tuzağı: değişiklik olmadığında nil dönüşü

```ruby
"hello".upcase!     # "HELLO"
"HELLO".upcase!     # nil! — bang methods return nil if NOTHING changed
# → don't chain off a bang method's return value carelessly
str.strip!&.upcase  # be careful — strip! returns nil if there was nothing to strip
```

İnce bir tuzak: bang yöntemleri değişiklik yapmazlarsa **`nil`** döndürürler — bu nedenle bunların dönüş değerinden zincirlemek bozulabilir.

## Neden önemli

Dize manipülasyonu programlamada her yerde bulunur, bu nedenle Ruby'nin zengin string yöntemlerini bilmek günlük yararlı bir bilgidir — ancak en önemli nokta **bang (`!`) ile bang olmayan ayrımını anlamaktır**, bu hem Ruby adlandırma kuralıdır hem de sık hataların kaynağıdır.

Bang olmayan versiyon **yeni** bir dize döndürür (orijinali değişmeden bırakır), **bang versiyonu ise orijinali yerinde mutasyona uğratır** — ve bunları karıştırmak orijinal nesnenin değişip değişmediğini değiştirir, bu da ince ve hata ayıklaması zor olan hataları ortaya çıkarır (örneğin orijinalin değişmez kalması beklenir ancak `upcase!` onu mutasyona uğratır, veya mutasyon beklenir ancak `upcase` orijinali değişmez bırakır).

Ruby dizeleri değişken (mutable) olduğu ve birçok yöntemin her iki formu olduğu için, bu ayrımı anlamak doğruluk açısından önemlidir — `!` tipik olarak "yerinde değiştirir / tehlikeli versiondur" anlamına gelir (bu kural dizelerin ötesine diğer Ruby yöntemleri gibi `map!`, `sort!` uzanır) ve bu da mutasyon davranışını tahmin etmenize ve kontrol etmenize olanak sağlar.

Bang yöntemlerinin değişiklik yapmadığında `nil` döndürmesinin ek **tuzağı** (bu yöntem zincirlemesini bozabilir) de bilmek değerlidir.

Ruby'nin yararlı string yöntemlerini ve özellikle **bang/bang olmayan mutasyon ayrımını** (orijinalin değişip değişmediğini etkileyen bir Ruby kuralı) anlamak doğru Ruby yazmanız ve dizeleri güvenli şekilde işlemeniz açısından önemlidir — bu mutasyon hatalarının sık kaynağıdır ve `!` kuralı Ruby'de yerinde değişim versus yeni nesne semantiğini anlamayı yansıtan temel bir Ruby deyimi olup, Ruby'deki sabit string çalışması için pratik olarak ilgili bilgi ve karakteristik, hata açısından riskli bir Ruby kuralı hakkında yaygın bir konudur.