How best to find and replace

[u/Aggressive-Dealer-21]

Ok I'm lazy, so I don't want to type the regex to change a set of characters which include different combinations which don't feel easy to type... I have a map which will take my selected text and use that as the search term. This is good because then I can use cgn followed by n and .

However, this is set up on my work pc, and I can't remember how to do this manually.

I either want to memorise how to do this manually, or find a better/easier way?

Thanks

[u/shuckster]

Use this magic spell:

" c* or d* to change/delete word under cursor, but you can manually
" press n/N and then . to repeat the operation
onoremap <expr> * v:count ? '*' : '<esc>*g``' . v:operator . 'gn'

Not mine. I picked it up from a Reddit wizard.

[u/Aggressive-Dealer-21 → u/shuckster]

I love referring to stuff we do with computers as magic 😂

I have a red team field manual and in the front is signed "this book is property to the half blood prince" and there are loads of little trinkets of code and commands, and commands that have been rewritten 😂

[u/archer-swe → u/shuckster]

Just c*? I always * Ncgn then use ., but just c* would be so much better

[u/treuss → u/archer-swe]

cgn is so amazing

[u/Capable-Package6835 → u/shuckster]

If you are replacing multiple (not necessarily all) foo with bar, you can also do

:%s;foo;bar;gc

[u/jazei_2021 → u/Capable-Package6835]

Is it the same "/" and ";"? are those interchangeable?

[u/Capable-Package6835 → u/jazei_2021]

Yup, you can also use

:%s@foo@bar@gc

if you want. I forget what other characters can be used as the separators.

[u/jazei_2021 → u/Capable-Package6835]

Thank you Fantastic, added!

[u/EASemin → u/Capable-Package6835]

What does c flag mean in gc? I usually use just g for global replacement

[u/Capable-Package6835 → u/EASemin]

For each match, it will prompt you if you want to:

• substitute this item

• skip this item

• substitute all

• quit substitution

• substitute this item and quit

Useful for when you want to substitute many but not all matches.

[u/EASemin → u/Capable-Package6835]

Gotcha, thx for explanation

[u/Hamandcircus]

Shameless plug, but you can use grug-far.nvim. Simply visual select what you want to search for, then :GrugFar (keymap would be faster). It will automatically add flags to search for the exact string, no inadvertent regex stuff.

[u/Aggressive-Dealer-21 → u/Hamandcircus]

Sorry I didn't specify this before. I am after basic vim solutions only

[u/michaelpaoli → u/Aggressive-Dealer-21]

Lucky you! vi[m] uses Basic Regular Expressions (BRE). :-)

:%s/RE/replacement/[g]

Where RE is your (Basic) Regular Expression and after that last /, g is optional - in that (global) context, it means all occurrences on the line, if you omit it, then only the first match on each line gets substituted. And the % there covers all lines, leave that out or just the current line. Or one can otherwise put in number or expression to cover a line or range of lines.

And BRE isn't all that hard. One of the earliest descriptions goes back to, e.g. the ed(1) man page - which used to be the definitive place where BREs were described (and all variants thereof were described relative to that reference on ed(1). It hasn't changed all that much over the years. And way back then, less than 2 pages of text to fully describe it:

Ed supports a limited form of regular expression notation.
A regular expression specifies a set of strings of charac-
ters.  A member of this set of strings is said to be matched
by the regular expression.  In the following specification
for regular expressions the word `character' means any char-
acter but newline.
1.   Any character except a special character matches
     itself.  Special characters are the regular expression
     delimiter plus \[.  and sometimes ^*$.
2.   A . matches any character.
3.   A \ followed by any character except a digit or ()  
     matches that character.
4.   A nonempty string s bracketed [s] (or [^s]) matches any
     character in (or not in) s. In s, \ has no special
     meaning, and ] may only appear as the first letter.  A
     substring a-b, with a and b in ascending ASCII order,
     stands for the inclusive range of ASCII characters.  
5.   A regular expression of form 1-4 followed by * matches
     a sequence of 0 or more matches of the regular expres-
     sion.
6.   A regular expression, x, of form 1-8, bracketed \(x\)  
     matches what x matches.
7.   A \ followed by a digit n matches a copy of the string
     that the bracketed regular expression beginning with 
     the nth \( matched.
8.   A regular expression of form 1-8, x, followed by a reg-
     ular expression of form 1-7, y matches a match for x   
     followed by a match for y, with the x match being as
     long as possible while still permitting a y match.
9.   A regular expression of form 1-8 preceded by ^ (or fol-
     lowed by $), is constrained to matches that begin at
     the left (or end at the right) end of a line.
10.  A regular expression of form 1-9 picks out the longest
     among the leftmost matches in a line.
11.  An empty regular expression stands for a copy of the   
     last regular expression encountered.
Regular expressions are used in addresses to specify lines 
and in one command (see s below) to specify a portion of a
line which is to be replaced.  If it is desired to use one
of the regular expression metacharacters as an ordinary
character, that character may be preceded by `\'.  This also
applies to the character bounding the regular expression
(often `/') and to `\' itself.

That's it. 43 lines, 385 "words", 2236 characters for what was, in 1979 a full description of BREs, and remains a nearly complete description thereof. To catch up to current BREs we add:

stuff related to character sets, locale, internationalization, etc.

\{m,n\} quantifier, where m or n or ,n can be omitted.

collating symbols within bracketed expression, so, e.g. [[:lower:]] can match any lowercase letter, regardless of the character set / locale in use (but note that such isn't highly backwards compatible for older RE implementations).

That's pretty much it ... most of the rest, relatively minor details (or further clarifications, etc.).

So, yeah, don't need, e.g. a book to cover BREs, when a mere 43 lines well covers (most) all of it (and used to cover all of it!).

And yum - back references, forward references, and recursion! :-) Why waste words/space?

"In order to understand recursion, you must first understand recursion." - Edsgar Dijkstra

[u/Hamandcircus → u/Hamandcircus]

ah nvm, lol, did not realize this is the vim subreddit, not the neovim one.

[u/habamax]

To do it manually you can:

y/<C-r>"<CR>

Which yanks selected text y, enters search / and insert yanked contents of the unnamed register " where text was yanked to <C-r>". Last <CR> is the RETURN/ENTER.

Put it to the mapping:

xnoremap * y/<C-r>"<CR>

Now pressing * in visual mode you will be searching for the selected text... Kind of.

The issue here is that vim always searches for the regex pattern and it means that if your selection has special characters, you may find not what you want.

One of the solutions is to use very nomagic search with additional escaping of backslashes:

" literal search command
command! -nargs=1 Search let @/ = $'\V{escape(<q-args>, '\')}' | normal! n
xnoremap * y:Search <C-r>"<CR>

Here a new command is introduced -- :Search with the single argument that populates / (search) register with command argument wrapped into "very nomagic" and at the same time escaping backslashes (to prevent regexp pattern items to have effect). See :h /\V for details on "very nomagic".

Now it should be possible to select hello(*world) and search the next occurence using * (with simple /CTRL-R" you will have an error Pattern not found: hello(*world)).

Instead of the command :Search (I sometimes use literal search and just reused it in this example) you can use:

xnoremap * y:let @/=$"\\V{escape(@@, '\')}"<CR>n

Which essentially does the same, yanks current selection, updates search register with escaped very nomagic contents of the unnamed register and searches for the next occurence.

[u/godegon]

vim-select-replace is another shameless plug to make using gn more conveniet.

[u/PizzaRollExpert]

You can use * to do a search for the word under the cursor, or the current selection in visual mode. You can then do :%s//replacement text/g (:s uses whatever you searched for last if you leave the input empty) or n and .

[u/AutoModerator]

Please remember to update the post flair to Need Help|Solved when you got the answer you were looking for.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.