Working With Files and Directories
Last updated on 2023-05-02 | Edit this page
Estimated time: 50 minutes
Overview
Questions
- How can I create, copy, and delete files and directories?
- How can I edit files?
Objectives
- Create a directory hierarchy that matches a given diagram.
- Create files in that hierarchy using an editor or by copying and renaming existing files.
- Delete, copy and move specified files and/or directories.
Creating directories
We now know how to explore files and directories, but how do we create them in the first place?
In this episode we will learn about creating and moving files and
directories, using the exercise-data/writing directory as
an example.
Step one: see where we are and what we already have
We should still be in the shell-lesson-data directory on
the Desktop, which we can check using:
OUTPUT
/Users/nelle/Desktop/shell-lesson-dataNext we’ll move to the exercise-data/writing directory
and see what it contains:
$ cd exercise-data/writing/{: .language-bash}
OUTPUT
haiku.txt LittleWomen.txtCreate a directory
Let’s create a new directory called thesis using the
command mkdir thesis (which has no output):
As you might guess from its name, mkdir means ‘make
directory’. Since thesis is a relative path (i.e., does not
have a leading slash, like /what/ever/thesis), the new
directory is created in the current working directory:
OUTPUT
haiku.txt LittleWomen.txt thesis/Since we’ve just created the thesis directory, there’s
nothing in it yet:
Note that mkdir is not limited to creating single
directories one at a time. The -p option allows
mkdir to create a directory with nested subdirectories in a
single operation:
The -R option to the ls command will list
all nested subdirectories within a directory. Let’s use
ls -FR to recursively list the new directory hierarchy we
just created in the project directory:
OUTPUT
../project/:
data/ results/
../project/data:
../project/results:Two ways of doing the same thing
Using the shell to create a directory is no different than using a
file explorer. If you open the current directory using your operating
system’s graphical file explorer, the thesis directory will
appear there too. While the shell and the file explorer are two
different ways of interacting with the files, the files and directories
themselves are the same.
Good names for files and directories
Complicated names of files and directories can make your life painful when working on the command line. Here we provide a few useful tips for the names of your files and directories.
- Don’t use spaces.
Spaces can make a name more meaningful, but since spaces are used to
separate arguments on the command line it is better to avoid them in
names of files and directories. You can use - or
_ instead (e.g. north-pacific-gyre/ rather
than north pacific gyre/). To test this out, try typing
mkdir north pacific gyreand see what directory (or
directories!) are made when you check with ls -F.
- Don’t begin the name with
-(dash).
Commands treat names starting with - as options.
- Stick with letters, numbers,
.(period or ‘full stop’),-(dash) and_(underscore).
Many other characters have special meanings on the command line. We will learn about some of these during this lesson. There are special characters that can cause your command to not work as expected and can even result in data loss.
If you need to refer to names of files or directories that have
spaces or other special characters, you should surround the name in
quotes ("").
Create a text file
Let’s change our working directory to thesis using
cd, then run a text editor called Nano to create a file
called draft.txt:
Which Editor?
When we say, ‘nano is a text editor’ we really do mean
‘text’. It can only work with plain character data, not tables, images,
or any other human-friendly media. We use it in examples because it is
one of the least complex text editors. However, because of this trait,
it may not be powerful enough or flexible enough for the work you need
to do after this workshop. On Unix systems (such as Linux and macOS),
many programmers use Emacs or Vim (both of which require more time to
learn), or a graphical editor such as Gedit or VScode. On Windows, you may
wish to use Notepad++.
Windows also has a built-in editor called notepad that can
be run from the command line in the same way as nano for
the purposes of this lesson.
No matter what editor you use, you will need to know where it searches for and saves files. If you start it from the shell, it will (probably) use your current working directory as its default location. If you use your computer’s start menu, it may want to save files in your Desktop or Documents directory instead. You can change this by navigating to another directory the first time you ‘Save As…’
Let’s type in a few lines of text.
Once we’re happy with our text, we can press
Ctrl+O (press the Ctrl or
Control key and, while holding it down, press the
O key) to write our data to disk. We will be asked to provide
a name for the file that will contain our text. Press Return
to accept the suggested default of draft.txt.
Once our file is saved, we can use Ctrl+X to quit the editor and return to the shell.
Control, Ctrl, or ^ Key
The Control key is also called the ‘Ctrl’ key. There are various ways in which using the Control key may be described. For example, you may see an instruction to press the Control key and, while holding it down, press the X key, described as any of:
Control-XControl+XCtrl-XCtrl+X^XC-x
In nano, along the bottom of the screen you’ll see
^G Get Help ^O WriteOut. This means that you can use
Control-G to get help and Control-O to save
your file.
nano doesn’t leave any output on the screen after it
exits, but ls now shows that we have created a file called
draft.txt:
OUTPUT
draft.txtCreating Files a Different Way
We have seen how to create text files using the nano
editor. Now, try the following command:
What did the
touchcommand do? When you look at your current directory using the GUI file explorer, does the file show up?Use
ls -lto inspect the files. How large ismy_file.txt?When might you want to create a file this way?
The
touchcommand generates a new file calledmy_file.txtin your current directory. You can observe this newly generated file by typinglsat the command line prompt.my_file.txtcan also be viewed in your GUI file explorer.When you inspect the file with
ls -l, note that the size ofmy_file.txtis 0 bytes. In other words, it contains no data. If you openmy_file.txtusing your text editor it is blank.Some programs do not generate output files themselves, but instead require that empty files have already been generated. When the program is run, it searches for an existing file to populate with its output. The touch command allows you to efficiently generate a blank text file to be used by such programs.
What’s In A Name?
You may have noticed that all of Nelle’s files are named ‘something
dot something’, and in this part of the lesson, we always used the
extension .txt. This is just a convention; we can call a
file mythesis or almost anything else we want. However,
most people use two-part names most of the time to help them (and their
programs) tell different kinds of files apart. The second part of such a
name is called the filename extension and indicates
what type of data the file holds: .txt signals a plain text
file, .pdf indicates a PDF document, .cfg is a
configuration file full of parameters for some program or other,
.png is a PNG image, and so on.
This is just a convention, albeit an important one. Files merely contain bytes; it’s up to us and our programs to interpret those bytes according to the rules for plain text files, PDF documents, configuration files, images, and so on.
Naming a PNG image of a whale as whale.mp3 doesn’t
somehow magically turn it into a recording of whale song, though it
might cause the operating system to associate the file with a
music player program. In this case, if someone double-clicked
whale.mp3 in a file explorer program,the music player will
automatically (and erroneously) attempt to open the
whale.mp3 file.
Moving files and directories
Returning to the shell-lesson-data/exercise-data/writing
directory,
In our thesis directory we have a file
draft.txt which isn’t a particularly informative name, so
let’s change the file’s name using mv, which is short for
‘move’:
The first argument tells mv what we’re ‘moving’, while
the second is where it’s to go. In this case, we’re moving
thesis/draft.txt to thesis/quotes.txt, which
has the same effect as renaming the file. Sure enough, ls
shows us that thesis now contains one file called
quotes.txt:
OUTPUT
quotes.txtOne must be careful when specifying the target file name, since
mv will silently overwrite any existing file with the same
name, which could lead to data loss. By default, mv will
not ask for confirmation before overwriting files. However, an
additional option, mv -i (or
mv --interactive), will cause mv to request
such confirmation.
Note that mv also works on directories.
Let’s move quotes.txt into the current working
directory. We use mv once again, but this time we’ll use
just the name of a directory as the second argument to tell
mv that we want to keep the filename but put the file
somewhere new. (This is why the command is called ‘move’.) In this case,
the directory name we use is the special directory name .
that we mentioned earlier.
The effect is to move the file from the directory it was in to the
current working directory. ls now shows us that
thesis is empty:
OUTPUT
$Alternatively, we can confirm the file quotes.txt is no
longer present in the thesis directory by explicitly trying
to list it:
ERROR
ls: cannot access 'thesis/quotes.txt': No such file or directoryls with a filename or directory as an argument only
lists the requested file or directory. If the file given as the argument
doesn’t exist, the shell returns an error as we saw above. We can use
this to see that quotes.txt is now present in our current
directory:
OUTPUT
quotes.txtMoving Files to a new folder
After running the following commands, Jamie realizes that she put the
files sucrose.dat and maltose.dat into the
wrong folder. The files should have been placed in the raw
folder.
BASH
$ ls -F
analyzed/ raw/
$ ls -F analyzed
fructose.dat glucose.dat maltose.dat sucrose.dat
$ cd analyzedFill in the blanks to move these files to the raw/
folder (i.e. the one she forgot to put them in)
Copying files and directories
The cp command works very much like mv,
except it copies a file instead of moving it. We can check that it did
the right thing using ls with two paths as arguments — like
most Unix commands, ls can be given multiple paths at
once:
OUTPUT
quotes.txt thesis/quotations.txtWe can also copy a directory and all its contents by using the recursive option
-r, e.g. to back up a directory:
We can check the result by listing the contents of both the
thesis and thesis_backup directory:
OUTPUT
thesis:
quotations.txt
thesis_backup:
quotations.txtRenaming Files
Suppose that you created a plain-text file in your current directory
to contain a list of the statistical tests you will need to do to
analyze your data, and named it statstics.txt
After creating and saving this file you realize you misspelled the filename! You want to correct the mistake, which of the following commands could you use to do so?
cp statstics.txt statistics.txtmv statstics.txt statistics.txtmv statstics.txt .cp statstics.txt .
- No. While this would create a file with the correct name, the incorrectly named file still exists in the directory and would need to be deleted.
- Yes, this would work to rename the file.
- No, the period(.) indicates where to move the file, but does not provide a new file name; identical file names cannot be created.
- No, the period(.) indicates where to copy the file, but does not provide a new file name; identical file names cannot be created.
Moving and Copying
What is the output of the closing ls command in the
sequence shown below?
OUTPUT
/Users/jamie/dataOUTPUT
proteins.datBASH
$ mkdir recombined
$ mv proteins.dat recombined/
$ cp recombined/proteins.dat ../proteins-saved.dat
$ lsproteins-saved.dat recombinedrecombinedproteins.dat recombinedproteins-saved.dat
We start in the /Users/jamie/data directory, and create
a new folder called recombined. The second line moves
(mv) the file proteins.dat to the new folder
(recombined). The third line makes a copy of the file we
just moved. The tricky part here is where the file was copied to. Recall
that .. means ‘go up a level’, so the copied file is now in
/Users/jamie. Notice that .. is interpreted
with respect to the current working directory, not with
respect to the location of the file being copied. So, the only thing
that will show using ls (in /Users/jamie/data) is the
recombined folder.
- No, see explanation above.
proteins-saved.datis located at/Users/jamie - Yes
- No, see explanation above.
proteins.datis located at/Users/jamie/data/recombined - No, see explanation above.
proteins-saved.datis located at/Users/jamie
Removing files and directories
Returning to the shell-lesson-data/exercise-data/writing
directory, let’s tidy up this directory by removing the
quotes.txt file we created. The Unix command we’ll use for
this is rm (short for ‘remove’):
We can confirm the file has gone using ls:
ERROR
ls: cannot access 'quotes.txt': No such file or directoryDeleting Is Forever
The Unix shell doesn’t have a trash bin that we can recover deleted files from (though most graphical interfaces to Unix do). Instead, when we delete files, they are unlinked from the file system so that their storage space on disk can be recycled. Tools for finding and recovering deleted files do exist, but there’s no guarantee they’ll work in any particular situation, since the computer may recycle the file’s disk space right away.
Using rm Safely
What happens when we execute
rm -i thesis_backup/quotations.txt? Why would we want this
protection when using rm?
OUTPUT
rm: remove regular file 'thesis_backup/quotations.txt'? yThe -i option will prompt before (every) removal (use
Y to confirm deletion or N to keep the file). The
Unix shell doesn’t have a trash bin, so all the files removed will
disappear forever. By using the -i option, we have the
chance to check that we are deleting only the files that we want to
remove.
If we try to remove the thesis directory using
rm thesis, we get an error message:
ERROR
rm: cannot remove `thesis': Is a directoryThis happens because rm by default only works on files,
not directories.
rm can remove a directory and all its contents
if we use the recursive option -r, and it will do so
without any confirmation prompts:
Given that there is no way to retrieve files deleted using the shell,
rm -r should be used with great caution (you might
consider adding the interactive option rm -r -i).
Operations with multiple files and directories
Oftentimes one needs to copy or move several files at once. This can be done by providing a list of individual filenames, or specifying a naming pattern using wildcards. Wildcards are special characters that can be used to represent unknown characters or sets of characters when navigating the Unix file system.
Copy with Multiple Filenames
For this exercise, you can test the commands in the
shell-lesson-data/exercise-data directory.
In the example below, what does cp do when given several
filenames and a directory name?
In the example below, what does cp do when given three
or more file names?
OUTPUT
basilisk.dat minotaur.dat unicorn.datIf given more than one file name followed by a directory name
(i.e. the destination directory must be the last argument),
cp copies the files to the named directory.
If given three file names, cp throws an error such as
the one below, because it is expecting a directory name as the last
argument.
ERROR
cp: target 'basilisk.dat' is not a directoryUsing wildcards for accessing multiple files at once
Wildcards
* is a wildcard, which represents zero
or more other characters. Let’s consider the
shell-lesson-data/exercise-data/alkanes directory:
*.pdb represents ethane.pdb,
propane.pdb, and every file that ends with ‘.pdb’. On the
other hand, p*.pdb only represents pentane.pdb
and propane.pdb, because the ‘p’ at the front can only
represent filenames that begin with the letter ‘p’.
? is also a wildcard, but it represents exactly one
character. So ?ethane.pdb could represent
methane.pdb whereas *ethane.pdb represents
both ethane.pdb and methane.pdb.
Wildcards can be used in combination with each other. For example,
???ane.pdb indicates three characters followed by
ane.pdb, giving
cubane.pdb ethane.pdb octane.pdb.
When the shell sees a wildcard, it expands the wildcard to create a
list of matching filenames before running the preceding
command. As an exception, if a wildcard expression does not match any
file, Bash will pass the expression as an argument to the command as it
is. For example, typing ls *.pdf in the
alkanes directory (which contains only files with names
ending with .pdb) results in an error message that there is
no file called *.pdf. However, generally commands like
wc and ls see the lists of file names matching
these expressions, but not the wildcards themselves. It is the shell,
not the other programs, that expands the wildcards.
List filenames matching a pattern
When run in the alkanes directory, which ls
command(s) will produce this output?
ethane.pdb methane.pdb
ls *t*ane.pdbls *t?ne.*ls *t??ne.pdbls ethane.*
The solution is 3.
1. shows all files whose names contain zero or more
characters (*) followed by the letter t, then
zero or more characters (*) followed by
ane.pdb. This gives
ethane.pdb methane.pdb octane.pdb pentane.pdb.
2. shows all files whose names start with zero or more
characters (*) followed by the letter t, then
a single character (?), then ne. followed by
zero or more characters (*). This will give us
octane.pdb and pentane.pdb but doesn’t match
anything which ends in thane.pdb.
3. fixes the problems of option 2 by matching two
characters (??) between t and ne.
This is the solution.
4. only shows files starting with
ethane..
More on Wildcards
Sam has a directory containing calibration data, datasets, and descriptions of the datasets:
BASH
.
├── 2015-10-23-calibration.txt
├── 2015-10-23-dataset1.txt
├── 2015-10-23-dataset2.txt
├── 2015-10-23-dataset_overview.txt
├── 2015-10-26-calibration.txt
├── 2015-10-26-dataset1.txt
├── 2015-10-26-dataset2.txt
├── 2015-10-26-dataset_overview.txt
├── 2015-11-23-calibration.txt
├── 2015-11-23-dataset1.txt
├── 2015-11-23-dataset2.txt
├── 2015-11-23-dataset_overview.txt
├── backup
│ ├── calibration
│ └── datasets
└── send_to_bob
├── all_datasets_created_on_a_23rd
└── all_november_filesBefore heading off to another field trip, she wants to back up her data and send some datasets to her colleague Bob. Sam uses the following commands to get the job done:
BASH
$ cp *dataset* backup/datasets
$ cp ____calibration____ backup/calibration
$ cp 2015-____-____ send_to_bob/all_november_files/
$ cp ____ send_to_bob/all_datasets_created_on_a_23rd/Help Sam by filling in the blanks.
The resulting directory structure should look like this
BASH
.
├── 2015-10-23-calibration.txt
├── 2015-10-23-dataset1.txt
├── 2015-10-23-dataset2.txt
├── 2015-10-23-dataset_overview.txt
├── 2015-10-26-calibration.txt
├── 2015-10-26-dataset1.txt
├── 2015-10-26-dataset2.txt
├── 2015-10-26-dataset_overview.txt
├── 2015-11-23-calibration.txt
├── 2015-11-23-dataset1.txt
├── 2015-11-23-dataset2.txt
├── 2015-11-23-dataset_overview.txt
├── backup
│ ├── calibration
│ │ ├── 2015-10-23-calibration.txt
│ │ ├── 2015-10-26-calibration.txt
│ │ └── 2015-11-23-calibration.txt
│ └── datasets
│ ├── 2015-10-23-dataset1.txt
│ ├── 2015-10-23-dataset2.txt
│ ├── 2015-10-23-dataset_overview.txt
│ ├── 2015-10-26-dataset1.txt
│ ├── 2015-10-26-dataset2.txt
│ ├── 2015-10-26-dataset_overview.txt
│ ├── 2015-11-23-dataset1.txt
│ ├── 2015-11-23-dataset2.txt
│ └── 2015-11-23-dataset_overview.txt
└── send_to_bob
├── all_datasets_created_on_a_23rd
│ ├── 2015-10-23-dataset1.txt
│ ├── 2015-10-23-dataset2.txt
│ ├── 2015-10-23-dataset_overview.txt
│ ├── 2015-11-23-dataset1.txt
│ ├── 2015-11-23-dataset2.txt
│ └── 2015-11-23-dataset_overview.txt
└── all_november_files
├── 2015-11-23-calibration.txt
├── 2015-11-23-dataset1.txt
├── 2015-11-23-dataset2.txt
└── 2015-11-23-dataset_overview.txtOrganizing Directories and Files
Jamie is working on a project, and she sees that her files aren’t very well organized:
OUTPUT
analyzed/ fructose.dat raw/ sucrose.datThe fructose.dat and sucrose.dat files
contain output from her data analysis. What command(s) covered in this
lesson does she need to run so that the commands below will produce the
output shown?
OUTPUT
analyzed/ raw/OUTPUT
fructose.dat sucrose.datReproduce a folder structure
You’re starting a new experiment and would like to duplicate the directory structure from your previous experiment so you can add new data.
Assume that the previous experiment is in a folder called
2016-05-18, which contains a data folder that
in turn contains folders named raw and
processed that contain data files. The goal is to copy the
folder structure of the 2016-05-18 folder into a folder
called 2016-05-20 so that your final directory structure
looks like this:
OUTPUT
2016-05-20/
└── data
├── processed
└── rawWhich of the following set of commands would achieve this objective? What would the other commands do?
The first two sets of commands achieve this objective. The first set uses relative paths to create the top-level directory before the subdirectories.
The third set of commands will give an error because the default
behavior of mkdir won’t create a subdirectory of a
non-existent directory: the intermediate level folders must be created
first.
The fourth set of commands achieve this objective. Remember, the
-p option, followed by a path of one or more directories,
will cause mkdir to create any intermediate subdirectories
as required.
The final set of commands generates the ‘raw’ and ‘processed’ directories at the same level as the ‘data’ directory.
Key Points
-
cp [old] [new]copies a file. -
mkdir [path]creates a new directory. -
mv [old] [new]moves (renames) a file or directory. -
rm [path]removes (deletes) a file. -
*matches zero or more characters in a filename, so*.txtmatches all files ending in.txt. -
?matches any single character in a filename, so?.txtmatchesa.txtbut notany.txt. - Use of the Control key may be described in many ways, including
Ctrl-X,Control-X, and^X. - The shell does not have a trash bin: once something is deleted, it’s really gone.
- Most files’ names are
something.extension. The extension isn’t required, and doesn’t guarantee anything, but is normally used to indicate the type of data in the file. - Depending on the type of work you do, you may need a more powerful text editor than Nano.