O que há no seu .vimrc? [fechadas]

157

O Vi e o Vim permitem uma personalização realmente impressionante, normalmente armazenada dentro de um .vimrcarquivo. Recursos típicos para um programador seriam realce de sintaxe, recuo inteligente e assim por diante.

Que outros truques para programação produtiva você tem, ocultos no seu .vimrc?

Estou interessado principalmente em refatorações, classes de automóveis e macros de produtividade semelhantes, especialmente para C #.

alguém
fonte
11
Eu acho que você deveria ter pedido às pessoas para postarem seus arquivos de configuração comentados do vim.
InnaM 28/10/09
Por que não compartilhar essas coisas no github? Eu tenho a minha pasta .vim todo sob git e tudo isso pode ser visto aqui: github.com/lsdr/vim-folder
lsdr
1
Eu não acho que .vimrcs inteiros sejam úteis; se um monte de pessoas votarem uma resposta, você simplesmente pegará a coisa toda e a colocará no seu sistema? Trechos são muito mais úteis, assim como uma lista de aliases ou funções úteis é muito melhor que arquivos inteiros. (Bash | z) rc.
Xiong Chiamiov 03/11/2009

Respostas:

104

Você pediu por isso :-)

"{{{Auto Commands

" Automatically cd into the directory that the file is in
autocmd BufEnter * execute "chdir ".escape(expand("%:p:h"), ' ')

" Remove any trailing whitespace that is in the file
autocmd BufRead,BufWrite * if ! &bin | silent! %s/\s\+$//ge | endif

" Restore cursor position to where it was before
augroup JumpCursorOnEdit
   au!
   autocmd BufReadPost *
            \ if expand("<afile>:p:h") !=? $TEMP |
            \   if line("'\"") > 1 && line("'\"") <= line("$") |
            \     let JumpCursorOnEdit_foo = line("'\"") |
            \     let b:doopenfold = 1 |
            \     if (foldlevel(JumpCursorOnEdit_foo) > foldlevel(JumpCursorOnEdit_foo - 1)) |
            \        let JumpCursorOnEdit_foo = JumpCursorOnEdit_foo - 1 |
            \        let b:doopenfold = 2 |
            \     endif |
            \     exe JumpCursorOnEdit_foo |
            \   endif |
            \ endif
   " Need to postpone using "zv" until after reading the modelines.
   autocmd BufWinEnter *
            \ if exists("b:doopenfold") |
            \   exe "normal zv" |
            \   if(b:doopenfold > 1) |
            \       exe  "+".1 |
            \   endif |
            \   unlet b:doopenfold |
            \ endif
augroup END

"}}}

"{{{Misc Settings

" Necesary  for lots of cool vim things
set nocompatible

" This shows what you are typing as a command.  I love this!
set showcmd

" Folding Stuffs
set foldmethod=marker

" Needed for Syntax Highlighting and stuff
filetype on
filetype plugin on
syntax enable
set grepprg=grep\ -nH\ $*

" Who doesn't like autoindent?
set autoindent

" Spaces are better than a tab character
set expandtab
set smarttab

" Who wants an 8 character tab?  Not me!
set shiftwidth=3
set softtabstop=3

" Use english for spellchecking, but don't spellcheck by default
if version >= 700
   set spl=en spell
   set nospell
endif

" Real men use gcc
"compiler gcc

" Cool tab completion stuff
set wildmenu
set wildmode=list:longest,full

" Enable mouse support in console
set mouse=a

" Got backspace?
set backspace=2

" Line Numbers PWN!
set number

" Ignoring case is a fun trick
set ignorecase

" And so is Artificial Intellegence!
set smartcase

" This is totally awesome - remap jj to escape in insert mode.  You'll never type jj anyway, so it's great!
inoremap jj <Esc>

nnoremap JJJJ <Nop>

" Incremental searching is sexy
set incsearch

" Highlight things that we find with the search
set hlsearch

" Since I use linux, I want this
let g:clipbrdDefaultReg = '+'

" When I close a tab, remove the buffer
set nohidden

" Set off the other paren
highlight MatchParen ctermbg=4
" }}}

"{{{Look and Feel

" Favorite Color Scheme
if has("gui_running")
   colorscheme inkpot
   " Remove Toolbar
   set guioptions-=T
   "Terminus is AWESOME
   set guifont=Terminus\ 9
else
   colorscheme metacosm
endif

"Status line gnarliness
set laststatus=2
set statusline=%F%m%r%h%w\ (%{&ff}){%Y}\ [%l,%v][%p%%]

" }}}

"{{{ Functions

"{{{ Open URL in browser

function! Browser ()
   let line = getline (".")
   let line = matchstr (line, "http[^   ]*")
   exec "!konqueror ".line
endfunction

"}}}

"{{{Theme Rotating
let themeindex=0
function! RotateColorTheme()
   let y = -1
   while y == -1
      let colorstring = "inkpot#ron#blue#elflord#evening#koehler#murphy#pablo#desert#torte#"
      let x = match( colorstring, "#", g:themeindex )
      let y = match( colorstring, "#", x + 1 )
      let g:themeindex = x + 1
      if y == -1
         let g:themeindex = 0
      else
         let themestring = strpart(colorstring, x + 1, y - x - 1)
         return ":colorscheme ".themestring
      endif
   endwhile
endfunction
" }}}

"{{{ Paste Toggle
let paste_mode = 0 " 0 = normal, 1 = paste

func! Paste_on_off()
   if g:paste_mode == 0
      set paste
      let g:paste_mode = 1
   else
      set nopaste
      let g:paste_mode = 0
   endif
   return
endfunc
"}}}

"{{{ Todo List Mode

function! TodoListMode()
   e ~/.todo.otl
   Calendar
   wincmd l
   set foldlevel=1
   tabnew ~/.notes.txt
   tabfirst
   " or 'norm! zMzr'
endfunction

"}}}

"}}}

"{{{ Mappings

" Open Url on this line with the browser \w
map <Leader>w :call Browser ()<CR>

" Open the Project Plugin <F2>
nnoremap <silent> <F2> :Project<CR>

" Open the Project Plugin
nnoremap <silent> <Leader>pal  :Project .vimproject<CR>

" TODO Mode
nnoremap <silent> <Leader>todo :execute TodoListMode()<CR>

" Open the TagList Plugin <F3>
nnoremap <silent> <F3> :Tlist<CR>

" Next Tab
nnoremap <silent> <C-Right> :tabnext<CR>

" Previous Tab
nnoremap <silent> <C-Left> :tabprevious<CR>

" New Tab
nnoremap <silent> <C-t> :tabnew<CR>

" Rotate Color Scheme <F8>
nnoremap <silent> <F8> :execute RotateColorTheme()<CR>

" DOS is for fools.
nnoremap <silent> <F9> :%s/$//g<CR>:%s// /g<CR>

" Paste Mode!  Dang! <F10>
nnoremap <silent> <F10> :call Paste_on_off()<CR>
set pastetoggle=<F10>

" Edit vimrc \ev
nnoremap <silent> <Leader>ev :tabnew<CR>:e ~/.vimrc<CR>

" Edit gvimrc \gv
nnoremap <silent> <Leader>gv :tabnew<CR>:e ~/.gvimrc<CR>

" Up and down are more logical with g..
nnoremap <silent> k gk
nnoremap <silent> j gj
inoremap <silent> <Up> <Esc>gka
inoremap <silent> <Down> <Esc>gja

" Good call Benjie (r for i)
nnoremap <silent> <Home> i <Esc>r
nnoremap <silent> <End> a <Esc>r

" Create Blank Newlines and stay in Normal mode
nnoremap <silent> zj o<Esc>
nnoremap <silent> zk O<Esc>

" Space will toggle folds!
nnoremap <space> za

" Search mappings: These will make it so that going to the next one in a
" search will center on the line it's found in.
map N Nzz
map n nzz

" Testing
set completeopt=longest,menuone,preview

inoremap <expr> <cr> pumvisible() ? "\<c-y>" : "\<c-g>u\<cr>"
inoremap <expr> <c-n> pumvisible() ? "\<lt>c-n>" : "\<lt>c-n>\<lt>c-r>=pumvisible() ? \"\\<lt>down>\" : \"\"\<lt>cr>"
inoremap <expr> <m-;> pumvisible() ? "\<lt>c-n>" : "\<lt>c-x>\<lt>c-o>\<lt>c-n>\<lt>c-p>\<lt>c-r>=pumvisible() ? \"\\<lt>down>\" : \"\"\<lt>cr>"

" Swap ; and :  Convenient.
nnoremap ; :
nnoremap : ;

" Fix email paragraphs
nnoremap <leader>par :%s/^>$//<CR>

"ly$O#{{{ "lpjjj_%A#}}}jjzajj

"}}}

"{{{Taglist configuration
let Tlist_Use_Right_Window = 1
let Tlist_Enable_Fold_Column = 0
let Tlist_Exit_OnlyWindow = 1
let Tlist_Use_SingleClick = 1
let Tlist_Inc_Winwidth = 0
"}}}

let g:rct_completion_use_fri = 1
"let g:Tex_DefaultTargetFormat = "pdf"
let g:Tex_ViewRule_pdf = "kpdf"

filetype plugin indent on
syntax on
Frew
fonte
78
Mas por que 3, defina shiftwidth = 3, defina softtabstop = 3 ... talvez 2 ou 4, mas por que 3?
Johan
1
Apenas imaginando, mas o mapeamento de jj para <Esc> fornecerá um pequeno atraso ao pressionar j no modo de inserção?
sykora
1
@ sykora: sim, mas assim que você digitar outro caractere (que não seja j), ele aparecerá. Eu faço a mesma coisa, mas em vez disso com jk, acho que acertar jk é mais rápido do que acertar jj. Somente as vezes que isso me afetou foi digitar o alfabeto, então talvez você seja melhor.
197 David Miani
2
@ John: porque 'três é um número mágico'. :) Na verdade, isso é apenas ciclismo, mas eu prefiro três também. :)
Robert Massaioli
4
Se homens de verdade usam o gcc, por que não? (compilador gcc é comentada!)
Abdulsattar Mohammed
73

Isso não está no meu arquivo .vimrc, mas ontem eu aprendi sobre o ]pcomando. Isso cola o conteúdo de um buffer da mesma forma que pfaz, mas ajusta automaticamente o recuo para corresponder à linha em que o cursor está! Isso é excelente para mover o código.

Greg Hewgill
fonte
Você quer dizer que isso é semelhante a: set paste, p,: set nopaste?
hyperboreean
3
Até onde eu sei, a opção: set paste não afeta o comando p, apenas afeta o texto digitado (ou colado em um terminal) no modo de inserção. Então não, é um recurso diferente.
Greg Hewgill 17/04/09
1
Não deve ser upvoting para isso, porque não está respondendo à pergunta, mas eu gosto muito dele;)
Gorsky
53

Eu uso o seguinte para manter todos os arquivos temporários e de backup em um só lugar:

set backup
set backupdir=~/.vim/backup
set directory=~/.vim/tmp

Economiza diretórios de trabalho desorganizados em todo o lugar.

Você precisará criar esses diretórios primeiro, o vim não os criará para você.

Harley Holcombe
fonte
2
Devo mencionar que você terá que criar esses diretórios por conta própria, o vim não fará isso por você.
Harley Holcombe
Isso lida com vários arquivos idênticos corretamente? (por exemplo, se você está editando vários ramos diferentes do mesmo código)
yungchin
Não, isso substituirá os arquivos de backup antigos com o mesmo nome. Se alguém tiver uma maneira de contornar isso, me avise.
Harley Holcombe
3
Tente o seguinte: au BufWritePre * let & bex = '-'. tempo de operação ("% Y% m% d-% H% M% S"). '.vimbackup' (Essa é uma linha). E devo mencionar isso também: vim.wikia.com/wiki/VimTip962
Zsolt Botykai
1
Isso também evita que o Vim se queixe ao abrir arquivos sincronizados pelo Dropbox em várias máquinas.
Cody Hess
31

Alguém (viz. Frew) que postou acima tinha esta linha:

"CD automaticamente no diretório em que o arquivo está:"

autocmd BufEnter * execute "chdir ".escape(expand("%:p:h"), ' ')

Eu estava fazendo algo parecido até descobrir que a mesma coisa poderia ser realizada com um cenário incorporado:

set autochdir

Eu acho que algo semelhante aconteceu comigo algumas vezes diferentes. O Vim tem tantas configurações e opções internas diferentes que, às vezes, é mais rápido e mais fácil de fazer você mesmo do que pesquisar nos documentos pela maneira integrada de fazê-lo.

Herbert Sitz
fonte
ótimo encontrar! eu gosto de usar coisas embutidas mais ^ _ ^. Além disso, isso não falha se houver um | no nome do arquivo.
Javed Ahamed 4/08/09
2
O autochdir tem alguns aborrecimentos que eu nunca poderia contornar (alterar o diretório antes de carregar um arquivo fornecido na linha de comando) e li em outro lugar aqui no SO sobre o autocmd BufEnter * silent! lcd %:p:h:gs/ /\\ /que faz a mesma coisa básica, mas não prejudica a linha de comando.
dash-tom-bang
Eu prefiro fazê-lo opcional e usar este comando para inserir o diretório do arquivo atual: cd%: h
staackuser2
28

Minha mais recente adição é para destacar a linha atual

set cul                                           # highlight current line
hi CursorLine term=none cterm=none ctermbg=3      # adjust color
Martin
fonte
2
existe alguma maneira de selecionar entre mais cores?
Fzs2
Qual é a diferença entre set cul e set cursorline?
putolaruan
Eu apenas uso o "set cul" para obter uma linha na minha linha atual. A configuração da linha do cursor está mexendo demais com a sintaxe destacada para o meu gosto.
Claes Mogren
2
Consulte este script ( vim.org/scripts/script.php?script_id=1349 ) para obter as cores disponíveis. Pode ser necessário ativar o suporte de 256 cores para o vim para obter uma variedade maior.
Brian Wigginton
1
@ Claude Na verdade, set cule set cursorlinefaça exatamente a mesma coisa.
Gerardo Marset
24

Atualização 2012 : agora eu realmente recomendo verificar o vim-powerline que substituiu meu antigo script de linha de status, embora atualmente não haja alguns recursos que eu sinto falta.


Eu diria que o material da linha de status no meu vimrc foi provavelmente o mais interessante / útil do momento (extraído dos autores vimrc aqui e da postagem do blog correspondente aqui ).

Captura de tela:

linha de status http://img34.imageshack.us/img34/849/statusline.png

Código:

"recalculate the trailing whitespace warning when idle, and after saving
autocmd cursorhold,bufwritepost * unlet! b:statusline_trailing_space_warning

"return '[\s]' if trailing white space is detected
"return '' otherwise
function! StatuslineTrailingSpaceWarning()
    if !exists("b:statusline_trailing_space_warning")

        if !&modifiable
            let b:statusline_trailing_space_warning = ''
            return b:statusline_trailing_space_warning
        endif

        if search('\s\+$', 'nw') != 0
            let b:statusline_trailing_space_warning = '[\s]'
        else
            let b:statusline_trailing_space_warning = ''
        endif
    endif
    return b:statusline_trailing_space_warning
endfunction


"return the syntax highlight group under the cursor ''
function! StatuslineCurrentHighlight()
    let name = synIDattr(synID(line('.'),col('.'),1),'name')
    if name == ''
        return ''
    else
        return '[' . name . ']'
    endif
endfunction

"recalculate the tab warning flag when idle and after writing
autocmd cursorhold,bufwritepost * unlet! b:statusline_tab_warning

"return '[&et]' if &et is set wrong
"return '[mixed-indenting]' if spaces and tabs are used to indent
"return an empty string if everything is fine
function! StatuslineTabWarning()
    if !exists("b:statusline_tab_warning")
        let b:statusline_tab_warning = ''

        if !&modifiable
            return b:statusline_tab_warning
        endif

        let tabs = search('^\t', 'nw') != 0

        "find spaces that arent used as alignment in the first indent column
        let spaces = search('^ \{' . &ts . ',}[^\t]', 'nw') != 0

        if tabs && spaces
            let b:statusline_tab_warning = '[mixed-indenting]'
        elseif (spaces && !&et) || (tabs && &et)
            let b:statusline_tab_warning = '[&et]'
        endif
    endif
    return b:statusline_tab_warning
endfunction

"recalculate the long line warning when idle and after saving
autocmd cursorhold,bufwritepost * unlet! b:statusline_long_line_warning

"return a warning for "long lines" where "long" is either &textwidth or 80 (if
"no &textwidth is set)
"
"return '' if no long lines
"return '[#x,my,$z] if long lines are found, were x is the number of long
"lines, y is the median length of the long lines and z is the length of the
"longest line
function! StatuslineLongLineWarning()
    if !exists("b:statusline_long_line_warning")

        if !&modifiable
            let b:statusline_long_line_warning = ''
            return b:statusline_long_line_warning
        endif

        let long_line_lens = s:LongLines()

        if len(long_line_lens) > 0
            let b:statusline_long_line_warning = "[" .
                        \ '#' . len(long_line_lens) . "," .
                        \ 'm' . s:Median(long_line_lens) . "," .
                        \ '$' . max(long_line_lens) . "]"
        else
            let b:statusline_long_line_warning = ""
        endif
    endif
    return b:statusline_long_line_warning
endfunction

"return a list containing the lengths of the long lines in this buffer
function! s:LongLines()
    let threshold = (&tw ? &tw : 80)
    let spaces = repeat(" ", &ts)

    let long_line_lens = []

    let i = 1
    while i <= line("$")
        let len = strlen(substitute(getline(i), '\t', spaces, 'g'))
        if len > threshold
            call add(long_line_lens, len)
        endif
        let i += 1
    endwhile

    return long_line_lens
endfunction

"find the median of the given array of numbers
function! s:Median(nums)
    let nums = sort(a:nums)
    let l = len(nums)

    if l % 2 == 1
        let i = (l-1) / 2
        return nums[i]
    else
        return (nums[l/2] + nums[(l/2)-1]) / 2
    endif
endfunction


"statusline setup
set statusline=%f "tail of the filename

"display a warning if fileformat isnt unix
set statusline+=%#warningmsg#
set statusline+=%{&ff!='unix'?'['.&ff.']':''}
set statusline+=%*

"display a warning if file encoding isnt utf-8
set statusline+=%#warningmsg#
set statusline+=%{(&fenc!='utf-8'&&&fenc!='')?'['.&fenc.']':''}
set statusline+=%*

set statusline+=%h "help file flag
set statusline+=%y "filetype
set statusline+=%r "read only flag
set statusline+=%m "modified flag

"display a warning if &et is wrong, or we have mixed-indenting
set statusline+=%#error#
set statusline+=%{StatuslineTabWarning()}
set statusline+=%*

set statusline+=%{StatuslineTrailingSpaceWarning()}

set statusline+=%{StatuslineLongLineWarning()}

set statusline+=%#warningmsg#
set statusline+=%{SyntasticStatuslineFlag()}
set statusline+=%*

"display a warning if &paste is set
set statusline+=%#error#
set statusline+=%{&paste?'[paste]':''}
set statusline+=%*

set statusline+=%= "left/right separator

function! SlSpace()
    if exists("*GetSpaceMovement")
        return "[" . GetSpaceMovement() . "]"
    else
        return ""
    endif
endfunc
set statusline+=%{SlSpace()}

set statusline+=%{StatuslineCurrentHighlight()}\ \ "current highlight
set statusline+=%c, "cursor column
set statusline+=%l/%L "cursor line/total lines
set statusline+=\ %P "percent through file
set laststatus=2

Entre outras coisas, ele informa sobre a linha de status das informações de arquivo padrão usuais, mas também inclui itens adicionais, como avisos para: colar conjunto, recuo misto, espaço em branco à esquerda etc.

Além disso, e como mostrado na captura de tela, combiná-lo com o sintático permite destacar quaisquer erros de sintaxe (assumindo que o seu idioma de escolha tenha um verificador de sintaxe associado incluído.

Gavin Gilmour
fonte
Estou tendo problemas com o exposto acima. Há uma condicional ausente em LongLines (). Eu mudei para "while i <threshold", no entanto, também está faltando len que está sendo chamado dentro dessa condição. Alguma idéia sobre o len?
Ali
É ok, eu achei a coisa real aqui: dotfiles.org/~gregf/.vimrc
Ali
@pug Erro interno do servidor lá agora. = (Você pode dar uma dica ou cole parte relevante de algum lugar .vimrc, por favor?
Anton Strogonoff
O @Anton corrigiu a pasta que foi desarrumada pela formatação do código. Deve ser bom agora. Eu também recomendo colocá-lo em um arquivo plugin / statusline.vim para evitar que você atrapalhe seu arquivo .vimrc, se você for usá-lo.
Gavin Gilmour
@ Gavin Funciona excelente, obrigado pela correção e pela dica! Eu costumava ter algo comoautocmd BufEnter *.py match OverLength /\%81v.\+/ .vimrc para destacar linhas longas, mas sua abordagem pode ser menos perturbadora. Além disso, o resultado da verificação de sintaxe na barra de status é uma coisa muito legal!
Anton Strogonoff
19

Minha mini versão:

syntax on
set background=dark
set shiftwidth=2
set tabstop=2

if has("autocmd")
  filetype plugin indent on
endif

set showcmd             " Show (partial) command in status line.
set showmatch           " Show matching brackets.
set ignorecase          " Do case insensitive matching
set smartcase           " Do smart case matching
set incsearch           " Incremental search
set hidden              " Hide buffers when they are abandoned

A versão grande, coletada em vários lugares:

syntax on
set background=dark
set ruler                     " show the line number on the bar
set more                      " use more prompt
set autoread                  " watch for file changes
set number                    " line numbers
set hidden
set noautowrite               " don't automagically write on :next
set lazyredraw                " don't redraw when don't have to
set showmode
set showcmd
set nocompatible              " vim, not vi
set autoindent smartindent    " auto/smart indent
set smarttab                  " tab and backspace are smart
set tabstop=2                 " 6 spaces
set shiftwidth=2
set scrolloff=5               " keep at least 5 lines above/below
set sidescrolloff=5           " keep at least 5 lines left/right
set history=200
set backspace=indent,eol,start
set linebreak
set cmdheight=2               " command line two lines high
set undolevels=1000           " 1000 undos
set updatecount=100           " switch every 100 chars
set complete=.,w,b,u,U,t,i,d  " do lots of scanning on tab completion
set ttyfast                   " we have a fast terminal
set noerrorbells              " No error bells please
set shell=bash
set fileformats=unix
set ff=unix
filetype on                   " Enable filetype detection
filetype indent on            " Enable filetype-specific indenting
filetype plugin on            " Enable filetype-specific plugins
set wildmode=longest:full
set wildmenu                  " menu has tab completion
let maplocalleader=','        " all my macros start with ,
set laststatus=2

"  searching
set incsearch                 " incremental search
set ignorecase                " search ignoring case
set hlsearch                  " highlight the search
set showmatch                 " show matching bracket
set diffopt=filler,iwhite     " ignore all whitespace and sync

"  backup
set backup
set backupdir=~/.vim_backup
set viminfo=%100,'100,/100,h,\"500,:100,n~/.viminfo
"set viminfo='100,f1

" spelling
if v:version >= 700
  " Enable spell check for text files
  autocmd BufNewFile,BufRead *.txt setlocal spell spelllang=en
endif

" mappings
" toggle list mode
nmap <LocalLeader>tl :set list!<cr>
" toggle paste mode
nmap <LocalLeader>pp :set paste!<cr>
Adam Gibbins
fonte
fyi, 'smartindent' é obsoleto (o cindent substitui) e não está fazendo nada quando você usa recuo de tipo de arquivo, e só estará ativo quando não for útil
graywh
13

Às vezes, as coisas mais simples são as mais valiosas. As 2 linhas no meu .vimrc que são totalmente indispensáveis:

nunca; :
antes;
William Pursell
fonte
Em nore \ ;vez disso, eu fiz desde que eu uso ,como meu<leader>
aehlke
3
Mas o que isso faz ? :)
Henrik Bjørnskov
6
ponto e vírgula é um comando raramente usado. dois pontos é um comando extremamente comum, usado para entrar no modo de linha de comando. Remapear um para o outro permite que você entre no modo de linha de comando sem pressionar a tecla Shift, economizando assim os músculos dos seus dedinhos.
William Pursell
7
Nos teclados franceses, você não precisa de 'shift' para escrever ',', ';' e ':' ... Mas '\', '[' e ']' são uma verdadeira dor.
amigos estão dizendo sobre olivier pons
12

Misc. configurações:

  1. Desative sinos de erro irritantes:

    set noerrorbells
    set visualbell
    set t_vb=
    
  2. Faça o cursor se mover conforme o esperado com linhas quebradas:

    inoremap <Down> <C-o>gj
    inoremap <Up> <C-o>gk
    
  3. A pesquisa ctags"tags" arquiva o diretório, até que um seja encontrado:

    set tags=tags;/
    
  4. Exibir arquivos SCons com sintaxe Python:

    autocmd BufReadPre,BufNewFile SConstruct set filetype=python
    autocmd BufReadPre,BufNewFile SConscript set filetype=python
    
Alex B
fonte
Dê # / usr / bin / python para o arquivo SConstruct, ele irá acionar do Vim construído em magia de detecção de tipo de arquivo
richq
Existe uma maneira melhor de fazer j/ kmover como esperado com linhas quebradas? Eu não quero pressionar o gtempo todo.
puk
8

Eu não sou o vim'er mais avançado do mundo, mas aqui estão alguns que eu peguei

function! Mosh_Tab_Or_Complete()
    if col('.')>1 && strpart( getline('.'), col('.')-2, 3 ) =~ '^\w'
        return "\<C-N>"
    else
        return "\<Tab>"
endfunction

inoremap <Tab> <C-R>=Mosh_Tab_Or_Complete()<CR>

Faz com que o preenchimento automático de tabulação decida se você deseja colocar uma palavra ali ou uma tab real (4 espaços).

map cc :.,$s/^ *//<CR>

Remova todo o espaço em branco de abertura daqui até o final do arquivo. Por alguma razão, acho isso muito útil.

set nu! 
set nobackup

Mostre os números das linhas e não crie esses arquivos de backup irritantes. Eu nunca restaurei nada de um backup antigo de qualquer maneira.

imap ii <C-[>

Enquanto estiver inserindo, pressione i duas vezes para acessar o modo de comando. Eu nunca me deparei com uma palavra ou variável com 2 i em uma linha e, dessa forma, não preciso que meus dedos saiam da linha inicial ou pressione várias teclas para alternar entre elas.

Whaledawg
fonte
3
Mapeamento interessante de ii ... muito interessante. É uma ideia muito legal - embora eu estivesse preocupado que isso afetasse gravemente minha capacidade de usar um vim de 'baunilha', se fosse necessário.
thomasrutter
Eu tenho feito a mesma coisa com ;; por um longo tempo e não encontrou nenhum problema. Quando forçado a usar o vanilla vi / vim, lembro-me imediatamente de usar a estúpida tecla [esc] (que foi uma das razões pelas quais odiei o vim por tantos anos!). Para mim, essa configuração é absolutamente essencial. Eu nunca usaria voluntariamente o vi (m) sem ele. <br> E eu gosto da idéia de usar 'ii' em vez de ';;': mais intuitivo, quase como uma alternância.
Iconoclast
Outra possibilidade é usar Ctrl-C para sair do modo de inserção. É quase o mesmo que Escape (a única diferença que me incomoda é ao operar nas linhas de um bloco visual).
a3nm
8

Meu vimrc fortemente comentado, com combinações de teclas readline-esque (emacs):

if version >= 700

"------ Meta ------"

" clear all autocommands! (this comment must be on its own line)
autocmd!

set nocompatible                " break away from old vi compatibility
set fileformats=unix,dos,mac    " support all three newline formats
set viminfo=                    " don't use or save viminfo files

"------ Console UI & Text display ------"

set cmdheight=1                 " explicitly set the height of the command line
set showcmd                     " Show (partial) command in status line.
set number                      " yay line numbers
set ruler                       " show current position at bottom
set noerrorbells                " don't whine
set visualbell t_vb=            " and don't make faces
set lazyredraw                  " don't redraw while in macros
set scrolloff=5                 " keep at least 5 lines around the cursor
set wrap                        " soft wrap long lines
set list                        " show invisible characters
set listchars=tab:>·,trail:·    " but only show tabs and trailing whitespace
set report=0                    " report back on all changes
set shortmess=atI               " shorten messages and don't show intro
set wildmenu                    " turn on wild menu :e <Tab>
set wildmode=list:longest       " set wildmenu to list choice
if has('syntax')
    syntax on
    " Remember that rxvt-unicode has 88 colors by default; enable this only if
    " you are using the 256-color patch
    if &term == 'rxvt-unicode'
        set t_Co=256
    endif

    if &t_Co == 256
        colorscheme xoria256
    else
        colorscheme peachpuff
    endif
endif

"------ Text editing and searching behavior ------"

set nohlsearch                  " turn off highlighting for searched expressions
set incsearch                   " highlight as we search however
set matchtime=5                 " blink matching chars for .x seconds
set mouse=a                     " try to use a mouse in the console (wimp!)
set ignorecase                  " set case insensitivity
set smartcase                   " unless there's a capital letter
set completeopt=menu,longest,preview " more autocomplete <Ctrl>-P options
set nostartofline               " leave my cursor position alone!
set backspace=2                 " equiv to :set backspace=indent,eol,start
set textwidth=80                " we like 80 columns
set showmatch                   " show matching brackets
set formatoptions=tcrql         " t - autowrap to textwidth
                                " c - autowrap comments to textwidth
                                " r - autoinsert comment leader with <Enter>
                                " q - allow formatting of comments with :gq
                                " l - don't format already long lines

"------ Indents and tabs ------"

set autoindent                  " set the cursor at same indent as line above
set smartindent                 " try to be smart about indenting (C-style)
set expandtab                   " expand <Tab>s with spaces; death to tabs!
set shiftwidth=4                " spaces for each step of (auto)indent
set softtabstop=4               " set virtual tab stop (compat for 8-wide tabs)
set tabstop=8                   " for proper display of files with tabs
set shiftround                  " always round indents to multiple of shiftwidth
set copyindent                  " use existing indents for new indents
set preserveindent              " save as much indent structure as possible
filetype plugin indent on       " load filetype plugins and indent settings

"------ Key bindings ------"

" Remap broken meta-keys that send ^[
for n in range(97,122) " ASCII a-z
    let c = nr2char(n)
    exec "set <M-". c .">=\e". c
    exec "map  \e". c ." <M-". c .">"
    exec "map! \e". c ." <M-". c .">"
endfor

""" Emacs keybindings
" first move the window command because we'll be taking it over
noremap <C-x> <C-w>
" Movement left/right
noremap! <C-b> <Left>
noremap! <C-f> <Right>
" word left/right
noremap  <M-b> b
noremap! <M-b> <C-o>b
noremap  <M-f> w
noremap! <M-f> <C-o>w
" line start/end
noremap  <C-a> ^
noremap! <C-a> <Esc>I
noremap  <C-e> $
noremap! <C-e> <Esc>A
" Rubout word / line and enter insert mode
noremap  <C-w> i<C-w>
noremap  <C-u> i<C-u>
" Forward delete char / word / line and enter insert mode
noremap! <C-d> <C-o>x
noremap  <M-d> dw
noremap! <M-d> <C-o>dw
noremap  <C-k> Da
noremap! <C-k> <C-o>D
" Undo / Redo and enter normal mode
noremap  <C-_> u
noremap! <C-_> <C-o>u<Esc><Right>
noremap! <C-r> <C-o><C-r><Esc>

" Remap <C-space> to word completion
noremap! <Nul> <C-n>

" OS X paste (pretty poor implementation)
if has('mac')
    noremap  √ :r!pbpaste<CR>
    noremap! √ <Esc>√
endif

""" screen.vim REPL: http://github.com/ervandew/vimfiles
" send paragraph to parallel process
vmap <C-c><C-c> :ScreenSend<CR>
nmap <C-c><C-c> mCvip<C-c><C-c>`C
imap <C-c><C-c> <Esc><C-c><C-c><Right>
" set shell region height
let g:ScreenShellHeight = 12


"------ Filetypes ------"

" Vimscript
autocmd FileType vim setlocal expandtab shiftwidth=4 tabstop=8 softtabstop=4

" Shell
autocmd FileType sh setlocal expandtab shiftwidth=4 tabstop=8 softtabstop=4

" Lisp
autocmd Filetype lisp,scheme setlocal equalprg=~/.vim/bin/lispindent.lisp expandtab shiftwidth=2 tabstop=8 softtabstop=2

" Ruby
autocmd FileType ruby setlocal expandtab shiftwidth=2 tabstop=2 softtabstop=2

" PHP
autocmd FileType php setlocal expandtab shiftwidth=4 tabstop=4 softtabstop=4

" X?HTML & XML
autocmd FileType html,xhtml,xml setlocal expandtab shiftwidth=2 tabstop=2 softtabstop=2

" CSS
autocmd FileType css setlocal expandtab shiftwidth=4 tabstop=4 softtabstop=4

" JavaScript
" autocmd BufRead,BufNewFile *.json setfiletype javascript
autocmd FileType javascript setlocal expandtab shiftwidth=2 tabstop=2 softtabstop=2
let javascript_enable_domhtmlcss=1

"------ END VIM-500 ------"

endif " version >= 500
armas
fonte
fyi, 'smartindent' é obsoleto (cindent substitui-lo) e não está fazendo nada quando você usa filetype recuo, e só estará ativo quando não é útil
graywh
7
syntax on
set cindent
set ts=4
set sw=4
set backspace=2
set laststatus=2
set nohlsearch
set modeline
set modelines=3
set ai
map Q gq

set vb t_vb=

set nowrap
set ss=5
set is
set scs
set ru

map <F2> <Esc>:w<CR>
map! <F2> <Esc>:w<CR>

map <F10> <Esc>:qa<CR>
map! <F10> <Esc>:qa<CR>

map <F9>  <Esc>:wqa<CR>
map! <F9>  <Esc>:wqa<CR>

inoremap <s-up> <Esc><c-w>W<Ins>
inoremap <s-down> <Esc><c-w>w<Ins>

nnoremap <s-up> <c-w>W
nnoremap <s-down> <c-w>w

" Fancy middle-line <CR>
inoremap <C-CR> <Esc>o
nnoremap <C-CR> o

" This is the way I like my quotation marks and various braces
inoremap '' ''<Left>
inoremap "" ""<Left>
inoremap () ()<Left>
inoremap <> <><Left>
inoremap {} {}<Left>
inoremap [] []<Left>
inoremap () ()<Left>

" Quickly set comma or semicolon at the end of the string
inoremap ,, <End>,
inoremap ;; <End>;
au FileType python inoremap :: <End>:


au FileType perl,python set foldlevel=0
au FileType perl,python set foldcolumn=4
au FileType perl,python set fen
au FileType perl        set fdm=syntax
au FileType python      set fdm=indent
au FileType perl,python set fdn=4
au FileType perl,python set fml=10
au FileType perl,python set fdo=block,hor,mark,percent,quickfix,search,tag,undo,search

au FileType perl,python abbr sefl self
au FileType perl abbr sjoft shift
au FileType perl abbr DUmper Dumper

function! ToggleNumberRow()
       if !exists("g:NumberRow") || 0 == g:NumberRow
               let g:NumberRow = 1
               call ReverseNumberRow()
       else
               let g:NumberRow = 0
               call NormalizeNumberRow()
       endif
endfunction


" Reverse the number row characters
function! ReverseNumberRow()
       " map each number to its shift-key character
       inoremap 1 !
       inoremap 2 @
       inoremap 3 #
       inoremap 4 $
       inoremap 5 %
       inoremap 6 ^
       inoremap 7 &
       inoremap 8 *
       inoremap 9 (
       inoremap 0 )
       inoremap - _
    inoremap 90 ()<Left>
       " and then the opposite
       inoremap ! 1
       inoremap @ 2
       inoremap # 3
       inoremap $ 4
       inoremap % 5
       inoremap ^ 6
       inoremap & 7
       inoremap * 8
       inoremap ( 9
       inoremap ) 0
       inoremap _ -
endfunction

" DO the opposite to ReverseNumberRow -- give everything back
function! NormalizeNumberRow()
       iunmap 1
       iunmap 2
       iunmap 3
       iunmap 4
       iunmap 5
       iunmap 6
       iunmap 7
       iunmap 8
       iunmap 9
       iunmap 0
       iunmap -
       "------
       iunmap !
       iunmap @
       iunmap #
       iunmap $
       iunmap %
       iunmap ^
       iunmap &
       iunmap *
       iunmap (
       iunmap )
       iunmap _
       inoremap () ()<Left>
endfunction

"call ToggleNumberRow()
nnoremap <M-n> :call ToggleNumberRow()<CR>

" Add use <CWORD> at the top of the file
function! UseWord(word)
       let spec_cases = {'Dumper': 'Data::Dumper'}
       let my_word = a:word
       if has_key(spec_cases, my_word)
               let my_word = spec_cases[my_word]
       endif

       let was_used = search("^use.*" . my_word, "bw")

       if was_used > 0
               echo "Used already"
               return 0
       endif

       let last_use = search("^use", "bW")
       if 0 == last_use
               last_use = search("^package", "bW")
               if 0 == last_use
                       last_use = 1
               endif
       endif

       let use_string = "use " . my_word . ";"
       let res = append(last_use, use_string)
       return 1
endfunction

function! UseCWord()
       let cline = line(".")
       let ccol = col(".")
       let ch = UseWord(expand("<cword>"))
       normal mu
       call cursor(cline + ch, ccol)

endfunction

function! GetWords(pattern)
       let cline = line(".")
       let ccol = col(".")
       call cursor(1,1)

       let temp_dict = {}
       let cpos = searchpos(a:pattern)
       while cpos[0] != 0
               let temp_dict[expand("<cword>")] = 1
               let cpos = searchpos(a:pattern, 'W')
       endwhile

       call cursor(cline, ccol)
       return keys(temp_dict)
endfunction

" Append the list of words, that match the pattern after cursor
function! AppendWordsLike(pattern)
       let word_list = sort(GetWords(a:pattern))
       call append(line("."), word_list)
endfunction


nnoremap <F7>  :call UseCWord()<CR>

" Useful to mark some code lines as debug statements
function! MarkDebug()
       let cline = line(".")
       let ctext = getline(cline)
       call setline(cline, ctext . "##_DEBUG_")
endfunction

" Easily remove debug statements
function! RemoveDebug()
       %g/#_DEBUG_/d
endfunction

au FileType perl,python inoremap <M-d> <Esc>:call MarkDebug()<CR><Ins>
au FileType perl,python inoremap <F6> <Esc>:call RemoveDebug()<CR><Ins>
au FileType perl,python nnoremap <F6> :call RemoveDebug()<CR>

" end Perl settings

nnoremap <silent> <F8> :TlistToggle<CR>
inoremap <silent> <F8> <Esc>:TlistToggle<CR><Esc>

function! AlwaysCD()
       if bufname("") !~ "^scp://" && bufname("") !~ "^sftp://" && bufname("") !~ "^ftp://"
               lcd %:p:h
       endif
endfunction
autocmd BufEnter * call AlwaysCD()

function! DeleteRedundantSpaces()
       let cline = line(".")
       let ccol = col(".")
       silent! %s/\s\+$//g
       call cursor(cline, ccol)
endfunction
au BufWrite * call DeleteRedundantSpaces()

set nobackup
set nowritebackup
set cul

colorscheme evening

autocmd FileType python set formatoptions=wcrq2l
autocmd FileType python set inc="^\s*from"
autocmd FileType python so /usr/share/vim/vim72/indent/python.vim

autocmd FileType c      set si
autocmd FileType mail   set noai
autocmd FileType mail   set ts=3
autocmd FileType mail   set tw=78
autocmd FileType mail   set shiftwidth=3
autocmd FileType mail   set expandtab
autocmd FileType xslt   set ts=4
autocmd FileType xslt   set shiftwidth=4
autocmd FileType txt    set ts=3
autocmd FileType txt    set tw=78
autocmd FileType txt    set expandtab

" Move cursor together with the screen
noremap <c-j> j<c-e>
noremap <c-k> k<c-y>

" Better Marks
nnoremap ' `
Maxim Sloyko
fonte
6

Algumas correções para erros de digitação comuns me pouparam uma quantidade surpreendente de tempo:

:command WQ wq
:command Wq wq
:command W w
:command Q q

iab anf and
iab adn and
iab ans and
iab teh the
iab thre there
Dominic Dos Santos
fonte
25
Eu não gosto disso - apenas treina erros.
Svante
I como para as palavras: e, o, lá, mas não para o salvar e sair
sixtyfootersdude
3
@Svante, normalmente eu concordo, exceto que eu tenho isso no meu comando também, eu tendem a salvar frequentemente ou salvar / sair frequentemente. Muitas vezes, meu dedo mindinho é apenas uma fração de segundo lento demais para tirar a tecla Shift e o BAM um ou outro acaba sendo capitalizado, é irritante!
Pharaun 23/08/10
1
O vi foi gravado no e para o terminal ADM3A, que tinha uma tecla designada para dois-pontos (:), assim você não precisou pressionar Shift. Se você remapear uma chave que normalmente não é usada no modo normal / visual, como a barra de espaço, você não terá tanto problema. nnoremap <Space>: e vnomap <Space>: en.wikipedia.org/wiki/File:KB_Terminal_ADM3A.svg
aoeu
Gosto disso nos comandos save / quit, mas não nas palavras. Se você cometer um erro quando a rede de segurança não estiver lá, o Vim informará seu erro. Se você digitar "teh" quando a correção automática não estiver lá, não notará e parecerá sem instrução.
Robert Martin
5

Eu não sabia quantas das minhas 3200 linhas .vimrc eram apenas para minhas necessidades peculiares e seria muito pouco inspirador listar aqui. Mas talvez seja por isso que o Vim seja tão útil ...

iab AlP ABCDEFGHIJKLMNOPQRSTUVWXYZ
iab MoN January February March April May June July August September October November December
iab MoO Jan Feb Mar Apr May Jun Jul Aug Sep Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
iab NuM 12345678901234567890123456789012345678901234567890123456789012345678901234567890 
iab RuL ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0

" Highlight every other line
map ,<Tab> :set hls<CR>/\\n.*\\n/<CR>

" This is for working across multiple xterms and/or gvims
" Transfer/read and write one block of text between vim sessions (capture whole line):
" Write
nmap ;w :. w! ~/.vimxfer<CR>
" Read
nmap ;r :r ~/.vimxfer<CR>
" Append 
nmap ;a :. w! >>~/.vimxfer<CR>
rshdev
fonte
5

Minha linha de 242 .vimrcnão é tão interessante, mas como ninguém mencionou isso, senti que precisava compartilhar os dois mapeamentos mais importantes que aprimoraram meu fluxo de trabalho, além dos mapeamentos padrão:

map <C-j> :bprev<CR>
map <C-k> :bnext<CR>
set hidden " this will go along

Sério, alternar buffers é o que deve ser feito com muita frequência. Windows, claro, mas tudo não se encaixa tão bem na tela.

Conjunto semelhante de mapas para navegação rápida de erros (consulte quickfix) e resultados grep:

map <C-n> :cn<CR>
map <C-m> :cp<CR>

Simples, sem esforço e eficiente.

nperson325681
fonte
Não mudei muito entre os buffers, pois o Vim recebeu suporte para guias. Eu tenho as teclas extras "voltar" e "encaminhar" no meu teclado mapeadas para os comandos de navegação da guia.
Don Reba
@ Don Reba, você sabe, as guias apenas replicam algumas das funcionalidades dos buffers. Portanto, não há muita diferença em "usar" buffers ou guias. Os puristas dizem que as guias são destinadas a organizar tarefas para separar regiões e nada mais. Tudo o que eu dizer é que buffers têm toda a conveniência e que eu não deixaram usando guias, reservando-os para outra coisa se algo maior abstração vir a precisar :).
nperson325681
4

set nobackup 
set nocp
set tabstop=4
set shiftwidth=4
set et
set ignorecase

set ai
set ruler
set showcmd
set incsearch
set dir=$temp       " Make swap live in the %TEMP% directory
syn on

" Load the color scheme
colo inkpot
JaredPar
fonte
4

Eu uso o cscope de dentro do vim (fazendo ótimo uso dos vários buffers). Uso control-K para iniciar a maioria dos comandos (roubados de ctags, pelo que me lembro). Além disso, eu já gerei o arquivo .cscope.out.

se tiver ("cscope")

set cscopeprg=/usr/local/bin/cscope
set cscopetagorder=0
set cscopetag
set cscopepathcomp=3
set nocscopeverbose
cs add .cscope.out
set csverb

"
" cscope find
"
" 0 or s: Find this C symbol
" 1 or d: Find this definition
" 2 or g: Find functions called by this function
" 3 or c: Find functions calling this function
" 4 or t: Find assignments to
" 6 or e: Find this egrep pattern
" 7 or f: Find this file
" 8 or i: Find files #including this file
" 
map ^Ks     :cs find 0 <C-R>=expand("<cword>")<CR><CR>
map ^Kd     :cs find 1 <C-R>=expand("<cword>")<CR><CR>
map ^Kg     :cs find 2 <C-R>=expand("<cword>")<CR><CR>
map ^Kc     :cs find 3 <C-R>=expand("<cword>")<CR><CR>
map ^Kt     :cs find 4 <C-R>=expand("<cword>")<CR><CR>
map ^Ke     :cs find 6 <C-R>=expand("<cword>")<CR><CR>
map ^Kf     :cs find 7 <C-R>=expand("<cfile>")<CR><CR>
map ^Ki     :cs find 8 <C-R>=expand("%")<CR><CR>

fim se

pernil
fonte
3

Como estou no OS X, alguns deles podem ter padrões melhores em outras plataformas, mas independentemente:

syntax on
set tabstop=4
set expandtab
set shiftwidth=4
Trenton
fonte
1
Você pode procurar softtabstope usar isso em vez de tabstop. Sair tabstopno valor padrão 8 ajudará na leitura de arquivos criados por outras pessoas com guias.
Greg Hewgill 02/10/08
6
O que o OSX tem a ver com guias?
aehlke
3
map = }{!}fmt^M}
map + }{!}fmt -p '> '^M}
set showmatch

= é para reformatar parágrafos normais. + é para reformatar parágrafos em emails citados. showmatch é para piscar o parêntese / colchete correspondente quando digito um parêntese ou colchete próximo.

Andru Luvisi
fonte
3

Use o primeiro arquivo 'tags' disponível na árvore de diretórios:

:set tags=tags;/

Esquerda e direita são para alternar buffers, não movendo o cursor:

map <right> <ESC>:bn<RETURN>
map <left> <ESC>:bp<RETURN>

Desative o destaque da pesquisa com um único pressionamento de tecla:

map - :nohls<cr>
Jerub
fonte
3
set tabstop=4 softtabstop=4 shiftwidth=4 expandtab autoindent cindent 
set encoding=utf-8 fileencoding=utf-8
set nobackup nowritebackup noswapfile autoread
set number
set hlsearch incsearch ignorecase smartcase

if has("gui_running")
    set lines=35 columns=140
    colorscheme ir_black
else
    colorscheme darkblue
endif

" bash like auto-completion
set wildmenu
set wildmode=list:longest

inoremap <C-j> <Esc>

" for lusty explorer
noremap glr \lr
noremap glf \lf
noremap glb \lb

" use ctrl-h/j/k/l to switch between splits
map <c-j> <c-w>j
map <c-k> <c-w>k
map <c-l> <c-w>l
map <c-h> <c-w>h

" Nerd tree stuff
let NERDTreeIgnore = ['\.pyc$', '\.pyo$']
noremap gn :NERDTree<Cr>

" cd to the current file's directory
noremap gc :lcd %:h<Cr>
hasen j
fonte
Eu gosto muito do que está acontecendo na sua configuração. Vários conjuntos por linha if has("gui_running"), e mapas interessantes. Copiei a maior parte da sua configuração na minha. OBRIGADO!
Justin Force
3

Coloque isso no seu vimrc:

imap <C-l> <Space>=><Space>

e nunca pense em digitar um hashrocket novamente. Sim, eu sei que você não precisa no Ruby 1.9. Mas não importa.

Meu vimrc completo está aqui .

dpogg1
fonte
Essa é uma ótima idéia, mas eu sugeriria apenas o mapeamento para arquivos ruby:autocmd FileType ruby imap <C-l> <Space>=><Space>
csexton
Você poderia explicar o que isso faz para uma pessoa do Emacs que não conhece Ruby?
Thomas
Isso adiciona uma tecla de atalho Control-L ao modo de inserção do Vim para digitar automaticamente um hashrocket com espaços (=>). O hashrocket é o operador de valor-chave do Ruby para hashes.
precisa saber é o seguinte
2

Bem, você terá que vasculhar minhas configurações . Diverta-se. Principalmente, é apenas a minha configuração desejada, incluindo mapeamentos e material relevante para a sintaxe aleatória, além de instalação dobrável e alguma configuração de plug-in, um analisador de compilação tex, etc.

BTW, algo que achei extremamente útil é "destacar palavra sob o cursor":

 highlight flicker cterm=bold ctermfg=white
 au CursorMoved <buffer> exe 'match flicker /\V\<'.escape(expand('<cword>'), '/').'\>/'

Observe que apenas cterme termfgsão usados, porque eu não uso gvim. Se você deseja que isso funcione, gvimbasta substituí-los por guie guifg, respectivamente.

Aleksandar Dimitrov
fonte
Como fazê-lo funcionar com várias janelas abertas? Parece funcionar apenas com o buffer principal, lançado como primeiro.
ohnoes
2

Tentei manter o meu .vimrc o mais útil possível.

Um truque útil é o manipulador de arquivos .gpg para editá-los com segurança:

au BufNewFile,BufReadPre *.gpg :set secure vimi= noswap noback nowriteback hist=0 binary
au BufReadPost *.gpg :%!gpg -d 2>/dev/null
au BufWritePre *.gpg :%!gpg -e -r '[email protected]' 2>/dev/null
au BufWritePost *.gpg u
pixelbeat
fonte
2

1) Gosto de uma linha de status (com o nome do arquivo, o valor ASCII (decimal), o valor hexadecimal e as linhas padrão, colunas e%):

set statusline=%t%h%m%r%=[%b\ 0x%02B]\ \ \ %l,%c%V\ %P
" Always show a status line
set laststatus=2
"make the command line 1 line high
set cmdheight=1

2) Também gosto de mapeamentos para janelas divididas.

" <space> switches to the next window (give it a second)
" <space>n switches to the next window
" <space><space> switches to the next window and maximizes it
" <space>= Equalizes the size of all windows
" + Increases the size of the current window
" - Decreases the size of the current window

 :map <space> <c-W>w
:map <space>n <c-W>w
:map <space><space> <c-W>w<c-W>_
:map <space>= <c-W>=
if bufwinnr(1)
  map + <c-W>+
  map - <c-W>-
endif
Kris Kumler
fonte
2

Na verdade, não há muito no meu .vimrc (mesmo que tenha 850 linhas). Principalmente configurações e alguns mapeamentos comuns e simples que eu estava com preguiça de extrair em plugins.

Se você quer dizer "arquivos de modelo" por "auto-classes", estou usando um plug-in de expansão de modelos - nesse mesmo site, você encontrará os plug-ins que defini para edição em C & C ++, alguns podem ser adaptados a C # eu acho.

Em relação ao aspecto da refatoração, há uma dica dedicada a esse assunto em http://vim.wikia.com ; IIRC, o código de exemplo é para C #. Ele me inspirou um plugin de refatoração que ainda precisa de muito trabalho (na verdade, precisa ser refatorado).

Você deve dar uma olhada nos arquivos da lista de discussão do vim, especialmente os assuntos sobre o uso do vim como um IDE eficaz. Não se esqueça de dar uma olhada em: marca, tags, ...

HTH,

Luc Hermitte
fonte
2

Meu .vimrc inclui (entre outras coisas mais úteis) a seguinte linha:

set statusline=%2*%n\|%<%*%-.40F%2*\|\ %2*%M\ %3*%=%1*\ %1*%2.6l%2*x%1*%1.9(%c%V%)%2*[%1*%P%2*]%1*%2B

Fiquei entediado enquanto aprendia para as minhas finais do ensino médio.

Tadeusz A. Kadłubowski
fonte
você pode explicar o que isso faz?
Vijay Dev
Ele mostra uma linha de status com número do buffer, nome do arquivo, status da modificação, posição no buffer e um código hexadecimal do caractere sob o cursor. Bem formatado e colorido.
Tadeusz A. Kadłubowski 5/09/09
1

Aqui está o meu .vimrc. Eu uso o Gvim 7.2

set guioptions=em
set showtabline=2
set softtabstop=2
set shiftwidth=2
set tabstop=2

" Use spaces instead of tabs
set expandtab
set autoindent

" Colors and fonts
colorscheme inkpot
set guifont=Consolas:h11:cANSI

"TAB navigation like firefox
:nmap <C-S-tab> :tabprevious<cr>
:nmap <C-tab> :tabnext<cr>
:imap <C-S-tab> <ESC>:tabprevious<cr>i
:imap <C-tab> <ESC>:tabnext<cr>i
:nmap <C-t> :tabnew<cr>
:imap <C-t> <ESC>:tabnew<cr>i
:map <C-w> :tabclose<cr>

" No Backups and line numbers
set nobackup
set number
set nuw=6

" swp files are saved to %Temp% folder
set dir=$temp
" sets the default size of gvim on open
set lines=40 columns=90
Julien Nephtali
fonte
1

O que tem na minha .vimrc?

ngn@macavity:~$ cat .vimrc
" This file intentionally left blank

Os arquivos de configuração reais estão em ~/.vim/ :)

E a maioria das coisas que existem são parasitas dos esforços de outras pessoas, descaradamente adaptadas vim.orgà minha vantagem de edição.

ngn
fonte
2
Eu quase tenho isso, mas o .vimrc precisa conter "set nocompatible" se você usar esses recursos, não é? Pelo menos removê-lo causa uma carga de erros aqui!
richq