# 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)

• I suppose this is the original source with full commentary on how it works. 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. 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. 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. :-) 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. 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
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. Aug 6, 2016 at 4:20
• You mean “it defaults to case-insensitive,” right? Aug 7, 2016 at 22:22
• Vimcast episode: [Supercharged substitution with :Subvert]vimcasts.org/episodes/supercharged-substitution-with-subvert) Aug 10, 2016 at 18:01