Automatically insert a matching brace in Vim

VimAutocomplete

Vim Problem Overview

I spend way too much time fumbling around because Vim doesn't handle closing braces like most IDEs do. Here's what I want to happen:

Type this:

if( whatever )
{ <CR>

and get this:

if( whatever )
{
  |  
}

where <CR> mean hit the ENTER key and | is the position of the cursor. This is what Eclipse does. It's what Visual Studio does. And it's what I want Vim to do.

I've seen a few plugins, tried a few, and none of them seem to give me this behavior. Surely I can't be the first programmer to want this.

Vim Solutions

Solution 1 - Vim

In VimL, you can map the { to do exactly as you wish:

inoremap { {<CR>}<Esc>ko

depending on your autoindent setup, you may want to add a <BS> after <CR>.

For a more complete solution, I'd suggest you take a look at Luc Hermitte's vim plugins. They've never failed me so far.

Solution 2 - Vim

Using AutoClose with the following works correctly.

inoremap {<CR> {<CR>}<C-o>O

This is true for my system at least (Unix terminal on Mac OS X).

Solution 3 - Vim

Finally I found out there is no need for plugin but rather this works perfect for me:

inoremap { {}<Esc>ha
inoremap ( ()<Esc>ha
inoremap [ []<Esc>ha
inoremap " ""<Esc>ha
inoremap ' ''<Esc>ha
inoremap ` ``<Esc>ha

Solution 4 - Vim

A solution for braces, brackets and parenthesis with tab in between.

" Automatically closing braces
inoremap {<CR> {<CR>}<Esc>ko<tab>
inoremap [<CR> [<CR>]<Esc>ko<tab>
inoremap (<CR> (<CR>)<Esc>ko<tab>

Result:

function() {
  |
}

Solution 5 - Vim

Here is what I have in my vimrc:

let s:pairs={
            \'<': '>',
            \'{': '}',
            \'[': ']',
            \'(': ')',
            \'«': '»',
            \'„': '“',
            \'“': '”',
            \'‘': '’',
        \}
call map(copy(s:pairs), 'extend(s:pairs, {v:val : v:key}, "keep")')
function! InsertPair(left, ...)
    let rlist=reverse(map(split(a:left, '\zs'), 'get(s:pairs, v:val, v:val)'))
    let opts=get(a:000, 0, {})
    let start   = get(opts, 'start',   '')
    let lmiddle = get(opts, 'lmiddle', '')
    let rmiddle = get(opts, 'rmiddle', '')
    let end     = get(opts, 'end',     '')
    let prefix  = get(opts, 'prefix',  '')
    let start.=prefix
    let rmiddle.=prefix
    let left=start.a:left.lmiddle
    let right=rmiddle.join(rlist, '').end
    let moves=repeat("\<Left>", len(split(right, '\zs')))
    return left.right.moves
endfunction
 noremap! <expr> ,f   InsertPair('{')
 noremap! <expr> ,h   InsertPair('[')
 noremap! <expr> ,s   InsertPair('(')
 noremap! <expr> ,u   InsertPair('<')

And, for some filetypes:

inoremap {<CR> {<C-o>o}<C-o>O

// I know that InsertPair function is trivial, but it saves time because with it I can define both command and normal mode mappings with one command without having to write lots of <Left>s.

Solution 6 - Vim

Put the following in your .vimrc file:

inoremap { {}<ESC>ha

Whenever you press { in insert mode, {} is generated and puts your cursor on the right brace, so that you can start typing between them straight away. By putting the curly braces in sequence rather than on different lines, you can put tabs in front of } manually. That way you never have the wrong amount of tabs in front of it.

Perhaps someone can figure out how to count the amount of tabs the cursor is on, and then generate an equal amount of tabs in front of the } on a new line.

Solution 7 - Vim

For anyone that runs across this like I did, and was looking for something more recently updated than AutoClose: delimitMate I have found to be, not only a preferable solution to AutoClose, behavior wise, but also in active development. According to vim.org, AutoClose has not been updated since 2009.

Solution 8 - Vim

I have tried different plugins but I found most accurate and most easy to use auto-pairs. It is really intuitive and when you install it you get what you've expected out of the box.

Solution 9 - Vim

I've always preferred something like what sublime text does where it appends the closing brace as the next character, so I added the following to my .vimrc:

inoremap (  ()<ESC>hli

which moves the cursor to between the two braces.

Solution 10 - Vim

inoremap ( ()<ESC>i
inoremap " ""<ESC>i
inoremap ' ''<ESC>i
inoremap { {<Cr>}<Esc>O

Solution 11 - Vim

As you'll see in the wikia tip: there are many solutions to this recurrent question (I even have mine).

That is if you limit yourself to bracket pairs. Here you are in the context of a control statement. You're thus more likely to find snippet systems that will not expect you to type the ") {" when typing an "if" statement. Vim shortcut tend to be shorter from what I read in your question. Here again there are a lot of choices, you'll find most likely snipmate, and may be my C&C++ suite.

Solution 12 - Vim

delimitMate has a setting for this.

Solution 13 - Vim

Vim patch 7.4.849 added a binding to allow for cursor movements without restarting the undo sequence. Once updated to >= 7.4.849 then something like this works great.

inoremap ( ()<C-G>U<Left>

Note that I grabbed that straight from the documentation included in the patch. Best simple solution for this feature yet.

Solution 14 - Vim

Insert this into your ~/.vimrc if you have auto-indent enabled:

inoremap {<CR> {<CR>}<Esc>ko
inoremap [<CR> [<CR>]<Esc>ko
inoremap (<CR> (<CR>)<Esc>ko

and if not

inoremap {<CR> {<CR>}<Esc>ko<tab>
inoremap [<CR> [<CR>]<Esc>ko<tab>
inoremap (<CR> (<CR>)<Esc>ko<tab>

Then you can map a key (in my case the key is ä, this can be replaced with anything you want)...

map ä A<space>{<CR>

...to automatically do all of this for you, if you are anywhere in the line on key press.

example ('|' symbolizes where your cursor is):
int main(int a|rgc)
When you press the key now (in my case ä in command mode), the result will be this:

int main(int argc) {
    |
}

Solution 15 - Vim

Install and use Vim script AutoClose as recommended in the article titled Automatically append closing characters.

Solution 16 - Vim

Just a note to @Bob.

Karl Guertin's AutoClose has a function named ``double brace'', that is, you can type curly brace twice, as below.

int func_name(void) {{ ==> Type `{' twice here.

would result in:

int func_name(void) {
| ==> Cursor here.
}

Then, you can type a single Tab, to get indented according to your `shiftwidth' setting, then type.

Solution 17 - Vim

If you type {} and hit alti you will be in between the braces in INSERT mode (at least in a terminal). Then you can hit ENTER followed by altshifto to insert the line break. You could also just do {<CR>} and altshifto.

This may not be fully automatic, but I consider it semi-auto. It removes the need for more plugins, and is useful info to know for other use cases. For example, I use altshifto all the time to insert blank lines without having to explicitly leave INSERT mode, and alti for getting inside () etc.

Solution 18 - Vim

You do not need a special plugin to do this - but it is a two-step process.

First, add the following to your .vimrc to eat the triggering character:

" eat characters after abbreviation
function! Eatchar(pat)
    let c = nr2char(getchar(0))
    return (c =~ a:pat) ? '' : c
endfunction

and then add this abbreviation to your .vimrc:

inoreabbr <silent> { {
      \<cr><space><space>
      \<cr><esc>0i}<esc>k$i<c-r>=Eatchar('\m\s\<bar>\r')<cr>

The \ at the start of lines two and three is just a line continuation character. You could have done this all on one line, however and i added it so that i could spread the abbreviation out in a way that mirrors the output you're looking for -- just so things are a little more intuitive.

Solution 19 - Vim

My solution:

inoremap <expr> <CR> InsertMapForEnter()
function! InsertMapForEnter()
    if pumvisible()
        return "\<C-y>"
    elseif strcharpart(getline('.'),getpos('.')[2]-1,1) == '}'
        return "\<CR>\<Esc>O"
    elseif strcharpart(getline('.'),getpos('.')[2]-1,2) == '</'
        return "\<CR>\<Esc>O"
    else
        return "\<CR>"
    endif
endfunction

Explaination:

The code above first check if you are using Enter to do confirm a code completion, if not it will indent the {|} when you type Enter. Also, it provides html tags auto indent.

Examples:

if( whatever ){|}

press Enter and you will get

if( whatever )
{
  |  
}

This also works for html file. See the following example

<html>|<html>

press Enter and you will get

<html>
    |
</html>
Categories
Recommended Vim Solutions
Recommended Autocomplete Solutions

Previous Solution:

Changing CSS pseudo-element styles via JavaScript

JavascriptCssCss SelectorsPseudo ElementSelectors Api

Next Solution:

In javascript, how do you search an array for a substring match

JavascriptArraysSearch

Attributions

All content for this solution is sourced from the original question on Stackoverflow.

The content on this page is licensed under the Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license.

Content TypeOriginal AuthorOriginal Content on Stackoverflow
QuestionBobView Question on Stackoverflow
Solution 1 - VimMichael FoukarakisView Answer on Stackoverflow
Solution 2 - VimdmonopolyView Answer on Stackoverflow
Solution 3 - VimNika TsogiaidzeView Answer on Stackoverflow
Solution 4 - VimRodrigo PintoView Answer on Stackoverflow
Solution 5 - VimZyXView Answer on Stackoverflow
Solution 6 - Vimuser1534664View Answer on Stackoverflow
Solution 7 - VimEric HView Answer on Stackoverflow
Solution 8 - VimegelevView Answer on Stackoverflow
Solution 9 - VimAneesh DurgView Answer on Stackoverflow
Solution 10 - VimmaxView Answer on Stackoverflow
Solution 11 - VimLuc HermitteView Answer on Stackoverflow
Solution 12 - VimHenrik NView Answer on Stackoverflow
Solution 13 - VimJohn EikenberryView Answer on Stackoverflow
Solution 14 - VimlarsaarsView Answer on Stackoverflow
Solution 15 - VimDerek MaharView Answer on Stackoverflow
Solution 16 - VimjtukiView Answer on Stackoverflow
Solution 17 - VimSO_fix_the_vote_sorting_bugView Answer on Stackoverflow
Solution 18 - VimricardoView Answer on Stackoverflow
Solution 19 - VimWW00WWView Answer on Stackoverflow