JavaScript.CodeCompared.To/Ruby

Ruby has no let, const, or var. Variables are created on first assignment. All local variables are mutable — Ruby has no equivalent of const for local variables (constants are a separate concept using UPPER_CASE).

Ruby constants start with an uppercase letter (SCREAMING_SNAKE_CASE by convention). Unlike JavaScript's const, Ruby constants can be reassigned — Ruby issues a warning but does not raise an error. For true immutability, freeze the value: LIMIT = 100.freeze.

Ruby calls this "parallel assignment" or "multiple assignment." The * splat captures remaining elements — equivalent to JavaScript's rest operator .... The splat can appear anywhere in the pattern, not just at the end.

Ruby has only nil — there is no undefined. Accessing an uninitialized local variable raises NameError immediately. nil is an object (NilClass) with its own methods, including nil?, to_a (returns []), and to_s (returns "").

In Ruby, only false and nil are falsy. Everything else — 0, "", [], {} — is truthy. This is a frequent source of bugs for developers coming from JavaScript, where 0, "", null, undefined, and NaN are all falsy.

Ruby uses is_a? (alias: kind_of?) to check types. There is no typeof operator. Every Ruby value is an object with a .class method — 42.class returns Integer, nil.class returns NilClass.

In Ruby, .class returns the actual class object. Every value is an instance of a class: arrays are Array, plain hashes are Hash, and integers are Integer. Unlike JavaScript, there is no distinction between primitive types and objects — everything in Ruby is an object.

Ruby uses method-based conversion: to_i (to integer), to_f (to float), to_s (to string), to_a (to array). There is no implicit coercion between types — "3" + 3 raises TypeError rather than producing "33" or 6.

Ruby uses "..." with #{} for interpolation. Single-quoted strings ('...') do not interpolate — 'Hello, #{name}' is literal text. In Ruby 4.0, string literals are frozen by default; use +"mutable" or String.new("mutable") to get a mutable string.

Ruby string methods use snake_case rather than camelCase: upcase/downcase instead of toUpperCase/toLowerCase, include? instead of includes. Methods that return a boolean conventionally end with ?.

Ruby's string[start, length] takes a start index and a length (not an end index), unlike JavaScript's slice(start, end). string[range] with a Range object also works. Negative indices count from the end in both languages.

Ruby's <<~HEREDOC (squiggly heredoc) strips leading whitespace, so the content can be indented with the surrounding code. The closing delimiter can be any word. Ruby also supports regular multiline strings using "...", but heredocs are idiomatic for longer text.

Ruby's split and join work identically to JavaScript's — these are among the smoothest transitions between the two languages. split with no arguments splits on whitespace and removes empty strings, like Python's default split behavior.

Ruby symbols (:name) are immutable, interned objects — :active always refers to the exact same object in memory, making them fast to compare. They are lighter than strings and widely used as hash keys, method names, and identifiers. Unlike JavaScript's Symbol(), Ruby symbols with the same name are identical: :foo.equal?(:foo) is always true.

Ruby's { key: value } hash syntax creates symbol keys (e.g., :name), but accessing them requires bracket notation: hash[:name] — not hash.name. This surprises JavaScript developers who expect dot-access on plain hashes.

&:method_name converts a symbol to a proc that calls that method on each element — shorthand for { |item| item.method_name }. It is Ruby's most concise callback pattern and works with any method that takes no arguments: map(&:to_s), select(&:even?), reject(&:nil?).

Ruby arrays share the same literal syntax as JavaScript. In addition to index access (numbers[0]), Ruby provides first and last as named methods — these read more clearly when the intent is to access the beginning or end of a collection.

Ruby's push and pop work identically to JavaScript's. Ruby also uses << as an alias for push — you will see items << 4 frequently in Ruby code. shift and unshift operate on the front of the array, just as in JavaScript.

flatten removes all nesting (pass a depth integer to limit). compact removes nil values — the Ruby equivalent of filter(v => v != null). Note that compact only removes nil, not false or 0, since those are truthy in Ruby.

Ruby's array[start, length] takes a length argument (not an end index). array[range] with a Range object also works — the endless range n.. captures from index n to the end. JavaScript's slice(1, 3) (indices 1 and 2) maps to Ruby's [1, 2] (start 1, length 2).

Ruby hashes look like JavaScript objects but require bracket notation for access: hash[:key]. There is no dot-access on plain hashes. The { key: value } shorthand creates symbol keys — use { "key" => value } if you need string keys instead.

fetch raises KeyError when the key is missing (unlike [], which returns nil). Passing a second argument provides a default — similar to JavaScript's nullish coalescing ??. You can also pass a block: fetch(:key) { |k| compute_default(k) }.

merge returns a new hash — when keys overlap, the argument hash wins, just like JavaScript's spread operator. merge! (or update) modifies the receiver in place. Ruby hashes maintain insertion order (since Ruby 1.9), matching JavaScript object behavior.

Ruby hashes have a built-in each that yields key-value pairs directly — no need for Object.entries. The block receives two parameters: the key and the value. map, select, reject, and other Enumerable methods also work on hashes.

Ruby has a built-in Range type: 1..10 is inclusive (includes 10), and 1...10 is exclusive (excludes 10). Ranges work on any comparable type: 'a'..'z', Date.today..Date.today + 7. They are lazy — converting to an array with to_a is only needed when you want an actual array.

Range#step iterates with a custom increment. It returns an Enumerator (lazy), so chaining to_a, map, or each on it is normal. For floating-point steps, use (0.0..1.0).step(0.1).

Ruby's case/when uses === for matching, and Range#=== checks membership. This makes range-based conditionals extremely readable. The exclusive range 80...90 ensures score 90 matches the "A" arm above, not "B".

unless is the logical inverse of if — equivalent to if !condition. It reads more naturally when the condition is already negative. Similarly, until is the inverse of while. Avoid double-negatives: prefer unless active over if !active.

In Ruby, if, unless, case, and begin are all expressions — they return the last evaluated value. Assigning an if to a variable is idiomatic Ruby, though the ternary operator ? : is also available for the same pattern.

Ruby's case/when does not fall through between cases — no break is needed. when accepts multiple comma-separated values, ranges, and regular expressions. The whole expression returns a value, so assigning it directly is idiomatic.

Ruby allows if and unless as trailing modifiers: return "no data" if data.nil?. This reads as plain English and is idiomatic for guard clauses. The last expression in a method is its return value — no return keyword needed for the happy path.

Ruby methods return the last evaluated expression — no return keyword is needed for the normal return path (use it only for early returns). Method names use snake_case by convention. Parentheses on method calls are optional when unambiguous.

Ruby default parameter syntax is identical to JavaScript's. The default can reference earlier parameters or any expression, including method calls. Unlike JavaScript, Ruby evaluates the default expression fresh each time the method is called.

Ruby has first-class keyword arguments declared in the method signature with :. Required keywords (no default) raise ArgumentError if omitted. Callers must use the keyword name — create_user(name: "Alice") — making calls self-documenting without relying on parameter order.

Ruby's *args (splat) is the equivalent of JavaScript's ...args (rest). Inside the method, numbers is an ordinary array. Ruby also has **kwargs for capturing keyword arguments into a hash, and &block for capturing a passed block as a Proc.

Ruby method names can end with ? (predicates that return boolean, e.g. empty?, nil?) or ! (methods that modify in place or raise instead of returning nil, e.g. sort!, map!). This is a naming convention — both characters are valid in method names.

A Ruby block is an anonymous chunk of code passed to a method, delimited by { |params| ... } (single-line convention) or do |params| ... end (multi-line convention). Unlike JavaScript callbacks, blocks are not objects by default — they are passed implicitly and received by the method via yield.

yield calls the block that was passed to the method. If no block is given, yield raises LocalJumpError. Use block_given? to check whether a block was passed before yielding. yield can pass arguments to the block: yield value passes value to the block parameter.

Adding &block_name as the last parameter captures the block as a Proc object, which can be stored, passed to other methods, or called with .call(). This makes the block explicit and composable. &: also converts a Proc back to a block when passing it to another method.

Ruby's map (also aliased as collect) works identically to JavaScript's. Both return a new array. map! modifies the array in place. Ruby's Enumerable module provides map and dozens of other iteration methods to any class that implements each.

Ruby's select (also filter) keeps elements where the block is truthy. reject is its complement — it removes elements where the block is truthy, equivalent to filter(x => !condition). Having both makes intent clearer: choose the one that reads more naturally for your condition.

Ruby's reduce (also inject) puts the accumulator first in the block parameters: |total, element|. With a symbol argument, reduce(:+) is shorthand for reduce { |sum, n| sum + n }. If no initial value is given, the first element is used as the seed.

Both each_with_index and JavaScript's forEach yield the element first and the index second. Ruby also provides each.with_index(start) to offset the index counter, and each_with_object for accumulating into a mutable object while iterating.

each_with_object passes an accumulator as the second block parameter and always returns it — you do not need to return it explicitly from the block. It is cleaner than reduce when building a mutable object. Hash.new { |h, k| h[k] = [] } creates a hash with a default value computed by a block.

sort_by extracts a sort key from each element — cleaner and faster than sort { |a, b| a.length <=> b.length }. The <=> spaceship operator returns -1, 0, or 1 and is the basis of all Ruby sorting. Ruby's sort does not mutate in place — use sort! for that.

flat_map (also collect_concat) maps then flattens one level. It is equivalent to .map { ... }.flatten(1) but more efficient. Use it whenever each element maps to an array and you want a single flat result.

A Proc is a first-class function object. proc { |x| ... } creates a block-wrapper that can be stored and passed. Procs have "loose" argument handling — extra arguments are ignored and missing ones become nil. return inside a proc returns from the enclosing method, not just the proc.

-> (stabby lambda) is the modern lambda syntax. Lambdas enforce argument count — passing the wrong number raises ArgumentError, unlike proc. return inside a lambda returns from the lambda only, not the enclosing method. Lambdas are the closer Ruby equivalent to JavaScript arrow functions.

method(:name) returns a Method object for a named method. Combined with &, it converts the method to a block — allowing named methods to be passed where blocks are expected. The one-liner method syntax def double(x) = x * 2 (Ruby 3.0+) is a concise way to define simple methods.

Ruby uses initialize instead of constructor, and new is a class method rather than a keyword. Instance variables are prefixed with @. There is no this — you access the current object's state through @instance_vars and call its methods by name.

attr_accessor :name generates both a getter (name) and a setter (name=). attr_reader generates only a getter; attr_writer only a setter. These replace explicit get name() / set name(v) definitions and are idiomatic Ruby.

Ruby uses < for single inheritance. super calls the parent method — bare super forwards all arguments; super(args) passes specific ones; super() passes no arguments. Ruby does not support multiple inheritance of classes — use modules (mixins) instead.

Ruby uses def self.method_name to define class methods (equivalent to JavaScript's static). Class variables (@@name) are shared across the class and all subclasses — many Rubyists prefer class-level instance variables (@count defined in a class method) to avoid this surprising inheritance behavior.

Ruby modules serve as namespaces (grouping related methods and constants under a common name) and as mixins (sharing behavior across classes). They cannot be instantiated — Module.new is possible but Auth.new raises NoMethodError.

include brings a module's instance methods into a class. The module's methods look up self at runtime, so they can call methods defined on the including class — here, greet calls name, which is provided by attr_reader. A class can include multiple modules, making this Ruby's answer to multiple inheritance.

Including Comparable and defining <=> (spaceship operator) gives the class <, >, <=, >=, between?, clamp, and sort support automatically. Enumerable similarly grants map, select, reduce, etc. to any class that defines each.

Ruby's rescue catches exceptions. You specify the exception class after rescue (like Java's typed catch) — rescuing without a class catches StandardError and its subclasses. Multiple rescue clauses can handle different exception types, matched top-to-bottom.

ensure runs regardless of whether an exception was raised or rescued — equivalent to JavaScript's finally. It is commonly used for cleanup: closing files, releasing locks, or resetting state. The return value of ensure is discarded; it does not affect the value of the whole begin expression.

Ruby uses raise (or its alias fail) to throw exceptions — raise ExceptionClass, "message". Using a specific exception class lets callers rescue only the errors they expect. raise with no arguments inside a rescue block re-raises the current exception.

Custom exception classes inherit from StandardError (not Exception, which also catches signals and fatal errors). A one-liner class body is idiomatic when no custom behavior is needed — StandardError provides message and backtrace automatically.

Ruby's case/in (introduced in Ruby 3.0) matches and deconstructs in one step. Integer => result both checks the type and binds the value. Hash patterns match by key presence — extra keys in the hash are allowed by default. Unmatched patterns raise NoMatchingPatternError.

Array patterns in case/in deconstruct positionally. Unlike regular destructuring assignment, array patterns can include type checks: [Integer => x, Integer => y] matches and validates. Patterns can also be nested for deep deconstruction.

The find pattern [*, target_pattern, *] searches for a matching element anywhere in an array — like Array#find but integrated into pattern matching with deconstruction and type checking. The * wildcards capture any number of elements before and after the match.