Bash.CodeCompared.To/Ruby

Two neighbors worth meeting now. print is the one that does not add a newline, which is the reverse of the habit printf gives you. And p prints a debugging representation — p "a" shows the quotation marks — which is the fastest way to see whether a value is the string "3" or the number 3, a distinction the shell never made you think about.

The one thing worth adding at the top of a Ruby script is # frozen_string_literal: true, which is about performance and mutation rather than about safety. Note the asymmetry that catches shell programmers: an undefined local variable raises, but an undefined hash key quietly returns nil — so settings[:levl] is the typo that survives, and settings.fetch(:levl) is how you make it raise.

Ruby closes every block with end rather than with a keyword matched to the opener, so there is no fi/done/esac to keep straight — but there is also no visual reminder of what is being closed, which is why indentation matters more in practice than the parser cares. The interpolation #{name} works only in double quotes, exactly as $name does in the shell.

That type distinction is the one to hold on to, because Ruby will not convert for you: "3" + 4 raises a TypeError rather than quietly producing 7 or "34". After years of a language where everything is text and conversion is invisible, this reads as strictness — and it is the same strictness that makes count + 1 mean addition without a $(( )) around it.

Word splitting is not a bug, it is the 1978 design — an unquoted expansion is re-split on whitespace and then glob-expanded, because that made the shell convenient to type at. Every "$variable" you have written is you switching it off. In Ruby a string is a value like any other: passing it, storing it, printing it and handing it to a method never splits it, and the whole category of filename-with-a-space bugs stops existing rather than being defended against.

🚨 The one difference that bites: the shell treats the empty string as missing, and Ruby does not. "" is truthy in Ruby — only nil and false are falsy — so name || "default" keeps an empty string where ${name:-default} would replace it. When you mean "empty counts as missing", write name.to_s.empty? ? "default" : name, and be glad the decision is visible.

Ruby integers are arbitrary precision, so 2 ** 200 is exact rather than overflowing. The trap in the other direction is that 7 / 2 is 3, not 3.5 — integer division, the same answer $(( )) gives — so a stray integer silently discards your fraction. Beyond floats there is BigDecimal for money and Rational for exact ratios (1r/3), neither of which needs a subprocess.

What #{} adds over $name is that the braces are mandatory, so there is no ambiguity about where the name ends and no need for ${name}_suffix. And anything may go inside: #{count * 2}, #{name.upcase}, or a whole method call. Ruby also has %w[] for word arrays and heredocs with <<~TEXT, whose squiggle strips the leading indentation — the thing shell heredocs need <<- and a literal tab for.

The shell's expansions are terse and nobody remembers which of # and % works from which end; each one here is a named method instead. Note delete_suffix rather than chomp(".log") — chomp with an argument does the same thing, but strip-shaped methods elsewhere remove any of the given characters repeatedly, which is a real and common bug. For paths, prefer File or Pathname over pattern-matching the string.

🚨 That IFS dance is the source of a nasty class of bug: forget to scope the assignment and IFS stays changed, so unrelated code five functions away starts splitting on commas. Ruby's separator is also a full regular expression when you want one — line.split(/\s*,\s*/) handles the spaces around the commas in the same call — and parts.first and parts.last retire ${parts[0]} and the ${parts[-1]} that older shells do not support.

Sorting is the row that shows the size of the change. In the shell, sorting an array means printing it, piping it to sort, and reading the text back — a subprocess and a round trip through a stream. names.sort is a method on the array, it returns a new array, and sort_by { |name| name.length } handles anything sort -k cannot. Ruby arrays also nest, are passed to methods and returned from them, and hold any mixture of types — none of which a Bash array does.

Note ${!counts[@]} for the keys against ${counts[@]} for the values — one exclamation mark apart, which is exactly the kind of thing that makes a shell script hard for the next reader. Ruby's block receives both at once. Two shell limits that do not carry over: associative arrays need Bash 4 or later, ruling out macOS's system /bin/bash, and their values can only be strings, so a hash of arrays has no shell equivalent at all.

This is usually the row that ends the argument. Once a script has more than one thing to say about each item, the shell forces you to invent an encoding, and every encoding has a character it cannot survive. Note also that the port on the right is a real integer, comparable and addable, while everything in the left column is text. The role: spelling makes a symbol key — an interned name, cheaper than a string and the conventional choice for a fixed set of field names.

The correspondence is close enough to be worth learning as a table: grep is select, grep -v is reject, awk '{print $2}' is map, sort is sort or sort_by, uniq is uniq, uniq -c is tally, wc -l is count, head is first(n), and xargs is each. What changes is that every stage passes objects rather than text, so nothing is re-parsed between stages and a count is a number you can add to.

This is the idea with no shell counterpart and the one worth spending an afternoon on, because it explains the rest of Ruby: each, map, select, File.open, Dir.chdir and every timing, retry and transaction wrapper are the same mechanism. The File.open form is the one to notice today — the file is closed when the block ends, including when an exception passes through, which is what trap … RETURN is doing in a shell script.

The shorthand you will see everywhere is &: — map(&:upcase) means map { |item| item.upcase }. And when a chain gets long enough to be doing real work, each_with_object, group_by, partition and sum usually replace three stages with one; tally in the first row of this section is the same idea.

Worth knowing before someone tells you Ruby cannot handle a large file. File.foreach(path) reads one line at a time, each_line and lazy chain the way pipeline stages do, and Enumerator lets you write your own producer. What the shell still wins on is that its stages are separate processes on separate cores, where a lazy chain is one thread doing one thing at a time.

That rule is a genuine improvement once it clicks: if value means exactly "is there a value here", with no special case for a legitimate zero or an intentionally empty string. The comparison operators simplify too — the shell needs -eq for numbers and == for strings inside [[ ]], where Ruby has one == and "08" == 8 is simply false, because a string is not a number.

What when can match is where it stops being a translation. A shell case pattern is a glob against a string; a Ruby when accepts a regular expression, a range (when 1..9), a class (when Integer), or anything defining ===. And case/in, added in Ruby 3.0, destructures instead of comparing: in {role: String => role, port: Integer => port} matches the shape of a hash and binds the pieces in one statement.

One real gain: (1..limit) works with a variable, where the shell's {1..$limit} does not — brace expansion happens before variables are substituted, so it produces the literal text and the loop runs once over nonsense. That is the bug seq exists to work around. Ruby also has 3.times, 1.step(10, 2) and each_slice, and idiomatic code iterates the collection rather than an index.

🚨 local is the most important word in the left column and leaving it out is a silent bug — the variable becomes global and clobbers one three levels up. Ruby has the opposite default: a name assigned inside a method is local to it, full stop, and reaching a script-level variable from inside a method is not even possible without making it global with a $ sigil. Keyword arguments have no shell equivalent at all, and they are what keeps a five-parameter call readable.

Three costs vanish at once. There is no fork, so a script can be split into small methods without paying for each call. The value keeps its type — a number stays a number, an array stays an array. And returning two things is just returning an array, which the caller destructures with low, high =, rather than an encoding the caller has to reverse. That last one is where shell scripts usually start pushing data through globals and become hard to follow.

*arguments collects the rest into an ordinary array, so it can be measured, sliced, passed onward and stored. **options does the same for keyword arguments, which the shell has no concept of, and method(*array) spreads an array back out into separate arguments — the equivalent of writing "${array[@]}" at a call site.

Two Ruby-side gains. The replacement can be a block — gsub(/\d+/) { |match| match.to_i * 2 } doubles every number, which sed cannot do at all — and the pattern is not passing through shell quoting first, so there is one layer of escaping rather than two. There is also no delimiter to collide with, so a pattern containing a slash needs no s|…|…| trick.

awk is genuinely good at this and a one-line field extraction should stay one line of awk. The case for moving is names — $2 is a mystery on line 40 and role is not — and the fact that the same program can then do something a pipeline cannot: look a value up in a hash, keep a running total in a real number, or write two output files at once. The line where a script stops being a pipeline is usually the line where a stage needs to remember something.

Three things improve at once: the captures have names, so line 40 of the script is readable; the result is a value, so an unrelated match two lines later cannot clobber it; and the pattern is not passing through the shell's quoting first — notice the backslash-escaped spaces the Bash version needs, and that quoting the pattern inside [[ ]] would silently turn the whole regular expression off.

The block form of File.open closes the handle when the block ends, including when an exception passes through, which is the job trap does in a shell script. For anything small, File.read and File.write skip the block entirely, and File.foreach streams a large file one line at a time. Both columns here write to a filesystem that starts empty on every run, which is why each example creates what it reads.

File.size? returns the size rather than merely true, and nil when the file is empty or missing — which is why it works in a condition. 🚨 One warning specific to this page: the permission predicates File.readable?, writable? and executable? answer false in the browser for a file the VM has just written, because the WebAssembly filesystem carries no permission bits for anyone to ask about. Use exist?, file?, directory? and size?, all of which are reliable.

An unmatched shell glob expands to the pattern itself, so the loop body runs once with a filename that does not exist — the bug shopt -s nullglob exists to prevent and that nobody remembers to enable. Dir.glob returns an empty array, so the loop simply does not run. Two more: results come back in filesystem order, so .sort is worth writing when order matters, and Dir.glob("**/*.txt") recurses without needing find, -print0 and xargs -0.

This is where the shell keeps its advantage, and it is worth saying plainly: running programs is what a shell is for, and three lines against one is a real cost. What you get back is that the output, the error output and the status are three separate values you can examine, rather than one string plus a magic $? that the next command overwrites. Open3.capture3 adds standard error as a third value.

The comment at the bottom is the real lesson: once the data is inside the program, there is usually no reason to send it back out to a utility at all. sort.uniq does what sort -n | uniq does, without two processes, and it sorts numbers numerically without needing -n. Keep a script in the shell when it is mostly this; move it when the pipeline is a small part of something larger.

set -euo pipefail is the right first line of any shell script and it is still not enough: -e is famously full of exceptions, ignoring failures inside an if condition, in anything followed by &&, and in most of a function called in a condition. Nobody holds the whole rule in their head. Ruby's version is one sentence — an exception propagates until something rescues it — and rescue can be selective by class, which an exit status cannot.

The comment at the bottom is the idiom to reach for first. Anything that has to be released — a file, a directory you changed into, a lock, a timer — is usually handed out by a method that takes a block and cleans up when the block ends, so the cleanup lives in the library rather than at every call site. That is the same reason the language never needed a finally keyword.

An exit status is one number out of 256 and the message is unstructured text on another stream, so a caller can only tell failures apart by convention. An exception carries a class, a message, any attributes you gave it and the stack it came from, so rescue ArgumentError and rescue Errno::ENOENT respond differently without parsing anything. exit(2) still exists for the boundary where a Ruby script genuinely has to answer a shell.

Being an array rather than a set of numbered variables is the practical difference: it can be sliced, passed to a method, and iterated without the quoting rules that make "$@" and $* behave differently. For anything with options, do not parse it by hand — the next row is what you want.

This is the row that quietly justifies the move for anything another person will run. getopts handles single letters and nothing else, so every script accepting --dry-run contains a hand-written loop with its own bugs and a usage string that drifts out of date the first time an option is added. OptionParser is in the standard library, needs nothing installed, and also handles type conversion, required arguments and a list of permitted values.

So moving to Ruby does not mean abandoning the shell — a Ruby one-liner sits exactly where awk did, and reaches for a hash or a standard-library module when the job outgrows one expression. That makes the migration gradual: replace the one stage that has become unreadable, leave the rest, and keep going only as far as it helps. ruby -i.backup -pe is sed -i.

JSON.parse returns real objects: data["ports"] is an array of integers you can sum, sort or append to, and data["ports"][1] + 1 is 444 rather than a string concatenation. Pass symbolize_names: true to get symbol keys, which read better in the rest of the program. The reverse direction is the next row, and it is where the shell struggles most.

The shell rule is that JSON must be built with jq -n and --arg for every value, never by interpolation — a rule that gets skipped under deadline pressure precisely because the naive version works on the test data. to_json takes objects rather than text, so quoting is not a decision the caller makes and cannot be got wrong. The same argument applies to building SQL, HTML, URLs and shell commands.

A file is loaded once no matter how many others require it, so there is no include-guard problem, and the require lines at the top are an honest inventory of what a file depends on — which a pile of source lines is not. Two modules may both define log without either being disturbed. A shell script that has reached three files is telling you something.

Due to limitations of running Ruby inside the browser, minitest’s autorun feature cannot be used, which merely triggers Minitest.run when the code exits. Instead we must explicitly call Minitest.run. For that reason this code will look slightly different from what you’ll normally see or write. Testability is the quiet reason scripts get rewritten. A shell function can only be tested through the text it prints, so the test asserts on formatting as well as behavior and breaks when a message is reworded. A method returns a value, so the test checks the value and ignores the presentation. The wider tooling assumes that shape too — RSpec, SimpleCov for coverage, RuboCop for style, and Rake for running any of it.

That distinction earns its keep as soon as three tasks share a setup step: a dependency runs once no matter how many tasks name it, where a called function runs every time. rake -T lists the tasks with their descriptions, which is the usage message you no longer maintain by hand. And a Rakefile is ordinary Ruby, so a task can loop, read a configuration file, or be generated — none of which a case statement can do.

The test is not length. It is whether the script has logic — data with more than one level, arithmetic beyond counting, error handling that must distinguish failures, more than a few options, or anything the next person will modify under pressure. Orchestration and glue belong in the shell. And the move need not be all at once: ruby -ne is a pipeline stage, so the usual path is to replace the one unreadable stage and leave everything around it alone.