Pro vim 笔记
ch2 Installation & configuration
configure your terminal
Zsh is a replacement for Bash and can be thought of as an improvement to the feature found in the Bash.
editing .zshrc
apt-get install zsh
cat /etc/shells
chsh -s /bin/zsh
Ch3 Fundamental
fundamental concepts for VIM:
- Commands
- Buffers
- Windows
- Tabs
- Modes
Buffers
When you open a file in Vim and start editing it, you are, in fact, only editing a copy of the file.
The original file remains unchanged until you actually write the buffer back to the file.
Buffers have multiple states: active, hidden, and active.
Windows
Vim allows you to split the current viewpoint/screen into smaller window.
Tabs
Used in a scenariors that you expect another application.
Modes
One of the most important concepts in Vim is its built-in “modes”, of which there are six main ones. The are others, such as SELECT and EX:
- NORMAL
- INSERT
- VISUAL
- REPLACE
- COMMAND-LINE
- VISUAL-BLOCK
-
static list
:history
-
dynamic list
q: (in any modes but insert, it will open up command line window.)
Modes | Trigger |
---|---|
NORMAL | <Esc> |
INSERT | i |
VISUAL | v |
REPLACE | R |
COMMAND-LINE | : |
VISUAL-BLOCK | <C-v> |
If you are already in command-line mode, pressing <C-f> to drop you into command line window.
Online community
Stack Overflow Or Experts Exchange
Key bindings
Command | Bindings |
---|---|
nmap | Display key binding for NORMAL mode |
vmap | Display key binding for VISUAL mode |
imap | Display key binding for INSERT mode |
map | Display key binding for all mode |
The :only command closes all split windows until there is one window left open.
Ch4 Files
Open file
vim file.txt
vim file1.txt file2.txt
once you’re in vim, using edit (:e ) command:
:e path/to/your/file.txt
When using the edit command :e, press <Space> and then <C-d>, you can list all available dir/files, and press <Tab> key to cycle through all available items.
File formats
set fileformat= {dos|mac|unix}
Inserting File
To do a basic file load, use vim’s :read command.
:read file2.txt
:8read file2.txt
:read !ls -a | grep ‘^.’ | grep –invert-match ‘.DS_Store|.$’
Moving between files
When open multiple files, using vim’s suite of buffer comands.
- :bn: next buffer
- :bp: previous buffer
- :ls: list all buffers that are available
- :b#: to alternative buffer
- :bf/l: to first/last buffer
- :bm: next modified buffer
Saving files
- :w: save a file
- :wq: save & close
- x: write the buffer when a modification is actually detected
- 5,9wq: save line 5 ~ 9, then quit.
quit files: - :qa!:
- :wqa.
- :conf wqa. need a confirm.
- wqa!
Creating new file
- :new: empty buffer within a horizontal split window
- :enew: empty buffer
- :vnew: tempty buffer within a vertical split window
- tabnew: empty buffer within a new tab.
Creating New Files from a Template
autocmd BufNewFile *.html Or ~/skeleton.html
autocmd BufNewFile ruby_class.rb Or ~/ruby_class_template.rb
Creating a Scratch Buffer
- Create Scratch buffer without plug-in.
- :set buftype=nofile
- :set bufhidden=hide
- :setlocal noswapfile
- With plug-in.
- :Scratch: create a scratch buffer in current window.
- :Sscratch: create a scratch buffer in a horizontal split window.
File Name Modifiers
file name modifier takes the form of %{:option},
see h: filename-modifiers
Switching Working Directories
cd %:p:h
Ch5 Commands
Commands for editing content are used primarily within NORMAL mode.
Editing Commands
[count] {operator} {[count] motion|text object}
Operators
Operator | Explanation |
---|---|
yy | Yanks entire line |
p/P | paste after/before current cursor position |
i/a | put into INSERT mode before/after current cursor position |
f/t | finds specified character to the right / until the specified character |
o/O | move cursor to the next/previous line and enter INSERT mode |
x | cuts the character |
s/S | substitute the character / entire line |
~ | swap character casing |
dd | deletes current line |
D | delete from the cursor until the end of line (same as d$) |
gx | opens URL under your cursor in web browser |
Motions
Motion | Explanation |
---|---|
0 | start of the line |
$ | end of the line (inclusive of newline) |
g_ | ~ (exclusive of newline) |
b | backward through each word |
e | end of the word |
w | start of next word |
gg/G | start/end of the buffer |
% | next bracket (or parenthesis) |
( / ) | previous / next sentence |
{ / } | start / end of a paragraph |
[( / ]) | previous / next available parenthesis |
[{ / ]} | previous / next available bracket |
Command Inversion
- p / P
- f / F
- r / R
- a / A
- i / I
Cursor Movement
h, j, k, l
Page Movement
Command | Explanation |
---|---|
<C-u> | half page up |
<C-d> | half page down |
<C-b> | one page up |
<C-f> | one page down |
zt | shift page content so current line sits at the top of the viewport |
zb | current line sits at bottom ~ |
zz | current line sits at middle ~ |
H | move cursor to the top of the viewport |
M | ~ middle ~ |
L | ~ bottom ~ |
one vim configuration:
set scrolloff = {n}
Text Objects
The syntax structure of a text object:
{special motion} {object}
Type | Name | Explanation |
---|---|---|
sp motion | Inside (i) | select inside the object (exclusive whitespace) |
sp motion | Arround (a) | select arround (inclusive whitespace) |
object | Word(w) | select a single word |
object | Sentence(s) | single sentence |
object | Paragraph(p) | single paragraph |
object | Tag(t) | single XML/HTML mark-up tag |
object | Quote(“|’|`) | select content inside/around quotation marks |
object | Block({}|[]|<>|()) | ~ block (exclusives whitespace) |
Executing Commands Within INSERT Mode
Use <C-o>, to enter a special mode in which you’re placed back in NORMAL mode. After a command has completed, it will back into INSERT mode.
Ch6 Register
Vim register types:
1. The unnamed register “”
2. 10 numbered register “0 to “9
3. The small delete register “-
4. 26 named registers “a to “z or “A to “Z
5. 4 read-only registers “:, “., “%, and “#
6. The expression register “=
7. The selection and drop registers “*, “+, and “~
8. The black hole register “_
9. Last search pattern register “/
view registers by command :reg.
Accessing a Specific Register
Enter a double quote character “, followed by the register you want to access.
“bp
Unnamed Register
If we delete(d), change(c), substitute(s), cut(x), or yank(y) content, that content would end up in the unnamed register. Vim use the register effectively as a “last used register”.
“”p
Numbered Register
Text that is yanked(y) or deleted(d) is automatically placed inside the numbered register 0~9. Each subsequent piece of content that is stored willl shift the previous stored content down to the next numbered register.
viw”2y
Named Register
It based on the alphabet, so it has 26 registers in total, and it will be used when you explicitly tell it to do so.
viw”ay : cleanup and store.
viw”Ay : append and store.
Read-Only Register
- “. : last edit made via INSERT mode.
- “% : name of the current file
- “# : name of the alternative file
- “: : most recently executed COMMAND-LINE command.
Expression Register (“=)
Entering the expression register only works when you’re inside INSERT mode.
0f1viwyea<Space>()<Esc>i<C-r>=strftime(“%Y”)-<C-r>”<CR>
Selection/Drop Register
Related to GUI version.
Blackhole Register
Last Search Register
Clearing Your Registers
Ch7 Folding
Fold Options
- manual
- indent
- expr
- syntax
- diff
- marker
to change fold method: :set foldmethod=manual. The defualt fold setting is manual, it isn’t remembered after the file has been closed.
Creating Folds
When used with different motions, zf can take the following multiple forms.
* v{motion|text object}zf : fold a selection
* zf{motion|text object} : fold around a motion or text object (e.g., zf3j)
* zf’a : fold from current postion up to the a mark.
* {count}zF : fold counted number of lines from current position.
Opening/Closing/Toggling Folds
- zc : close the fold.
- zo : open the fold.
- za : alternate the fold.
Open/Close All Folds
- zM : close all folds
- zR : open all folds
Marker
A marker fold gives the illusion of remembering the folds set in a file, when really it does this by searching the buff as it’s being read for specific tags, wrapping content we want to fold and then processing those tags.
Automatically Closing Folds
autocmd BufRead setlocal foldmethod=mark*
autocmd BufRead normal zM*
Folding by indentation
set foldmethod=indent
set foldlevel=5
Nested Folds
Folding by Syntax
:set foldmethod=syntax
Folding Content Dynamically
Folding Unchanged Lines
:setlocal diff foldmethod=diff scrollbind nowrap foldlevel=1
Ch8 VISUAL-BLOCK
Entering VISUAL-BLOCK Mode
Cmd <C-v> from NORMAL mode.
Canceling
<Esc> : escape and apply changes for all selections.
<C-c> : escape.
Adding Additional Content in Block Format
e.g., gg<C-v>4jI*<Esc>
End-of-Line Concerns
e.g., gg<C-v>$4jA!<Esc>
Better Selection Capabilities
o : opposite position of selection block
O : opposite position in the same line.
see :h visual-change
Ch9 Bulk Command Processing
Vim list: buffer, tab, window, argument. For each list type, Vim providers a command which enables us to carry out actions in bulk.
* bufdo
* windo
* tabdo
* argdo
bufdo
e.g., add a timestamp to the bottom of each file.
:bufdo exe “:normal i” . strftime(“%c”) | update
windo
The :windo command works in a similar fashion to :bufdo but with one very important difference, which is that it only works on visible buffers.
windo %s/2014/1914/ge
tabdo
In each tab, the cursor is placed in the top window, and we want the cursor to be actually in the bottom window instead.
tabdo wincmd j
see :h win-move-cursor
argdo
modifying the Arguments List
args ~/Desktop/{foo, bar, baz}.txt
Example
:argdo echo expand(‘%:p’) | bd!
Ch10 Editing Workflow
Practical Examples
Moving Around a Single File
[count]gg
105gg / 105G
Moving Around a Single Line
f / F
Moving Around Long Files
/#+\w : search using regex.
Moving Between Blocks
using % motion.
Complex Syntax
vt{x}
va{x}
Text Objects
Find and Replace
[range]s/{pattern}/{replacement}/[flags]
Workflow Management
redundant if you use a VCS.
Ch11 Search and Replace
Finding Files
:find foo.txt
:sfind foo.txt
Paths
Most system have the concept of a “load path”, this fundamental principle is that when Vim starts up, it has a path variable that holds a list of folders.
These folders are where Vim to execute find command.
:set path
:set path+=~/Desktop
:Explore / :Sexplore
Searching for Content
With the Current Buffer
Using command \
Navigating search result using n / N
\%>{line_number}l and \%<{line_number}l
Don’t Wast Time Typing
running * command when your cursor inside a word
* and # : search forward for the nearest word to the cursor.
Moving backward
?
Change Pattern Matches More Quickly
Feature for recent Vim7.4. need more study.
Searching Within Multiple Buffers
- vimgrep
- lvimgrep
- grep
- lgrep
Lists
- vimgrep uses Vim’s quickfix list
- lvimgrep uses Vim’s location list
vimgrep /{searchTerm}/[gj] {path/to/project/*//java}
Search result will displayed in quickfix or location window. Commands for Quickfix and Location window
Command | Explanation |
---|---|
copen/cclose | Open/Close the quickfix list |
lopen/lclose | ~ location list |
cnext/cprev | Move cursor to next/previous quickfix result |
lnext/lprev | ~ location result |
<CR> | Opens file and places cursor on the match |
cnfile/cpfile | Open the next/previous file with a match |
Multiple Search History
Vim’s search stack can remember the last 10 search lists.:colder
:cnewer
Search & Replace
Within the Current Buffer
:[range]s/{pattern}/{replacement}/[flags]
e.g., :%s/DataStore/VimStore/g
e.g., :%s/data_\?store/VimStore/gci
Regular Expressions
%s/data(_\?)(store)/Vim\1\2/gci
%s/V(im_store)/v\1/g
Diffrences in Regex Flavors
Word boundary in Vim aren’t common \b syntax but \< and \\>.Avoiding Escaping Characters
By adding the *\v* flag before the search pattern, we can avoid the need to escape characters.%s/\vdata(_?)(store)/Vim\1\2/gci
Tricks Specific to Vim’s Regex Flavor
- \zs : reset the start position for your match.
- @<=: look behind.
/.*\zsfoo
/\v(foo)@<=bar
Validating Substitution Patterns
:%s/^#/!!/n
Vim returns the number of mentions.
Reusing a Previous Search Pattern
/some thing
:%s//more things/g
Search & Replace Within VISUAL-BLOCK Selection
:’<,’>s/foo/bar/g
:<,’>s/\%Vfoo\%V/bar/g
Search & Replace Within Multiple Buffers
- The Vim way (argdo)
- The Unix way (sed)
The Vim Way
vim **/*.txt
:argdo %s/{search}/{replace}/ge | update
The Unix Way
sed -i – ‘s/search/replace/’ *.txt && rm *.txt–*
Global Command
:g/{pattern}/{command}
e.g., *:g/\v^(a|g)/:d
:[range]g[lobal][!]/{pattern}/[cmd]
e.g., :g/\w /normal 3X
Expression Replacements
:%s/today/\=strftime(“%c”)/
Ch 12 Buffer/Window/Tab Management
Buffer Management
Viewing All Buffers
:ls, % indicates currently visible buffer, and # is alternative buffer.
Splitting Buffers into Windows
- :sba
- :vert sba
Diffrent Ways to Close Buffers
:bd *.php : file type based.
:bd 1 : number based
:bd 3 5
:4, 7 bd
:bufdo bd
Window Management
*Openinig Split Windows
:sp [file]
:vs [file]
Closing All but Current One
on[ly]
Changing Window Layout
<C-w>H/J/K/L : left/down/up/right
Resizing Windows
Changing window dimensions Incremently
<C-w>+/- : Increase/Reduce height by one row.
<C-w>>/<: ~ width by one column.
Changing window dimentions by a Set Amount
:resize +{n}
:resize -{n}
:vertical resize +{n}
:vertical resize -{n}
Maximizing Windows
<C-w>_
<C-w>|
<C-w>=
Moving a Window to a Tab
<C-w>T
Tab Management
Creating & Navigating Tabs
:tabnew
gt / gT, 4gt
Closing Tabs
:tabonly
Rearranging Tabs
:tabmove [n]
Ch 13 Automation
Ex mode is a variation of Vim’s COMMAND-LINE mode, meaning it has the same syntax :{command}, but instead of only being able to execute one command at a time like COMMAND-LINE mode, you can execute multiple commands, one after the other.
Automation Through Ex Mode
- Typing ex in your terminal.
- Starting Vim using the -E flag.
- Executing Q from within Vim’s NORMAL mode.
- :h holy-grail
Automation Through Macros
Recording Macros
q{register}{command}q
e.g., qa0f=wvg_xalog()<Esc>”“Pjq
Executing Macros
@{register}
- Manually run @a two more times
- Specify a count: 2@a
- Manually run @@ twice. (second @ mean last executed register)
- Specify a count with the last executed register: 2@@
e.g., qa0xf”d2li<Space><Esc>eldg_jq
Applying Macros Across Multiple Files
:bufdo normal @a
:bufdo exe “normal @a” | write
More Dynamic Macros Using the Expression Register
qaxi<C-r>=2*<C-r>”<Enter><Esc>jq
:%g{pattern}/norm @a
Editing Macros
Appending
- qA
Editing
There is a a register looks like: qaxi<C-r>=2*<C-r>”<Enter><Esc>jq
* :put a : Write the relevant macro to the buffer.
* f2 : Find the number 2.
* r4 : Replace it with the number 4.
* 0V : Select the macro again.
* “ay : Yank the selection into the a register.
* :put : Display the udpated register.
Ch14 Lists
Change Lists
:changes
Move Back Through Our Change Positions
:changes {n}
Jump Lists
:jumps
- <C-o> : Move to the previous jump position
- <C-i> : Move to next jump position
2<C-o>
Ignoring Jumps
:keepjumps
Ch15 Marks
- Temporary marks : only last as long as the buffer is open.
- Long-term marks : last until you delete them.
Creating Marks
m{a-zA-Z}
Viewing Marks
List of Marks Vim Automatically Generates:marks
Mark | Explanation |
---|---|
‘ | Marks the line where the cursor jumped from (in current buffer) |
` | Marks the position ~ |
. | Marks the position where the last change occurred (in current buffer) |
“ | ~ where the user last exited the current buffer |
[ | Marks the beginning of the previously changed or yanked text |
] | ~ end of ~ |
< | Marks the beginning of the last visual selection |
> | ~ end of ~ |
Local & Global Marks
- lowercase marks are local
- uppercase marks are global
Navigating Marks
List of Commands for Navigating Vim Marks
Operator | Explanation |
---|---|
]’ | Next mark line position |
[‘ | Previous ~ |
]` | Next mark line and column position |
[` | Previous ~ |
Moving to Specific Marks
- ‘{identifier} : line
- `{identifier} : line & column
How to Avoid Modifying the Jump List
Use the g prefix: g’{mark} or g`{mark}
Deleting Marks
- :delmarks A B c 1
- :delmarks a-d
Manipulating Content with Marks
d`D
Ch 16 Sessions
Views and Sessions
View : which holds information related to a single window.
Session : which holds information related to a complete state of Vim at the time of creating the session.
Creating a View
mkview [1-9|path]
File-Based Views
~~~~
Loading a View
:loadview [1-9]
:source {path}
Creating a Session
:mksession!
it will generate a file named session.vim.
Loading a Session
:source path/to/session.vim
vim -S path/to/session.vim
Removing Sessions
Simply delete the session.vim file.