# What is the most efficient way to invert two words?

Let's say that I have a file containing several occurrences of the word `foo` and several occurrences of the word `bar`.

I need to make all the words `foo` become `bar` and inversely all the words `bar` become `foo`.

What is the most efficient way to do that?

My first thought was to make it 3 steps:

• First make `bar` become something temporary: `%s/bar/barTEMP/g`
• Then make `foo` become `bar`: `:%s/foo/bar/g`
• Finally substitute `barTEMP`: `:%s/barTEMP/foo/g`

It is an implementation of a classical algorithm to switch the value of two variables but is there a more efficient way to do this?

I know I can write a function to do the 3 substitutions for me but what I'm wondering is if there is a different method than using a temporary substitution. For example I was thinking maybe something could be done by using an `|` in the search pattern:

``````:%s/\(foo\|bar\)/???/g
``````

But that would require to make the replacement string change depending on the actually matched word and I don't know how to do that. (Note that this idea is just an example, if someone come up with something better that would be nice too)

• stackoverflow.com/a/9273857/1924583 Commented Aug 5, 2016 at 13:35
• I suppose this is the original source with full commentary on how it works. Commented Aug 5, 2016 at 13:40
• Tim Pope's abolish provides some syntactic sugar for it: `:%S/{foo,bar}/{bar,foo}/g`. This works well as long as you don't want to match only whole words. Commented Aug 5, 2016 at 13:42
• I usually use the ternary operator in a replacement expression for just two words (not very obviously at `:h expr1`), though using a dictionary is obviously better for >2 words. Commented Aug 5, 2016 at 14:11
• Yeah, it took me several minutes to find it, so, when I finally did, I thought I'd better mention where it was. :-) Commented Aug 5, 2016 at 16:30

Posting this so it can have an answer on our SE, but this is this source with full explanation.

Here's a good way to use a single regex to do multiple substitutions:

``````:%s/foo\|bar/\={'foo':'bar','bar':'foo'}[submatch(0)]/g
``````

See `:help sub-replace-expression` and `:help Dictionary` for Vim's documentation on how this works.

• Thanks for this one, I didn't saw it on SO. That seems like a good way to go. Commented Aug 5, 2016 at 15:13
• Just mentioning the solution using the ternary operator that @Antony suggested above: `:%s/foo\|bar/\=submatch(0) == "foo" ? "bar" : "foo"/g`.
– Rich
Commented Oct 27, 2017 at 9:15

For vanilla vim, Tumbler41's answer is probably the best way to go. If you are OK with installing plugins, you could use tpope/vim-abolish to do this.

This plugin supplies many awesome feature, but the relevant one for this case is called "Subvert" (abbreviated to `:%S`. Essentially, it allows you to create a list of matches, and a list of replacements. I like the example from the README on the plugin, so I'll use that. If you want to change "child" to "adult", while simultaneously changing "children" to "adults", that is a single subvert command.

``````:%S/child{,ren}/adult{,s}/
``````

In your case, you could do

``````:%S/{foo,bar}/{bar,foo}
``````

One important note about this approach is that it doesn't support regexes very well, and it defaults to case-sensitive, so it would also change "FOO" to "BAR". However, for simple substitutions, this approach is very simple and convenient.

• `abolish` does support regexes, it's just that (1) it uses "very magic" mode, and (2) your regexes are likely to conflict with its own. Like the vast majority of Vim plugins, it's an useful hack, not a rock-solid solution. Commented Aug 6, 2016 at 4:20
• You mean “it defaults to case-insensitive,” right? Commented Aug 7, 2016 at 22:22
• Vimcast episode: [Supercharged substitution with :Subvert]vimcasts.org/episodes/supercharged-substitution-with-subvert) Commented Aug 10, 2016 at 18:01