How to extract all regex matches in a file using Vim?

Question

Consider the following example:

case Foo:
    ...
    break;
case Bar:
    ...
    break;
case More: case Complex:
    ...
    break:
...

Say, we would like to retrieve all the regex matches (the whole matching text, or even better, the part between \( and \)) of the regex case \([^:]*\):, which should give us (preferably in a new new buffer) something like:

Foo
Bar
More
Complex
...

Another use case example would be the extraction of some parts, for instance, URLs of images from an HTML file.

Is there a simple way to graph all regex matches and put them in a buffer in Vim?

Note: It’s similar to the question “How to extract text matching a regex using Vim?”. However, unlike the setting in that question, I’m also interested in removing the lines that don’t match, preferably without a huge or complex regex.

Answer 1

There is a general way of collecting pattern matches throughout a piece of text. The technique takes advantage of the substitute with an expression feature of the :substitute command (see :help sub-replace-\=). The key idea is to use a substitution enumerating all of the pattern matches to evaluate an expression storing them without replacement.

First, let us consider saving the matches. In order to keep a sequence of matching text fragments, it is convenient to use a list (see :help List). However, it is not possible to modify a list straightforwardly, using the :let command, since there is no way to run Ex commands in expressions (including \= substitute expressions). Yet, we can call one of the functions that modify a list in place. For example, the add() function is designed to append a given item to the specified list (see :help add()).

Another problem is how to avoid text modifications while running a substitution. One approach is to make the pattern always have a zero-width match by prepending \ze or by appending \zs atoms to it (see :help /\zs, :help /\ze). The pattern modified in this way captures an empty string preceding or succeeding an occurrence of the original pattern in text (such matches are called zero-width matches in Vim; see :help /zero-width). Then, if the replacement text is also empty, substitution effectively changes nothing: it just replaces a zero-width match with an empty string.

Since the add() function, as well as the most of the list modifying functions, returns the reference to the changed list, for our technique to work, we need to somehow get an empty string from it. The simplest way is to extract a sublist of zero length from it by specifying a range of indices such that a starting index is greater than an ending one.

Combining the aforementioned ideas, we obtain the following Ex command:

:let t=[] | %s/\<case\s\+\(\w\+\):\zs/\=add(t,submatch(1))[1:0]/g

After its execution, all matches of the first subgroup are accumulated in the list referenced by the variable t, and can be used as is or processed in some way. For instance, to paste contents of the list one by one on separate lines in Insert mode, type

Ctrl+R=tEnter

To do the same in Normal mode, simply use the :put command:

:pu=t

Answer 2

Though it's not possible to write a one-liner to accomplish your example, it's hard to type commands such as :%s/case \([^:]*\):/\=.../ interactively.

I prefer using vim-grex with the following steps:

1. Use / to check whether a regular expression matches to expected lines. For example: /^\s*\<case\s\+\([^:]*\):.*$<Enter>
2. Execute :Grey. It yanks lines matched to the current search pattern.
3. Open a new buffer by :new etc.
4. Put the yanked lines by p etc.
5. Trim uninteresting parts by :%s//\1/.

Answer 3

How to use vim regex to extract the word from the following line, given that 'help' might be any word like 'rust' or 'perlang'.

vim:tw=78:ts=8:ft=help:norl:

Solution:

let foo = substitute(foo, '^\s*vim:.*:ft=\([a-z]\+\).*:\s*$', '\1', '')
echo "foo: '" . foo . "'"

Prints:

foo: 'help'

Guru meditation: What's going on here?

Take the string in the variable foo and match it to assert the beginning of the line, then any number of spaces, the literal vim and a literal colon, then any number of any characters followed by colon ft= with any word with letters, then anything, and assert the line ends with a colon. Throw all that into a register named 1, then get that back in parameter 2 which substitute takes on and replaces the prior string with.

As a general philosophy, any regex longer than your finger on the screen is an epic fail, so decrease screen resolution until it fits.