CYBER WEEK SALE: Get 50% off your Pro annual membership using code [CYBER23](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=CYBER23)


Begin using the command line by learning how to navigate directories and files.

Navigation

The next command we're going to look at is `pwd`, which stands for "print working directory." It outputs the name of the directory you are currently in, called the *working directory*. 

Here the working directory is **blog/**. In Codecademy courses, your working directory is usually inside the **/home/ccuser/workspace/** directory.

Together with `ls`, the `pwd` command is useful to show where you are in the filesystem.

Now that we've covered the basics of navigating your filesystem from the command line, let's look at some helpful commands that will make using it easier! 

<kbd>tab</kbd> can be used to autocomplete your command. When you are typing the name of an existing file or directory, you can use <kbd>tab</kbd> to finish the rest of the name.

The up and down arrows (<kbd>&#8593;</kbd> and <kbd>&#8595;</kbd>) can be used to cycle through your previous commands. <kbd>&#8593;</kbd> will take you up through your most recent commands, and <kbd>&#8595;</kbd> will take you back through to the most recent one.

`clear` is used to clear your terminal, which is useful when it's full of previous commands and outputs. It doesn't change or undo your previous commands, it just clears them from view. As mentioned above, you can use the up and down arrow keys to review your command history anytime.

Helper Commands

In the previous exercise, we used `cd` multiple times to go from the **blog/** directory to the **memory/** directory. You can reference the file system [here](https://s3.amazonaws.com/codecademy-content/courses/learn-command-line/img/LCL-fileTrees-01.png). 

To move across multiple directories with a single command, we can provide `cd` a relative path to the **memory/** directory as an argument. From the **blog/** directory use:

```bash
$ cd 2015/jan/memory
```
The relative path is a forward slash (/) separated list of all the directories leading to the goal directory. In the above example, we navigate directly to **memory/** from **blog/** using `cd` with the relative path `2015/jan/memory`.

We can also move up multiple directories using the `..` argument. To go from **memory** up 2 directories to **2015**, we use `../..:

```bash
$ pwd
/home/ccuser/workspace/blog/2015/jan/memory
$ cd ../..
$ pwd
/home/ccuser/workspace/blog/2015
```
The relative path `../..` can be read: the directory above and the directory above that.

Lastly, we can move to an adjacent directory using `..` and then a directory name. If we are in the **2015/** directory and we want to go into the **2014/** directory, we go up one directory then into the **2014/** directory:
```bash
$ ls
2014  2015  hardware.txt
$ cd 2015
$ pwd
/home/ccuser/workspace/blog/2015
$ cd ../2014
$ pwd
/home/ccuser/workspace/blog/2014
```
The relative path is the directory above **2015/** (which is **blog/**) and then the **2014/**. 

cd II

Now that we can traverse the existing filesystem, let's try editing it by making directories (folders) through the command line. The command for that is `mkdir`:

```bash
$ mkdir media
```

The `mkdir` command stands for "make directory". It takes in a directory name as an argument and then creates a new directory in the current working directory.

Here we used `mkdir` to create a new directory named **media/** inside our working directory.


mkdir

Congratulations! You've learned five commands commonly used to navigate the filesystem from the command line. What can we generalize so far?

* The *command line* is a text interface for the computer's operating system. To access the command line, we use the terminal.
* A *filesystem* organizes a computer's files and directories into a tree structure. It starts with the *root directory*. Each parent directory can contain more child directories and files. 
* From the command line, you can navigate through files and folders on your computer:
  * `pwd` outputs the name of the current working directory.
  * `ls` lists all files and directories in the working directory.
  * `cd` switches you into the directory you specify.
  * `mkdir` creates a new directory in the working directory.
  * `touch` creates a new file inside the working directory.
* You can use helper commands to make navigation easier:
  * `clear` clears the terminal
  * <kbd>tab</kbd> autocompletes the name of a file or directory
  * <kbd>&#8593;</kbd> and <kbd>&#8595;</kbd> allow you to cycle through previous commands

Review

A filesystem organizes a computer's files and directories into a tree structure:

1. The first directory in the filesystem is the *root directory*. It is the parent of all other directories and files in the filesystem.
2. Each parent directory can contain more child directories and files. In the filesystem on the right, **blog/** is the parent of **2014/**, **2015/**, and **hardware.txt**.
3. Each directory can contain more files and child directories. The parent-child relationship continues as long as directories and files are nested.

You're probably already familiar with this tree structure - Mac Finder and Windows Explorer represent the filesystem as trees as well.

We are going to use the pictured filesystem for the rest of the lesson. You can reference it at anypoint <a href="https://content.codecademy.com/courses/learn-command-line/img/LCL-fileTrees-01.png" target="_blank" rel="noopener noreferrer">here</a>.


Filesystem

The **command line** is a text interface for your computer. It's a program that takes in commands and passes them on to the computer's operating system to run.

From the command line, you can navigate through files and folders on your computer, just as you would with Finder on Mac OS or Windows Explorer on Windows. The difference is that the command line is fully text-based.

The advantage of using the command line is its power. You can run programs, write scripts to automate common tasks, and combine simple commands to handle difficult tasks. All of these traits come together to make it an important programming tool.

This course is for unix-based systems such as Linux and Mac OS X. You can also download programs on Windows that will allow you to use the same commands. An appendix of all commands taught in this course is available <a href="https://www.codecademy.com/articles/command-line-commands" target="_blank" rel="noopener noreferrer">here</a>.


Introduction

The first command we're going to look at is `ls`. A *command* is a directive to the computer to perform a specific task. When you type `ls`, the command line looks at the directory you are in, and then "lists" all the files and directories inside of it. Be sure to type the letter `l` as in “List” and not the number 1.

In the terminal, the first thing you see is `$`. This is called a *shell prompt*. It appears when the terminal is ready to accept a command.

If we typed:
```shell
$ ls
```
the terminal would display our current directory's files and directories:
```shell
2014  2015  hardware.txt
```
The directories **2014/**, **2015/**, and the file **hardware.txt** are the contents of the current directory.


Now we know how to create directories through the command line, but how do we create new files? 

We can do this using the command `touch`:

```shell
$ touch keyboard.txt
```

The `touch` command creates a new file inside the working directory. It takes in a filename as an argument and then creates an empty file with that name in the current working directory.

Here we used `touch` to create a new file named **keyboard.txt**.


touch

Our next command is `cd`, which stands for "change directory." Just as you would click on a folder in Windows Explorer or Finder, `cd` switches you into the directory you specify. In other words, `cd` changes the working directory.

Let's say the directory we change into is **2015/**:
```shell
$ cd 2015
```

When a file, directory, or program is passed into a command, it is called an *argument*. Here the **2015/** directory is an argument for the `cd` command.

The `cd` command takes a directory name as an argument and switches into that directory.

It is also important to move up one directory. For this, we use:

```shell
$ cd ..
```

The argument `..` stands for the directory above the current working directory. Assuming we are in **/home/ccuser/workspace/blog/2015**:
```bash
$ pwd
/home/ccuser/workspace/blog/2015
$ cd ..
$ pwd
/home/ccuser/workspace/blog
``` 
The above example uses the command `cd ..` to navigate up to the **/home/ccuser/workspace/blog/** directory.
