Apakah method String yang berguna dan varian bang (!)?

Question

Accepted Answer

String Ruby mempunyai set method yang kaya untuk manipulasi, dan banyak yang datang dalam dua bentuk: versi biasa (mengembalikan string **baharu**) dan versi **bang (`!`)** (mengubah suai string **di tempat asal**, memutasi yang asal). Memahami perbezaan ini adalah penting untuk ketepatan dan mengelakkan bug.

## Method string lazim

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

## Perbezaan bang (!) yang penting: mutasi di tempat asal

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

**Versi `!` (bang) memutasi string asal di tempat asal**, manakala versi bukan-bang mengembalikan string baharu dan membiarkan yang asal tidak berubah. Ini ialah perbezaan kritikal — menggunakan `upcase!` apabila anda bermaksud `upcase` (atau sebaliknya) mengubah sama ada yang asal diubah suai, yang boleh menyebabkan bug yang halus.

## Satu gotcha bang: pengembalian nil apabila tiada perubahan

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

Satu gotcha yang halus: method bang mengembalikan **`nil`** jika ia tidak membuat sebarang perubahan — jadi melakukan chaining daripada nilai pengembaliannya boleh rosak.

## Mengapa ia penting

Manipulasi string berleluasa dalam pengaturcaraan, jadi mengetahui method string Ruby yang kaya adalah pengetahuan harian yang berguna — tetapi poin paling penting ialah memahami **perbezaan bang (`!`) vs bukan-bang**, yang merupakan kedua-dua konvensyen penamaan Ruby dan punca bug yang kerap.

Versi bukan-bang mengembalikan string **baharu** (membiarkan yang asal tidak berubah), manakala **versi bang memutasi yang asal di tempat asal** — dan mengelirukannya mengubah sama ada objek asal diubah suai, yang menyebabkan bug yang halus dan sukar dinyahpepijat (cth. menjangka yang asal tidak berubah tetapi menggunakan `upcase!` memutasinya, atau menjangka mutasi tetapi menggunakan `upcase` membiarkan yang asal tidak tersentuh).

Memandangkan string Ruby adalah mutable dan banyak method mempunyai kedua-dua bentuk, memahami perbezaan ini adalah penting untuk ketepatan — mengetahui bahawa `!` lazimnya bermaksud "mengubah suai di tempat asal / versi berbahaya" (konvensyen yang merentas melebihi string kepada method Ruby lain seperti `map!`, `sort!`) membolehkan anda meramal dan mengawal tingkah laku mutasi.

**Gotcha** tambahan bahawa method bang mengembalikan `nil` apabila ia tidak membuat sebarang perubahan (yang boleh merosakkan chaining method) juga bernilai untuk diketahui.

Memahami method string Ruby yang berguna dan terutamanya **perbezaan mutasi bang/bukan-bang** (konvensyen Ruby teras yang mempengaruhi sama ada yang asal diubah suai) adalah penting untuk menulis Ruby yang tepat yang mengendalikan string dengan selamat — ia adalah punca bug mutasi yang kerap, dan konvensyen `!` ialah idiom Ruby asas yang mencerminkan pemahaman tentang semantik di-tempat-asal vs objek-baharu, menjadikannya pengetahuan yang relevan secara praktikal untuk kerja string yang berterusan dalam Ruby serta topik yang lazim tentang konvensyen Ruby yang tersendiri dan terdedah kepada bug.