Visual Basic.CodeCompared.To/Bash

No module, no entry point, no compilation. Console.WriteLine becomes echo, which is a shell builtin rather than a library call. The important difference in kind: a Bash script is a list of commands, and every line you write is something you could also type interactively — which is why the shell is where system automation lives and why a script can be built up a line at a time.

A $name inside double quotes is expanded; inside single quotes it is literal, which is the whole distinction between the two quote characters. That makes "Hello, $name!" the equivalent of $"Hello, {name}!". For anything with a format specifier use printf, which takes the same C-style verbs as .NET does not — %05d for D5, %.2f for F2 — and needs an explicit \n. Prefer printf to echo in scripts: echo's handling of backslashes and leading dashes varies between shells.

' becomes #, and there is no block comment — a commented-out passage is a column of hashes. The first line, #!/usr/bin/env bash, is the shebang: it tells the system what to run the file with, and env bash finds whichever Bash is on the PATH rather than hard-coding a location. Without it the file is run by whatever shell invoked it, which on a Mac may still be Bash 3.2. There is no documentation-comment convention.

Dim count As Integer = 10 becomes count=10 — no spaces, because a space would make count a command and = its argument. There is no Dim and no type. Const becomes readonly. Every variable is global by default, even inside a function, which is the opposite of every other language on this anchor; local inside a function is what scopes one, and forgetting it is how a helper quietly overwrites a caller's variable.

An unquoted $path is split on whitespace and then glob-expanded, so a filename with a space silently becomes two arguments. Quoting it — "$path" — passes exactly one. There is no equivalent mistake in Visual Basic, because a String is one value however it is passed. The rule is simple and absolute: quote every variable expansion unless you have a specific reason not to. Almost every mysterious shell-script bug involving filenames is this.

A Bash variable holds a string, always. Arithmetic happens only inside $(( ... )), where a string is read as a number; outside it, "$count" + 5 is three words. Note also that $(( )) does integer arithmetic only — 7 / 2 is 3, and there is no floating point in the shell at all. Anything with a decimal point needs an external tool such as bc or awk, which is a strong hint that the task has outgrown a shell script.

${name:-default} yields the variable's value, or the default when it is unset or empty — If(supplied, "(unnamed)") exactly. Related forms: ${name:=default} also assigns the default, as the last two lines show, and ${#name} is the length. There is a fourth, ${name:?message}, which aborts the whole shell when the variable is unset — useful as a required-argument check at the top of a script, and not demonstrated here precisely because it would end the example. Note that Bash does not distinguish unset from empty unless you drop the colon (${name-default}), which is a finer distinction than Nothing versus "".

Every command produces an exit code: 0 for success and non-zero for failure, available in $?. That is the shell's error mechanism — there are no exceptions and no Try. An if does not test a boolean; it runs a command and branches on its exit code, which is why if check 5 has no brackets around it. The inversion catches everyone: 0 is success here and falsy everywhere else, so never reason about $? as though it were a Boolean.

$(command) runs the command and substitutes its output in place. That is the shell's defining convenience: every program's output is text and every program's text can be captured, which is why gluing tools together is what shells are for. Trailing newlines are stripped. The older backtick form does the same thing but cannot nest cleanly — use $( ). And quote the result when you use it, for exactly the reason the quoting row gave.

A pipe connects one command's output to the next one's input, so sort | uniq | wc -l is OrderBy().Distinct().Count() assembled from three independent tools. The shared interface is lines of text — that is the whole contract, and it is why a shell can compose programs nobody designed to work together. It is also the limitation: there are no objects flowing through, so structured data has to be re-parsed at every stage, which is what PowerShell and Nushell were built to fix.

> writes (truncating), >> appends, and < feeds a file in as input — so File.WriteAllText, File.AppendAllText and File.ReadAllText are one character each. >&2 sends a line to standard error, which is Console.Error and is where diagnostics belong so they do not pollute a pipeline. 2>/dev/null discards errors, and &> redirects both streams at once.

End If becomes fi and ElseIf becomes elif. The condition is a test command, and its operators split by type: numbers use -gt, -lt, -eq, -ne; strings use ==, !=, <. Using > on numbers inside [[ ]] compares them as text, so 9 > 100 is true. Prefer [[ ]] to the older [ ]: it does not word-split, so an unquoted variable is safe inside it. -n, -z, -f and -d test non-empty, empty, file and directory.

Select Case becomes case ... esac, Case a, b becomes a|b), and Case Else becomes *). Each branch ends with ;;, and no branch falls through. The addition is that the labels are glob patterns, so *.log matches any name ending in .log — pattern matching that Select Case cannot do without a chain of Ifs. This is how almost every script parses a subcommand.

For Each x In list becomes for x in item item; do ... done — and that is the only for. A counted loop uses a brace range, {1..5}, which is expanded before the loop runs. While ... End While becomes while ...; do ... done, and (( )) is the arithmetic form where a variable needs no $. The last form — piping into while read -r line — is how a script processes a file or another command's output line by line, and -r stops backslashes being eaten.

A function declares no parameters at all: arguments arrive positionally as $1, $2, with $# as the count and "$@" as all of them. The idiom is to assign them to local names immediately, which is the only documentation the signature gets. A default is ${2:-Hello}, the parameter-expansion form from earlier. "$@" must be quoted — unquoted, it re-splits every argument on whitespace.

return sets the function's exit code, and an exit code is a single byte — 0 to 255, with 0 meaning success. So it is for success or failure, not for a value. A function's result is whatever it prints, captured by the caller with $(...). That is the shape of every Bash function that computes something, and it has one consequence worth knowing: anything else the function echoes, including a stray debug line, becomes part of the result.

Add becomes +=( ), Count becomes ${#fruits[@]}, and an element is ${fruits[0]}, zero-based. The distinction that matters: "${fruits[@]}" expands to one word per element, preserving spaces inside them, while "${fruits[*]}" joins them into a single string. Iterating always wants "${fruits[@]}", quoted — dropping either the quotes or the [@] re-splits everything on whitespace.

declare -A creates an associative array; without it, ages["Ada"]=36 quietly assigns to index 0 of an ordinary array. ContainsKey becomes [[ -v ages["key"] ]], and "${!ages[@]}" is the list of keys — the ! means "the keys, not the values". Iteration order is unspecified. 🚨 These need Bash 4.0+, and macOS ships Bash 3.2, so a script using them must run under a Homebrew Bash and say so in its shebang.

These are parameter expansions, and they are worth learning because they need no external program. ${#x} is Length. ${x^^} is ToUpper. ${x##*/} strips the longest match of */ from the front, which is Path.GetFileName; ${x%/*} strips the shortest match from the end, which is the directory. ${x%.txt} removes a suffix and ${x/a/b} replaces the first occurrence (// for all). One # or % is shortest-match, two is longest.

grep selects lines — Where. sed edits them — Replace, with regular expressions. awk splits each line into fields and is a small programming language of its own, which is what you want for anything column-shaped. Note IFS=: read -r name age: setting the field separator for one read splits a line straight into named variables, which is Split without an array. Learning these three well is most of what "knowing the shell" means.

There is no exception to propagate, so a failed command sets $? and execution continues to the next line. That is how a backup script deletes the old copy after the new one failed. The conventional first line is set -euo pipefail: -e exits on a failed command, -u treats an unset variable as an error, and -o pipefail makes a pipeline fail if any stage does rather than only the last. It is not a complete safety net — -e has well-known exceptions, notably inside if conditions and && chains — but it turns most silent failures into loud ones.

trap 'commands' EXIT runs those commands when the shell exits — normally, on an error under set -e, or when interrupted. That is Finally, registered at the point the resource is acquired rather than wrapped around the work, which is the same idea as Go's defer. Other signals can be trapped too (INT for Ctrl-C, TERM), and mktemp plus a trap on the next line is the standard way a script handles a temporary file.

A failing function writes its message to standard error (>&2) and returns non-zero — keeping the error off stdout so a caller capturing the result does not get it mixed in. Then command || handler runs the handler on failure, if ! output=$(...) captures the message and branches, and && ... || ... chains both. There is no exception object and no stack trace, so a script that wants to be debuggable says which step failed itself.

Sub Main(args As String()) becomes $1, $2, $# and "$@" at the top level of a script. $0 is the script's own name. The option-parsing idiom is a while over $# with a case inside and shift to consume one argument per pass — there is no argument-parsing library in the language, though getopts handles single-letter flags. A usage message goes to standard error and the script exits non-zero, by convention 2 for a usage error.

Nothing checks a shell script before the line executes — a misspelled variable expands to nothing, a wrong operator silently does something else. ShellCheck is what replaces the compiler: it reads the script and reports the specific traps this page has been describing, each with an SC#### code and an explanation. The second example above is genuinely dangerous — an unquoted, empty variable turns rm -rf $file/* into rm -rf /*. Install it, run it on everything, and put it in CI.

Bash is superb at what it was built for: running programs, wiring them together, and reacting to exit codes. It has no JSON parsing, no floating point, no nested data structures, no modules and no real testing culture. The signs to stop are concrete — you want a dictionary of lists, you are parsing JSON with sed, you need a decimal, the file passed a hundred lines, or you have written the same three-line function twice. The usual next step is Python, which is also the other page a VBA reader on this anchor should read.

Word splitting happens on every unquoted expansion, so $name holding my report.txt becomes two arguments. Then globbing runs, so a value containing * expands to matching filenames — a second way one value becomes several. Quoting stops both. There is no counterpart in Visual Basic, where a String is one value in every context. The habit that removes the entire class of bug: quote every expansion — "$name", "$@", "${array[@]}", "$(command)" — and let ShellCheck find the ones you miss.

An exit code of 0 means success, so if command takes the branch when the command returned 0. Inside (( )), which is arithmetic, 0 is false and non-zero is true, as in C. So return 0 means "it worked" and (( 0 )) means "false" — in the same script, a few lines apart. Never store a truth value as 0/1 and test it both ways; use a string ([[ $ready == yes ]]) or rely on exit codes consistently.

Inside [[ ]], < and > compare as text, so "9" sorts after "100" — the same lexicographic surprise JavaScript's sort() produces. Numeric comparison inside [[ ]] uses the word operators: -gt, -lt, -ge, -le, -eq, -ne. Or use (( )), which is arithmetic throughout and lets you write the symbols you meant. Worse still, inside the older single-bracket [ ], an unquoted > is a redirect and will create a file.

A subshell — anything in ( ) — runs in a separate process with a copy of the variables, so assignments inside it are invisible outside, as the first two lines show. Each stage of a pipeline is also a subshell, which means a while read loop on the right of a | updates its own total and the original is still 0 when the pipeline ends — no error, no warning. That is why the pipeline version is written as a comment here: the in-browser Bash has no fork(), so it runs the stages in one process and would print the right answer for the wrong reason, teaching the opposite of the point. In a real shell it prints 0. The fix is to avoid the pipe: done < <(command) is process substitution, which feeds the output in as a file so the loop runs in the current shell.

VBScript's power on Windows came from COM — FileSystemObject, WScript.Shell, driving Excel and Outlook by automation. None of that exists here, and Bash has no object model to replace it: the shared currency between programs is lines of text. On Windows the direct successor is PowerShell, which kept objects in the pipeline and is the closer match to a VBScript mental model. On Linux and macOS, Bash is what the machine gives you, and for anything past simple glue the answer is Python.