PHP.CodeCompared.To/Ruby

Ruby has no <?php opening tag — every file is Ruby from the first byte, and top-level code runs the moment the file loads. puts writes its argument followed by a newline, so unlike PHP's echo you do not append \n yourself. There are no semicolons; a newline ends a statement.

Both languages are interpreted and run a file directly — no compile step. Ruby comments use # rather than //. Ruby does not run inside a web server by default the way PHP historically did; it is a general-purpose scripting language, and web frameworks such as Rails or Sinatra sit on top of it explicitly.

Ruby splits PHP's echo into two: print writes exactly what you give it, while puts adds a trailing newline (and one per array element). Ruby's p is the analogue of var_dump for quick debugging — it prints the inspect form and returns its argument, so you can wrap any expression in p without changing it.

Ruby variables have no $ sigil — the bare name is the variable. The sigil-free style means a name like name reads as a plain word, but it also means Ruby uses other rules (capitalization) to distinguish constants and the leading character (@, @@, $) to mark instance, class, and global variables.

In Ruby every value is an object, so you ask the value itself for its type with .class rather than calling a global gettype(). PHP's NULL is Ruby's nil, and notice that even true is a full object (an instance of TrueClass), not a primitive.

This is the deepest difference: PHP scalars are primitives acted on by global functions (strlen, abs), while in Ruby 5, "hello", and even nil are objects that respond to messages. There is no global function namespace to memorize — you discover behavior by asking an object what it can do.

Ruby uses explicit to_i, to_s, and to_f methods instead of cast syntax like (int). Crucially, Ruby never converts implicitly: "42" + 8 raises a TypeError rather than silently coercing, so you convert deliberately. This is the opposite of PHP's eager juggling and eliminates a whole class of surprises.

Ruby has no const keyword or define() function: any identifier that begins with a capital letter is a constant. Reassigning one only prints a warning rather than raising, so the convention is enforced socially, not strictly — but the capitalization rule means class and module names are constants too.

Ruby interpolates with #{ ... }, and any expression fits inside — there is no difference between a bare variable and a computed value, so you never drop out to concatenation the way PHP does with . ($age + 1) .. Interpolation works only in double-quoted strings; single-quoted strings are literal in both languages.

Every PHP string function becomes a method you call on the string. The names are shorter and chainable: text.upcase.reverse reads left to right, whereas strrev(strtoupper($text)) reads inside-out. Note sub replaces the first match and gsub replaces all — PHP's str_replace always replaces all.

Ruby's split and join replace explode and implode, and the argument order feels more natural — the separator is the argument to a method on the thing being split or joined. With no argument, split divides on whitespace, a common convenience PHP lacks.

Both languages have heredocs. Ruby's squiggly heredoc <<~ strips the leading indentation of the least-indented line, so you can indent the heredoc to match surrounding code and still get a flush-left result — handy for keeping templates readable inside a method body.

This is the single biggest mental shift. PHP's array is one type that is both a list and a dictionary; Ruby separates them into Array (integer-indexed, contiguous) and Hash (key-value). The append operator is << rather than [], and count/length/size are interchangeable.

A Ruby Hash uses the same => "hash rocket" arrow that PHP borrowed, but it is a distinct type from Array and wraps in { }. Iteration is a method call (each) taking a block, rather than a foreach statement — the block parameters |name, age| destructure each pair automatically.

Idiomatic Ruby keys hashes with symbols (:name) rather than strings. A symbol is an immutable, interned identifier — cheaper to compare and store than a string, and the name: shorthand makes hash literals read like named arguments. Symbols have no PHP equivalent; think of them as lightweight, reusable string constants.

Ruby's map, select, and reduce are methods on the array, so they chain naturally and put the collection first — no more remembering whether the callback or the array comes first in array_map vs array_filter. The { |x| ... } block is Ruby's closure syntax, covered in the Closures section.

Ruby destructures on the left of = without brackets — x, y = point just works. The splat * captures the rest (first, *others = list), and a bare _ conventionally names an ignored slot. This parallel assignment also powers the multiple-return-value idiom shown later.

Ruby's Range is a first-class lazy object written 1..5 (inclusive) or 1...5 (exclusive of the end), not just a function that materializes an array. You can iterate a range directly, use it in a case, or call to_a to expand it — far more flexible than PHP's eager range().

Ruby drops the parentheses around the condition and the braces around the body, closing the whole block with end. The keyword is elsif (one word, no second e) rather than PHP's elseif. There is no colon-style alternative syntax; end is the one and only block terminator.

Ruby lets a condition trail the statement it guards: puts "..." if balance < 0. This statement modifier form has no PHP equivalent and is idiomatic for short guards. Ruby also adds unless (the negation of if), so you rarely write if (!condition).

Ruby's case is the counterpart to PHP 8's match: it is an expression that returns a value, has no fall-through, and accepts several values per branch (when 2, 3). But case compares with the === operator, so a when can be a class, a range, or a regex — not just an equal value, as the next example shows.

Because Ruby's when uses ===, a range like 80.. matches any score it covers — no match (true) trick needed. The same mechanism lets you switch on when String, when Integer, or when /regex/, making case dramatically more expressive than PHP's equality-only match.

Ruby almost never uses a C-style for loop. You send an iteration message to an object: 3.times, (1..10).each, or array.each. The block receives each value. This object-sends-its-own-iteration model is why explicit index counters are rare in idiomatic Ruby.

Memorize this one difference and you avoid a category of bugs: in Ruby only nil and false are falsy. 0, "", "0", and [] are all truthy, unlike PHP. So if $count to test "is it nonzero" is a PHP habit that breaks in Ruby — write if count > 0 instead.

Ruby uses def ... end and has no type annotations on parameters or return. The biggest surprise: the last expression is returned automatically, so an explicit return is usually omitted. return exists for early exits, but a one-expression method needs none.

Ruby distinguishes positional parameters from keyword parameters with a trailing colon (port:). PHP 8 lets you pass any argument by name; Ruby requires the method to opt in by declaring the parameter as a keyword. The payoff is the same readable call site, connect("db.local", ssl: true), with order-independence guaranteed.

Ruby's splat operator is a single * rather than PHP's ..., used both to collect arguments in a definition (*numbers) and to spread an array at a call site (sum(*values)). A double splat **options does the same for keyword arguments, mirroring PHP's ...$named spread of associative arrays.

Ruby has no special tuple type either, but returning an array and destructuring it on assignment (low, high = ...) is so seamless it feels like true multiple return. Note the method name min_max uses snake_case — the universal Ruby convention for methods and variables, versus PHP's common camelCase.

Ruby permits ? and ! as the final character of a method name, a piece of syntax PHP lacks. By convention ? marks a predicate that returns a boolean (even?, empty?, nil?) and ! marks a "dangerous" variant that mutates the receiver or raises (sort!, save!). The names document intent.

Ruby's signature feature is the block: an anonymous function written with do...end (or { }) and passed after the method's parentheses, not inside them. It is not an argument in the list — it is a dedicated slot every method can receive. This is why each, map, and times read so cleanly.

A block has two interchangeable forms. The convention: { } for a single-line block that returns a value (like map), and do...end for multi-line blocks run for their side effects (like each). PHP's arrow function fn($n) => ... is closest to the brace form, but blocks are not objects unless you ask for them.

Ruby closures capture surrounding variables automatically — there is no use ($factor) clause to maintain. The ->( ) { } syntax (a "stabby lambda") creates a callable Proc object; invoke it with .call, the shorthand .( ), or [ ]. Closing over the live variable also means changes are visible, unlike PHP's capture-by-value default.

Any Ruby method can accept a block implicitly and invoke it with the yield keyword — you do not declare a callable parameter. This makes "take a block and call it" the lightest pattern in the language, and block_given? lets a method behave differently when no block is passed.

Ruby's &:upcase is the everyday counterpart to PHP 8.1's strtoupper(...): the & converts a symbol naming a method into a block that calls that method on each element. It is the most common way to write point-free transformations like map(&:to_i) or select(&:even?).

The constructor is named initialize, instance variables carry an @ sigil (@name), and you call methods with a dot (greeter.greet) rather than ->. You instantiate with Greeter.new — new is a method on the class object, not a keyword. There is no public keyword; methods are public by default.

Ruby instance variables are always private — there is no public field. To expose one you generate accessor methods with attr_accessor (read + write), attr_reader (read only), or attr_writer. So point.x = 10 is never a direct field poke; it always calls an x= method, which means you can later swap in validation without changing callers.

Ruby spells extends as < (class Dog < Animal) and uses super to call the parent — bare super even forwards the same arguments automatically. The example also shows Ruby 4.0's one-line method syntax def speak = "...", a concise form for single-expression methods.

A class method is defined with def self.square and called with a dot, just like an instance method — Ruby does not use :: to call methods (that is for constants and nested classes). Inside the class, self refers to the class object itself, since classes are ordinary objects in Ruby too.

Ruby's to_s is the analogue of __toString and is called automatically by puts and interpolation. A companion method, inspect, provides the debugging representation that p prints — splitting the "human" and "developer" views into two hooks rather than PHP's single one.

Struct.new generates a class with accessors, a constructor, ==, and more from a list of attribute names — perfect for the lightweight data holders you would write as a small readonly class in PHP. The optional block adds methods. For an immutable variant, Ruby 3.2+ offers Data.define.

Ruby's module mixed in with include is the direct counterpart to a PHP trait used with use. Both inject shared methods into a class. The difference: a Ruby module is a real object that also forms a node in the method-lookup chain, so super works across mixins — they compose, rather than being flattened in at compile time.

A Ruby module doubles as a namespace: nest classes inside it and reference them with :: (Billing::Invoice). Unlike PHP's namespace declaration, which applies to a whole file, Ruby modules are ordinary module ... end blocks you can reopen, nest, and assign — the same construct used for mixins.

Define one method — <=> (the spaceship, which PHP also has) — and include Comparable hands you <, <=, ==, between?, clamp, and sortability for free. Enumerable works the same way: define each and you inherit map, select, min, and dozens more. This "define one method, get many" pattern has no PHP analogue.

Ruby spells throw as raise, catch as rescue, and finally as ensure. (Ruby does have throw/catch, but those are a non-error control-flow mechanism — do not reach for them here.) The error message comes from .message rather than ->getMessage(), and the rescued exception is bound with => error.

Custom exceptions subclass StandardError, not the very top Exception — a bare rescue catches StandardError and its descendants, deliberately leaving system-level signals like Interrupt alone. This mirrors PHP's distinction between Exception and Error, but the rule of thumb "inherit from StandardError" is firmer in Ruby.

Two Ruby tools have no PHP equivalent. The inline expr rescue fallback modifier evaluates to the fallback when expr raises — a compact default-on-error idiom. And inside a begin block, retry jumps back to the top to attempt the operation again, ideal for transient failures without a manual loop.

This is a place where PHP is genuinely ahead: PHP 8.1 has a real enum type with cases, backing values, and ::from(), whereas Ruby has no native enum. The common substitutes are a module of frozen constants (shown here) or symbols. Libraries and Rails add richer enum behavior, but the language core leaves it to convention.

In everyday Ruby, a symbol like :admin fills the role of a lightweight enum value. Symbols are interned, compare by identity, and read cleanly in case branches and as hash keys — so where PHP reaches for an enum case or a string constant, idiomatic Ruby often just passes a symbol.

PHP enums can carry methods directly on each case — a clean piece of object-orientation Ruby cannot match without a full class. To attach behavior to symbol-style values in Ruby, you typically pair them with a lookup hash or a module method, as here, or graduate to a proper class when the behavior grows.

Ruby's case/in (pattern matching, since 3.0) destructures and tests shape in one step — something PHP has no equivalent for. The pattern { status: "ok", data: [_, *rest] } matches a hash with that exact status whose data is an array, binding the tail to rest. A bare message: binds that key to a local variable of the same name.

Patterns can match by class (Integer => number binds and type-checks at once) and add a guard with a trailing if. This folds PHP's chain of is_int/is_string checks plus binding into a single readable structure, with the matched value already destructured into a named local.

Ruby's || covers most of PHP's ??, but watch the truthiness difference: || falls through on any falsy value, and since nil/false are the only falsy ones, 0 survives (good) but false would not. For exact "is the key present" semantics like ??, use Hash#fetch with a default — it only supplies the default when the key is genuinely absent.

Ruby's safe-navigation operator &. is the twin of PHP's nullsafe ?->: it calls the method only when the receiver is non-nil, otherwise short-circuits to nil. Combine it with || for a fallback, exactly as you combine ?-> with ?? in PHP.

After require "json", every object gains to_json and you parse with JSON.parse. By default JSON.parse returns string keys (like json_decode($json, true)); pass symbolize_names: true to get symbol keys instead. Ruby groups such utilities into requirable standard-library modules rather than PHP's always-loaded global functions.

Ruby's sort returns a new array and leaves the original untouched (the mutating version is sort!) — the opposite of PHP's in-place sort. For sorting by a derived key, sort_by { |x| ... } is clearer and faster than writing a spaceship comparator, since it computes each key once.

Because every collection operation returns a collection, Ruby code reads as a top-to-bottom pipeline — select then sort then first(3) — instead of PHP's inside-out nesting of array_slice(array_values(array_filter(...))). This fluent style is one of the most visible day-to-day differences when reading Ruby.

A genuine trap. PHP copies arrays on assignment, so $copy is independent. Ruby variables hold references: copy = original makes both names point at the same array, so mutating one mutates both. When you need an independent copy, call .dup (shallow) or Marshal/deep_dup for nested structures.

Ruby has no loose ==: it compares values without coercion, so the PHP juggling surprises ("1" == 1, null == false) simply do not happen. Ruby's three levels are == (value), eql? (value and type, used by hashes), and equal? (object identity). There is no operator that behaves like PHP's loose ==.

Beware: 7 / 2 is 3 in Ruby, not 3.5 — dividing two integers yields an integer, the reverse of PHP's automatic float promotion. Make an operand a float (7.0 / 2) to get a real quotient. Ruby also floors toward negative infinity, so -7 / 2 is -4, where PHP's intdiv truncates toward zero to give -3.

Ruby makes parentheses optional on method calls, so array.length looks like a field access but is a real method call (there are no public fields, remember). This uniformity is powerful but can surprise: puts foo calls foo if it is a method. When passing arguments, parentheses are still wise for clarity even though the language permits omitting them.

In Ruby 4.0 string literals are frozen (immutable), so the in-place tricks PHP allows — $message[0] = "J" or .= appending to a literal — raise a FrozenError. Reassignment with += is fine because it builds a new string. When you truly need a mutable buffer, create one with String.new and append with <<.

Ruby treats a newline as a statement terminator, so you cannot break a line wherever you like. A line that ends with a binary operator (or an open bracket, or a comma) is understood as continuing; a "complete-looking" line is not. The safe place to break a method chain is before the dot, putting .method at the start of the next line.