Ruby

FILE is the current file's path and $0 (alias $PROGRAM_NAME) names the script Ruby launched. They match only in that launched file, so guarded code runs when executed directly, not when required. ARGV holds the arguments after the script name.

CRuby, also called MRI, is the reference Ruby written in C: it parses source with Prism, compiles it to YARV bytecode and interprets that bytecode. JRuby runs Ruby on the JVM; TruffleRuby runs it on GraalVM.

require searches $LOAD_PATH and runs a file once, returning true then false; require_relative resolves the path from the calling file's directory with the same once-only rule; load runs the named file on every call and returns true.

RUBY_VERSION holds the running version as a String such as "4.0.7". Comparing it with < compares characters, so "3.4.10" < "3.4.9" is true; wrap both sides in Gem::Version, which compares numeric segments.

exit raises SystemExit (default status 0), so ensure clauses and at_exit handlers run and it can be rescued. abort prints its message to $stderr and raises SystemExit with status 1. exit! ends the process at once (default status 1), skipping ensure and at_exit.

Both are conventions Ruby does not enforce. A ? method answers a yes/no question with a truthy or falsy value, not always true or false. A ! method is the more dangerous twin of a same-named method, often mutating or raising.

The parser enforces only the first character: an uppercase initial makes a constant, so class and module names must be capitalised, while a lowercase or underscore initial makes a local or method. snake_case, CamelCase and SCREAMING_SNAKE_CASE are conventions.

7 / 2 is 3 and -7 / 2 is -4, because Integer division floors; 7 / 2.0 is 3.5, because a Float operand gives Float division. Split with 100.divmod(3), which returns [33, 1], and hand out the leftover cent.

puts and print write each argument's to_s (puts adds newlines, print does not) and return nil; p writes inspect plus a newline and returns its argument; pp is p with line-wrapped pretty-printing.

The prefix is the scope: a bare name is a local limited to its current scope, @name belongs to the current object, @@name is shared by a class, its subclasses and instances, and $name is visible to the whole process.

Ruby evaluates the case subject once, then for each when value in order calls when_value === subject; the first truthy result selects that branch. The case returns that branch's last expression, the else branch if nothing matched, or nil without an else.

Ruby's if and unless are expressions: they return the value of the last expression evaluated in the branch that ran, and nil when no branch runs, so the whole conditional can be assigned to a variable or returned from a method.

A modifier puts the condition after the statement: Ruby evaluates the condition first and runs the statement only if it is truthy (if) or falsy (unless). Use it for a one-line body with a short condition, especially guard clauses.

In a Ruby block, next ends only the current call of the block and its argument (nil by default) becomes the block's result; break ends the whole iteration and makes the method that yielded, such as each or map, return immediately.

Ruby's for...in calls each on the collection but opens no new scope, so its loop variable and body locals survive the loop and every closure made inside shares one variable; each gives every iteration a fresh block parameter.

String#+ accepts only a String or an object with to_str, and Integer has no to_str, so Ruby raises TypeError: no implicit conversion of Integer into String. Convert explicitly with 6.to_s, or build the string with interpolation.

Only nil and false are falsy in Ruby. Every other object, including 0, 0.0, "", [], {} and the string "false", is truthy, so test emptiness or zero explicitly with empty?, zero? or nil?.

Float stores IEEE 754 binary doubles, and 0.1, 0.2 and 0.3 have no exact binary form, so the sum is 0.30000000000000004. Compare Floats with a tolerance, or compute with Rational, BigDecimal or integer cents when exactness matters.

A Symbol is an immutable, interned name: every :delivered is the same object with one object_id, while each evaluation of the literal "delivered" builds a new String. Use symbols for identifiers and fixed flags, strings for text.

"12abc".to_i returns 12 and returns 0 when nothing parses. Integer("12abc") raises ArgumentError, and Integer(nil) raises TypeError. Use Integer() or Float() when bad input must be reported; exception: false returns nil instead.

Double-quoted strings process escape sequences such as \n and \t and interpolate #{...}; single-quoted strings do neither, except for ' and \. %q(...) behaves like single quotes, %Q(...) and %(...) like double quotes.

Ruby hands the method a reference to the caller's String object. strip! edits that object in place, so the caller sees it; name = name.strip builds a new string and rebinds only the method's local parameter.

=~ returns the index where the match starts or nil, match returns a MatchData or nil, and match? returns true or false. =~ and match set $~, $1 and the other match variables; match? sets none of them.

String#encode returns a new string whose bytes are converted so the same characters exist in the target encoding. String#force_encoding keeps the bytes and only relabels the receiver. Relabel when the label is wrong; encode when bytes must change.

Plain <<EOS needs its terminator at column 0 and keeps text as written; <<-EOS lets the terminator be indented; <<~EOS also removes the smallest common indentation from the body. Quoting the identifier as 'EOS' turns off interpolation and escapes.

row[-1] is the last element; row[1, 2] and row[1..2] both return a new two-element array starting at index 1. An out-of-range index returns nil, and so does a slice whose start lies beyond the array's size.

Hash#[] returns the hash's default, nil unless one was set, for a missing key. Hash#fetch raises KeyError instead, or returns its second argument or its block's value, and it ignores the hash's default and default proc.

In single-threaded Ruby an Array is both: push with pop is last-in-first-out, push with shift is first-in-first-out. push and unshift return the array; pop and shift return the removed element, or nil when empty.

1..10 includes 10; 1...10 stops before it, and exclude_end? reports which. An endless range like (5..) has a nil end and never stops; a beginless range like (..5) has a nil begin and supports comparisons but not iteration.

Array.new(3, []) stores the same array object at all three indexes, so appending to one row with << changes every row. Array.new(3) { [] } runs the block once per index and builds three distinct rows.

Most iterating methods return an Enumerator when no block is given: an object that remembers the receiver, the method and its arguments and runs them later. You chain it (each_with_index.map), iterate it elsewhere, or pull values with next.

Array#each with a block returns the receiver itself, the very same array object, and throws away whatever the block returns. Assigning its result gives you the original array back, never the block's values; map is the method that collects them.

Call each.with_index(1): Enumerator#with_index takes a starting offset. each_with_index always counts from 0 and forwards its arguments to each, so on an Array each_with_index(1) raises ArgumentError instead of shifting the index.

find (alias detect) returns the first element whose block is truthy and stops there, or nil when none matches. select (alias filter) walks the whole collection and returns an array of every match, empty when none.

map returns a new array with one block result per element, so array results stay nested. flat_map concatenates array results one level into a single flat array, keeps non-array results unchanged, and never flattens deeper, unlike map followed by flatten.

A Ruby method returns the value of the last expression it actually evaluated, so no return keyword is needed. Explicit return earns its place for early exits such as guard clauses; return a, b returns one Array.

The signature declares one required keyword, to:, and two optional keywords, subject: and cc:, that fall back to their defaults. Omitting to: raises ArgumentError (missing keyword: :to); an unlisted bcc: raises ArgumentError (unknown keyword: :bcc).

*messages gathers every leftover positional argument into a new Array, empty when there are none. log(lines) passes one argument, so messages is [lines]; log(*lines) splats the Array into separate arguments first.

String#strip! returns nil when there was no surrounding whitespace to remove, so the next link calls squeeze! on nil. Titles that needed stripping pass; clean ones crash. Chain the non-bang forms, or call each bang method as its own statement.

Both yield the receiver to a block. tap returns the receiver itself, ignoring the block's value, so it suits side effects such as logging mid-chain; then (alias yield_self) returns the block's value, so it transforms or pipes the value onward.

The & marks :email as the block for map. Because a Symbol is not a Proc, Ruby converts it with Symbol#to_proc, a lambda that calls email on each yielded user, so the result equals users.map { |user| user.email }.

A Ruby block can read and reassign every local already assigned above it in the enclosing scope. A name first assigned inside the block is local to that block run, so using it after the block raises NameError.

yield runs the block attached to the current method call, passes its arguments to the block's parameters and evaluates to the block's last value. With no block, yield raises LocalJumpError; block_given? lets the method check first.

An &block parameter captures the call's block as a Proc object, or nil when no block was given. The method can call, store or test it, and forwards it to another method as a block by writing other(&block).

A Ruby lambda closes over the local variable itself, not a copy of its value. When the lambda is created, CRuby moves the method's locals into a heap environment, so the lambda can still read and reassign clicks after the method returns.

attr_reader :temp defines temp, returning @temp; attr_writer :temp defines temp=, assigning @temp; attr_accessor defines both. Since Ruby 3.0 each call returns an Array of the defined method names as Symbols.

Ruby parses a bare target = 22 as assignment to a new local variable, not a call to target=. Writer methods always need a receiver, so inside the class write self.target = 22.

Write def self.build inside the class body, where self is the class, and call it as Shape.build. Instances do not have it; they call self.class.build. Subclasses inherit it, and inside it self is whichever class received the call.

freeze stops changes to that one object's own state and returns the object; later writes raise FrozenError. It is shallow: objects it references stay mutable. Freezing a constant's value also does not stop the constant being reassigned, which only warns.

equal? asks whether both are the same object; == compares values and is overridden per class; eql? is the stricter hash-key equality. Numeric == compares across types, so 1 == 1.0, but eql? requires the same class.

include Auditable makes the module's instance methods available on every Product instance. extend Auditable inside the class adds them to the Product class object itself, so they become class methods like Product.audited_fields, and instances do not get them.

Module#ancestors returns the ordered list of classes and modules Ruby searches for an instance method: the class, its mixed-in modules, then the superclass chain down to BasicObject. Calling job.log runs the first log found walking that list.

A module is a container for constants, so Ingest::JSON::Parser and Ingest::CSV::Parser can coexist. :: walks into a module; a leading ::JSON starts the lookup at Object, the top level, bypassing a nested JSON that shadows it.

include only gives the host's instances the module's methods. The module's included hook calls base.extend(ClassMethods), mixing a nested module into the class itself, so its methods become class methods such as configuration macros.

include places a module after the class in method lookup, so the class's own save wins. prepend places it before the class, so AuditSave#save runs first and its super calls Product#save, which makes wrapping possible.

A bare rescue, like rescue => e, catches StandardError and its subclasses only. Classes outside that branch pass through: SignalException and its subclass Interrupt, SystemExit, ScriptError (LoadError, SyntaxError, NotImplementedError), NoMemoryError and SystemStackError.

raise "msg" raises a RuntimeError; raise Klass, "msg" builds the error through Klass.exception, which calls new; raise an_instance raises that object. A bare raise inside rescue re-raises the current exception with its original backtrace.

The body runs; on an exception the first matching rescue runs, otherwise else runs; ensure always runs last. The expression's value comes from the rescue, from else, or from the body when there is no else; ensure's value is discarded.

By default Ruby turns Ctrl-C into an Interrupt and TERM into a SignalException raised in the main thread, and exit raises SystemExit. All inherit from Exception, so rescue Exception catches them, logs them and the loop continues. Rescue StandardError instead.

Subclass StandardError, define initialize(msg = "default text", field: nil), call super(msg) and store the field with attr_reader. raise Klass, "msg" then passes the message to new, while raise Klass.new(field: 30) sets the field.

Kernel#methods lists every public and protected method the object responds to, including everything inherited from Object, Kernel and BasicObject. Subtract Object.instance_methods, grep for a pattern, or ask the class for instance_methods(false).

Writing class String again reopens the existing String class instead of creating one, so the def adds a method to String itself. Every string in the process, including older strings and strings inside gems, can then call it.

Pass the name as a Symbol or String to send or public_send, with any arguments after it. send calls the method even if it is private or protected; public_send calls only public methods and raises NoMethodError otherwise.

def gateway.charge defines a singleton method: it is stored in gateway's own singleton class, which Ruby checks before Gateway, so only that object uses it. Every other Gateway instance still finds Gateway#charge.

def takes a literal name and starts a fresh local scope. define_method takes the name as a Symbol or String value and uses a block as the body, so the body is a closure that sees the defining scope's local variables.

File.open with a block yields the File, closes it when the block exits, even through an exception, and returns the block's value. Without a block it returns the File, and the caller must close it or leak the descriptor.

JSON.parse turns a JSON object into a Hash whose keys are Strings, arrays into Arrays and null into nil. data[:name] looks up a Symbol key that does not exist, so it returns nil; symbolize_names: true makes the keys Symbols.

Relative paths resolve against the process's current working directory, not the source file's location. dir returns the absolute directory of the current file, so File.expand_path("config/settings.yml", dir) or File.join(dir, "config", "settings.yml") works from anywhere.

$stdout is a global variable holding the current standard output stream, and Kernel#puts writes to it; STDOUT is a constant holding the original stream. Redirect by reassigning $stdout; STDOUT stays as the way back.

Dir.glob("uploads/**/*_thumb.{jpg,png}") walks every subdirectory and returns matching paths, sorted by default since Ruby 3.0. It skips hidden entries unless File::FNM_DOTMATCH is passed, and returns an empty array when nothing matches.

Net::HTTP.get returns only the response body as a String, whatever the status, so a 404 page arrives without an exception. Net::HTTP.get_response returns a Net::HTTPResponse subclass whose class and String code carry the status.

system runs a command, waits, and returns true, false or nil; backticks and %x run it, wait, and return its standard output as a String; exec replaces the Ruby process; spawn starts it and returns the pid without waiting.

Time.now returns the current instant in the local zone; Time.at(seconds) builds a Time from Unix epoch seconds and to_i converts back. strftime formats with directives such as %Y-%m-%d %H:%M, and iso8601 returns a machine-readable 2026-05-28T20:26:40Z string.

After extend Forwardable, def_delegators :@user, :name, :email defines real instance methods that call the same methods on @user, and def_delegator :@user, :name, :display_name forwards one method under a new name. Unlisted methods stay unavailable.

SimpleDelegator.new(user) forwards every public method it does not define itself to user. A subclass adds or overrides presentation methods; getobj returns the wrapped user and setobj replaces it with another object.

Mutex#synchronize locks the mutex, runs the block, unlocks it even if the block raises, and returns the block's value. Manual lock/unlock can leave the mutex locked forever when an exception skips the unlock.

The GVL (Global VM Lock) lets only one thread per Ractor execute Ruby code at a time. Threads speed up I/O-bound work, because blocking I/O and sleep release the lock, but not CPU-bound Ruby code.

Thread.new starts a block in a new thread and returns the Thread. join waits and returns that thread, or nil when its limit expires; value returns the block's result or re-raises its exception. Unjoined threads die when main exits.

A zombie is a child that has exited but whose status the parent never collected. Process.wait(pid) blocks and reaps it, Process.wait(pid, Process::WNOHANG) reaps only if it already exited, and Process.detach(pid) starts a thread that reaps it for you.

@hits += 1 is a separate read, add and write. The GVL lets one thread run Ruby at a time but does not keep a thread running across those steps, so a switch between the read and the write loses an increment.

GC.start forces a garbage collection, a full blocking one by default; GC.disable stops automatic collection until GC.enable. Ruby already collects when it needs to, so forcing it wastes CPU and disabling it lets memory grow without limit.

YJIT is CRuby's built-in just-in-time compiler: once enabled, it turns frequently run Ruby methods from YARV bytecode into native machine code, falling back to the interpreter when needed. It is off by default and costs memory and compile time.

Benchmark.measure returns a Benchmark::Tms of CPU and real time, Benchmark.realtime returns elapsed seconds, bm prints a labelled table and bmbm adds a rehearsal pass. Since Ruby 4.0 benchmark is a bundled gem, so Bundler apps must list it.

Stop building intermediate collections and per-iteration temporaries: aggregate with block forms such as sum, count and filter_map, append to strings with << rather than +=, and mutate in place where safe. Prove it with the GC.stat(:total_allocated_objects) delta before and after.

Enable YJIT with the --yjit flag, the RUBY_YJIT_ENABLE=1 environment variable, or RubyVM::YJIT.enable from Ruby code. Prove it with RubyVM::YJIT.enabled? returning true or +YJIT appearing in RUBY_DESCRIPTION, the string ruby -v prints.

SecureRandom.urlsafe_base64(32): URL-safe characters, no padding, bytes from the operating system's secure source. The argument counts random bytes, not characters, so 32 bytes become 43 characters. rand and Random produce predictable output.

Each of them parses its string argument as Ruby source and runs it with the process's full privileges, so request data that shapes the string can run any code. Replace them with lookup tables, real parsers and block-based metaprogramming.

BCrypt::Password.create(password) returns a 60-character string holding version, cost, a random salt and the hash. To check, wrap the stored string with BCrypt::Password.new and call == with the candidate, which rehashes it with the stored salt and cost.

Ruby 4.0 removed process creation from Kernel#open and the IO class methods, so "|cmd" is now just a file name. A request path can still escape its directory, and URI.open still fetches any URL or reads a local file.

Compute OpenSSL::HMAC.hexdigest("SHA256", secret, raw_body), digest name first, then key, then data, and compare it with the received signature using OpenSSL.secure_compare, never ==. Sign the raw body bytes, before any JSON parsing.

RDoc documents a class, module, method, constant or attribute with the comment block directly above its definition. That comment is RDoc markup by default (bold, italic, +code+); a # :markup: markdown line switches the file to Markdown.

binding.irb pauses the program at that line and opens an IRB prompt inside that scope, with its locals, self and instance variables live. exit (or Ctrl-D) resumes the program from that line; exit! ends the process.

A Rakefile is Ruby: task release: %w[build tag] do ... end runs its prerequisites first, each at most once per run. desc describes the next task, rake -T lists only described tasks, and a bare rake runs the task named default.

The debug gem, bundled with Ruby since 3.1, defines binding.break (aliases binding.b and debugger) once require "debug" has started a session; execution stops there at an (rdbg) prompt. rdbg runs a script or, with -c, a command under the debugger without editing code.

YARD reads @tags from the comment above a method: @param name [Type] for each positional or keyword argument, @return [Type] for the result, @raise [ErrorClass] for exceptions and @example for indented usage code. yard doc renders them as structured HTML.