Shell programming

Terminal and prompt

A terminal is a window for typing commands. The shell is the program that reads and runs them; this course uses bash. A prompt such as $ or % means it is your turn to type. Enter a command after it and press Enter. This way of using a computer is called a CLI (command-line interface).

In more detail The prompt often shows more than $: on many computers it looks like you@laptop:~$ — your user name, the computer's name, the folder you are in (~ means your home folder) and then $. While a command is running the prompt disappears until it finishes; that is how you know the shell is busy. If a command seems stuck, press Ctrl+C to stop it and get the prompt back.

The three parts of a command

Most commands contain an action, options, and a target. For example, ls -l notes.txt means list files, show details, and use the notes.txt file. For a command you do not know, man followed by its name or the command with --help shows its manual (the practice terminal opens the real manual too — press q to close it).

In more detail Options usually start with a dash. One dash takes short, one-letter options, and you can join them: ls -l -a is the same as ls -la. Two dashes take long, readable names such as ls --all. Arguments are the things the command works on — usually file or folder names — and many commands accept several at once: ls notes.txt photos. If a name contains a space, wrap it in quotes so it stays one argument.

Know where you are

Your current folder always matters. Use pwd to see it, cd to move, and ls to inspect its contents. ~ means your home folder and .. means the parent folder.

In more detail A path is the address of a file. An absolute path starts at the top of the disk with / (for example /home/you/notes.txt), so it works from anywhere. A relative path starts from where you are now (photos/cat.jpg), so it only works in the right folder. cd on its own takes you straight home, and cd - jumps back to the folder you were in before. Press Tab while typing a name and the shell completes it for you (Tab completion) — fewer typing mistakes.

Opening a terminal on your own computer

On this page you can practise right away in the practice terminal, with nothing to install. On a Mac, open the Terminal app (search for Terminal in Spotlight). On Windows, open PowerShell from the Start menu; to use the same bash commands as this course, install WSL and open Ubuntu. On most Linux desktops, press Ctrl+Alt+T.

In more detail On a Mac the standard shell is zsh, which understands almost every command in this course; type bash if you want exactly the same shell as here. In PowerShell a few names (ls, cd, pwd) work but behave differently and many others do not exist, which is why WSL is recommended on Windows. Wherever you are, the arrow keys bring back earlier commands: press ↑ to repeat or edit the last one instead of typing it again.

When a command needs root — sudo

Anything that changes the whole computer — installing a program, or writing into a system folder such as /etc — belongs to the administrator (root), so the shell answers Permission denied. Put sudo in front and the same command runs with those rights: sudo apk add tree. The practice terminal asks for no password; on your own computer you type your login password. Use it only when a command really needs it.

In more detail sudo normally runs one command as administrator. Use it for tasks such as installing packages (apk add or apt install), changing /etc or /usr, or mounting disks. It does not prevent mistakes: check the command and target first. For permission errors in your home folder, inspect ownership and permissions. Even npm install -g may not need sudo, depending on the installation location.

Create — mkdir and touch

mkdir creates folders and touch creates empty files. mkdir -p a/b/c conveniently creates every missing parent folder. Like most commands, they print nothing when they succeed, so run ls to see the result.

In more detail touch has a second job: if the file already exists, it leaves the contents alone and only updates its 'last changed' time, so running it twice is safe. mkdir, on the other hand, complains with 'File exists' if the folder is already there — unless you add -p, which quietly accepts existing folders. Names with spaces need quotes (mkdir "my notes"); many people use - or _ instead of spaces to avoid that trouble.

Copy, move, rename — cp and mv

cp creates a copy and keeps the original. mv moves a file or renames it. For both, write the source first and the destination second. For example, mv memo.txt diary.txt renames memo.txt to diary.txt in the same folder.

In more detail When the last argument is an existing folder, cp and mv put the files inside it with the same names: cp a.txt b.txt backup/ copies two files into backup. To copy a whole folder you must add -r (recursive), otherwise cp refuses; mv moves folders without any option. Renaming with mv is instant even for huge files, because only the name changes and nothing is copied.

Read content — cat, head, tail

cat prints a whole file, while head and tail show only the beginning or end. rm deletes immediately without using the Trash, so use it carefully.

In more detail head and tail show 10 lines unless you say otherwise: head -n 3 shows three. tail -f follows a file and keeps printing new lines as they are added, which is how people watch a log while a program runs (Ctrl+C stops it). For long files use less: it shows one screen at a time, Space pages down, / searches and q quits. Because rm skips the trash, a good habit is to run ls with the same name or pattern first, and only then rm.

grep — find text

grep word file prints only matching lines. Add -i for case-insensitive search, -n for line numbers, or -r for recursive folder search.

In more detail grep reads a file line by line and prints every line that contains the pattern anywhere — a search for cat also finds 'concatenate'. Add -w to match whole words only. Put the pattern in quotes when it contains spaces or symbols (grep "error code" app.log). With -r and a folder, grep writes the file name in front of each match, so you can see where every hit is.

Sort and count — sort, uniq, wc

sort puts lines in order. uniq combines identical neighboring lines, so use sort first to bring scattered duplicates together. wc -l counts lines. In the next lesson, you will connect these commands with pipes to make simple summaries.

In more detail sort compares text, so by default 10 comes before 9; use sort -n for numbers and sort -r to reverse the order. uniq only joins identical lines that are next to each other, which is why it almost always comes after sort. wc without options prints three numbers — lines, words and bytes — in that order; -l, -w and -c choose one.

find — find files and folders

grep finds lines inside files; find finds the files and folders themselves. It walks the starting folder and every folder below it, and prints the path of each match on its own line. The skeleton is find where condition action.

• where — the folder to start from. . is the current folder and ~ is your home folder; if you leave it out, find uses .
• condition — -name "*.txt" matches by name (keep the pattern in quotes), -iname ignores case, -type f picks only files and -type d only folders. With several conditions, all of them must match.
• action — if you write none, it is -print (show the path). -exec command {} \; runs a command for every match, with the path in place of {}.

find . with no condition lists everything below the current folder. Each result is a path starting from the folder you gave, such as ./photos/cat.jpg, so you can hand it straight to another command.

In more detail find does not just look at matching names — it walks the whole folder tree from the top down. Run it on a big place such as / or your whole home folder and it takes a while, and every folder you may not read adds a Permission denied line; add 2>/dev/null at the end to throw those errors away. -maxdepth 1 keeps find in the current folder without going into subfolders. -name is case-sensitive (README.md and readme.md differ) and looks only at the name, not the path — use -path "*/src/*" to match the path. Paired with grep, it answers "which files contain that word?": find . -name "*.js" -exec grep -l "TODO" {} +

Pipes ( | )

commandA | commandB sends A’s output to B as input. In ls | grep txt, ls makes a list and grep txt shows only lines containing txt. Run the left-hand command first to see its output, then add | and the next command.

In more detail Every command has a standard input (where it reads) and a standard output (where it writes — normally the screen). A pipe connects the output of the left command to the input of the right one, and both run at the same time, so data flows through as soon as it is produced. Build pipelines step by step: run the first command, look at its output, then add | and the next command.

Redirection ( >, >>, < )

> overwrites a file, >> appends, and < uses a file as input. Use 2> to redirect errors separately.

In more detail The shell sets up redirection before the command starts. That is why sort data.txt > data.txt destroys the file: > empties data.txt first, and then sort reads an empty file. Write to a new file instead (sort data.txt > sorted.txt). Numbers name the streams: 0 is input, 1 is normal output and 2 is errors, so 2> sends only errors to a file, and > (the same as 1>) only normal output.

Show and save at once — tee

tee saves its input to a file and also sends it to the screen or the next command. Think of a T-shaped pipe splitting the flow in two. ls | tee list.txt displays and saves the list. Use tee -a to append to an existing file.

In more detail tee is also the usual way to write a file that needs administrator rights. echo "text" | sudo tee /etc/somefile works. But sudo echo "text" > /etc/somefile fails. That is because the redirection (>) is done by your own shell, not by sudo. Add > /dev/null at the end when you only want the file and not the copy on the screen.

Create and read variables

Create a variable with name=value and read it with $name. Never put spaces around =: name=Lyen works, while name = Lyen does not.

In more detail Variable names may use only English letters, digits and _ (no other scripts), and cannot start with a digit. By habit, your own variables are lowercase and settings shared with other programs (PATH, HOME) are UPPERCASE. A variable lives only in the shell where you made it: open a new terminal and it is gone. To keep a value for every session, put the line in ~/.bashrc (or ~/.zshrc on a Mac).

Protect values with double quotes

Use "$name" so values containing spaces stay together. This is one of the most important safe-shell habits.

In more detail Double quotes still let $ work, so "$name" gives the value, but they keep spaces and stop * from turning into file names. When letters follow a variable directly, use braces to show where the name ends: "${name}s" prints the value plus s, while "$names" looks for a variable called names. Single quotes switch variables off completely ('$name' prints $name).

Arithmetic and command substitution

$(( )) inserts a calculation result: $(( 3 + 4 )) becomes 7. $( ) inserts a command’s output. today=$(date) runs date and stores its output in today. Remember: double parentheses calculate; single parentheses here run a command.

In more detail Inside $(( )) you can write variables without $ ($(( count + 1 ))) and use +, -, *, / and % (the remainder) with parentheses. bash only counts in whole numbers, so $(( 7 / 2 )) is 3 — the decimal part is dropped. $( ) is different: it runs a command. Together they make lines such as files=$(ls | wc -l); echo "$(( files * 2 ))".

The if statement

if checks a condition and runs the commands after then when it is true. Use elif to check another condition, and else for what to do when none match. Finish with fi. Read if condition; then ... fi as “if this is true, do this.”

In more detail The condition after if is really a command: if runs it and checks its exit code, and 0 means true. That is why if grep -q milk notes.txt; then … works without any brackets. Indent the lines between then and fi so you can see where each block ends, and remember the ; before then when you write everything on one line.

Comparisons with [[ ]]

Use == and != for strings; for numbers use -eq (equal), -gt (greater than), -lt (less than), -ge (greater than or equal) and -le (less than or equal); and use -f or -d to check files and folders.

In more detail Inside [[ ]] you can join tests with && (and) and || (or), and ! means not: [[ -f notes.txt && ! -d backup ]]. Quote variables in comparisons when in doubt; with the older single bracket [ ] it is required, because an empty variable leaves a hole in the command. For pure numbers (( )) reads more naturally: if (( score >= 80 )); then …

The for loop

for item in list; do ... done puts each list item into a variable. You can loop over {1..5} or over files.

In more detail The list after in is expanded before the loop starts, so for f in *.txt runs once per text file with the name in $f. If no file matches, the pattern itself is used once ($f becomes *.txt), so check with [[ -e $f ]] or switch on nullglob (lesson 9). Do not loop over $(ls); the pattern is safer when names contain spaces.

Repeat a fixed number of times with seq

seq 1 20 produces the numbers 1 through 20. for i in $(seq 1 20); do ... done puts each number into i and repeats 20 times. Keep in in the pattern “for variable in list”. For a fixed range, you can also use for i in {1..20}.

In more detail seq can also count in steps and backwards: seq 0 5 20 gives 0 5 10 15 20, and seq 10 -1 1 counts down. Brace ranges such as {1..20} cannot use variables ({1..$n} does not work). When the end comes from a variable, use $(seq 1 "$n") or the C-style for ((i=1; i<=n; i++)).

Define and call functions

name() { commands; } turns a command sequence into a reusable name. Inside a function, $1 and $2 hold incoming arguments.

In more detail Define a function before calling it. Inside, $1 and $2 are the arguments passed to that function. Print a text result with echo and capture it with result=$(myfunc). return does not return text: return 0 signals success, while a nonzero value such as return 1 signals failure (range 0–255).

Script files and shebangs

A script stores several commands in a file such as hello.sh. Its first line, #!/bin/bash, is called a shebang. It selects bash when you run the file directly as ./hello.sh, even if your current shell is zsh. You can also choose the program explicitly with bash hello.sh.

In more detail The shebang must be the very first line and start exactly with #!. Many scripts use #!/usr/bin/env bash instead: env finds bash wherever it is installed, which helps on systems where bash is not in /bin. The .sh ending is only a hint for people; the shebang, not the name, decides which program runs the file.

Permission and arguments

Run chmod +x hello.sh before ./hello.sh. Read incoming values with $1, $2, $@, and $#.

In more detail ./ means 'the file in this folder'. The shell looks for commands only in the folders listed in PATH, and the current folder is not one of them, so hello.sh on its own gives 'command not found'. ls -l shows the permission: -rwxr-xr-x contains x, so the file can be run. $0 is the script's own name, and "$@" in quotes passes every argument on unchanged, even those with spaces.

Exit codes and $?

Every command returns 0 for success or another number for failure. $? reads the previous result, and A && B runs B only when A succeeds.

In more detail Each program chooses its own non-zero codes — grep, for example, returns 1 when nothing matched and 2 when something went wrong. A || B is the opposite of &&: B runs only if A failed, as in mkdir backup || echo "could not create". End a successful script with exit 0 and a failed one with exit 1 (or another number), so whoever runs it — a person, cron or another script — can check the result.

Automate repeated work

Combine loops with file commands to process many items, such as copying every photo into a dated backup folder.

In more detail Before changing files, preview the command by putting echo before it. This is a dry run. $(date +%F) in a backup name separates days, but another run on the same day reuses the name. Include the time for separate backups. Print messages at each step to show progress.

Scheduled runs — cron

cron schedules commands at set times. Open the configuration with crontab -e. Write five fields—minute, hour, day, month, weekday—then the command. 0 3 * * * means daily at 3 a.m. Put the schedule below in crontab; it is not a command to run at the prompt.

In more detail The five fields are minute (0–59), hour (0–23), day of the month, month and day of the week (0 = Sunday). * means every; */15 in the minute field means every 15 minutes; 1-5 in the weekday field means Monday to Friday. cron runs with a very short PATH and no terminal, so use full paths and send the output to a log, or you will never see the errors. crontab -l lists your current jobs.

Three kinds of quoting

Quotes change how a variable is read:

• "$var" (double quotes) — expands the variable but keeps spaces.
• '$var' (single quotes) — keeps everything literal.
• unquoted $var — may split at spaces and turn characters like * into file names.

When in doubt, wrap it in double quotes.

In more detail A quick test makes the difference visible: with name="a b", echo $name prints a b (the spaces are squeezed) while echo "$name" prints a b. To put a single quote inside text, wrap it in double quotes ("it's"). Inside double quotes only a few characters stay special — $, `, " and \ — and a backslash in front protects them.

Word splitting and globbing

bash first splits an unquoted variable on whitespace (word splitting), then replaces * and ? with matching file names (globbing). If file contains my notes.txt, cp $file backup/ can read it as two files. cp "$file" backup/ passes it as one name.

In more detail Splitting uses the characters in IFS — space, tab and newline by default. Globbing then replaces *, ? and [abc] with matching file names, so a variable holding * can suddenly turn into every file name in the folder. Both happen only to unquoted expansions; inside double quotes they never happen.

Defensive options

set -euo pipefail helps catch mistakes early in a script. Each option has a role.

• -e stops on command failure, with exceptions such as conditions tested by if.
• -u reports an error when you use an unset variable.
• pipefail makes a failure inside a pipeline affect its overall exit status.

These options do not prevent every mistake. Check with shellcheck and verify the actual results too.

In more detail Put set -euo pipefail right after the shebang so it covers the whole script. Install shellcheck with a package manager (brew install shellcheck, sudo apt install shellcheck). It works inside many editors and underlines mistakes as you type. Its warnings have codes such as SC2086 (missing quotes), and each code has a page that explains the fix.

What is Node.js?

Node.js is a program (a runtime) that runs JavaScript outside the browser — in terminals and servers. Tools for building web pages, command-line (CLI) tools, build scripts, and many AI coding agents depend on it. After shell basics, Node is the next foundation for installing developer tools.

In more detail Node.js uses the same JavaScript engine as Chrome (V8). But instead of showing web pages, it reads and writes files, opens network connections and runs other programs. Versions with an even number (22, 24 and so on) become long-term support (LTS) releases that get fixes for years, so they are the safe choice for learning. Install from nodejs.org, or with nvm (see the advanced topics).

The node command

Use node -v (or --version) to check the version. node app.js runs a file; node -e "console.log(1+1)" runs a one-liner. Missing files or syntax errors print an error message.

In more detail Typing node on its own opens the REPL — an interactive prompt (>) where each line of JavaScript runs at once; .exit or Ctrl+D leaves it. A script can read its arguments from process.argv: with node greet.js Mina, process.argv[2] is "Mina". console.log writes to standard output, so Node programs fit into pipes like any other command (node report.js | grep total).

npm and package.json

npm installs and manages packages: bundles of reusable code. A project’s package.json lists its name, version, required packages (dependencies), and commands (scripts). In that folder, npm install downloads packages and npm run start runs the start script. npx runs a package’s command without a global installation.

In more detail npm install creates two things. node_modules is the downloaded code — often very large; never edit it or commit it. package-lock.json lists the exact versions installed — you do commit it so everyone gets the same. npm ci installs exactly what the lock file says, which is what automatic builds use. A version like ^4.17.21 means 'this version or a newer compatible one'.

Why install tools in the terminal?

Modern development is not only an editor. These tools run in the terminal:

• AI coding agents — Grok Build, OpenAI Codex, Claude Code
• deploy CLIs — Firebase tools
• package managers — pnpm and others

The Node and npm skills from Lesson 10 are the starting point.

In more detail Most of these tools need an account: you sign in once in the browser (for example firebase login) and the tool remembers you. They are ordinary programs in your PATH, so everything from this course — pipes, scripts, exit codes — works with them too. An AI coding agent can run commands for you, which makes understanding what a command does more important, not less.

Common installs (short summary)

Official methods can change — always prefer the vendor docs. Typical starts:

• Claude Code: curl -fsSL https://claude.ai/install.sh | bash (or npm install -g @anthropic-ai/claude-code)
• OpenAI Codex: curl -fsSL https://chatgpt.com/codex/install.sh | sh (or npm install -g @openai/codex)
• Grok Build: the official installer, or npm install -g @xai-official/grok
• Firebase CLI: npm install -g firebase-tools

Then check the version with claude --version, codex --version, firebase --version.

In more detail If a command is missing just after installation, open a new terminal first: it may pick up the updated PATH. To reload settings manually, use the file for your shell, such as ~/.zshrc for zsh or ~/.bashrc for bash. Update using the installation method. For npm tools, use npm install -g firebase-tools@latest to update, or npm uninstall -g followed by the package name to remove.

Safe install habits

Prefer reading curl | bash scripts from trusted official domains. If global npm hits permission errors, fix nvm instead of using sudo. In teams and CI, pin tools as devDependencies so versions stay consistent.

In more detail Download an installer and read it before you run it. Get it with curl -fsSL URL -o install.sh, read it with less install.sh, then run bash install.sh. In -fsSL, -f stops on server errors, -s keeps quiet, -S still shows errors and -L follows redirects. Never paste a curl | bash line from a random video or forum; copy it from the tool's official site.

The shell is the conductor, not the soloist

Doing every calculation in shell alone hits a wall fast. Instead the shell decides who to call and when: Python for math and data, awk for tables, sed for bulk text edits — and the shell stitches the results together. Knowing the shell means you can use languages you have never studied.

Pass a single line — -c and -e

Most languages accept code as an argument and run it immediately: python3 -c "code", node -e "code", perl -e, ruby -e. Just replacing your calculator with python3 -c "print(2**10)" makes the terminal far more powerful.

Save it to a file and run it

If a program is worth keeping, put it in a file. Write the code into hello.py, and python3 hello.py runs it as is.

The shebang from Lesson 7 makes it simpler:

• Write #!/usr/bin/env python3 as the first line.
• Run chmod +x hello.py to make it executable.
• Now ./hello.py runs on its own, without python3 in front.

Type echo $? afterwards and you see whether it succeeded (0) or failed (1). So you can chain the next command with &&, exactly as Lesson 8 showed.

Pass many lines — the heredoc

Use a heredoc to pass several lines of code at once. Enter python3 - <<'PY', write Python code on the following lines, and finish with PY alone on a line. The text between the markers goes to Python. The - means read code from standard input instead of a file. Coding agents also use this form for multiline code.

<<'PY' is not the same as <<PY

Quote the closing tag (<<'PY') and the body is passed through literally. Leave it unquoted (<<PY) and the shell first substitutes $variables and $(commands) inside it. Python code rarely contains $, but a regex or string that does will break silently — so quoting the tag is the default when passing code.

sed — the stream editor that finds and replaces

The basic shape for replacing text with sed is s/find/replace/:

• sed 's/find/replace/' — changes the first match on each line.
• Add g at the end (s/…/…/g) to change every match on the line.
• Put a line number or /regex/ in front to choose the lines (2s/…/…/, /error/s/…/…/).
• Pair -n with p to print only the lines you picked.
• The delimiter need not be /. For paths, s|/old/path|/new/path| reads much better.

To edit the file itself, write sed -i.bak 's/find/replace/' file. It is safe because it keeps the original as file.bak. (macOS and Linux differ here — see Watch out below.)

awk — a small programming language for tables

awk is a small language and command for tabular text. It splits each line on whitespace: $1 is the first field, $2 the second. NF counts fields; NR counts lines. In awk 'pattern { action }', the pattern selects lines and { } sets the action. Omit the pattern for every line, or the action to print matching lines. BEGIN runs once before reading; END runs once afterward, for setup or totals.

Chain languages with pipes

Programs that read standard input and write standard output chain freely through pipes. For example, cat sales.txt | awk '{print $2}' | sort -n | tail -3 does all this in one line:

• read the file
• take the second column
• sort numerically
• keep the three largest

awk and sed are joined this way; Python takes its code through -c or a heredoc instead. That is what it means for the shell to be the conductor.

Run AI-generated code safely

AI usually answers in exactly this heredoc form. Before pasting it, check three things: read the file paths it touches, look for rm or > that overwrite, and back up anything important first with cp original original.bak. Being able to read shell means being able to verify what the AI gave you.

A regular expression describes the "shape" of text

Searching for 010-1234-5678 finds that number. To find numbers with the same 3-4-4 digit format, write [0-9]{3}-[0-9]{4}-[0-9]{4}. [0-9] means one digit; {3} repeats it three times. This search rule is a regular expression. grep, sed, awk, vim, Python, JavaScript, and PHP share many basic symbols; check each tool’s syntax details.

Symbols that pick one character

. is any one character (a.c matches abc and a1c). [abc] is one of the characters in the brackets, [^abc] is one character that is not in them, and [a-z] or [0-9] is one character in a range. Common sets have short names: \d is a digit, \w is a word character (letter, digit or _), and \s is whitespace. Capital letters (\D \W \S) mean the opposite. Shell tools also accept POSIX names such as [[:digit:]] and [[:space:]].

Symbols that say how many times

* means the character just before it 0 or more times, + means 1 or more, ? means 0 or 1 (colou?r matches color and colour), {n} means exactly n times, and {n,m} means n to m times. A repeat symbol applies only to the one character (or one bracket group) right before it. Repeats also grab as much as they can (they are greedy): ".*" takes everything from the first quote to the last quote on the line, so to stay inside one pair of quotes write "[^"]*".

Symbols that mark a position — ^ $ \b

^ is the start of a line and $ is the end. ^error matches lines that start with error, done$ matches lines that end with done, and ^$ matches an empty line. \b is a word boundary, so \bart\b finds art but not party. These symbols take up no characters; they only mark a position. Do not confuse them with a ^ at the front of brackets ([^0-9]), which means "not" — something completely different.

Groups and alternatives — ( ) |

red|blue means red or blue. ( ) turns several characters into one unit — (ab)+ matches ab, abab and ababab. Groups also let you take out what was found: \1 \2 in sed, ${BASH_REMATCH[1]} in a shell script, and m.group(1) in Python. That is why turning 2026-10-15 into 15.10.2026 takes just one line.

Using a symbol as a plain character — escaping

. * + ? ( ) [ ] { } ^ $ | \ all have special meanings. To find the character itself, put \ in front of it: a dot is \., a star is \*, an opening bracket is \(. If you write the IP address 192.168.0.1 as it is, each . means "any character", so 192x168y0z1 matches too. And in the shell, always wrap the pattern in single quotes. Otherwise the shell changes * ? $ { } its own way before the command even sees them.

Basic and extended grammar — why add -E

You meet three regex grammars with grep and sed:

• basic grammar (BRE) — what grep and sed read by default. + ? | ( ) { } are ordinary characters, so to use them as features you write \+ \| \( with a backslash.
• extended grammar (ERE) — add -E (grep -E, sed -E) and write the symbols as they are. When in doubt, always add -E.
• Perl style (PCRE) — uses symbols such as \d. So in grep -E, \d is the letter d, not a digit.

In shell tools write [0-9]; if you really want \d, use grep -P (Linux). Python, JavaScript, PHP and ripgrep (rg) understand \d out of the box.

Commands built in on macOS, Linux and Windows

macOS and Linux come with grep, sed, awk, find and perl. But each system is a little different:

• macOS — grep and sed are BSD versions. There is no grep -P, you write [[:space:]] instead of \s, and sed -i needs '' after it when editing a file.
• Linux — the GNU versions, where -P, \s and \+ all work.
• Windows — Command Prompt has findstr, and PowerShell has Select-String, -match and -replace. PowerShell understands \d as it is. Install WSL or Git Bash and you can use grep and sed too.

The "Built-in commands by OS" table below collects examples.

Using regex in shell scripts and Python

In a bash script, check a value with [[ $value =~ pattern ]]:

• It is true when it matches, so you can follow it with && or use it in if.
• The parts in ( ) go into ${BASH_REMATCH[1]}.
• Quoting the pattern makes bash compare it as plain text. So write the pattern without quotes, or keep it in a variable like re='…' and use [[ $value =~ $re ]].

In Python, import re and use the functions below. Write the pattern as a raw string with an r in front, like r"\d+".

• re.search — find
• re.findall — find all
• re.sub — replace
• re.fullmatch — check the whole text