Files and directories from the command line

rm -rf -- "$build_dir/" deletes a build folder, until the day build_dir is empty and the same line means “delete everything under /”. The shell has no recycle bin, so the commands that create, copy, move and delete files are worth learning with their one or two sharp edges in view.

Below you will move around a small tree with relative and absolute paths, build, copy, move and delete files and folders, write a delete that refuses to run on an empty variable, and look inside files with cat, head, tail, wc and file, all in recorded sessions you can repeat.

Paths start at the top, at home or at the current folder

Every command runs in a current folder, which pwd prints. A path that starts with / is absoluteabsolute path: A path that starts at the top of the file system, /, so it names the same file wherever a command runs, such as /etc/hosts.: it is read from the top of the disk, wherever you are. A path that starts with ~ starts at your home folder. Any other path is relativerelative path: A path read from the current folder, the one pwd prints; . is the current folder and .. its parent, so docs/a.txt names a different file in each folder. and is read from the current folder: . is the current folder itself and .. its parent. Step through the moves of the session below in the tree it builds:

Here is the same walk as a recorded session. So that no real user name appears, the session shows its home folder as ~; on your own computer pwd prints the full path, such as /home/asha/demo or /Users/asha/demo:

from session import run

# Moving around a small tree with relative and absolute paths. The session starts in ~/demo.
run("""
pwd
mkdir -p project/src project/docs
cd project
pwd
cd src
pwd
cd ../docs
pwd
cd ~/demo
pwd
cd ..
pwd
cd demo/project/src
pwd
cd ~/demo
ls project
""")

$ pwd
~/demo
$ mkdir -p project/src project/docs
$ cd project
$ pwd
~/demo/project
$ cd src
$ pwd
~/demo/project/src
$ cd ../docs
$ pwd
~/demo/project/docs
$ cd ~/demo
$ pwd
~/demo
$ cd ..
$ pwd
~
$ cd demo/project/src
$ pwd
~/demo/project/src
$ cd ~/demo
$ ls project
docs
src

cd ../docs went up to project and down into docs in one step, and cd ~/demo came back from anywhere. ls project listed the folder without moving into it: most commands take a path, so you rarely need cd just to look.

Two shortcuts save typing. cd on its own goes straight back to your home folder, and cd - returns to the folder you were in before and prints its name. Both come from POSIX’s specification of cd, so they work in every POSIX shell, and both are handy when you jump between two folders while you work.

Four commands create, copy, move and delete, and deleting has no undo

Four commands do most of the work. mkdir -p a/b creates a folder and any missing parents, and succeeds if they exist already, which makes it safe to run twice. cp copies a file, and cp -R a whole tree. mv moves a file, and renames it when the destination is a new name in the same folder. rm deletes files, and rm -r folders with everything in them, at once and for good: there is no recycle bin. rmdir removes only an empty folder, which makes it the safe way to tidy up: it refuses any folder that still holds something.

from session import run

# Creating, copying, moving and deleting, then a sorted listing of what is left.
run("""
mkdir -p project/src project/docs
printf 'echo hi\\n' > project/src/main.sh
cp project/src/main.sh project/src/main.bak
mv project/src/main.bak project/docs/old.sh
cp -R project backup
printf 'secret\\n' > project/.env
ls project
ls -a project
find . -type f | sort
rm -r backup
ls
""")

$ mkdir -p project/src project/docs
$ printf 'echo hi\n' > project/src/main.sh
$ cp project/src/main.sh project/src/main.bak
$ mv project/src/main.bak project/docs/old.sh
$ cp -R project backup
$ printf 'secret\n' > project/.env
$ ls project
docs
src
$ ls -a project
.
..
.env
docs
src
$ find . -type f | sort
./backup/docs/old.sh
./backup/src/main.sh
./project/.env
./project/docs/old.sh
./project/src/main.sh
$ rm -r backup
$ ls
project

Two of these commands can also destroy data without asking. When the destination of cp or mv is an existing file, it is overwritten silently, so mv draft.txt final.txt replaces any final.txt that was there. cp -i and mv -i ask before they overwrite, and mv -n never overwrites at all, which makes them the safer choice when you are working by hand.

One more detail showed up: ls project did not list .env. Names that begin with a dot are hiddenhidden file: A file whose name begins with a dot, such as .env. ls and the glob * skip such names unless asked, for example with ls -a. from ls and from * unless you ask, and ls -a shows them, together with . and ... Configuration and secrets often live in such files, so look with ls -a before you copy or delete a folder.

Look before you delete, and make an empty variable stop the delete

Most deleting accidents come from a word that means something other than you think. A glob may match more than you expected, so run ls or echo with it first, then rm. A variable may be empty, and then "$build_dir/" is just /. The parameter expansion ${build_dir:?} stops the command when the variable is empty or unset, which is what ShellCheck asks for with SC2115:

from session import run

# A delete that refuses to run when the folder variable is empty, and the same line once it is set.
run("""
mkdir -p out/logs
printf 'log\\n' > out/logs/run.log
build_dir=
!rm -rf -- "${build_dir:?}/"
build_dir=out
echo rm -rf -- "${build_dir:?}/"
rm -rf -- "${build_dir:?}/"
ls
""")

$ mkdir -p out/logs
$ printf 'log\n' > out/logs/run.log
$ build_dir=
$ rm -rf -- "${build_dir:?}/"
bash: build_dir: parameter null or not set
[exit status 1]
$ build_dir=out
$ echo rm -rf -- "${build_dir:?}/"
rm -rf -- out/
$ rm -rf -- "${build_dir:?}/"
$ ls

With build_dir empty, Bash printed “build_dir: parameter null or not set” and did not run rm at all; the status was

1. Once the variable held out, echo showed the exact command first, and only then did the real rm remove the folder.

One more habit keeps scripts safe: never read the output of ls in a program. Its listing is formatted for people, and a file name may contain spaces or even a newline, so splitting it into names goes wrong. ShellCheck reports such code as SC2045. A glob such as logs/*.txt or the find command gives a script the names exactly as they are.

cat, head, tail, wc and file show what is inside

You can look inside a file without an editor. cat prints a whole file, head -n N its first N lines and tail -n N its last N, wc -l counts its lines, and file guesses what kind of file it is from its contents. Given several names, cat prints the files one after another, which is where its name comes from: it concatenates them. For long files, less shows one screen at a time: Space moves on, /word searches and q quits. man usually shows its pages through the same pager, so the same keys work there too.

from session import run

# Looking inside files without opening an editor.
run("""
printf 'one\\ntwo\\nthree\\nfour\\n' > notes.txt
cat notes.txt
head -n 2 notes.txt
tail -n 1 notes.txt
wc -l notes.txt
printf '#!/usr/bin/env bash\\necho hi\\n' > hi.sh
file notes.txt hi.sh
""")

$ printf 'one\ntwo\nthree\nfour\n' > notes.txt
$ cat notes.txt
one
two
three
four
$ head -n 2 notes.txt
one
two
$ tail -n 1 notes.txt
four
$ wc -l notes.txt
       4 notes.txt
$ printf '#!/usr/bin/env bash\necho hi\n' > hi.sh
$ file notes.txt hi.sh
notes.txt: ASCII text
hi.sh:     Bourne-Again shell script text executable, ASCII text

file recognised hi.sh as a Bash script from its first line alone, whatever its name. Notice that wc -l printed spaces before the 4: this session ran macOS’s own wc, which pads its numbers, while GNU wc on Linux prints 4 notes.txt without them. A script that reads that number should not depend on the spacing, which is one of the differences the portability module of this track collects.

Practise: paths, copies and safe deletes

The questions below put you in folders and in front of commands that are about to run. Pick what happens; each answer explains the rule it rests on:

Interview questions

Warm-up (fresher to 2–5 years): how do absolute and relative paths differ?

An absolute path starts at the top of the file system, /, so it names the same file wherever you run the command: /etc/hosts is always the same file. A relative path is read from the current folder, the one pwd prints, so docs/notes.txt names a different file in each folder. . means the current folder and .. its parent, and a path that starts with ~ begins at your home folder. Scripts usually build absolute paths, or cd to a known folder first and check that the cd worked, because a relative path silently points somewhere else when the script runs from another folder.

Two harder questions follow, about a cleanup that went too far and about copying a project safely. Decide what you would do before you open each first step:

Key takeaways

• An absolute path starts at / and a path with ~ at your home folder, while every other path is read from the current folder that pwd prints.
• mkdir -p creates missing parents safely, cp -R copies trees, mv moves and renames, and rm -r deletes for good, with no recycle bin.
• Names starting with a dot are hidden from ls and *, so list a folder with ls -a before you copy or delete it.
• Print a delete with echo first and write "${dir:?}", so an empty variable stops the command instead of widening it.
• cat, head, tail, wc -l and file show what a file holds, and less pages through long ones.