This lesson covers commands for viewing and manipulating text output, and techniques for redirecting input, output, and errors between commands and files - essential skills for efficient Linux system administration.

1. more

• Purpose: File perusal filter for viewing text one screen at a time

• Usage: more [filename]

• Navigation:

  • Enter: Move line-by-line

  • Spacebar: Move page-by-page

  • q: Quit

• Limitation: Older command, cannot scroll backwards

• Example: more /var/log/messages

2. less

• Purpose: Improved version of more with more features

• Usage: less [filename]

• Navigation:

  • Arrow keys: Up/down line-by-line

  • Page Up/Down: Move by pages

  • Enter/Spacebar: Forward movement

  • /pattern: Search forward

  • n: Next search result

  • Shift+N: Previous search result

  • q: Quit

• Key advantage: Can scroll backwards, better searching

• Remember: "Less is more" (less provides MORE features than more!)

• Example: less /var/log/messages

3. head

• Purpose: Display the first lines of a file

• Default: Shows first 10 lines

• Usage: head [filename]

• Options:

  • -n [number]: Specify number of lines

• Examples:

  • head /var/log/messages (shows first 10 lines)

  • head -n 20 /var/log/messages (shows first 20 lines)

4. tail

• Purpose: Display the last lines of a file

• Default: Shows last 10 lines

• Usage: tail [filename]

• Options:

  • -n [number]: Specify number of lines

  • -f: Follow mode - continuously display new lines as they're added (perfect for log files!)

• Examples:

  • tail /var/log/messages (shows last 10 lines)

  • tail -n 2 /var/log/messages (shows last 2 lines)

  • tail -f /var/log/messages (follows log in real-time)

• Exit follow mode: Ctrl+C

• Use case: Monitoring live logs during troubleshooting

5. grep (Global Regular Expression Print)

• Purpose: Search for and print lines matching a pattern/string

• Usage: grep [options] [pattern] [file]

• Important Options:

  • -i: Case-insensitive search

  • -R or -r: Recursive search through directories

• Examples:

  • grep "cloud_user" /var/log/messages (find exact string)

  • grep -i "joe" names.txt (case-insensitive search for "joe", "JOE", "Joe", etc.)

  • grep -R "cloud_user" /var/log/ (search all files in directory recursively)

• Key feature: Invaluable for finding configurations, troubleshooting, searching logs

6. sort

• Purpose: Sort lines of text files

• Default: Ascending alphabetical/character order

• Usage: sort [options] [file]

• Important Options:

  • -n: Sort numerically (not just by character)

  • -r: Reverse order (descending)

  • -o [filename]: Output to file

• Examples:

  • sort names.txt (alphabetical sort)

  • sort -n numbers.txt (numerical sort: 14, 22, 100)

  • sort -nr numbers.txt (reverse numerical: 9000, 100, 22, 14)

  • sort names.txt numbers.txt (sorts multiple files together)

• Note: Character sort vs numerical sort

  • Character: 100, 14, 22, 9000 (compares character by character)

  • Numerical: 14, 22, 100, 9000 (compares actual values)

Linux uses three standard streams for input/output:

File Descriptors:

1. 0 = stdin (Standard Input)

   • Default: Keyboard input

   • What you type into commands

2. 1 = stdout (Standard Output)

   • Default: Screen/terminal display

   • Normal command output

3. 2 = stderr (Standard Error)

   • Default: Screen/terminal display

   • Error messages

   • Separate from stdout so you can handle errors differently

Redirection allows you to change where input comes from and where output goes (instead of keyboard/screen defaults).

Output Redirection

Single > (Redirect and Overwrite)

• Symbol: >

• Purpose: Send stdout to a file (overwrites existing content)

• Syntax: command > file

• Examples:

  • sort names.txt > sorted.txt (saves sorted output to file)

  • ls > filelist.txt (saves directory listing to file)

• Warning: Overwrites file if it exists!

Double >> (Redirect and Append)

• Symbol: >>

• Purpose: Send stdout to a file (appends to existing content)

• Syntax: command >> file

• Examples:

  • sort numbers.txt >> sorted.txt (adds to existing file)

  • echo "new line" >> log.txt (appends text to file)

• Safe: Doesn't overwrite, adds to end of file

Input Redirection

Single < (Input from File)

• Symbol: <

• Purpose: Feed file contents as input to command

• Syntax: command < file

• Example:

  • sort < numbers.txt (uses file as input)

  • sort < numbers.txt > sorted.txt (input from file, output to file)

Double << (Here Document)

• Symbol: <<

• Purpose: Feed multi-line input directly to command

• Syntax: command << DELIMITER

• Example:

sort << EOF

50

22

3

17

40

EOF

• Type input until you type the delimiter (EOF)

• Delimiter can be any word (EOF is common)

rror Redirection

Redirect stderr Only

• Symbol: 2>

• Purpose: Redirect only error messages (not regular output)

• Syntax: command 2> errorfile

• Examples:

  • Sort numbers.txt 2> error.log (captures "command not found" error)

  • ls /baddir 2> errors.txt (captures "no such directory" error)

Redirect stderr and Append

• Symbol: 2>>

• Purpose: Append error messages to file

• Syntax: command 2>> errorfile

Merging stdout and stderr

Method 1: 2>&1

• Symbol: 2>&1

• Purpose: Makes stderr go to same place as stdout

• Syntax: command > file 2>&1

• Explanation:

  • > file redirects stdout to file

  • 2>&1 makes stderr (2) go to same target as stdout (1)

• Example: ls /home /root /baddir > merge.log 2>&1

Method 2: &>

• Symbol: &>

• Purpose: Redirect both stdout and stderr to file (shorthand)

• Syntax: command &> file

• Example: ls /home /root /baddir &> merge.log

• Note: Simpler syntax, same result as method 1

Pipe Symbol |

• Symbol: | (vertical bar)

• Purpose: Send output of one command as input to another command

• Syntax: command1 | command2

• Chaining: Can chain multiple commands: command1 | command2 | command3

Examples:

1. Simple pipe:

ps -ef | grep ssh

• Lists all processes, then filters for only SSH-related ones

1. Multiple pipes:

ps -ef | grep ssh | wc -l

• Lists processes → filters for SSH → counts the lines (9 results)

1. Common combinations:

• cat file.txt | grep "pattern" (search in file)

• ls -l | less (view long directory listing with paging)

• history | grep "command" (search command history)

• cat log.txt | grep ERROR | wc -l (count error lines)

sort names.txt > sorted.txt # Sort and save (overwrite)

sort numbers.txt >> sorted.txt # Sort and append

sort < numbers.txt > sorted.txt # Input from file, output to file

Sort numbers.txt 2> error.log # Wrong command, error saved to log

ls /home /root /baddir > merge.log 2>&1 # Method 1

ls /home /root /baddir &> merge.log # Method 2 (same result)

ps -ef | grep ssh # Show only SSH processes

ps -ef | grep ssh | wc -l # Count SSH processes

tail -f /var/log/messages # Monitor log in real-time # Press Ctrl+C to exit

1. less > more: Less command has MORE features than more

2. head = top, tail = bottom of files

3. tail -f: Essential for monitoring live logs

4. grep -i: Case-insensitive search (very useful!)

5. grep -R: Recursive search through directories

6. sort -n: Numerical sort (not character sort)

7. stdin=0, stdout=1, stderr=2: File descriptors

8. > overwrites, >> appends

9. 2> redirects errors, &> redirects everything

10. | pipes output to next command

11. Ctrl+C exits tail -f and other running commands

more: Older, basic text viewer

• Can only scroll forward (line-by-line or page-by-page)

• Less features

• Navigation: Enter (line), Spacebar (page), q (quit)

less: Modern, feature-rich text viewer

• Can scroll backward AND forward

• Arrow keys work

• Better search functionality (/pattern, n for next, Shift+N for previous)

• More versatile

Remember: "Less is more" - less provides MORE features!

Purpose: Displays the first/beginning lines of a file

Default: Shows first 10 lines

Syntax: head [filename]

Options:

• -n [number]: Specify number of lines

Examples:

• head file.txt (first 10 lines)

• head -n 20 file.txt (first 20 lines)

• head -n 5 /var/log/messages (first 5 lines of log)

Purpose: Displays the last/ending lines of a file

Default: Shows last 10 lines

Key Options:

• -n [number]: Specify number of lines

• -f: Follow mode - continuously displays new lines as they're added to file

Examples:

• tail file.txt (last 10 lines)

• tail -n 2 file.txt (last 2 lines)

• tail -f /var/log/messages (monitor log in real-time)

Use case: Perfect for troubleshooting live issues by watching logs Exit: Ctrl+C

Purpose: Search for and print lines matching a pattern/string

Syntax: grep [options] [pattern] [file]

Key Options:

• -i: Case-insensitive search (joe = JOE = Joe)

• -R or -r: Recursive search through directories

Examples:

• grep "error" log.txt (find "error" in file)

• grep -i "joe" names.txt (case-insensitive)

• grep -R "config" /etc/ (search all files in /etc/)

Why invaluable: Finding configurations, troubleshooting, searching logs

Purpose: Sort lines of text files

Default: Ascending alphabetical/character order

Key Options:

• -n: Numerical sort (not character sort)

• -r: Reverse order (descending)

• -o file: Output to file

Examples:

• sort names.txt (alphabetical A-Z)

• sort -n numbers.txt (14, 22, 100 not 100, 14, 22)

• sort -nr numbers.txt (reverse: 9000, 100, 22, 14)

Important: Without -n, "100" comes before "22" (character comparison)

1. 0 = stdin (Standard Input)

   • Default: Keyboard

   • What you type into commands

2. 1 = stdout (Standard Output)

   • Default: Screen/terminal

   • Normal command output

3. 2 = stderr (Standard Error)

   • Default: Screen/terminal

   • Error messages only

Why separate stderr?: So you can handle errors differently from normal output

(Single angle bracket):

• Overwrites file content

• Creates new file or replaces existing content

• Example: sort names.txt > sorted.txt

• Warning: Destroys existing file content!

>> (Double angle bracket):

• Appends to file content

• Adds to end of existing file

• Example: sort numbers.txt >> sorted.txt

• Safe: Preserves existing content

Remember: Single > = overwrite, Double >> = append

Use < (left-pointing angle bracket)

Syntax: command < inputfile

Example:

• sort < numbers.txt (feed file as input to sort)

• sort < numbers.txt > sorted.txt (input from file, output to file)

What it does: Makes the command read from file instead of keyboard

Can combine: Input redirection (<) + Output redirection (>) in same command

Creates a "here document" - allows multi-line input directly in command

Syntax:

command << DELIMITER

[input lines]

DELIMITER

Example:

sort << EOF

50

22

3

EOF

How it works:

• Type command with << EOF (or any word)

• Enter multiple lines of input

• Type delimiter word (EOF) to signal end

• Command processes all input at once

Delimiter: Can be any word (EOF, END, STOP common)

Use 2> (file descriptor 2 with angle bracket)

Syntax: command 2> errorfile

Examples:

• Sort file.txt 2> error.log (wrong command, error captured)

• ls /baddir 2> errors.txt (directory doesn't exist, error saved)

Why 2>?:

• 2 is the file descriptor for stderr

• Regular > only redirects stdout (1)

• Errors still appear on screen unless you use 2>

Append errors: command 2>> errorfile

Two methods:

Method 1: command > file 2>&1

• > file redirects stdout to file

• 2>&1 makes stderr go to same place as stdout

• Example: ls /home /baddir > output.log 2>&1

Method 2: command &> file

• Shorthand for redirecting both

• Simpler syntax, same result

• Example: ls /home /baddir &> output.log

Both methods: Capture normal output AND errors in one file

Purpose: Sends output of one command as input to another command

Symbol: | (vertical bar)

Syntax: command1 | command2

Can chain multiple: command1 | command2 | command3

Examples:

• ps -ef | grep ssh (list processes, filter for SSH)

• ls -l | less (directory listing with paging)

• cat file.txt | grep error (search for errors in file)

• history | grep sudo (find sudo commands in history)

Power: Combine simple commands for complex tasks without temporary files

Counts the number of SSH-related processes

Breaking it down:

1. ps -ef: Lists all processes on system

2. | grep ssh: Filters output to show only lines containing "ssh"

3. | wc -l: Counts the number of lines (where wc = word count, -l = lines)

Result: A single number showing how many SSH processes are running

Concept: Chaining pipes to progressively filter and process data

Use tail -f command

Syntax: tail -f /path/to/logfile

Example: tail -f /var/log/messages

What happens:

• Shows last 10 lines of file

• Continues to display new lines as they're added

• Updates in real-time

• Perfect for monitoring active logs

Exit: Press Ctrl+C to stop following

Use case: Troubleshooting live issues, watching application logs, monitoring system events

Use the -i option

Syntax: grep -i "pattern" file

Example: grep -i "joe" names.txt

What it does:

• Finds "joe", "JOE", "Joe", "jOe", etc.

• Ignores uppercase/lowercase differences

Without -i:

• grep "joe" would ONLY find exact lowercase "joe"

• Would miss "JOE" or "Joe"

Very useful when: You're unsure of the exact case in configuration files or logs

Use grep -R or grep -r

Syntax: grep -R "pattern" /directory/

Example: grep -R "cloud_user" /var/log/

What it does:

• Searches the specified directory

• Searches all files in subdirectories

• Searches files in sub-subdirectories, etc.

• Shows filename and matching line

Use case:

• Finding configuration settings when you don't know which file

• Searching logs across multiple files

• Finding text anywhere in a directory tree

Combine options: grep -Ri "pattern" /dir/ (recursive AND case-insensitive)

Character Sort (default):

• Compares character by character, left to right

• Example result: 100, 14, 22, 9000

• "1" comes before "2", so 100 comes before 14

Numerical Sort (with -n):

• Compares actual numeric values

• Example result: 14, 22, 100, 9000

• Understands 14 < 22 < 100 < 9000

Commands:

• sort numbers.txt (character: 100, 14, 22, 9000)

• sort -n numbers.txt (numerical: 14, 22, 100, 9000)

Remember: Always use -n when sorting numbers!

Use the -r option

Syntax: sort -r file

Examples:

• sort -r names.txt (Z to A)

• sort -nr numbers.txt (largest to smallest)

• sort -r file.txt > reversed.txt (save reversed sort)

Combining options:

• -n: Numerical sort

• -r: Reverse order

• -nr: Numerical reverse (9000, 100, 22, 14)

Default: Ascending (A-Z, smallest to largest) With -r: Descending (Z-A, largest to smallest)

In less viewer:

Start search:

• Type / followed by pattern

• Example: /Network searches for "Network"

Navigate results:

• n: Jump to next match (forward)

• Shift+N: Jump to previous match (backward)

Example workflow:

less /var/log/messages

/error # Search for "error"

n # Next occurrence

n # Next occurrence

Shift+N # Previous occurrence

q # Quit less

Remember: Forward slash / to search, n for next, Shift+N for previous

First 5 lines: head -n 5 filename

Last 5 lines: tail -n 5 filename

Example:

head -n 5 /var/log/messages # First 5 lines

tail -n 5 /var/log/messages # Last 5 lines

Can combine with pipe:

head -n 100 bigfile.txt | tail -n 5 # Lines 96-100

(First gets first 100, then tail gets last 5 of those)

Remember: -n specifies number of lines for both head and tail

Use > for output redirection

Syntax: sort inputfile > outputfile

Examples:

• sort names.txt > sorted.txt (creates/overwrites sorted.txt)

• sort -n numbers.txt > sorted_nums.txt (numerical sort to file)

• sort file1.txt file2.txt > combined_sorted.txt (sort multiple files)

Alternative: sort -o outputfile inputfile

• -o option built into sort command

• Example: sort -o sorted.txt names.txt

Both methods work, but > is more universal (works with any command)

What happens: Error message goes to stderr (file descriptor 2)

Example:

Sort numbers.txt # Wrong: uppercase S

# Output: -bash: Sort: command not found

Capture error to file: Use 2>

Sort numbers.txt 2> error.log

Result:

• No error appears on screen

• Error message saved in error.log

• Can review errors later: cat error.log

Why useful: Log errors for troubleshooting, keep screen clean, save error history

s /baddir > log.txt:

• Redirects ONLY stdout (normal output)

• Errors still appear on screen

• log.txt may be empty if command only produces errors

ls /baddir &> log.txt:

• Redirects BOTH stdout AND stderr

• Nothing appears on screen

• log.txt contains both output and errors

Example results:

ls /home /baddir > log.txt # Error shows on screen

ls /home /baddir &> log.txt # Error goes to file

Remember: &> captures everything, > only captures normal output

A: Method 1 (using pipe):

grep "error" /var/log/messages | wc -l

Method 2 (using grep's count option):

grep -c "error" /var/log/messages

Breaking down Method 1:

• grep "error" /var/log/messages: Find all lines with "error"

• |: Pipe output to next command

• wc -l: Count lines (where -l = line count)

Case-insensitive count:

grep -i "error" logfile | wc -l # Counts ERROR, error, Error, etc.

Uses both input and output redirection in one command

Breaking it down:

• < input.txt: Input redirection - feeds input.txt as input to sort

• sort: Sorts the input

• > output.txt: Output redirection - saves result to output.txt

Flow: input.txt → sort command → output.txt

Equivalent to:

• sort input.txt > output.txt (simpler, more common)

• cat input.txt | sort > output.txt (using pipe)

Why show this?: Demonstrates you can use < and > together

Use >> (append redirection)

Example:

echo "First line" > output.txt # Create/overwrite

echo "Second line" >> output.txt # Append

echo "Third line" >> output.txt # Append

Result in output.txt:

First line

Second line

Third line

With different commands:

ls -l > combined.txt # Directory listing (overwrite)

ps -ef >> combined.txt # Process list (append)

date >> combined.txt # Current date (append)

Key: First command uses >, subsequent commands use >>

Why separate:

1. Different handling: Process normal output and errors differently

2. Error logging: Save errors separately for troubleshooting

3. Clean output: Send normal output to file, errors to screen

4. Automation: Scripts can detect errors vs success

Practical examples:

Separate files:

command > output.txt 2> errors.txt

• Normal output → output.txt

• Errors → errors.txt

Discard errors:

command 2> /dev/null

• Errors disappear (sent to "black hole")

View errors only:

command > /dev/null

• Normal output discarded, errors on screen

Ctrl+C

What it does:

• Sends interrupt signal to running command

• Stops command execution immediately

• Returns you to command prompt

Common uses:

• Exit tail -f /var/log/messages (following log)

• Stop long-running command

• Cancel command you started by mistake

• Exit from unresponsive program

Other useful shortcuts:

• Ctrl+D: End of input/logout

• Ctrl+Z: Suspend process (background it)

• Ctrl+L: Clear screen (same as clear)

Remember: Ctrl+C = Cancel/interrupt

Use grep -R for recursive search

Command:

grep -R "password" /etc/

What it does:

• Searches /etc/ directory

• Searches all subdirectories recursively

• Finds all files containing "password"

• Shows filename and matching line

Better versions:

grep -Ri "password" /etc/ # Case-insensitive

grep -Rl "password" /etc/ # Show only filenames (-l)

sudo grep -R "password" /etc/ # May need sudo for permissions

Output format: filename:matching line text

Result: Both produce the SAME output

Method 1: cat file.txt | grep "error"

• cat reads file and outputs content

• Pipe sends output to grep

• grep searches through piped input

• Less efficient (two processes)

Method 2: grep "error" file.txt

• grep directly reads and searches file

• More efficient (one process)

• Preferred method

When to use pipe:

• When output comes from command (not file)

• Example: ps -ef | grep ssh (ps output isn't a file)

• Chaining multiple commands

Best practice: Use grep pattern file when possible

Use pipe to less

Command: ls -l | less

Breaking it down:

• ls -l: Long directory listing (lots of output)

• |: Pipe output to next command

• less: View with scrolling capability

Navigation in less:

• Arrow keys: up/down

• Space/Page Down: next page

• Page Up: previous page

• /pattern: search

• q: quit

Other examples:

ps -ef | less # View processes

history | less # View command history

cat largefile.txt | less # Better: just use `less largefile.txt`

What it is: The "black hole" of Linux - discards everything sent to it

Purpose: Throw away unwanted output

Common uses:

Discard normal output, keep errors:

command > /dev/null

Discard errors, keep normal output:

command 2> /dev/null

Discard everything:

command &> /dev/null # Or: command > /dev/null 2>&1

Why useful:

• Suppress noisy output

• Hide expected errors

• Clean scripts (don't clutter screen)

Example: find / -name file.txt 2> /dev/null (hide permission denied errors)

grep "failed" /var/log/messages | tail -n 10

Breaking it down:

1. grep "failed" /var/log/messages: Find all lines with "failed"

2. |: Pipe results to next command

3. tail -n 10: Show last 10 lines of the filtered results

Alternative (case-insensitive):

grep -i "failed" /var/log/messages | tail -n 10

To save results:

grep "failed" /var/log/messages | tail -n 10 > recent_failures.txt

Concept: Chaining commands with pipes to progressively filter data

sort -nr numbers.txt > sorted_reverse.txt

Breaking it down:

• sort: Sort command

• -n: Numerical sort (not character sort)

• -r: Reverse order (descending)

• numbers.txt: Input file

• >: Output redirection

• sorted_reverse.txt: Output file

Result: Numbers sorted from largest to smallest

Example:

• Input: 14, 9000, 22, 100

• Output: 9000, 100, 22, 14

Without -n: Would get character sort (9000, 22, 14, 100)

Use man pages or help

Methods:

1. man grep: Full manual page

   • Detailed documentation

   • All options explained

   • Examples

   • Press q to quit

2. grep --help: Quick help

   • Brief option summary

   • Faster than man page

   • Good for quick reference

3. info grep: Info documentation

   • Alternative to man

   • Sometimes more detailed

For any command: man [command] or [command] --help

Example:

man less # Learn about less

man sort # Learn about sort

grep --help # Quick grep options