Control Structures

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.

Class#=== (from Module) tests instance-of-or-subclass, Range#=== tests whether the value lies between begin and end, Regexp#=== tests for a match in a string, and Proc#=== calls the proc. One case can mix them to classify input by type, range, pattern and predicate.

A break ends a Ruby loop or iterator call with break's argument, or nil for a bare break. Run to completion, while and until give nil, each and times give their receiver, and map gives the new array.

Use case/when when many branches test the same subject, listing alternatives with commas. A subjectless case is a boolean chain that RuboCop prefers as if/elsif. A pure value-to-value mapping reads best as a hash lookup.

Ruby's ternary cond ? a : b is a compact if/else expression that returns a or b. It fits a short condition choosing between two short values; nesting or spreading it over lines hurts readability, so use if/elsif or case instead.

unless runs its body when the condition is falsy, so it reads well for one simple negative test. Adding else makes the reader negate twice to see when each branch runs, so the convention is to rewrite it as if with the positive case first.

Ruby counts with methods on Integer: n.times yields 0 to n-1, a.upto(b) and a.downto(b) yield every integer between the two, inclusive. With a block each returns its receiver; without one each returns an Enumerator.

case/in matches a value's structure — arrays, hashes and nested data — and binds parts to local variables, while case/when only tests each value with ===. If no in branch matches and there is no else, case/in raises NoMatchingPatternError instead of returning nil.

when String calls String === subject, which asks whether the subject is a String instance. With case value.class the subject is the class String itself, an instance of Class, so the test is false. Write case value and let Module#=== do the type check.

A Ruby break ends only the innermost each, so outer levels keep going. Wrap the loops in catch(:found) and throw :found, bin, extract them into a method that returns the bin, or rewrite the search as a single find.

A while or until modifier on an ordinary statement tests first, so the statement may never run; on a begin...end block it tests after, so the body runs at least once. Lint/Loop flags that special case and suggests loop with break.

An array pattern must account for every element, so [Integer, Integer] rejects a three-element array unless you add *rest. A hash pattern checks only the keys it names, so extras are ignored; **nil forbids them, **rest collects them, and {} matches only an empty hash.

expr in pattern returns true or false and never raises on a mismatch; expr => pattern binds and raises. A single-pattern match that fails on a missing hash key raises NoMatchingPatternKeyError, a NoMatchingPatternError subclass with key and matchee.

A Ruby method returns its last expression, and an if without else evaluates to nil when its test fails. nil passes truthiness checks but serialises as null and fails == false, so return a real boolean via a guard clause or an explicit else.

Ruby's throw is non-error unwinding to the catch with the same tag object, handing it a value and running ensure clauses; rescue never sees it. With no matching catch, throw raises UncaughtThrowError, an ArgumentError subclass.

Kernel#loop rescues StopIteration raised anywhere in its block and returns that exception's result, so an exhausted enumerator deep in the polling code ends the loop as if it had finished normally.

Define deconstruct (returning an Array) for array and find patterns and deconstruct_keys(keys) (returning a Hash) for hash patterns. keys lists the Symbols the pattern needs, or is nil when it uses **rest, so you may compute only those keys.

In a pattern a bare name always binds a new value, so using an existing local like team_id silently overwrites it and matches anything. The pin ^team_id uses the variable's current value as a value pattern (tested with ===) instead; ^@ivar and ^(expr) work too.

Ruby decides at parse time, in source order, whether a bare name is a local. In p a if a = lookup the body is parsed first, so a is a method call; x = 1 if false still declares x as nil.

Ruby's redo restarts the current iteration from the top of the body without re-testing the loop condition or advancing to the next element; if whatever triggered it never changes, the same pass repeats forever.

For floats, Numeric#step computes the number of values up front and yields start + i * step, clamping an overshoot to the limit, so rounding error never accumulates; a while loop that keeps adding 0.1 drifts and skips 2.0.

Define === on the pattern object, or use a lambda, Method or Set, whose === already works. Keep it total so wrong input returns false, and build matchers once as constants, since when values are re-evaluated on every run.

A find pattern [*, p, *] matches a run of elements anywhere in an array and can bind them. Alternatives p1 | p2 accept either shape but cannot bind (except _names). Guards (in p if cond) run after binding, only on case/in branches.