Ruby.CodeCompared.To/Zsh

Zsh requires no spaces around the = sign — a space on either side causes a syntax error. Variable names are case-sensitive. Unlike Ruby, Zsh has no separate integer or string types at the variable level — everything is a string unless you use typeset -i.

In Zsh, curly braces around a variable name (${variable}) are optional for simple access but required when the variable name is immediately followed by letters, digits, or underscores that should not be part of the name. Ruby's #{} syntax is analogous but always required for interpolation.

Single quotes in Zsh prevent all interpretation — no variable expansion, no escape sequences. Double quotes allow variable and command substitution but prevent word splitting and glob expansion. Ruby's single-quote strings prevent interpolation similarly, but still allow \\ and \' escapes.

The ${var:-default} expansion returns the default if the variable is unset or empty, without modifying it. This is Zsh's idiomatic equivalent of Ruby's ||= for providing fallbacks. The :- variant treats both unset and empty string as "missing"; - (without colon) only triggers on unset.

The ${var:=value} expansion assigns the value to the variable if it is unset or empty, then expands to that value. The leading : (the null command) discards the expansion result while still triggering the assignment. This is Zsh's equivalent of Ruby's ||= when you want the assignment to persist.

The ${var:+alt} expansion returns the alternate value if the variable is set and non-empty, otherwise returns nothing. It is the inverse of ${var:-default}. Useful for optionally inserting a prefix or flag based on whether a variable is set.

The typeset -r flag marks a variable as read-only. Any attempt to reassign it causes a runtime error. typeset is the idiomatic Zsh form; declare also works as an alias. In Ruby, constants (capitalized names) warn on reassignment but still allow it — Zsh is stricter.

The typeset -i flag forces a variable into integer context. Assignments to it are evaluated as arithmetic expressions — string values that cannot be parsed as integers are treated as zero. This is Zsh's idiomatic form; typeset is preferred over declare in Zsh scripts.

The typeset -l flag auto-lowercases every value assigned to the variable; typeset -u auto-uppercases. The transformation is applied at assignment time, not at read time. This is Zsh's idiomatic form — typeset is preferred over declare -l/-u in Zsh scripts.

In Zsh, environment variables inherited from the process are immediately accessible as plain variables. Ruby accesses them through the ENV hash. Zsh convention uses uppercase names for environment variables and lowercase for local script variables, though Zsh itself enforces no such distinction.

The ${#variable} expansion returns the number of characters in the string. In Ruby, .length and .size are equivalent methods. For arrays, the same Zsh syntax (${#array}) returns the element count.

The ${var:offset:length} expansion extracts a substring starting at offset (0-indexed). Omitting :length returns everything from the offset to the end. Negative offsets count from the end: ${var: -3} (space required before the minus). Ruby's slice syntax [start, length] maps directly to this.

Zsh uses parameter flags inside ${(flags)var} for case transformation: (U) uppercases, (L) lowercases, (C) capitalizes the first letter of each word. This is distinct from Bash's ${var^^} / ${var,,} syntax. The flags approach is more powerful and consistent across Zsh expansions.

The ${var/pattern/replacement} expansion replaces the first match of the glob pattern. Ruby's String#sub is equivalent but uses a Regexp by default. Note that Zsh patterns use glob syntax (*, ?, [...]), not regular expressions.

The ${var//pattern/replacement} expansion (double slash) replaces all occurrences. The single-slash version only replaces the first. Ruby's String#gsub is the equivalent. Unlike gsub, the Zsh pattern is a glob, not a regexp.

The ${var#pattern} expansion removes the shortest prefix matching the glob; ${var##pattern} removes the longest matching prefix. This is frequently used to strip directory components from paths. Ruby uses delete_prefix, sub, or regexp operations for the same task.

The ${var%pattern} expansion removes the shortest matching suffix; ${var%%pattern} removes the longest. Together with the prefix operators, these four expansions cover most path and filename manipulation tasks without calling external tools.

In Zsh, the == operator inside [[ ]] performs glob matching when the right side is unquoted. Wrapping the pattern in *...* checks for a substring anywhere in the string. Quoting the entire right side would do a literal string comparison instead.

Zsh has no string concatenation operator. Strings are simply placed adjacent to each other inside double quotes. There is no + operator for strings — using it would attempt arithmetic and likely produce an error or zero. Ruby's + and #{} interpolation are both cleaner for this.

The Zsh parameter flag (j:sep:) joins array elements with the given separator — this is Zsh's clean equivalent of Ruby's Array#join. The colon is the flag delimiter; any character can be the separator. This is one of the clearest examples of Zsh's parameter flags being more ergonomic than pure Bash.

The Zsh parameter flag (s:sep:) splits a string on the given separator into an array — this is Zsh's built-in equivalent of Ruby's String#split. Note that the resulting array is 1-indexed, so the first element is ${parts[1]}, not ${parts[0]}.

Zsh has no built-in trim function. The idiomatic approach nests parameter expansions: ${var%%[! ]*} extracts the leading spaces, then ${var#...} strips that prefix. This works but is deliberately obscure — it highlights why Ruby's .strip is a real quality-of-life advantage.

The $(( )) construct is arithmetic expansion — it evaluates integer arithmetic and expands to the result as a string. This is entirely different from $() command substitution (which requires fork()). Zsh only supports integer arithmetic natively; for floating-point, use the zsh/mathfunc module or an external tool.

The (( )) construct (without the leading $) evaluates arithmetic and is used as a command — it returns exit code 0 if the result is non-zero, 1 if zero. This makes it usable directly in if and while conditions. All C-style compound operators work: +=, -=, *=, /=, %=, **=.

Zsh supports C-style post-increment (counter++) and pre-increment (++counter) inside (( )). The difference: post-increment returns the value before incrementing; pre-increment returns the value after. Ruby has no ++ or -- operators — use += 1 instead.

Inside (( )), comparison operators use C syntax: ==, !=, <, >, <=, >=. This is much cleaner than the legacy -eq, -lt, -gt flags used with [ ] or [[ ]] for numeric comparisons. The (( )) style is unambiguous and preferred in modern Zsh.

Arithmetic expansion supports the C ternary operator cond ? yes : no, but it only works for integer results, not strings. The && ... || ... idiom chains shell commands — it works like a ternary for string output but can misbehave if the "then" command fails. Use an explicit if for clarity.

Zsh's arithmetic is integer-only by default — $(( 1/3 )) produces 0, not 0.333. The printf builtin can format floating-point literals (strings that look like floats) using %f. For actual float arithmetic, load zmodload zsh/mathfunc and use $(( sin(x) )) etc.

The let builtin evaluates arithmetic expressions and assigns results to variables. It is older than (( )) and less commonly used in modern Zsh scripts. Both forms are equivalent — (( product = 6 * 7 )) is the contemporary idiom. let is supported in both Zsh and Bash.

Zsh arrays are 1-indexed by default — the first element is at index 1, unlike Ruby and Bash which both start at 0. This is the most important difference from Bash. Negative indices count from the end: ${fruits[-1]} is the last element. Set setopt KSH_ARRAYS for 0-based indexing if needed.

In Zsh, ${#array} returns the number of elements (without the [@] subscript). The Bash form ${#array[@]} also works in Zsh, but ${#array} is the idiomatic Zsh shorthand. Both are equivalent for non-sparse arrays.

Inside double quotes, "${array[@]}" expands to one separate word per element, preserving spaces within elements. "${array[*]}" joins all elements into a single word separated by the first character of IFS. Always prefer [@] inside double quotes when iterating.

The += operator appends elements to an array when the right-hand side is a parenthesized list. This is analogous to Ruby's << or push. You can append a single element or multiple at once. Zsh also supports fruits[6]="fig" for sparse assignment.

The ${array[@]:offset:length} slice uses a 0-based offset even in Zsh's otherwise 1-indexed world — :1:2 starts after the first element. To slice starting from the second element (index 2 in Zsh's 1-based indexing), use ${fruits[2,3]} — Zsh's native slice syntax, which is 1-based.

Always quote "${fruits[@]}" in the for loop. Without quotes, elements containing spaces would be split into multiple words. The double-quoted [@] expansion ensures each array element is treated as a single word, matching Ruby's block-based iteration.

The Zsh parameter flag (@k) (or (k)) expands to the list of keys/indices of the array — for an indexed array this is 1 2 3 ... (1-based). This differs from Bash's ${!fruits[@]} which yields 0 1 2 .... The loop prints 1: apple, 2: banana, etc.

In Zsh, unset fruits[2] removes the second element (1-based indexing). After deletion, reassign the array to itself to compact the indices: fruits=("${fruits[@]}"). This contrasts with Bash where unset fruits[1] removes what Bash calls index 1 (its second element). Ruby's delete_at compacts automatically.

Brace expansion ({start..end} and {start..end..step}) 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.

Associative arrays require typeset -A before use — typeset is the idiomatic Zsh form (equivalent to Bash's declare -A). Without it, Zsh treats the variable as a scalar and string keys are ignored. Unlike Ruby hashes, Zsh associative arrays only support string keys and values, and iteration order is undefined.

Associative arrays can be initialized inline using the ([key]=value ...) syntax inside parentheses, combined with typeset -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 Zsh parameter flags (k) and (v) expand an associative array to its keys or values respectively. Alternatively, ${!scores[@]} (Bash-compatible) gives the keys. Iteration order is undefined — unlike Ruby where hashes preserve insertion order since Ruby 1.9.

The ${+assoc[key]} expansion is Zsh's idiomatic key-existence test — it returns 1 if the key exists, 0 if not. The (( )) arithmetic context interprets this as a boolean. The Bash-compatible [[ -v assoc[key] ]] also works in Zsh 5.3+. Do not use [[ -n ${assoc[key]} ]] — that conflates an empty-string value with a missing key.

Iterate over keys with "${(@k)inventory}" (Zsh-idiomatic) or "${!inventory[@]}" (Bash-compatible). The (@k) flag forces word-splitting on each key so spaces in keys are handled correctly. Iteration order is undefined — sort with print -l "${(@ok)inventory}" for deterministic output.

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 ${(k)settings} and (( ${+settings[verbose]} )) returns false.

${#assoc} counts the number of keys in an associative array — the same ${#} prefix works for string length, indexed array length, and associative array length in Zsh.

Zsh 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 Zsh 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.

Zsh 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.

Zsh'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.

Zsh'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 Zsh 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 Zsh 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.

Zsh'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 Zsh (and POSIX shell) 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).

Zsh 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 Zsh 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 scoped to the function — they do not bleed out to the calling script.

In Zsh, 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.

Zsh 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 (true in arithmetic but "success" in exit-code terms).

Since Zsh 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 (typeset -n). The $(function_call) command-substitution pattern also works but requires fork(), which is unavailable in this browser runtime.

Zsh 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 Zsh 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 — each function call is a new stack frame, and shell scripts are much slower than Ruby for recursive algorithms.

typeset -n (Zsh 5.1+) 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. typeset -n is the idiomatic Zsh form; declare -n (Bash-style) also works. This enables 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 Zsh.

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

After a successful =~ match, Zsh stores capture groups in the match array (1-indexed: ${match[1]} is the first capture). The full match is in $MATCH. This differs from Bash, which uses BASH_REMATCH. The match array is analogous to Ruby's MatchData object.

Zsh's extended glob patterns are enabled with setopt EXTENDED_GLOB. The (a|b) syntax matches exactly one alternative (like Bash's @(a|b)). Zsh also adds ^pattern for negation and #/## as quantifiers. These are often cleaner than regex for filename matching.

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.

Every command in Zsh 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 Zsh 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, Zsh silently expands unset variables to empty strings — a common source of bugs. With set -u, Zsh behaves more like Ruby's strict variable-must-be-defined enforcement.

The command || { fallback commands; } pattern is Zsh'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. ZERR triggers when any command fails (Zsh's equivalent of Bash's ERR). This is Zsh'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 for portability. Zsh's print builtin is an enhanced alternative: print -P supports prompt-style escape sequences.

Zsh'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 Zsh — the escape character is \033 (octal) or \e. Color codes: 30–37 for foreground colors, 40–47 for backgrounds, 0 to reset, 1 for bold. Zsh also has the %F{color}...%f prompt escape syntax, but that only works in prompts via print -P.

Storing a format string in a variable and reusing it with printf "$format" is idiomatic 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.

Zsh has its own set of automatic special variables: $0 (script/function name), $$ (process ID), $? (last exit code), $! (last background PID), $ZSH_VERSION, $HOST (hostname), $RANDOM (random integer), $SECONDS (seconds since shell start). Note $ZSH_VERSION vs Bash's $BASH_VERSION.

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.