Ruby.CodeCompared.To/Bash

Associative arrays require declare -A before use — without it, Bash treats the variable as an ordinary indexed array and the string key is ignored (coerced to 0). Unlike Ruby hashes, Bash associative arrays only support string keys and string values, and their iteration order is undefined.

Associative arrays can be initialized inline using the ([key]=value ...) syntax inside parentheses, combined with declare -A. The key must be in brackets. This mirrors Ruby's hash literal syntax but is less readable due to the required brackets and parentheses.

The ${!assoc[@]} expansion returns all keys; ${assoc[@]} returns all values. Iteration order is undefined (hash-based internally) — unlike Ruby where hashes preserve insertion order since Ruby 1.9. Always account for arbitrary key order when writing scripts.

The [[ -v array[key] ]] test (Bash 4.2+) checks whether a key exists in an associative array without expanding the value. This is important because an existing key with an empty string value should still be "present". Do not use [[ -n ${assoc[key]} ]] — that conflates an empty-string value with a missing key.

Iterate over keys with "${!assoc[@]}" and then look up each value inside the loop. The double-quoted [@] form is essential to handle keys that contain spaces. Iteration order is undefined — sort with printf "%s\n" "${!inventory[@]}" | sort for deterministic output (pipe not available in browser).

The unset builtin removes a key from an associative array. Quote the expression to prevent glob expansion of the key. After deletion, the key no longer appears in ${!settings[@]} and [[ -v settings[verbose] ]] returns false.

The same ${#array[@]} syntax that counts elements in an indexed array also counts keys in an associative array. This is consistent across both array types in Bash.

Bash uses then, elif, and fi (if backwards) to delimit conditional blocks. The then must be on a new line or preceded by a semicolon. Using (( )) for numeric tests is the modern idiom — it supports all C-style comparison operators without the awkward -gt/-lt flags.

The [[ ]] construct (double brackets) is the modern conditional expression. It supports == and != for string comparison, -z for "zero length", and -n for "non-zero length". The [[ ]] is safer than the older [ ] because it handles empty variables without quoting issues.

Numeric comparisons in Bash can use either legacy flags (-eq, -ne, -lt, -le, -gt, -ge) inside [[ ]], or C-style operators (==, <, etc.) inside (( )). The (( )) style is more natural for arithmetic comparisons.

Bash uses && and || for logical AND and OR both between separate commands and inside [[ ]]. You can combine tests from different constructs ((( )) and [[ ]]) with &&. Avoid the older -a and -o flags inside [ ] — they are deprecated.

Bash's case/esac is the inverse spelling of case (like fi for if). Patterns use | for alternatives and ;; to end each branch. Patterns are glob expressions, not regexes. The * default case is the equivalent of Ruby's else.

The case statement is especially powerful for matching file extensions and other glob patterns. The *. prefix matches any string followed by a dot and extension. This replaces the need for many if/elif chains. Ruby's equivalent uses case/when with regexps, which are more powerful but heavier.

Bash's && and || short-circuit at the command level based on exit codes, not boolean values. Exit code 0 is "success" (truthy); any non-zero is "failure" (falsy). This is the opposite of most languages where 0 is falsy. The pattern command && on-success || on-failure mimics a ternary but can misbehave if the success branch fails.

The for item in list; do ... done loop iterates over whitespace-separated words. The list is subject to word splitting and glob expansion — be careful with spaces. Always quote array expansions: for item in "${array[@]}". Ruby's .each block is semantically identical.

The C-style for (( init; condition; increment )) loop uses arithmetic context throughout — no $ needed inside. This is the idiomatic Bash replacement for Ruby's .times or .upto when you need an index. The loop variable is available after the loop ends.

The while condition; do ... done loop runs as long as the condition command returns exit code 0. Using (( )) as the condition gives C-style arithmetic tests. Unlike Ruby's while, the Bash loop body must end with a separator (; or newline) before done.

The until loop runs as long as the condition is false (exit code non-zero). It is the logical inverse of while. Ruby has both while and until with the same inversion semantics. In practice, until is less common in both languages — a negated while is often clearer.

Bash's break and continue work exactly like Ruby's break and next for loops. Both accept an optional numeric argument to break or continue an outer loop: break 2 exits the two innermost loops. This is more explicit than Ruby's break in nested loops.

Brace expansion generates a sequence of words at parse time, before any variables are resolved. This means {1..n} where n is a variable does not work — use a C-style for (( i=1; i<=n; i++ )) loop instead. Ruby's Range with .step is more flexible.

The canonical Bash pattern for reading file content line by line uses while IFS= read -r line; do ... done < file. The IFS= prevents leading/trailing whitespace stripping; -r disables backslash processing. This pattern is not runnable in the browser (no real filesystem or pipes), but is fundamental to real-world shell scripting.

Bash functions are defined with name() { ... } or function name { ... }. They are called like commands — no parentheses, arguments separated by spaces. Parameters are positional: $1 is the first argument, $2 is the second, etc. Unlike Ruby, there is no parameter naming in the function signature.

Inside a Bash function, $# is the argument count and $@ is all arguments as separate words. $* joins all arguments into one string. Use "$@" (quoted) when passing arguments forward to preserve spacing. These special variables are reset to function scope — they do not bleed out to the calling script.

In Bash, variables inside functions are global by default — without local, assigning to a variable inside a function modifies the outer scope. This is the opposite of Ruby, where all variables are local to their scope. Always use local for function-internal variables to avoid subtle bugs.

Bash functions do not return values — they return exit codes (0 = success/true, 1–255 = failure/false). The exit code is set by the last command executed or by an explicit return n statement. An arithmetic expression like (( n % 2 == 0 )) exits 0 when the expression is non-zero (even), and 1 when zero (odd) — exactly backwards from arithmetic convention.

Since Bash functions only return exit codes, returning a string value requires a workaround: write to a known global variable. The convention is to use a variable like result_var or a nameref (declare -n). The $(function_call) pattern (command substitution) also works but requires fork() which is unavailable in this browser runtime.

Bash has no default parameter syntax in the function signature. The idiomatic substitute is local var="${n:-default}" inside the function body — this uses the positional parameter if provided, otherwise uses the default. Ruby's def foo(x = default) is cleaner and handles any expression as the default value.

Recursion works in Bash but is awkward since return values must flow through global variables rather than a clean call stack. The local keyword correctly scopes variables to each invocation. Deep recursion is expensive in Bash — each function call is a new stack frame, and Bash scripts are much slower than Ruby for recursive algorithms.

declare -n (Bash 4.3+) creates a nameref — a reference to another variable by name. The nameref variable acts as an alias: reading or writing it reads or writes the target variable. This is Bash's equivalent of passing an object by reference in Ruby, enabling functions to modify arrays and hashes in the caller's scope.

Inside [[ ]], the right-hand side of == and != is treated as a glob pattern when unquoted. * matches any sequence of characters, ? matches exactly one. Quoting the pattern forces a literal string comparison. This is the fastest way to do prefix/suffix/substring checks in Bash.

The =~ operator inside [[ ]] matches the left side against an extended regular expression (ERE). The pattern is unquoted — quoting it forces a literal string match. Bash uses POSIX ERE syntax (no \d, use [0-9] instead). Successful matches set BASH_REMATCH with the captured groups.

After a successful =~ match, BASH_REMATCH[0] holds the full match and BASH_REMATCH[1], [2], etc. hold each capture group. This is equivalent to Ruby's MatchData object. The BASH_REMATCH array is read-only and set globally — in functions, save it before any subsequent [[ =~ ]] overwrites it.

Extended glob patterns (shopt -s extglob) add regex-like quantifiers to glob syntax: @(a|b) matches exactly one of the alternatives, *(a|b) matches zero or more, +(a|b) matches one or more, ?(a|b) matches zero or one, and !(pattern) matches anything except the pattern. These are often cleaner than regex for file-matching tasks.

case patterns support character classes ([YyNn]), alternation (pat1|pat2), and glob wildcards (*, ?). They do not support regular expressions — for regex matching, use [[ =~ ]]. The character-class approach shown here is idiomatic for case-insensitive yes/no prompts in Bash.

Every command in Bash produces an exit code stored in $?. Exit code 0 means success; any other value means failure. This is the fundamental error-signaling mechanism — there are no exceptions. The builtins true and false exist solely to produce exit codes 0 and 1. Ruby's exceptions are a higher-level abstraction over this concept.

set -e (or set -o errexit) makes the script exit immediately if any command returns a non-zero exit code. This makes Bash scripts behave more like Ruby — failing early rather than silently continuing. set +e turns it off. Many production scripts combine set -euo pipefail for maximum strictness.

set -u (or set -o nounset) causes the script to exit with an error if any unset variable is expanded. By default, Bash silently expands unset variables to empty strings — a common source of bugs. With set -u, Bash behaves more like Ruby's strict variable-must-be-defined enforcement.

The command || { fallback commands; } pattern is Bash's idiomatic error handler. The right side of || runs only when the left side fails (non-zero exit code). The braces group multiple fallback commands. This is more concise than if ! command; then ... fi for simple one-shot error handling.

trap registers a command to run when a signal or special event occurs. EXIT triggers on any exit (normal or error). INT triggers on Ctrl-C. ERR triggers when any command fails (useful with set -e). This is Bash's equivalent of Ruby's at_exit and ensure blocks.

echo always appends a newline (suppress with -n). printf uses C-style format strings and appends no newline unless you include \n. In scripts, printf is preferred over echo because echo behavior varies across shells and operating systems for flags like -e.

Bash's printf supports the same format specifiers as C: %s (string), %d (integer), %f (float), %x (hex), %o (octal). Width and precision modifiers (%10s, %-10s, %.2f) work identically to Ruby's Kernel#printf.

ANSI escape sequences are identical in Ruby and Bash — the escape character is \033 (octal) in Bash or \e in Ruby. Color codes: 30–37 for foreground colors, 40–47 for backgrounds, 0 to reset, 1 for bold. In Bash, use printf rather than echo for portability, as echo -e is not POSIX.

Storing a format string in a variable and reusing it with printf "$format" is idiomatic Bash for consistent tabular output. Width specifiers align columns: %-12s left-aligns in 12 characters; %8s right-aligns in 8. This approach avoids the need for external tools like column or awk.

Bash has many automatic special variables: $0 (script name), $$ (process ID), $? (last exit code), $! (last background PID), $BASH_VERSION, $HOSTNAME, $RANDOM (random integer), $SECONDS (seconds since shell start). Ruby mirrors some of these via $$, $0, and $?.

Here-documents (<) feed a multiline string to a command's standard input, with variable expansion. Using <<-EOF strips leading tabs. Using <<'EOF' (quoted) suppresses variable expansion (like Ruby's <<~'HEREDOC'). File descriptor support is required, so here-docs are not runnable in this browser runtime.