How do variables and basic types work in Ruby?

Question

Accepted Answer

Ruby is **dynamically typed** — variables don't declare a type and hold any value. Ruby has several basic types (all objects), and uses **naming conventions** (sigils) to indicate variable scope.

## Variables and dynamic typing

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

## The basic types (all are objects)

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

## Variable naming conventions indicate scope

```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 uses **sigils** (prefixes) to denote variable scope: plain names are local, `@` for instance variables, `@@` for class variables, `$` for globals (discouraged), and uppercase for constants. This is distinctive — the prefix tells you the scope at a glance.

## Truthiness (a Ruby quirk)

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

**Only `false` and `nil` are falsy** in Ruby — `0`, `""`, and `[]` are all truthy (unlike many languages where 0/empty are falsy). A common gotcha.

## Why it matters

Understanding Ruby's variables and basic types is fundamental everyday knowledge.

Ruby is dynamically typed (variables hold any value, no type declarations), and a distinctive feature is its use of **naming conventions (sigils) to indicate variable scope** — `@` for instance variables, `@@` for class variables, `$` for globals, uppercase for constants — so the variable's prefix tells you its scope at a glance, which is important for reading and writing Ruby correctly (especially `@instance` variables, used constantly in classes).

Knowing the basic types (all of which are objects in Ruby's pure object-oriented model) — including the distinctive **Symbol** type — is necessary for working with data.

A particularly important quirk to understand is Ruby's **truthiness**: **only `false` and `nil` are falsy**, while everything else (including `0`, `""`, and `[]`) is truthy — this differs from many languages (where 0 or empty values are falsy) and is a common source of bugs for developers coming from other languages.

Understanding dynamic typing, the scope-indicating naming conventions, the basic types, and especially the false-and-nil-only truthiness rule is foundational for writing correct Ruby and avoiding common pitfalls, making it essential, must-know knowledge for the language.