Variables and Data Types
Ruby is dynamically typed, meaning variables do not have a fixed type declared in advance; instead, a variable simply references whatever object it was last assigned, and that object carries its own type information. This gives Ruby code flexibility, since the same variable name can hold an integer at one point and a string later, but it also means type-related bugs surface at runtime rather than compile time. Understanding Ruby's variable naming conventions and its core built-in types is foundational to writing correct, idiomatic code.
Cricket analogy: A Ruby variable is like a jersey handed to whichever player takes the field -- the number 7 shirt might be worn by an opener today and a bowler next series -- the variable just references whoever's wearing it, and the object itself carries the batting or bowling stats, not the shirt.
Variable Naming and Scope Prefixes
Ruby distinguishes variable scope through naming conventions rather than explicit keywords like let or var. A lowercase or underscore-prefixed name (count, _unused) is a local variable, scoped to the current block or method. An @ prefix (@name) denotes an instance variable, tied to a specific object. A double @@ prefix (@@total) denotes a class variable, shared across all instances of a class. A capitalized name (MAX_SIZE) is a constant, which Ruby allows reassigning but will warn about. Global variables use a $ prefix ($config) and are generally discouraged because they create hidden coupling across a codebase.
Cricket analogy: A local variable count is like a scratchpad tally a scorer keeps just for the current over, gone once the over ends; @runs is an instance variable tied to one specific batter's innings; @@matches_played is a class variable shared across every player on the team; and $umpire_decision is a global flag every match official can see, risky because it's visible everywhere.
Core Built-in Types
Ruby's core numeric types are Integer (arbitrary precision, no separate 'long' type needed) and Float (IEEE 754 double-precision). String objects are mutable sequences of characters by default. Symbol objects (:name) are immutable, interned identifiers commonly used as hash keys or enum-like values, more memory-efficient than repeatedly allocating equivalent strings. true and false are singleton instances of TrueClass and FalseClass. nil, the sole instance of NilClass, represents 'no value' and is Ruby's only value besides false that is falsy in a boolean context.
Cricket analogy: Integer handles a career run tally without overflow, however large it grows, while Float tracks a bowler's economy rate like 4.85; a player's name is a mutable String, but their fixed role tag :allrounder is a Symbol; out and not_out behave like true/false; and nil is like a scorecard cell for a match that hasn't been played yet.
age = 30 # Integer
price = 19.99 # Float
name = "Ada" # String (mutable)
status = :active # Symbol (immutable, interned)
is_admin = false # FalseClass
middle_name = nil # NilClass
@instance_var = "set inside an object"
@@shared_count = 0
MAX_RETRIES = 3 # Constant (SCREAMING_SNAKE_CASE by convention)
puts age.class # => Integer
puts status.class # => Symbol
puts 10.frozen? # => true (small integers are always frozen)Unlike JavaScript, Ruby has no separate undefined; the absence of a value is always represented by nil. And unlike Python's None, Ruby's nil is a full object that responds to methods, e.g. nil.to_s returns an empty string rather than raising an error.
In Ruby, only false and nil are falsy — everything else, including 0, "" (empty string), and [] (empty array), is truthy. This trips up developers coming from languages like JavaScript or Python where empty collections and zero are falsy.
- Ruby is dynamically typed: variables reference objects, and the object—not the variable—carries type information.
- Naming prefixes indicate scope: no prefix/underscore is local, @ is instance, @@ is class, $ is global, capitalized is constant.
- Integer has arbitrary precision in Ruby; there is no separate long/bignum type to manage manually.
- Symbols (:name) are immutable and interned, making them efficient for hash keys and fixed sets of values.
- Only
falseandnilare falsy in Ruby; 0, empty strings, and empty arrays are all truthy. - nil is a real object (instance of NilClass) that responds to methods, unlike JavaScript's undefined.
Practice what you learned
1. Which two values are falsy in a Ruby boolean context?
2. What does a double `@@` prefix denote on a Ruby variable?
3. What makes Ruby's Symbol type different from String?
4. What is true about Ruby's Integer type regarding size limits?
5. What does `nil.to_s` return in Ruby?
Was this page helpful?
You May Also Like
Hello World and Ruby Syntax
Write your first Ruby program and learn the fundamental syntax conventions: statements, indentation, method calls, and file structure.
Symbols Explained
What Ruby symbols are, how they differ from strings under the hood, and why they're the idiomatic choice for hash keys, method names, and identifiers.
Operators in Ruby
A tour of Ruby's arithmetic, comparison, logical, assignment, and range operators, including the fact that most operators are actually method calls.
Strings and String Methods
How Ruby represents text with the String class, including literal syntax, interpolation, mutability, encoding, and the most commonly used string methods.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics