What are useful String methods and bang (!) variants?

Question

Accepted Answer

Ruby strings have a rich set of methods for manipulation, and many come in two forms: a normal version (returns a **new** string) and a **bang (`!`)** version (modifies the string **in place**, mutating the original). Understanding this distinction is important for correctness and avoiding bugs.

## Common string methods

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

## The crucial bang (!) distinction: in-place mutation

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

The **`!` (bang) versions mutate the original string in place**, while the non-bang versions return a new string and leave the original unchanged. This is a critical distinction — using `upcase!` when you meant `upcase` (or vice versa) changes whether the original is modified, which can cause subtle bugs.

## A bang gotcha: nil return when no change

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

A subtle gotcha: bang methods return **`nil`** if they made no change — so chaining off their return value can break.

## Why it matters

String manipulation is pervasive in programming, so knowing Ruby's rich string methods is useful everyday knowledge — but the most important point is understanding the **bang (`!`) vs non-bang distinction**, which is both a Ruby naming convention and a frequent source of bugs.

The non-bang version returns a **new** string (leaving the original unchanged), while the **bang version mutates the original in place** — and confusing them changes whether the original object is modified, which causes subtle, hard-to-debug bugs (e.g. expecting the original unchanged but using `upcase!` mutates it, or expecting mutation but using `upcase` leaves the original untouched).

Since Ruby strings are mutable and many methods have both forms, understanding this distinction is important for correctness — knowing that `!` typically means "modifies in place / is the dangerous version" (a convention extending beyond strings to other Ruby methods like `map!`, `sort!`) lets you predict and control mutation behavior.

The additional **gotcha** that bang methods return `nil` when they make no change (which can break method chaining) is also valuable to know.

Understanding Ruby's useful string methods and especially the **bang/non-bang mutation distinction** (a core Ruby convention affecting whether the original is modified) is important for writing correct Ruby that handles strings safely — it's a frequent source of mutation bugs, and the `!` convention is a fundamental Ruby idiom that reflects understanding of in-place vs. new-object semantics, making it practically-relevant knowledge for the constant string work in Ruby and a common topic about a distinctive, bug-prone Ruby convention.