Learning the vi and Vim Editors, Seventh Edition Text processing at maximum speed and power (Arnold Robbins, Elbert Hannah, Linda Lamb) (Z-Library)

【One-Line Pitch】 If you spend any time in a terminal, this is the definitive guide to mastering vi and Vim—the editors that power Unix, Linux, and macOS. From your first keystroke to advanced scripting, it turns a frustrating tool into your fastest path from thought to text. 【Book Arc】 - **Opening (~0%–9%)**: Introduces vi's philosophy and history, explains why it's not a WYSIWYG word processor, and covers opening/closing files, quitting, and the basic command structure. This stage solves the "where do I start?" problem with a clear mental model. - **Early (~9%–25%)**: Dives into simple editing—cursor movement, insert/delete/change commands, undo/redo, and screen navigation (H/M/L, scrolling). It also introduces the general command pattern (command + number + text object), which is the key to vi's power. This stage builds muscle memory for everyday editing. - **Early–Middle (~25%–38%)**: Explores global replacement with :g and :s, including regular expressions, special replacement characters (&, ~, \u, \l), and the :set command for customizing options. This stage solves the "I need to change this everywhere" problem efficiently. - **Middle (~38%–47%)**: Covers advanced editing—abbreviations, key mapping with :map, named buffers, and autoindent for source code. It also introduces shift commands (>>, <<) and tabstop/shiftwidth settings. This stage is about personalizing your workflow. - **Late (~47%–end)**: Moves into Vim-specific features and power tools: interval expressions in regex, enhanced tags with Exuberant ctags, and tag stacks for navigating code. This stage is for users ready to go beyond basic vi into clone-specific optimizations. 【Key Takeaways】 - **The command pattern is everything** (Early): Most vi commands follow `(command)(number)(text object)`—like `d2w` to delete two words. Understanding this unlocks the editor's composability; you can mix and match commands (c, d, y) with movements to do complex edits in a few keystrokes. - **Undo is more powerful than you think** (Early): `u` undoes the last command, `U` undoes all edits on a line, and you can toggle between versions by undoing the undo. Vim adds `CTRL-R` for redo and infinite undo history, letting you move forward and backward through your edit history. - **Global replacement is a lifesaver** (Early): The `:s/old/new/g` command changes every occurrence on a line, while `:%s/old/new/g` does it file-wide. Special characters like `&` (replay the match) and `\u`/`\l` (change case) make it a precision tool, not just a find-and-replace. - **Customize with :set and .exrc** (Middle): Toggle options like `:set ic` (ignore case) or value options like `:set window=20` change how vi behaves. Startup files (.exrc in home and local directories, plus EXINIT) let you define different environments for different tasks—English text vs. source code. - **Abbreviations and mappings save keystrokes** (Middle): `:ab` expands short phrases into long ones (watch out for infinite loops), while `:map` assigns complex command sequences to unused keys. These turn repetitive tasks into single keystrokes, dramatically speeding up your workflow. - **Autoindent is a coder's best friend** (Middle): The `autoindent` option, combined with `>>`/`<<` shift commands and `shiftwidth` settings, keeps source code properly indented. Special `CTRL-D` variants handle C preprocessor lines and reset indentation levels, helping you avoid bugs from mismatched braces. - **Vim's regex and tags go deeper** (Late): Interval expressions like `{n,m}` give precise control over repetitions, and Exuberant ctags (supported by most clones) enables powerful tag stacks—saving multiple locations as you jump through code. This is where vi stops being an editor and becomes a navigation system. 【Reading Tips】 - **Skim the problem checklists** (Early): Each major section includes troubleshooting lists for common mistakes. Don't read them upfront—just know they're there and return when you hit a snag. - **Deep-read the command pattern chapter** (Early): The `(command)(number)(text object)` structure is the foundation. Spend extra time here; it's the difference between memorizing commands and truly understanding vi. - **Practice the global replacement examples** (Early–Middle): The `:s` and `:g` commands have many subtle options. Work through the examples with a test file—especially the `&`, `~`, and case-conversion characters—to see the results firsthand. - **Skip the clone-specific sections initially** (Late): The book covers vi, nvi, elvis, Vim, and vile. If you're on Linux or macOS, focus on Vim sections first; come back to the others only if you need them. - **Take away the .exrc setup** (Middle): Even if you skim the rest, learn how to create a .exrc file with your preferred :set options. It's a small investment that pays off every time you open the editor. 【Coverage Limits】 This guide synthesizes the first ~47% of the book in depth; the later portions on Vim-specific features, multi-window editing, and scripting are covered only at a high level. Excerpts do not cover the book's appendices or advanced Vim scripting.