RED HAT ENTERPRISE LINUX

Working with Text Files

Create, View, and Edit from the Command Line

College-Level Course Module | RHEL System Administration

Welcome to this essential module on working with text files from the Linux command line. Text files are the lifeblood of Linux administration. Configuration files, scripts, logs, documentation - almost everything important in Linux is stored as plain text. You must be proficient at creating, viewing, and editing text files without a graphical interface. This skill is essential when working on servers, through SSH connections, or in recovery situations where only the command line is available. You will learn multiple ways to view file contents - from quick peeks to sophisticated paging. You will create files using output redirection and here documents. Most importantly, you will master vim, the standard text editor in RHEL and one of the most powerful editing tools ever created. We will also cover nano for simpler editing tasks. These skills form the foundation for configuration management, scripting, and daily system administration.

Learning Objectives

View text file contents

Use cat, less, head, tail, and other viewing commands

Create text files

Use redirection, here documents, and editors

Edit files with vim

Navigate, insert, modify, search, and save in vim

Edit files with nano

Use nano for quick and simple text editing

We have four main learning objectives. First, you will learn to view text file contents using various commands - cat for small files, less for paging through large files, head and tail for viewing portions. Second, you will create text files using output redirection, here documents, and text editors - multiple techniques for different situations. Third, you will edit files with vim, the powerful modal editor that is the standard on RHEL. You will learn its modes, navigation, editing commands, searching, and saving. Vim has a learning curve, but mastering it pays dividends throughout your career. Fourth, you will edit files with nano, a simpler editor that is easier to learn. Nano is good for quick edits when you do not need vim's power. By the end, you will be comfortable creating and modifying configuration files, scripts, and any text content from the command line.

Why Text Files Matter

In Linux, everything is configured with text files. System settings, service configurations, scripts, logs - all are plain text that you can read and edit.

Configuration Files

/etc/hosts - hostname mappings
/etc/ssh/sshd_config - SSH server
/etc/httpd/conf/httpd.conf - Apache
/etc/fstab - filesystem mounts
~/.bashrc - shell configuration

Scripts and Logs

/var/log/messages - system log
/var/log/secure - security log
/usr/local/bin/*.sh - local scripts
~/.bash_history - command history
Cron jobs, systemd units, etc.

Philosophy: Text files are human-readable, versionable, scriptable, and transparent. No proprietary formats or special tools needed.

Understanding why text files matter helps you appreciate the skills we are building. In Linux, configuration is done through text files, not graphical control panels or binary registries. This is intentional - text files offer many advantages. Configuration files in /etc control system behavior. SSH settings, web server configuration, network settings, service parameters - all are text files you can read and modify. Scripts are text files containing commands. System logs are text files recording events. Your shell history is a text file. The philosophy behind this is powerful. Text files are human-readable - you can understand them without special tools. They are versionable - you can track changes with git. They are scriptable - you can generate and modify them programmatically. They are transparent - nothing is hidden. You can always see exactly what is configured. This is why command-line text skills are non-negotiable for Linux administrators.

Viewing Files: cat

cat (concatenate) displays file contents to the terminal. Best for small files - large files scroll by too quickly.

# Display file contents
[user@host ~]$ cat /etc/hostname
server.example.com

# Display multiple files (concatenates them)
[user@host ~]$ cat file1.txt file2.txt

# Show line numbers
[user@host ~]$ cat -n /etc/passwd
     1  root:x:0:0:root:/root:/bin/bash
     2  bin:x:1:1:bin:/bin:/sbin/nologin
     3  daemon:x:2:2:daemon:/sbin:/sbin/nologin
...

# Show non-printing characters (useful for debugging)
[user@host ~]$ cat -A file.txt
Line with tab^Iand end$

# Number only non-empty lines
[user@host ~]$ cat -b file.txt

Caution: cat on a large file (like a log) floods your terminal. Use less for big files.

cat is the simplest way to view file contents. Its name comes from concatenate - it was designed to join files together, but most often we use it to display a single file. Just type cat followed by the filename, and the contents appear on your terminal. For multiple files, cat displays them in sequence, concatenated together. The -n option adds line numbers to every line - useful when discussing specific lines with others or in documentation. The -b option numbers only non-empty lines. The -A option shows all characters including non-printing ones. Tabs appear as ^I, line endings as $. This is invaluable for debugging files with hidden characters or wrong line endings. The main limitation of cat is that it dumps everything at once. For large files, the content scrolls by too fast to read. For those cases, use less or other paging tools. cat is perfect for small configuration files, quick checks, and when you want to capture output for further processing.

Viewing Files: less

less is a pager - it displays files one screen at a time, letting you scroll forward and backward. Essential for large files.

# Open file in less
[user@host ~]$ less /var/log/messages

Key	Action	Key	Action
Space	Next page	b	Previous page
↓ or j	Down one line	↑ or k	Up one line
g	Go to beginning	G	Go to end
/pattern	Search forward	?pattern	Search backward
n	Next search match	N	Previous match
q	Quit	h	Help

Remember: Press q to quit less. Man pages use less, so these keys work there too!

less is the standard pager on Linux - it shows files one screen at a time with navigation controls. Use it for any file too large to view with cat. Navigation is intuitive once you learn the keys. Space moves forward one page, b moves back. Arrow keys or j/k move by single lines. g goes to the beginning, G to the end. Searching is powerful. Type / followed by a pattern to search forward. Type ? to search backward. n finds the next match, N finds the previous. This is how you find specific information in large log files. less is used by man pages, so these navigation skills transfer directly to reading documentation. less is also used by journalctl and other tools. The name less is a play on words - it is more capable than the older more command. The saying goes "less is more." Common less options include -N to show line numbers, -S to chop long lines instead of wrapping, and +F to follow the file like tail -f.

Viewing Files: head and tail

# Show first 10 lines (default)
[user@host ~]$ head /etc/passwd
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
...

# Show first 5 lines
[user@host ~]$ head -n 5 /etc/passwd
[user@host ~]$ head -5 /etc/passwd      # Short form

# Show last 10 lines (default)
[user@host ~]$ tail /var/log/messages

# Show last 20 lines
[user@host ~]$ tail -n 20 /var/log/secure

# Follow file in real-time (watch for new lines)
[user@host ~]$ tail -f /var/log/messages
(new lines appear as they're written)
Press Ctrl+C to stop

# Follow multiple files
[user@host ~]$ tail -f /var/log/messages /var/log/secure

tail -f is essential for monitoring logs in real-time. Watch services start, troubleshoot errors, and observe system activity live.

head and tail show portions of files - head shows the beginning, tail shows the end. By default, both show 10 lines. Use -n to specify a different number. head is useful for quickly seeing what a file contains, checking file formats, or grabbing the first few lines for processing. tail is particularly valuable for log files, where the most recent (and relevant) entries are at the end. The killer feature is tail -f (follow). It shows the last lines, then waits and displays new lines as they are added. This is essential for real-time monitoring. Watch a log file while you start a service to see if it succeeds or fails. Watch security logs while testing authentication. Watch application logs during debugging. Press Ctrl+C to stop following. You can follow multiple files simultaneously - tail shows which file each line comes from. Some administrators keep a terminal with tail -f running on important logs at all times.

Other Viewing Commands

# wc - word count (lines, words, characters)
[user@host ~]$ wc /etc/passwd
  45   89  2567 /etc/passwd
[user@host ~]$ wc -l /etc/passwd      # Lines only
45 /etc/passwd

# grep - search for patterns
[user@host ~]$ grep "root" /etc/passwd
root:x:0:0:root:/root:/bin/bash
[user@host ~]$ grep -n "error" /var/log/messages  # With line numbers
[user@host ~]$ grep -i "ERROR" /var/log/messages  # Case insensitive

# diff - compare two files
[user@host ~]$ diff file1.txt file2.txt
3c3
< old line three
---
> new line three

# file - determine file type
[user@host ~]$ file /etc/passwd
/etc/passwd: ASCII text
[user@host ~]$ file /bin/ls
/bin/ls: ELF 64-bit LSB executable...

Several other commands help you work with text files. wc (word count) provides statistics - lines, words, and bytes. Use -l for just line count, -w for words, -c for characters. Great for quick file size checks. grep searches for patterns in files. It is one of the most powerful and frequently used Linux commands. grep "pattern" file shows lines containing the pattern. Add -n for line numbers, -i for case-insensitive matching, -r for recursive directory search. We will cover grep in depth later. diff compares two files and shows differences. The output shows what changed between versions - essential for configuration management and troubleshooting. The < symbol indicates lines from the first file, > from the second. file determines what type a file is - text, binary, script, image, etc. Use it when you are unsure if a file is safe to cat or edit. Binary files displayed with cat can corrupt your terminal.

Creating Files: Redirection

Output redirection sends command output to a file instead of the screen. Use > to create/overwrite, >> to append.

# Create file with echo
[user@host ~]$ echo "Hello, World!" > greeting.txt
[user@host ~]$ cat greeting.txt
Hello, World!

# Append to existing file
[user@host ~]$ echo "Second line" >> greeting.txt
[user@host ~]$ cat greeting.txt
Hello, World!
Second line

# WARNING: > overwrites without asking!
[user@host ~]$ echo "Oops" > greeting.txt   # Previous content GONE

# Create empty file with redirection
[user@host ~]$ > emptyfile.txt

# Redirect command output to file
[user@host ~]$ ls -la > directory_listing.txt
[user@host ~]$ date > timestamp.txt

Warning: > destroys existing content! Use >> to append safely.

Output redirection is a fundamental shell feature that sends command output to files instead of the screen. The greater-than symbol creates a new file or overwrites an existing one. The double greater-than appends to existing content. echo with redirection is a quick way to create files with simple content. echo "text" > file.txt creates the file with that text. This is faster than opening an editor for simple tasks. The danger is that > overwrites without warning. If the file exists, its content is replaced. This catches many beginners by surprise. Always use >> if you want to add to a file rather than replace it. Any command's output can be redirected. ls -la > listing.txt captures a directory listing. date > timestamp.txt records the current time. Command output > file is a pattern you will use constantly. The bare > emptyfile.txt creates an empty file, similar to touch but slightly different in behavior.

Creating Files: Here Documents

Here documents let you create multi-line content inline. The content between the markers becomes the input.

# Create multi-line file with here document
[user@host ~]$ cat > config.txt << EOF
server=192.168.1.100
port=8080
enabled=true
EOF

[user@host ~]$ cat config.txt
server=192.168.1.100
port=8080
enabled=true

# Use any marker (common: EOF, END, STOP)
[user@host ~]$ cat > script.sh << 'END'
#!/bin/bash
echo "Current date: $(date)"
echo "Current user: $USER"
END

# Quoted marker ('EOF') prevents variable expansion
# Unquoted marker (EOF) expands variables

Common use: Here documents are perfect for creating configuration files, scripts, and multi-line content in shell scripts.

Here documents, or heredocs, provide inline multi-line input. The syntax is command << MARKER followed by lines of content, then the MARKER on its own line to end. Everything between the markers becomes input to the command. cat > file << EOF is the common pattern for creating files with heredocs. Type your content, then EOF (or whatever marker you chose) to finish. The file contains everything between the markers. You can use any word as the marker - EOF, END, STOP are common by convention. The marker must appear alone on its final line with no leading spaces. An important subtlety: if the marker is unquoted, variables and commands in the content are expanded. If quoted ('EOF'), content is literal. For scripts containing shell syntax, use quoted markers to prevent premature expansion. Heredocs are invaluable in scripts for generating configuration files, creating multi-line output, and anywhere you need to embed substantial text content.

Introduction to vim

vim (Vi IMproved) is the standard text editor on RHEL and most Linux systems. It is powerful, efficient, and available everywhere - but has a learning curve.

Why Learn vim?

Available on every Linux system
Works over SSH
Extremely powerful editing
Fast once mastered
Required for RHCSA exam

The Challenge

Modal editor (modes matter)
Non-intuitive for beginners
Keys do different things in different modes
No on-screen menus
Must learn commands

# Open or create a file with vim
[user@host ~]$ vim filename.txt

# vi is often aliased to vim
[user@host ~]$ vi filename.txt

vim, short for Vi IMproved, is the standard text editor in RHEL. It descends from vi, created in 1976, and adds many enhancements. Understanding vim is essential for Linux administration. vim is available on virtually every Unix and Linux system. It works perfectly over SSH connections. It is extremely powerful for text manipulation. Once mastered, it is faster than graphical editors for many tasks. The RHCSA exam requires vim proficiency. However, vim is challenging for beginners. It is a modal editor - keys do different things depending on what mode you are in. There are no familiar menus or mouse support. You must memorize commands. It feels completely alien at first. The key insight is that vim is designed for efficiency, not discoverability. It prioritizes speed for experienced users over ease for beginners. The investment in learning vim pays off throughout your career. Every time you edit a configuration file for the rest of your career, vim skills make you faster.

vim Modes

vim is a modal editor. Keys behave differently in each mode. Understanding modes is the key to using vim.

Mode	Purpose	Enter With	Exit With
NORMAL	Navigation, commands, operators	Esc	(Default mode)
INSERT	Typing and inserting text	i, a, o	Esc
COMMAND	Save, quit, search, substitute	:	Enter or Esc
VISUAL	Select text for operations	v, V	Esc

vim - modes illustration

This is some text in the file.
The cursor is blinking here._

NORMAL filename.txt [+] 2,25 All

Lost? Press Esc repeatedly to return to Normal mode. This is your safe haven.

vim's modal nature is what makes it both powerful and confusing. In Normal mode (the default), keys are commands - j moves down, d deletes, y yanks (copies). You do not type text in Normal mode. In Insert mode, keys type text like a regular editor. You enter Insert mode with i (insert before cursor), a (append after cursor), or o (open new line below). You see "-- INSERT --" at the bottom. Press Escape to return to Normal mode. In Command mode, you type commands at the bottom of the screen. Enter it by pressing colon. Commands like :w (save), :q (quit), and :wq (save and quit) are entered here. Visual mode lets you select text for operations. Press v to select characters, V for lines. Selected text is highlighted. If you ever feel lost or vim is not responding as expected, press Escape multiple times. This returns you to Normal mode, the stable starting point. From Normal mode, you can navigate, enter other modes, or quit.

vim Essential Commands

Starting and Quitting		Entering Insert Mode
:w	Save (write)	i	Insert before cursor
:q	Quit (fails if unsaved)	a	Append after cursor
:wq	Save and quit	o	Open line below
:q!	Quit without saving	O	Open line above
:wq!	Force save and quit	A	Append at end of line

Navigation (Normal Mode)		More Navigation
h j k l	Left, down, up, right	0	Beginning of line
w	Next word	$	End of line
b	Previous word	gg	First line of file
Ctrl+f	Page forward	G	Last line of file
Ctrl+b	Page backward	:42	Go to line 42

Minimum survival: i to type, Esc when done, :wq to save and quit.

Let me cover the essential vim commands you need to be productive. For saving and quitting: :w writes (saves) the file. :q quits vim - but fails if you have unsaved changes. :wq does both - save and quit. :q! quits without saving, discarding changes. The exclamation mark means force. For entering Insert mode: i inserts text before the cursor. a appends after the cursor. o opens a new line below and enters Insert mode. O opens a line above. A appends at the end of the current line. For navigation in Normal mode: h, j, k, l move left, down, up, right (arrow keys also work). w jumps forward by words, b backward. 0 goes to line start, $ to line end. gg goes to the first line, G to the last. Ctrl+f pages forward, Ctrl+b pages back. :42 jumps to line 42. The absolute minimum to edit a file: press i to enter Insert mode, type your changes, press Escape to return to Normal mode, type :wq and Enter to save and quit.

vim Editing Commands

Command	Action	Command	Action
x	Delete character under cursor	dd	Delete entire line
dw	Delete word	d$	Delete to end of line
yy	Yank (copy) line	yw	Yank word
p	Paste after cursor	P	Paste before cursor
u	Undo last change	Ctrl+r	Redo
r	Replace single character	cw	Change word (delete + insert)

# Combining commands with counts
5dd     - Delete 5 lines
3yy     - Yank 3 lines
10j     - Move down 10 lines
d5w     - Delete 5 words
2p      - Paste 2 times

# Repeat last change
.       - Repeat last editing command

Pattern: vim commands combine: [count][operator][motion]. Example: d3w = delete 3 words.

vim editing commands follow patterns that make them powerful once understood. Basic deletions: x deletes the character under the cursor. dd deletes the entire line. dw deletes from cursor to end of word. d$ deletes to end of line. Copying and pasting: yy yanks (copies) the current line. yw yanks a word. p pastes after the cursor, P pastes before. In vim, deleted text is also placed in the buffer, so dd followed by p effectively moves a line. Undo and redo: u undoes the last change. Keep pressing u to undo more. Ctrl+r redoes undone changes. Changing text: r replaces a single character without entering Insert mode. cw changes a word - deletes it and enters Insert mode. The power comes from combining commands. Prefix with a number to repeat: 5dd deletes 5 lines. 3yy yanks 3 lines. Commands combine operators and motions: d (delete) + 3w (3 words) = d3w. The period (.) repeats your last editing command - incredibly useful.

vim Search and Replace

# Search forward
/pattern    - Search forward for "pattern"
n           - Next match
N           - Previous match

# Search backward
?pattern    - Search backward for "pattern"

# Search and replace (substitute)
:s/old/new/         - Replace first "old" with "new" on current line
:s/old/new/g        - Replace ALL "old" with "new" on current line
:%s/old/new/g       - Replace ALL occurrences in entire file
:%s/old/new/gc      - Replace all, but ask for Confirmation each time

# Examples
:%s/http/https/g           - Change http to https everywhere
:%s/^#/;/g                  - Change comment character from # to ;
:5,15s/foo/bar/g            - Replace only on lines 5-15

The substitute pattern: :[range]s/search/replace/[flags]
Flags: g = global (all matches), c = confirm each, i = case insensitive

Searching in vim is fast and powerful. Type / followed by your search pattern and press Enter. vim jumps to the first match and highlights all matches. Press n to go to the next match, N for the previous. Use ? instead of / to search backward. Search and replace uses the substitute command. The basic form :s/old/new/ replaces the first occurrence of "old" with "new" on the current line. Add g flag for all occurrences on the line. The % means the entire file, so :%s/old/new/g replaces everywhere in the file. The c flag makes it interactive - vim asks about each replacement. Answer y for yes, n for no, a for all remaining. You can limit substitution to specific line ranges. :5,15s/foo/bar/g only affects lines 5 through 15. The search pattern supports regular expressions for powerful matching. This makes vim incredibly effective for bulk text transformations.

vim Visual Mode

Visual mode lets you select text visually, then apply operations to the selection. More intuitive for some tasks.

Key	Selection Type
v	Character-wise selection (highlight characters)
V	Line-wise selection (highlight entire lines)
Ctrl+v	Block selection (rectangular region)

# Visual mode workflow:
1. Position cursor at start of selection
2. Press v (or V for lines)
3. Move cursor to extend selection (highlighted)
4. Press operator: d (delete), y (yank), c (change), etc.

# Examples:
V5jd       - Select 5 lines down, delete them
viw        - Select inner word (visual-inner-word)
va"        - Select including quotes (visual-around-")
Vjj:s/old/new/g  - Substitute only in selected lines

Tip: Visual mode is great when you're not sure exactly what you want to select. See it highlighted before acting.

Visual mode provides a more intuitive way to select text. Instead of counting words or lines, you visually see the selection highlighted. Press v for character-wise selection - individual characters are highlighted as you move. Press V for line-wise selection - entire lines are highlighted. Ctrl+v gives block selection - a rectangular region, useful for column editing. Once you have a selection, press an operator: d to delete, y to yank, c to change, or even : to apply an ex command to just the selected lines. Visual mode is particularly helpful when you are not sure exactly what you want to select. Select first, verify it looks right, then act. The text objects work in Visual mode too: viw selects the inner word, va" selects around quotes including the quotes. Block selection (Ctrl+v) is powerful for editing columns of text - like adding or removing characters at the same position on multiple lines.

vim Configuration

# Useful settings (use during session or add to ~/.vimrc)
:set number         - Show line numbers
:set nonumber       - Hide line numbers
:set hlsearch       - Highlight search matches
:set nohlsearch     - Remove highlights
:set ignorecase     - Case-insensitive search
:set smartcase      - Case-sensitive if uppercase used
:set tabstop=4      - Tab width of 4 spaces
:set expandtab      - Use spaces instead of tabs
:set autoindent     - Auto-indent new lines
:set syntax=on      - Enable syntax highlighting

# Create persistent configuration
[user@host ~]$ vim ~/.vimrc
set number
set hlsearch
set ignorecase
set smartcase
set tabstop=4
set expandtab
set autoindent
syntax on

~/.vimrc is loaded every time vim starts. Put your preferred settings there for permanent configuration.

vim is highly configurable. You can change settings temporarily during a session or permanently in your configuration file. Useful display settings include :set number to show line numbers (very helpful for programming and configuration files), and :set hlsearch to highlight all search matches. Search settings like :set ignorecase make searches case-insensitive, while :set smartcase is smart - it is case-insensitive unless you include uppercase letters. Tab and indentation settings are important for code. :set tabstop=4 makes tabs display as 4 spaces. :set expandtab converts tabs to spaces. :set autoindent maintains indentation on new lines. Syntax highlighting with syntax on colors code based on the file type - invaluable for reading scripts and configuration files. To make settings permanent, add them to ~/.vimrc. This file is loaded when vim starts. Put one setting per line without the colon prefix. You can also add custom key mappings and more complex configurations.

vim Practice Workflow

vim workflow example

1. Open file: vim /etc/hosts
2. Navigate to line: :5 (go to line 5)
3. Go to end of line: $
4. Enter insert mode: a (append after cursor)
5. Type your text...
6. Return to normal: Esc
7. Save and quit: :wq

:wq

Practice tip: Create a test file and experiment. Use :q! to quit without saving your experiments.

# Built-in vim tutorial (highly recommended!)
[user@host ~]$ vimtutor
# Takes about 30 minutes, teaches all basics interactively

Let me walk through a typical vim workflow. You open a file with vim filename. You navigate to where you need to make changes - maybe :5 to jump to line 5, then $ to go to the end of that line. You enter Insert mode with a (append) or i (insert). You type your changes. You press Escape to return to Normal mode. You save and quit with :wq. This pattern - navigate, enter Insert mode, edit, Escape, save - is the fundamental vim workflow. Every edit follows this cycle. The best way to learn vim is practice. Create a test file and experiment. If you make a mess, :q! quits without saving. Nothing is permanent until you :w. The vimtutor command launches an interactive tutorial. It takes about 30 minutes and teaches all the basics with hands-on exercises. Highly recommended for new vim users - it is the best way to build muscle memory.

Introduction to nano

nano is a simple, user-friendly text editor. It displays keyboard shortcuts on screen and works like a typical editor - no modes.

GNU nano 5.6 - config.txt

server=192.168.1.100
port=8080
enabled=true

^G Help ^O Write Out ^W Where Is ^K Cut ^U Paste ^X Exit

# Open or create file with nano
[user@host ~]$ nano filename.txt

# Open at specific line number
[user@host ~]$ nano +25 filename.txt

The ^ symbol means Ctrl. So ^X means Ctrl+X. All shortcuts are shown at the bottom.

nano is the friendly alternative to vim. It is modeless - you just type, and text appears. It shows keyboard shortcuts at the bottom of the screen, so you do not need to memorize commands. When you open nano, you see the file content with shortcut hints at the bottom. The caret symbol means Ctrl, so ^X means Ctrl+X. Common shortcuts are always visible. nano works like text editors most people are familiar with. Type to enter text. Use arrow keys to navigate. Ctrl+K cuts a line, Ctrl+U pastes. Ctrl+O saves (writes out), Ctrl+X exits. nano is perfect for quick edits when you do not need vim's power. It is also a good fallback when you are on an unfamiliar system and not sure if vim is available or configured the way you expect. The downside is nano lacks vim's powerful editing commands. For simple tasks, this does not matter. For complex text manipulation, vim is more efficient.

nano Essential Commands

Shortcut	Action	Shortcut	Action
Ctrl+O	Write Out (save)	Ctrl+X	Exit
Ctrl+K	Cut line	Ctrl+U	Paste (uncut)
Ctrl+W	Where Is (search)	Ctrl+\	Search and replace
Ctrl+G	Help	Ctrl+C	Show cursor position
Ctrl+A	Beginning of line	Ctrl+E	End of line
Ctrl+Y	Page up	Ctrl+V	Page down
Alt+U	Undo	Alt+E	Redo
Ctrl+_	Go to line number	Alt+G	Go to line (also)

# Common workflow:
1. nano filename.txt     - Open file
2. (make edits directly - just type)
3. Ctrl+O, Enter         - Save
4. Ctrl+X                - Exit

# Search and replace:
1. Ctrl+\                - Start replace
2. Enter search term, Enter
3. Enter replacement, Enter
4. A (for all) or Y/N for each

nano's shortcuts are shown at the bottom, but let me highlight the essential ones. Saving uses Ctrl+O (write Out). nano asks for the filename - just press Enter to confirm. Ctrl+X exits - if you have unsaved changes, it asks if you want to save first. Editing is straightforward. Ctrl+K cuts the current line (or selection). Ctrl+U pastes (uncutting). These work together for cut-and-paste. Searching with Ctrl+W prompts for a search term. Ctrl+\ does search and replace - enter search term, then replacement, then choose to replace all or one at a time. Navigation uses arrow keys, with Ctrl+A and Ctrl+E for line start/end, Ctrl+Y and Ctrl+V for page up/down, and Ctrl+_ or Alt+G to jump to a line number. Undo is Alt+U, redo is Alt+E. The help system (Ctrl+G) lists all commands if you need a reminder. The workflow is simple: open, edit, Ctrl+O to save, Ctrl+X to exit.

vim vs nano

vim Strengths

Extremely powerful editing
Very fast once learned
Available everywhere
Required for RHCSA exam
Macro recording
Extensive customization
Plugin ecosystem

nano Strengths

Immediately usable
On-screen help
No learning curve
Good for quick edits
Familiar interface
Less cognitive load
Lower risk of mistakes

Recommendation: Learn vim well - it is a career skill. Use nano for quick, simple edits when vim's power is overkill.

# Set your default editor (optional)
[user@host ~]$ export EDITOR=vim
[user@host ~]$ echo 'export EDITOR=vim' >> ~/.bashrc

Both editors have their place. vim excels at complex editing tasks. Once mastered, it is incredibly fast. It is available on every Linux system and is required for the RHCSA exam. Features like macros, powerful search-replace, and text objects make complex edits efficient. nano excels at simplicity. There is no learning curve - you can use it immediately. The on-screen help means you never need to memorize commands. For quick edits to configuration files, nano gets the job done without cognitive overhead. My recommendation: invest in learning vim well. It is a skill that pays dividends throughout your career. But also know nano for those times when vim is overkill or when you are on an unfamiliar system. The EDITOR environment variable sets your default editor for programs like crontab and git that need to open an editor. Set it in your .bashrc to make your preference permanent.

Key Takeaways

Viewing: cat for small files, less for paging, head/tail for portions. tail -f follows logs.

Creating: > redirects output to files. >> appends. Here documents for multi-line content.

vim: Modal editor: Normal (commands), Insert (typing), Command (:). i to type, Esc to stop, :wq to save.

nano: Simple editor with on-screen help. Ctrl+O saves, Ctrl+X exits. Good for quick edits.

Graded Lab

View /etc/passwd with cat, less, head, and tail
Create a configuration file using echo and redirection
Create a multi-line file using a here document
Complete vimtutor (run: vimtutor)
Edit a file in vim: navigate, insert text, save, quit
Practice vim search and replace on a test file
Make a quick edit with nano for comparison

Next: Redirecting Shell Input and Output

Let me summarize what we have covered. For viewing files, use cat for small files where you want to see everything at once. Use less for paging through larger files with navigation and search. Use head and tail for viewing file portions, and tail -f for watching logs in real-time. For creating files, output redirection with > creates or overwrites files. Double >> appends safely. Here documents let you create multi-line content inline in scripts. vim is the standard editor you must learn. It is modal - understand Normal mode for commands, Insert mode for typing, and Command mode for saving and quitting. The minimum workflow is i to type, Escape when done, :wq to save and quit. nano is simpler with on-screen shortcuts. Ctrl+O saves, Ctrl+X exits. Good for quick edits when vim's power is not needed. Your lab exercises provide essential hands-on practice. Definitely run vimtutor - it is the best 30 minutes you can invest in learning vim. These text file skills are foundational - you will use them in every module that follows.