Ruby MCQ

Explanation

puts outputs its argument followed by a newline; print does not automatically add a newline.

Explanation

The "#" symbol starts a single-line comment in Ruby.

Explanation

Methods in Ruby are defined using "def methodname ... end".

Explanation

Ruby variables are dynamically typed and assigned simply with "=", without any declaration keyword.

Explanation

A colon prefix denotes a Symbol, an immutable, interned identifier commonly used as hash keys or method names.

Explanation

Arrays in Ruby are created using square brackets containing comma-separated elements.

Explanation

Both size and length (aliases of each other) return the number of elements in an array; count also works similarly.

Explanation

each iterates over a collection, calling the given block once per element without modifying the collection.

Explanation

Ruby hashes can be created with the "key => value" syntax or, for symbol keys, the shorthand "key: value" syntax.

Explanation

"if condition ... end" is the standard conditional statement syntax in Ruby.

Explanation

nil is Ruby's representation of "nothing" or "no value", distinct from false, 0, or an empty string.

Explanation

Classes are defined with "class ClassName ... end", with class names conventionally in CamelCase.

Explanation

"self" refers to the current object (instance) within instance methods, similar to "this" in other languages.

Explanation

Instance variables are prefixed with a single "@", e.g. "@name", and are scoped to the object instance.

Explanation

The "+" operator concatenates strings in Ruby; "<<" can also append in place.

Explanation

The "**" operator performs exponentiation, so 3 ** 2 equals 9 (3 squared).

Explanation

The Integer#times method, e.g. "5.times do |i| ... end", executes the block 5 times.

Explanation

The spaceship operator returns -1, 0, or 1 for less than, equal, or greater than respectively, and is used to implement Comparable.

Explanation

Methods ending in "?" conventionally return booleans; String#empty? returns true if the string has zero length.

Explanation

Ruby source files conventionally use the ".rb" extension.

Explanation

".." creates an inclusive range (1 to 5 includes 5), while "..." creates an exclusive range (excludes the last value).

Explanation

String#to_i converts a string to an integer, returning 0 if conversion is not possible.

Explanation

attr_accessor generates both a reader (getter) and writer (setter) method for the given instance variable, saving boilerplate.

Explanation

irb (Interactive Ruby) launches a REPL where Ruby code can be executed interactively.

Explanation

nil.to_s returns an empty string "", while nil.inspect returns the string "nil".

Explanation

Ruby uses "begin ... rescue => e ... end" to catch and handle exceptions.

Explanation

Dividing a Float by an Integer yields a Float result; only Integer/Integer division truncates to an integer.

Explanation

In Ruby, identifiers starting with an uppercase letter are treated as constants by convention (modifiable but triggers a warning).

Explanation

map (alias collect) transforms each element via the given block and returns a new array of the results, leaving the original unchanged.

Explanation

"==" checks if two objects have equal values; "=" is assignment, and "===" is used for case equality (often in case/when).

Explanation

require loads a Ruby file or library, ensuring it is only loaded once per program.

Explanation

When puts is given an array, it prints each element on its own line rather than the array literal representation.

Explanation

Blocks are anonymous pieces of code passed to methods, commonly used with iterators like each, map, and select.

Explanation

Array#pop removes and returns the last element, while Array#shift does the same for the first element.

Explanation

upcase returns a copy of the string with all lowercase letters converted to uppercase.

Explanation

Default parameter values are specified with "=" in the parameter list, used when the caller omits the argument.

Explanation

"unless" is the inverse of "if" — the associated code runs only when the condition evaluates to false.

Explanation

freeze makes an object immutable; attempting to modify a frozen object raises a FrozenError.

Explanation

"module ModuleName ... end" defines a module, used for namespacing and as mixins via include.

Explanation

A Gemfile lists the gems a project depends on; Bundler reads it to install and lock dependency versions in Gemfile.lock.

Explanation

Lambdas check the number of arguments strictly and a "return" inside returns from the lambda itself, whereas Procs are lenient about arity and "return" returns from the enclosing method context.

Explanation

Prefixing the last parameter with "&" converts an implicit block argument into an explicit Proc object, which can be stored, passed around, or invoked with call/yield.

Explanation

Duck typing means "if it walks like a duck and quacks like a duck, it's a duck" — Ruby cares whether an object responds to the needed methods, not its actual class.

Explanation

include mixes a module's instance methods into a class, inserting the module into the class's ancestor chain.

Explanation

include mixes module methods in as instance methods of the including class; extend adds module methods directly to the singleton class of an object (or class, making them class methods).

Explanation

method_missing is invoked when a method that doesn't exist is called on an object, allowing dynamic handling of arbitrary method calls.

Explanation

yield invokes the block associated with the current method call, optionally passing arguments to it.

Explanation

inject (alias reduce) takes an optional initial value and a block, applying the block cumulatively to reduce the collection to a single result.

Explanation

== is typically overridden for value comparison, equal? checks if two references point to the same object, and eql? additionally requires the same type (e.g. 1.eql?(1.0) is false).

Explanation

Including Comparable and defining <=> gives the class all standard comparison operators and helper methods like clamp and between? for free.

Explanation

Any class that includes Enumerable and defines an "each" method gains access to a wide range of iteration methods like map, select, sort, and reduce.

Explanation

case/when calls "===" on each candidate, which different classes implement differently (e.g. Range#=== checks membership, Class#=== checks instance, Regexp#=== checks match), giving more flexible matching than plain equality.

Explanation

Methods declared after "private" cannot be called with an explicit receiver from outside the object (with rare exceptions for setters), restricting them to internal use.

Explanation

select (filter) returns a new array with only the elements that satisfy the block's condition, leaving the original array unchanged.

Explanation

respond_to?(:method_name) returns true if the object has a method with that name, often used to support duck typing checks.

Explanation

"class << self" opens the singleton (eigenclass) of the current object/class, a common idiom for defining multiple class methods at once.

Explanation

dup and clone both produce shallow copies, but clone preserves frozen status and singleton class methods of the original object, whereas dup resets these.

Explanation

Keyword arguments let callers specify arguments by name (e.g. greet(name: "Bob")), improving readability and allowing any order, with defaults for optional ones.

Explanation

The splat operator "*args" gathers any number of extra positional arguments passed to the method into an array.

Explanation

require keeps track of files already loaded and skips re-loading them, while load re-executes the file content each time it is called.

Explanation

Iterating a hash with each yields [key, value] pairs, often destructured as "|key, value|" in the block parameters.

Explanation

tap passes self to the given block and returns self, useful for inserting debugging or side-effect code into a method chain without breaking it.

Explanation

Because classes can be reopened at any time, developers can add or override methods on existing classes — a powerful but potentially risky technique called monkey patching.

Explanation

ObjectSpace provides interfaces for examining the object graph, including iterating over all currently allocated objects, useful for memory profiling.

Explanation

Struct.new(:a, :b) creates a new class with attribute accessors for :a and :b, plus useful methods like == and to_a, reducing boilerplate for simple data objects.

Explanation

The ensure clause executes regardless of whether an exception occurred, was rescued, or the method returned normally — typically used for cleanup.

Explanation

gsub (global substitution) replaces every match of the pattern (string or regex) with the replacement, returning a new string; sub replaces only the first match.

Explanation

Even though Ruby constants can technically be reassigned (with a warning), freezing the object they reference prevents in-place mutation of that object's state.

Explanation

protected allows calling the method on another object of the same class hierarchy (e.g. comparing two instances), whereas private restricts calls to implicit self only.

Explanation

flatten returns a new array with all nested arrays recursively merged into a single, flat array; an optional depth argument limits recursion.

Explanation

send(:method_name, *args) invokes the named method dynamically, bypassing normal access control (unlike public_send which respects it).

Explanation

Methods ending with "!" conventionally mutate the receiver in place; map! transforms and replaces the elements of the original array rather than returning a new one.

Explanation

clamp restricts a value to a given range, returning the boundary value if the original value is below the minimum or above the maximum.

Explanation

fetch provides safer access by raising an error (or returning a specified default/block result) for missing keys, while [] silently returns nil.

Explanation

Unlike include (which places the module after the class in the method lookup chain), prepend places the module before the class, allowing the module to intercept and wrap the class's methods via super.

Explanation

instance_variable_get allows reading an instance variable's value by name dynamically, bypassing the need for a getter method.

Explanation

each_with_index yields each element along with its zero-based index, useful when both the value and its position are needed.

Explanation

split divides a string into an array of substrings based on the given delimiter, here producing ["a", "b", "c"].

Explanation

is_a? and kind_of? are synonyms that return true if the object's class, superclass chain, or included modules include the given class/module.

Explanation

uniq removes duplicate values from an array, keeping the first occurrence of each unique element and preserving relative order.

Explanation

The ancestors method shows the linearized lookup order; when multiple modules are included, the most recently included one takes precedence (appears earlier in the chain) for method resolution.

Explanation

instance_eval changes self to the receiver for the duration of the block, often used for DSLs or accessing privates; class_eval changes self to a class/module, allowing def to define instance methods on it dynamically.

Explanation

Modern MRI (Ruby) implements a generational GC that separates objects into young and old generations, focusing collection efforts on the young generation (which is collected more often) for efficiency.

Explanation

MRI's Global VM Lock means only one thread runs Ruby bytecode at a time, so CPU-bound multithreading does not provide parallel speedup, though threads can still interleave during I/O waits (and Ractors offer an alternative for parallelism).

Explanation

define_method takes a block as the method body, which can close over local variables from the surrounding scope, enabling dynamic method generation that's difficult or impossible with literal def syntax.

Explanation

Refinements (defined with refine, activated with using) provide a way to alter class behavior in a controlled, scoped manner, limiting the impact of changes compared to global monkey patches.

Explanation

Fibers provide manual, cooperative context-switching within a single thread; Enumerator and many async libraries are built on top of Fibers.

Explanation

Without overriding respond_to_missing?, respond_to? would incorrectly return false for methods that method_missing actually handles, breaking duck-typing checks performed by other code.

Explanation

BasicObject is intentionally minimal, lacking the Kernel module methods that Object provides, making it ideal for building proxy objects that rely heavily on method_missing without naming collisions.

Explanation

WeakMap holds references that do not count toward an object's reachability for garbage collection purposes, making it suitable for caches or object registries that shouldn't leak memory.

Explanation

With this magic comment, every string literal becomes frozen automatically, improving performance by avoiding repeated allocation of identical immutable strings, though code that mutates string literals in place will need adjustment.

Explanation

Ractors enable parallel execution by running independent Ruby VM instances that cannot directly share mutable objects, communicating instead through message passing, sidestepping the GVL limitation for parallelism.

Explanation

binding captures the current scope (variables, self, method visibility context) as an object, which tools like debuggers (e.g. byebug, pry) use to evaluate expressions as if running at that exact point in the code.

Explanation

The flexibility of case/when comes from each class providing its own meaningful "===" implementation, allowing a single case statement to match values against ranges, types, patterns, or even custom callable conditions.

Explanation

each_object provides powerful introspection across the entire object heap but comes with significant performance overhead and is typically reserved for debugging, profiling, or specialized tooling rather than everyday application logic.

Explanation

const_get(name, inherit = true) by default follows the normal constant resolution including ancestors; passing false restricts the search to the receiver itself, offering programmatic control not directly expressible with "::" syntax.

Explanation

When <=> cannot meaningfully compare two objects (e.g. different incompatible types), it should return nil, and Comparable's derived operators raise an error rather than silently returning a misleading boolean.

Explanation

Ruby only warns (rather than errors) when a constant is reassigned, reflecting that "constant" is a naming convention rather than a hard guarantee; freeze affects the mutability of the referenced object/class, which is a related but distinct concept from the constant binding itself.

Explanation

UnboundMethod represents a method definition independent of any particular object; binding it to a new (compatible) receiver allows reusing method implementations across otherwise unrelated class hierarchies in advanced metaprogramming scenarios.

Explanation

Before the unification, small integers (Fixnum) and arbitrarily large integers (Bignum) were separate classes; merging them into Integer simplified the type hierarchy since the distinction was an implementation detail that confused type checks.