Silicon Soul

Knowing how to manipulate file system objects via the command line interface (CLI) is a fundamental part of the GNU/Linux experience.

Note: If you are not familiar with the GNU/Linux command line interface, review the Conventions page before proceeding.

Creating Objects

The objects you need to manipulate are files and directories.

Creating Text Files

You can create a text file with the touch command:

touch ex_file.txt...

Alternatively, you can use redirection:

> ex_file.txt

Normally, a terminal's standard output (/dev/stdout) is sent to the terminal display. Above, the > sign (short for 1>, where 1 is the file descriptor associated with the standard output) redirects the terminal's standard output to the specified file, ex_file.txt.

If ex_file.txt does not exist when the command is run, it is created. If ex_file.txt does exist when the command is run, it will most likely be clobbered (i.e., overwritten), depending on how your shell is configured.

Creating Directories

The mkdir command creates a directory.

mkdir ex_directory...

If you need to simultaneously create a directory and its parent directories, you can use mkdir's -p (--parents) option.

mkdir -p ex_directory_1/ex_directory_2/ex_directory_3/

Above, ex_directory_1/, ex_directory_2/, and ex_directory_3/ are simultaneously created.

Copying Objects

Files and directories can be copied with the cp command.

Copying Files

You can copy a file with cp as follows:

cp ex_file... ex_destination_directory

For example, the command below copies the file foo.txt in the current directory to the /tmp directory:

cp 'foo.txt' '/tmp/'

Alternatively, you can use cp to create a copy of a file in the current directory with a new name.

cp ex_file new_ex_file

Below, a copy of foo.txt in the current directory is created in the same directory, but with the name bar.txt:

cp 'foo.txt' 'bar.txt'

cp works well with shell search patterns. For example, you can copy any files in the current directory that start with foo and end with .txt to the /tmp directory like this:

cp foo*.txt '/tmp/'

Above, the * character will match any character (except for /) from zero to many times. If you are not sure how the shell will expand foo*.txt, you can always pass it to the echo command to verify how the shell will interpret your search pattern before you use it with the cp command.

$ echo foo*.txt
foo_1.txt foo_2.txt foo_3.txt foo_4.txt foo_5.txt

cp does not ask whether it should overwrite an existing file with the same name as the file to be copied, i.e., it just does it. When cp does this, the destination file is opened for writing and truncated to a length of zero before the source data is written to it.

If you do not have write access to the existing file, the copy operation will fail. However, you can override the failure with cp's -f (--force) option. This will cause cp to remove the existing file you do not have write access to before proceeding with its copy operation.

By default, cp will copy the target of symbolic links, not the symbolic links themselves, although you can change this behavior with the -d or -P options.

Here are some of cp's most useful options:

-b

Back up a copy of existing destinations by appending a tilde (~) to their names.

-d

Copy symbolic links, not their targets; equivalent to -P.

-f, --force

Force copy and overwrite existing destination file without prompting (i.e., when an existing destination file cannot be written to, the existing file is removed, and then the copy operation proceeds).

-i, --interactive

Interactively ask (once per file) whether existing destination files should be overwritten.

-l, --link

Create hard links of files, instead of copying them (referred to as creating a link farm).

-p

Try to preserve all attributes of the source file for the copy.

-P, --no-dereference

Copy symbolic links, not their targets. Equivalent to -d.

-s, --symbolic-link

Create symbolic links of files, instead of copying them (referred to as creating a symbolic link farm).

-u, --update

Only copy if the source file is newer than the destination file (or the destination file does not exist).

-v, --verbose

Verbose output.

Copying Directories

To copy a directory, you can use cp's -R (--recursive) option.

cp -R ex_directory... ex_destination_directory

The following example copies the foobar directory in the current directory to ${HOME}/Documents/:

cp -R 'foobar/' "${HOME}/Documents/"

Moving Objects

To move a file or directory, you can use the mv command.

mv ex_object... ex_destination_directory

The command below moves the foobar/ directory in the current directory to ${HOME}/Documents/:

mv 'foobar' "${HOME}/Documents/"

The mv command is similar to the cp command and has many of the same options. Like cp, mv also does not ask for confirmation if a destination object exists. It just overwrites it and has a -f option to force the operation when you do not have write permissions for the destination object.

A mv operation is strictly a file system operation on directory contents. An exception is if an object is moved to a different file system. In this case, in order to physically move the object, it is first copied to the new file system, and then removed from the old one.

In addition, the mv command can be used to rename a file or directory.

mv ex_object new_ex_object

For example, the following command renames the foobar/ directory in the current directory to xyzzy/:

mv 'foobar/' 'xyzzy/'

Removing Objects

The rm command removes files and directories.

Removing Files

You can remove a file with rm as follows:

rm ex_file...

By default, rm removes files without any confirmation.

However, rm will prompt you to proceed with an entire removal operation if:

• The -I (--interactive=once) option is used
• The -R option (equivalent to -r or --recursive) is used
• There are more than three files involved in the removal operation

If the response given is not affirmative, the entire removal operation is aborted.

Also, rm will prompt you to proceed with removing individual files if:

• The -i option (short for --interactive=always) is used
• You do not have write access to a file in the removal operation
• The standard input is a terminal

If the response given is not affirmative, the file in question is skipped.

rm's -f (--force) option can be used to ignore non-existent files and prevent removal prompts.

When rm is given a symbolic link as an argument, it removes the symbolic link itself, not the target that it points to.

Removing Directories

If you need to remove an empty directory, you can do so with the rmdir command.

rmdir ex_empty_directory...

You can simultaneously remove an empty directory and its empty parent directories with rmdir's -p (--parents) option:

rmdir -p ex_directory_1/ex_directory_2/ex_directory_3/

If a directory is not empty, you can use the previously mentioned rm command with the addition of its -f and -R options to remove it.

rm -fR ex_non_empty_directory...

Documentation

You can find out more about the touch, mkdir, cp, mv, rm, and rmdir commands by examining their man pages, which are also available online.