Cosa c'è nel tuo .vimrc? [chiuso]


157

Vi e Vim consentono una personalizzazione davvero straordinaria, in genere memorizzata in un .vimrcfile. Le caratteristiche tipiche di un programmatore sono l'evidenziazione della sintassi, il rientro intelligente e così via.

Quali altri trucchi per la programmazione produttiva hai, nascosto nel tuo .vimrc?

Sono principalmente interessato a refactoring, classi automatiche e macro di produttività simili, in particolare per C #.


11
Penso che avresti dovuto chiedere alle persone di pubblicare i loro file di configurazione vim commentati .
innaM,

Perché non condividere queste cose su Github? Ho tutta la mia cartella .vim sotto git e tutto può essere visto qui: github.com/lsdr/vim-folder
lsdr

1
Non penso che interi .vimrcs siano utili; se un gruppo di persone vota una risposta, prenderai semplicemente tutto e lo schiaffi nel tuo sistema? Gli snippet sono molto più utili, proprio come un elenco di alias o funzioni utili è molto meglio di interi file. (Bash | z) rc.
Xiong Chiamiov,

Risposte:


104

Te la sei cercata :-)

"{{{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

78
Ma perché 3, impostare shiftwidth = 3, impostare softtabstop = 3 ... forse 2 o 4 ma perché 3?
Johan

1
Mi chiedo, ma mappare jj su <Esc> non ti darà un leggero ritardo quando si colpisce j in modalità insert?
Sykora,

1
@sykora: sì, ma non appena si digita un altro carattere (che non è j) apparirà. Faccio la stessa cosa, ma invece con jk, poiché penso che colpire jk sia più veloce che colpire jj. Solo volte questo mi ha influenzato a scrivere l'alfabeto, quindi forse stai meglio.
David Miani,

2
@Johan: perché "tre è un numero magico". :) In realtà, questo è solo il ciclismo ma ne preferisco anche tre. :)
Robert Massaioli,

4
Se i veri uomini usano gcc, perché non lo fai? (il compilatore gcc è commentato!)
Abdulsattar Mohammed,

73

Questo non è nel mio file .vimrc, ma ieri ho imparato a conoscere il ]pcomando. Questo incolla il contenuto di un buffer proprio come pfa, ma regola automaticamente il rientro in modo che corrisponda alla linea su cui si trova il cursore! Questo è eccellente per spostare il codice.


Vuoi dire che è simile a: set paste, p,: set nopaste?
iperboreo,

3
Per quanto ne so, l'opzione: set paste non ha alcun effetto sul comando p, influenza solo il testo digitato (o incollato attraverso un terminale) in modalità inserimento. Quindi no, è una caratteristica diversa.
Greg Hewgill,

1
Non dovrei votare per questo, perché non risponde alla domanda, ma mi piace molto;)
gorsky

53

Uso quanto segue per conservare tutti i file temporanei e di backup in un unico posto:

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

Risparmia ingombranti directory di lavoro in tutto il luogo.

Dovrai prima creare queste directory, vim non le creerà per te.


2
Devo dire che dovrai creare quelle directory tu stesso, Vim non lo farà per te.
Harley Holcombe,

Gestisce correttamente più file identici? (ad esempio se stai modificando diversi rami dello stesso codice)
yungchin

No, questo sovrascriverà i vecchi file di backup con lo stesso nome. Se qualcuno ha un modo per aggirare questo, fammi sapere.
Harley Holcombe,

3
Prova questo: au BufWritePre * let & bex = '-'. prima ora ("% Y% m% d-% H% M% S"). '.vimbackup' (Questa è una riga.) E devo menzionare anche questo: vim.wikia.com/wiki/VimTip962
Zsolt Botykai,

1
Ciò impedisce anche a Vim di lamentarsi quando si aprono file sincronizzati con Dropbox su più macchine.
Cody Hess,

31

Qualcuno (vale a dire Frew) che ha pubblicato sopra aveva questa linea:

"CD automaticamente nella directory in cui si trova il file:"

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

Stavo facendo qualcosa del genere da solo fino a quando ho scoperto che la stessa cosa poteva essere realizzata con un'ambientazione integrata:

set autochdir

Penso che qualcosa di simile mi sia successo diverse volte. Vim ha così tante impostazioni e opzioni integrate che a volte è più veloce e più facile da implementare che cercare nei documenti il ​​modo integrato per farlo.


grande scoperta! mi piace usare roba integrata di più ^ _ ^. inoltre questo non fallisce se c'è un | nel nome del file.
Javed Ahamed,

2
autochdir ha alcuni fastidi che non potrei mai aggirare (cambiando directory prima di caricare un file dato sulla riga di comando), e ho letto altrove qui su SO su ciò autocmd BufEnter * silent! lcd %:p:h:gs/ /\\ /che fa la stessa cosa di base ma non paralizza la riga di comando.
dash-tom-bang,

Preferisco renderlo facoltativo e utilizzare questo comando per accedere alla directory del file corrente: cd%: h
staackuser2

28

La mia ultima aggiunta è per evidenziare la riga corrente

set cul                                           # highlight current line
hi CursorLine term=none cterm=none ctermbg=3      # adjust color

2
c'è un modo per selezionare tra più colori?
Fzs2,

Qual è la differenza tra set cul e set pointerline?
putolaruan,

Uso semplicemente il "set cul" per ottenere una riga sotto la mia riga corrente. L'impostazione della linea del cursore fa troppo casino con l'evidenziazione della sintassi per i miei gusti.
Claes Mogren,

2
Fare riferimento a questo script ( vim.org/scripts/script.php?script_id=1349 ) per ottenere i colori disponibili. Potrebbe essere necessario attivare il supporto a 256 colori per vim per ottenere una varietà più ampia.
Brian Wigginton,

1
@Claes In realtà, set cule set cursorlinefai esattamente la stessa cosa.
Gerardo Marset,

24

Aggiornamento 2012 : ora consiglierei davvero di provare vim-powerline che ha sostituito il mio vecchio script statusline, sebbene al momento manchi alcune funzionalità che mi mancano.


Direi che la roba statusline nel mio vimrc era probabilmente molto interessante / utile dal lotto (strappato dagli autori vimrc qui e corrispondente post sul blog qui ).

Immagine dello schermo:

linea di stato http://img34.imageshack.us/img34/849/statusline.png

Codice:

"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

Tra le altre cose, informa sulla riga di stato delle normali informazioni sul file standard, ma include anche elementi aggiuntivi come avvertenze per: imposta incolla, indentazione mista, spazio bianco finale ecc. Molto utile se sei particolarmente interessato alla formattazione del codice.

Inoltre, come mostrato nello screenshot, la combinazione con sintetico consente di evidenziare eventuali errori di sintassi (supponendo che la lingua scelta abbia un correttore di sintassi associato in bundle.


Sto riscontrando problemi con quanto sopra. C'è un condizionale mancante in LongLines (). L'ho cambiato in "while i <soglia" ma manca anche len che viene chiamato all'interno di quella condizione. Qualche idea sulla len?
Ali,

Va bene, ho trovato la cosa vera qui: dotfiles.org/~gregf/.vimrc
Ali

@pug Errore interno del server lì ora. = (Puoi dare un suggerimento o incollare una parte rilevante di .vimrc da qualche parte, per favore?
Anton Strogonoff

@Anton ha risolto il problema con l'incollaggio causato dalla formattazione del codice. Dovrebbe essere buono ora. Consiglierei anche di incollarlo in un file plugin / statusline.vim per evitare che ingombra il tuo .vimrc se lo userai.
Gavin Gilmour,

@Gavin Funziona alla grande, grazie per la correzione e per il suggerimento! Avevo qualcosa di simile autocmd BufEnter *.py match OverLength /\%81v.\+/a .vimrc per evidenziare le linee lunghe, ma il tuo approccio potrebbe essere meno distratto. Inoltre, il risultato del controllo della sintassi nella barra di stato è una cosa davvero interessante!
Anton Strogonoff,

19

La mia versione mini:

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

La versione grande, raccolta da vari luoghi:

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>

a proposito, 'smartindent' è obsoleto (cindent lo sostituisce) e non sta facendo nulla quando si usa il rientro del tipo di file, e sarà attivo solo quando non è utile
graywh

13

A volte le cose più semplici sono le più preziose. Le 2 righe nel mio .vimrc sono assolutamente indispensabili:

nore; :
nore,;

L'ho fatto nore \ ;invece da quando uso ,come mio<leader>
aehlke il

3
Ma che cosa fa ? :)
Henrik Bjørnskov

6
il punto e virgola è un comando usato raramente. due punti è un comando estremamente comune, utilizzato per accedere alla modalità riga di comando. Rimappare l'uno all'altro consente di accedere alla modalità riga di comando senza premere il tasto Maiusc, risparmiando così i muscoli delle dita.
William Pursell,

7
Sulle tastiere francesi non è necessario 'shift' per scrivere ',', ';' e ':' ... Ma '\', '[' e ']' sono un vero dolore.
Olivier Pons

12

Varie. impostazioni:

  1. Disattiva i fastidiosi campanelli di errore:

    set noerrorbells
    set visualbell
    set t_vb=
    
  2. Muovi il cursore come previsto con le linee avvolte:

    inoremap <Down> <C-o>gj
    inoremap <Up> <C-o>gk
    
  3. Consultare ctags "tag" nella directory fino a quando non ne viene trovato uno:

    set tags=tags;/
    
  4. Visualizza i file SCons con la sintassi di Python:

    autocmd BufReadPre,BufNewFile SConstruct set filetype=python
    autocmd BufReadPre,BufNewFile SConscript set filetype=python
    

Aggiungi #! / Usr / bin / python al file SConstruct, attiverà la magia di rilevamento del tipo di file integrata di Vim
richq

C'è un modo migliore per fare j/ kspostare come previsto con le linee avvolte? Non voglio premere gogni volta.
puk,

8

Non sono il vim'er più avanzato del mondo, ma eccone alcuni che ho raccolto

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>

Rende il completamento automatico della tabulazione capire se si desidera inserire una parola lì o una scheda effettiva (4 spazi).

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

Rimuovi tutti gli spazi bianchi di apertura da qui alla fine del file. Per qualche motivo lo trovo molto utile.

set nu! 
set nobackup

Mostra i numeri di riga e non creare quei fastidiosi file di backup. Non ho mai ripristinato nulla da un vecchio backup.

imap ii <C-[>

Durante l'inserimento, premere due volte i per passare alla modalità comando. Non ho mai trovato una parola o una variabile con 2 i di fila, e in questo modo non devo lasciare che le mie dita lascino la riga di casa o premere più tasti per passare avanti e indietro.


3
Mappatura interessante di ii ... molto interessante. È un'idea piuttosto interessante - anche se sarei preoccupato che avrebbe un grave impatto sulla mia capacità di usare un film "alla vaniglia" se dovessi.
thomasrutter,

Ho fatto la stessa cosa con ;; per molto tempo e non ho riscontrato alcun problema. Quando sono stato costretto a usare vanilla vi / vim, mi ricordo immediatamente di usare lo stupido tasto [esc] (che era una delle ragioni per cui odiavo vim da così tanti anni!). Per me, questa impostazione è assolutamente essenziale. Non userei mai volentieri vi (m) senza di essa. <br> E mi piace l'idea di usare 'ii' invece di ';;': più intuitivo, quasi come un interruttore.
iconoclasta,

Un'altra possibilità è usare Ctrl-C per uscire dalla modalità di inserimento. Fa quasi lo stesso di Escape (l'unica differenza che mi dà fastidio è quando si opera sulle linee di un blocco visivo).
a3nm,

8

Il mio vimrc pesantemente commentato, con le combinazioni di tasti 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

a proposito, 'smartindent' è obsoleto (cindent lo sostituisce) e non sta facendo nulla quando si usa il rientro del tipo di file, e sarà attivo solo quando non è utile
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 ' `

6

Alcune correzioni per errori di battitura comuni mi hanno fatto risparmiare una quantità di tempo sorprendente:

: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

25
Non mi piace: addestra solo errori.
Svante,

Mi piace per le parole: e, lì, ma non per il salvataggio e la chiusura
sixtyfootersdude

3
@Svante, normalmente sono d'accordo, tranne che ho anche questo nel mio comando, tendo a salvare spesso o salvare / chiudere spesso. Spesso il mio mignolo è solo una frazione di secondo troppo lento nel sollevare il tasto Maiusc e BAM l'una o l'altra finisce per essere capitalizzata, è fastidioso!
Pharaun,

1
vi è stato scritto su e per il terminale ADM3A, che aveva una chiave designata per i due punti (:) quindi non era necessario premere maiusc. Se si rimappa una chiave che normalmente non viene utilizzata affatto in modalità normale / visiva, come la barra spaziatrice, non si verificherà questo problema. nnoremap <Spazio>: e vnomap <Spazio>: en.wikipedia.org/wiki/File:KB_Terminal_ADM3A.svg
aoeu,

Mi piace questo per i comandi save / quit, ma non per le parole. Se commetti l'errore quando la rete di sicurezza non è presente, Vim ti dirà il tuo errore. Se scrivi "teh" quando la correzione automatica non è presente, non noterai e sembrerai non istruito.
Robert Martin,

5

Non mi ero reso conto di quante delle mie 3200 linee .vimrc fossero solo per le mie esigenze bizzarre e non sarebbe stato abbastanza interessante elencare qui. Ma forse è per questo che Vim è così utile ...

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>

5

La mia linea 242 .vimrcnon è così interessante, ma dal momento che nessuno l'ha menzionato, mi è sembrato di dover condividere i due mapping più importanti che hanno migliorato il mio flusso di lavoro oltre ai mapping predefiniti:

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

Scherzi a parte, cambiare buffer è la cosa da fare molto spesso. Windows, certo, ma non tutto si adatta allo schermo così bene.

Insieme simile di mappe per una rapida navigazione degli errori (vedi quickfix) e risultati grep:

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

Semplice, facile ed efficiente.


Non sono passato molto tra i buffer, poiché Vim ha ottenuto il supporto per le schede. Ho i tasti extra "indietro" e "avanti" sulla mia tastiera associati ai comandi di navigazione della scheda.
Don Reba,

@ Don Reba, sai, le schede replicano solo alcune delle funzionalità dei buffer. Quindi non c'è molta differenza nel "usare" buffer o schede. I puristi diranno che le schede hanno lo scopo di organizzare le attività in regioni separate e niente di più. Tutto quello che dico è che i buffer hanno tutta la comodità e che mi sono lasciati usare le schede, riservandole a qualcos'altro nel caso in cui dovesse
rendersi

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

4

Uso cscope da dentro vim (facendo un grande uso dei buffer multipli). Uso control-K per avviare la maggior parte dei comandi (rubati da tag come ricordo). Inoltre, ho già generato il file .cscope.out.

if has ("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>

finisci se



3

Sono su OS X, quindi alcuni di questi potrebbero avere impostazioni predefinite migliori su altre piattaforme, ma a prescindere:

syntax on
set tabstop=4
set expandtab
set shiftwidth=4

1
Potresti voler cercare softtabstope usare quello invece di tabstop. Lasciare tabstopil valore predefinito di 8 sarà di aiuto nella lettura di file creati da altri con le schede.
Greg Hewgill,

6
Cosa ha a che fare OSX con le schede?
aehlke,

3
map = }{!}fmt^M}
map + }{!}fmt -p '> '^M}
set showmatch

= è per riformattare i paragrafi normali. + serve per riformattare i paragrafi nelle e-mail citate. showmatch serve per far lampeggiare la parentesi / parentesi corrispondente quando scrivo una parentesi chiusa o parentesi.


3

Utilizzare il primo file "tag" disponibile nella struttura di directory:

:set tags=tags;/

Sinistra e destra servono per cambiare buffer, non spostare il cursore:

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

Disabilita l'evidenziazione della ricerca con un singolo tasto:

map - :nohls<cr>

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>

Mi piace molto di quello che sta succedendo nella tua configurazione. Più set per riga if has("gui_running")e mappe interessanti. Ho copiato la maggior parte della tua configurazione nella mia. GRAZIE!
Forza Justin

3

Metti questo nel tuo vimrc:

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

e non pensare mai più a digitare un hashrocket. Sì, lo so che non è necessario in Ruby 1.9. Ma non importa.

Il mio completo vimrc è qui .


Questa è un'ottima idea, ma suggerirei di autocmd FileType ruby imap <C-l> <Space>=><Space>
mapparla

Potresti spiegare cosa succede a una persona Emacs che non conosce Ruby?
Thomas,

Questo aggiunge un tasto di scelta rapida Control-L alla modalità di inserimento di Vim per digitare automaticamente un hashrocket con spazi (=>). L'hashrocket è l'operatore chiave-valore di Ruby per gli hash.
dpogg1,

2

Bene, dovrai scavare da solo le mie configurazioni . Divertiti. Principalmente è solo la mia configurazione desiderata, compresi i mapping e le cose casuali rilevanti per la sintassi, così come la configurazione pieghevole e alcune configurazioni di plugin, un parser di compilazione tex ecc.

A proposito, qualcosa che ho trovato estremamente utile è "evidenziare la parola sotto il cursore":

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

Nota che solo cterme termfgvengono utilizzati, perché io non uso gvim. Se vuoi che funzioni gvimsemplicemente sostituiscili con guie guifg, rispettivamente.


Come farlo funzionare con più finestre aperte? Sembra funzionare solo con il buffer principale, lanciato come primo.
ohnoes,

2

Ho provato a mantenere il mio .vimrc più utile possibile.

Un trucco utile è un gestore di file .gpg per modificarli in modo sicuro:

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 'name@email.com' 2>/dev/null
au BufWritePost *.gpg u

2

1) Mi piace una statusline (con il nome del file, il valore ASCII (decimale), il valore esadecimale e le linee standard, i col 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) Mi piacciono anche i mapping per le finestre divise.

" <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

2

In realtà non c'è molto nel mio .vimrc (anche se ha 850 righe). Principalmente impostazioni e alcune mappature comuni e semplici che ero troppo pigro per estrarre nei plugin.

Se intendi "file modello" per "classi automatiche", sto usando un plug-in di espansione modello - su questo stesso sito troverai i plug-in che ho definito per l'editing C & C ++, alcuni potrebbero essere adattati a C # Immagino.

Per quanto riguarda l'aspetto del refactoring, su http://vim.wikia.com è disponibile un suggerimento dedicato a questo argomento ; IIRC il codice di esempio è per C #. Mi ha ispirato un plugin di refactoring che necessita ancora di molto lavoro (in realtà deve essere sottoposto a refactoring).

Dovresti dare un'occhiata agli archivi della mailing list di vim, in particolare gli argomenti sull'uso di vim come IDE efficace. Non dimenticare di dare un'occhiata a: marca, tag, ...

HTH,


2

Il mio .vimrc include (tra le altre cose più utili) la seguente riga:

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

Mi sono annoiato mentre imparavo per le mie finali del liceo.


puoi per favore spiegare cosa fa questo?
Vijay Dev,

Mostra una linea di stato con numero di buffer, nome file, stato di modifica, posizione all'interno del buffer e un codice esadecimale del carattere sotto il cursore. Ben formattato e colorato.
Tadeusz A. Kadłubowski,

1

Ecco il mio .vimrc. Uso 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

1

Cosa c'è nel mio .vimrc?

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

I file di configurazione reali si trovano sotto ~/.vim/ :)

E la maggior parte delle cose ci sono parassiti sugli sforzi degli altri, palesemente adattati vim.orgal mio vantaggio di editing.


2
Ho quasi questo, ma .vimrc deve contenere "set nocompatible" se usi queste funzionalità, vero? Almeno rimuoverlo provoca un sacco di errori qui!
richq,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.