Linux Directory Tree Display

Introduction

In this lab, you will learn how to use the tree command in Linux. The tree command is a powerful utility that displays directory and file structures in a hierarchical, tree-like format. This visual representation makes it easier to understand the organization of files and directories in your system.

The tree command is particularly useful for system administrators, developers, and anyone who needs to navigate complex directory structures. By the end of this lab, you will be able to use basic and advanced features of the tree command to visualize directory structures effectively.

Skills Graph

Installing and Using the Basic Tree Command

In this step, you will install the tree command and learn its basic functionality.

Installing the Tree Command

First, let's make sure the tree command is installed on your system. In the terminal, enter:

if ! command -v tree &> /dev/null; then
  sudo apt-get update
  sudo apt-get install -y tree
fi

This checks if tree is already installed. If not, it updates the package lists and installs it for you.

Creating a Sample Directory Structure

Before using the tree command, we need a directory structure to visualize. Make sure you are in the correct working directory:

cd ~/project

Now, let's create a sample directory structure that represents log files organized by month:

mkdir -p ./logs/2023/{January,February,March}
touch ./logs/2023/January/log1.txt
touch ./logs/2023/February/log2.txt
touch ./logs/2023/March/log3.txt

This command sequence:

• Creates a main directory called logs
• Inside logs, creates a subdirectory called 2023
• Inside 2023, creates three subdirectories for each month
• Creates a log file in each month's directory

Using the Basic Tree Command

Now, let's run the basic tree command to see our file structure:

tree

You should see an output similar to this:

.
└── logs
    └── 2023
        ├── January
        │   └── log1.txt
        ├── February
        │   └── log2.txt
        └── March
            └── log3.txt

The tree command displays the directory structure starting from the current directory (represented by the dot at the top). The indentation and lines show the hierarchical relationship between directories and files.

Limiting Directory Tree Depth

When working with large directory structures, viewing the entire tree can be overwhelming. In this step, you will learn how to limit the depth of the displayed directory tree.

Creating a Deeper Directory Structure

Let's create a more complex directory structure to better demonstrate this feature:

mkdir -p ~/project/backups/2023/{January,February,March}/{week1,week2,week3}
touch ~/project/backups/2023/January/week1/data.bak

This creates:

• A backups directory with a structure similar to our logs
• An additional level for weeks within each month
• A sample backup file in January's week1 folder

Using the -L Option to Limit Depth

The -L option allows you to specify how many levels deep the tree should display. Let's limit our view to 3 levels:

tree -L 3

You should see an output similar to this:

.
├── backups
│   └── 2023
│       ├── January
│       ├── February
│       └── March
└── logs
    └── 2023
        ├── January
        ├── February
        └── March

Notice that the week directories and files within them are not shown because they would be at level 4, and we limited the display to 3 levels.

Changing the Depth Level

You can adjust the number after -L to show more or fewer levels. Let's try with a depth of 4:

tree -L 4

Now you should see the week directories but not the files inside them:

.
├── backups
│   └── 2023
│       ├── January
│       │   ├── week1
│       │   ├── week2
│       │   └── week3
│       ├── February
│       │   ├── week1
│       │   ├── week2
│       │   └── week3
│       └── March
│           ├── week1
│           ├── week2
│           └── week3
└── logs
    └── 2023
        ├── January
        │   └── log1.txt
        ├── February
        │   └── log2.txt
        └── March
            └── log3.txt

Being able to control the depth of the tree is useful when you only need a high-level overview of a complex directory structure.

Displaying Only Directories

Sometimes you may only be interested in the directory structure without seeing the files. In this step, you will learn how to display only directories using the tree command.

Using the -d Option

The -d option tells the tree command to show only directories and ignore files. Let's try it:

tree -d

You should see an output similar to this:

.
├── backups
│   └── 2023
│       ├── January
│       │   ├── week1
│       │   ├── week2
│       │   └── week3
│       ├── February
│       │   ├── week1
│       │   ├── week2
│       │   └── week3
│       └── March
│           ├── week1
│           ├── week2
│           └── week3
└── logs
    └── 2023
        ├── January
        ├── February
        └── March

Notice that none of the files (like log1.txt or data.bak) are shown in this view.

Combining Options

You can combine multiple options to customize the output further. For example, to show only directories up to a depth of 2 levels:

tree -d -L 2

This will display:

.
├── backups
│   └── 2023
└── logs
    └── 2023

Adding Directory Count

To see how many directories are in each subtree, you can add the -a flag:

tree -d -a

At the bottom of the output, you'll see a summary showing the number of directories:

X directories

Where X is the total number of directories.

Viewing only the directory structure is particularly useful when you want to understand the organization of a project without being distracted by individual files.

Summary

In this lab, you learned how to use the tree command in Linux to visualize directory structures. You started with basic usage, creating and viewing simple directory hierarchies. You then explored more advanced features like limiting the depth of displayed directories with the -L option and showing only directories with the -d option.

These skills will help you navigate and understand complex file systems more efficiently. The tree command is a valuable tool for system administrators, developers, and anyone who works with organized file structures in Linux environments. By visualizing directory hierarchies clearly, you can better manage your files and troubleshoot directory-related issues.