What is the difference between strings and symbols?

Question

Accepted Answer

**Strings** are mutable sequences of characters; **symbols** (`:name`) are immutable, **interned** identifiers — the same symbol is the exact same object in memory everywhere. Symbols are used as lightweight, efficient identifiers (especially hash keys), while strings hold actual text data.

## The core difference: identity and mutability

```ruby
# strings — each is a NEW object (even with the same content)
"hello".object_id == "hello".object_id    # false — two different objects
"hello" << " world"                        # mutable — can be modified in place

# symbols — the SAME symbol is always the SAME object (interned)
:hello.object_id == :hello.object_id       # true — identical object every time
:hello.frozen?                              # true — symbols are immutable
```

Every string literal creates a new object, but a symbol is **interned** — `:hello` is always the exact same object in memory, no matter how many times it appears. Symbols are also immutable.

## Memory and performance benefits of symbols

```text
Strings: each "name" allocates a new object → more memory, slower comparison (char by char)
Symbols: :name is ONE shared object → memory-efficient, fast comparison (by identity)
→ Symbols are ideal as identifiers used repeatedly (hash keys, method names, options).
```

## When to use which

```ruby
# SYMBOLS — for identifiers: hash keys, method names, options, fixed labels
user = { name: "Ann", role: :admin }       # symbol keys (the idiom)
send(:upcase)                               # method name as a symbol
status = :active                            # a fixed label/state

# STRINGS — for actual text DATA that you display, manipulate, or that varies
name = "Ann Smith"                          # real text content
message = "Hello, #{name}"                  # building/interpolating text
user_input = gets.chomp                     # data from outside
```

Use **symbols for identifiers** (hash keys, option names, states, method names — fixed, repeated labels) and **strings for actual text data** (content you display, manipulate, or that comes from users).

## Converting between them

```ruby
"hello".to_sym    # :hello
:hello.to_s        # "hello"
```

## Why it matters

Understanding the string-vs-symbol distinction is important and distinctly Ruby knowledge, since symbols are a feature many other languages lack, and using them appropriately is idiomatic Ruby.

The key difference is that **symbols are interned and immutable** (`:name` is always the same single object in memory, immutable), while **strings are mutable and each literal is a new object**.

This gives symbols **memory and performance benefits** as identifiers: they're allocated once and shared (memory-efficient when used repeatedly), and compared by identity (fast) rather than character-by-character.

The practical guidance — **use symbols for identifiers** (hash keys, method names, option labels, fixed states — things used repeatedly as labels) and **strings for actual text data** (content you display, manipulate, or receive from users) — is important idiomatic Ruby that affects both performance and clarity.

Symbol hash keys (`{ name: "Ann" }`) are the convention in Ruby and Rails, and using symbols for fixed identifiers rather than strings is efficient and conventional.

Understanding when to use each, the interning/immutability of symbols, and their efficiency as identifiers is foundational, frequently-applied Ruby knowledge — it's a common point of confusion for newcomers (why have both?), and grasping the distinction (symbols as efficient interned identifiers, strings as mutable text data) is essential for writing idiomatic, efficient Ruby and a frequent interview topic reflecting understanding of this distinctive Ruby feature.