Learn how to redirect input and output to and from files and programs.

Redirection

`|` is a "pipe." The `|` takes the standard output of the command on the left, and *pipes* it as standard input to the command on the right. You can think of this as "command to command" redirection.

To count the words in **volcanoes.txt** using the word count command `wc`:
```bash
$ cat volcanoes.txt | wc  
```

Above, the output of `cat volcanoes.txt` becomes the standard input of `wc`. In turn, the `wc` command outputs the number of lines, words, and characters in **volcanoes.txt**, respectively. 

```bash
$ cat volcanoes.txt | wc | cat > count.txt 
```

Multiple `|`s can be chained together. Above the standard output of `cat volcanoes.txt` is "piped" to the `wc` command. The standard output of `wc` is then "piped" to `cat`. Finally, the standard output of `cat` is redirected to `count.txt`.

You can view the output data of this chain by typing `cat count.txt`.


```bash
$ sort continents.txt 
```

`sort` takes the standard input and orders it alphabetically for the standard output (it doesn't change the file itself). Here, the continents in **continents.txt** will be listed in alphabetical order:
```bash
Africa
Antarctica
Asia
Australia
Europe
North America
South America
```

```bash
$ cat glaciers.txt | sort > sorted-glaciers.txt 
```

Here, the command takes the standard output from `cat glaciers.txt` and "pipes" it to `sort`. The standard output of `sort` is redirected to a new file named **sorted-glaciers.txt**.


sort

```bash
$ grep -R Arctic /home/ccuser/workspace/geography

/home/ccuser/workspace/geography/deserts.txt:Arctic Desert
/home/ccuser/workspace/geography/oceans.txt:Arctic Ocean
```

`grep -R` searches all files in a directory and outputs filenames and lines containing matched results. `-R` stands for "recursive". Above, `grep -R` searched the **/home/ccuser/workspace/geography** directory for the string "Arctic" and outputted filenames and lines with matching results.

```bash
$ grep -Rl Arctic /home/ccuser/workspace/geography

/home/ccuser/workspace/geography/deserts.txt
/home/ccuser/workspace/geography/oceans.txt
```

`grep -Rl` searches all files in a directory and outputs only filenames with matched results (so no lines). `l` (a lowercase `L`, not a capital `i`) stands for "files with matches." Here `grep -Rl` searched the **/home/ccuser/workspace/geography** directory for the string "Arctic" and outputs filenames with matched results. 


grep II

Congratulations! You learned how to use the command line to redirect standard input and standard output. What can we generalize so far?

* *Redirection* reroutes standard input, standard output, and standard error.

* The common redirection commands are:
   *  `>` redirects standard output of a command to a file, overwriting previous content.
   *  `>>` redirects standard output of a command to a file, appending new content to old content.
   *  `<` redirects standard input to a command. 
   *  `|` redirects standard output of a command to another command. 

* A number of other commands are powerful when combined with redirection commands:
   * `sort`: sorts lines of text alphabetically.
   * `uniq`: filters duplicate, adjacent lines of text.
   * `grep`: searches for a text pattern and outputs it.
   * `sed` : searches for a text pattern, modifies it, and outputs it.


Review

Up until now, we have run commands in the command line and received a stream of output in the terminal. In this lesson, we'll focus on input and output (I/O) redirection. 

Through *redirection* you can direct the input and output of a command to and from other files and programs, and chain commands together in a pipeline. Let's try it out.

You can reference the filesystem for this lesson <a href="https://content.codecademy.com/courses/learn-the-command-line/img/LCL-fileTrees-03.png" target="_blank">here</a>.

What happens when you type this command?

```
$ echo "Hello"
Hello
```

The `echo` command accepts the string "Hello" as *standard input*, and echoes the string "Hello" back to the terminal as *standard output*.

Let's learn more about standard input, standard output, and standard error:

1. *standard input*, abbreviated as `stdin`, is information inputted into the terminal through the keyboard or input device. 

2. *standard output*, abbreviated as `stdout`, is the information outputted after a process is run. 

3. *standard error*, abbreviated as `stderr`, is an error message outputted by a failed process. 

Redirection reroutes standard input, standard output, and standard error to or from a different location.


Introduction

```bash
$ cat deserts.txt > forests.txt
```

`>` takes the standard output of the command on the left, and redirects it to the file on the right. Here the standard output of `cat deserts.txt` is redirected to **forests.txt**.

Note that `>` overwrites all original content in **forests.txt**. When you view the output data by using `cat` on **forests.txt**, you will see only the contents of **deserts.txt**.


Now we know how to overwrite a file's contents, but what if we want to be able to add to a file without losing the original text? We can use the `>>` command!

```bash
$ cat deserts.txt >> forests.txt
```

`>>` takes the standard output of the command on the left and *appends* (adds) it to the file on the right. 

Here, the output data of **forests.txt** will contain the original contents of **forests.txt** with the content of **deserts.txt** appended to it. 


How does redirection work?

```bash
$ echo "Hello" > hello.txt
```

The `>` command redirects the standard output to a file. Here, `"Hello"` is entered as the standard input, and is then redirected to the file **hello.txt** by `>` . 

As a reminder, the `cat` command outputs the contents of a file to the terminal. When you type:
```bash
$ cat hello.txt
```
the contents of **hello.txt** are displayed.


Your First Redirect

```bash
sed 's/snow/rain/' forests.txt 
```

`sed` stands for "stream editor." It accepts standard input and modifies it based on an *expression*, before displaying it as output data. It is similar to "find and replace."

Let's look at the expression `'s/snow/rain/'`:

  * `s`: stands for "substitution." It is *always* used when using `sed` for substitution. 
  * `snow`: the search string, or the text to find.  
  * `rain`: the replacement string, or the text to add in place. 

In this case, `sed` searches **forests.txt** for the word "snow" and replaces it with "rain." Importantly, the above command will only replace the first instance of "snow" on a line.  

```bash
sed 's/snow/rain/g' forests.txt 
```

The above command uses the `g` expression, meaning "global." Here `sed` searches  **forests.txt** for the word "snow" and replaces it with "rain" *globally*. This means *all* instances of "snow" on a line will be turned to "rain."

`sed` as we've used it will only rewrite the command line output and the actual file won't be changed. In order to rewrite the actual file, we need to use `-i` at the beginning of the command:
```bash
sed -i 's/snow/rain/g' forests.txt
```
The above command will rewrite **forests.txt** and replace _all_ instances (since we're also using `g`) of "snow" with "rain".

`uniq` stands for "unique." It filters out adjacent, duplicate lines in a file. 

```bash
$ cat deserts.txt
Arctic Desert
Sahara Desert
Sahara Desert
Arabian Desert
Gobi Desert
Kalahari Desert
Great Basic Desert
Syrian Desert
Kalahari Desert

$ uniq deserts.txt
Arctic Desert
Sahara Desert
Arabian Desert
Gobi Desert
Kalahari Desert
Great Basic Desert
Syrian Desert
Kalahari Desert 
```

Above `uniq deserts.txt` filters out duplicates of `"Sahara Desert"`, because its duplicate directly follows the previous instance. The "Kalahari Desert" duplicates are not adjacent, and thus remain. 

```bash
$ sort deserts.txt | uniq
```

A more effective way to use `uniq` is to call `sort` to alphabetize a file, and "pipe" the standard output to `uniq`. By piping `sort deserts.txt` to `uniq`, all duplicate lines are alphabetized (and thereby made adjacent) and filtered out. 

```
sort deserts.txt | uniq > uniq-deserts.txt 
```

Here we simply send filtered contents to **uniq-deserts.txt**, which you can view with the `cat` command.


uniq

```bash
$ cat < deserts.txt
```

`<` takes the standard input from the file on the right and inputs it into the command on the left. Here, **deserts.txt** is the standard input for the `cat` command. The standard output appears in the terminal.

While this above example accomplishes the same thing as `cat deserts.txt` (without the redirect), it is important to know that input can be redirected.


```bash
$ grep America continents.txt 
```

`grep` stands for "global regular expression print." It searches files for lines that match a pattern and then returns the results. It is also case sensitive. Above, `grep` searched for anything that matched "America" in **continents.txt**. 

```bash
$ grep -i America continents.txt
```

`grep -i` enables the command to be case insensitive. Here, `grep` searched for capital *or* lowercase strings that match "America" in **continents.txt**. Note that we don't use quotes in our command.

The above commands are a great way to get started with `grep`. If you are familiar with regular expressions, you can also use regular expressions to search for patterns in files.
