Qual è il tuo collegamento più produttivo con Vim?


1126

Ho sentito molto parlare di Vim , sia di pro che di contro. Sembra davvero che dovresti essere (come sviluppatore) più veloce con Vim che con qualsiasi altro editor. Sto usando Vim per fare alcune cose di base e al massimo sono 10 volte meno produttivo con Vim.

Le uniche due cose di cui dovresti preoccuparti quando parli di velocità (potresti non preoccuparti abbastanza di loro, ma dovresti) sono:

  1. L'uso alternativamente delle mani sinistra e destra è il modo più veloce di usare la tastiera.
  2. Non toccare mai il mouse è il secondo modo per essere il più veloce possibile. Ci vogliono anni per muovere la mano, afferrare il mouse, spostarlo e riportarlo sulla tastiera (e spesso devi guardare la tastiera per essere sicuro di aver riportato correttamente la mano nel posto giusto)

Ecco due esempi che dimostrano perché sono molto meno produttivo con Vim.

Copia / Taglia e incolla. Lo faccio tutto il tempo. Con tutti gli editor contemporanei premi Shift con la mano sinistra e muovi il cursore con la mano destra per selezionare il testo. Quindi Ctrl+ Ccopie, sposta il cursore e Ctrl+ Vincolla.

Con Vim è orribile:

  • yy per copiare una riga (non vuoi quasi mai l'intera riga!)
  • [number xx]yyper copiare le xxrighe nel buffer. Ma non sai mai esattamente se hai selezionato ciò che volevi. Spesso devo fare [number xx]ddquindi uper annullare!

Un altro esempio? Cerca e sostituisci.

  • In PSPad : Ctrl+ fquindi digita ciò che desideri cercare, quindi premi Enter.
  • In Vim:, /quindi digitare ciò che si desidera cercare, quindi se ci sono alcuni caratteri speciali messi \prima di ogni carattere speciale, quindi premere Enter.

E tutto con Vim è così: sembra che non sappia come gestirlo nel modo giusto.

NB: ho già letto il cheat sheet di Vim :)

La mia domanda è:

Qual è il modo in cui usi Vim che ti rende più produttivo rispetto a un editor contemporaneo?


"Usare alternativamente le mani sinistra e destra è il modo più veloce di usare la tastiera." Stranamente per me. Quando riesco a digitare una parola con una mano, scopro di essere molto più veloce.
Ben Mordecai,

Risposte:


2860

Il tuo problema con Vim è che non si Grok VI .

Citi di tagliare yye lamentarti del fatto che non vuoi quasi mai tagliare intere linee. In effetti i programmatori, modificando il codice sorgente, molto spesso vogliono lavorare su intere linee, intervalli di linee e blocchi di codice. Tuttavia, yyè solo uno dei molti modi per trascinare il testo nel buffer della copia anonima (o "registra" come viene chiamato in vi ).

Lo "Zen" di vi è che stai parlando una lingua. L'iniziale yè un verbo. La dichiarazione yyè sinonimo di y_. La yraddoppia fino a rendere facile digitare, dato che è un'operazione così comune.

Questo può anche essere espresso come dd P(eliminare la riga corrente e incollare una copia in posizione; lasciando una copia nel registro anonimo come effetto collaterale). Le ye d"verbi" prendere qualsiasi movimento come loro "soggetto". Quindi yWè "yank da qui (il cursore) fino alla fine della parola corrente / successiva (grande)" ed y'aè "yank da qui alla linea contenente il segno denominato" a ".

Se capisci solo i movimenti di base del cursore su, giù, sinistra e destra, allora vi non sarà più produttivo di una copia di "blocco note" per te. (Va bene, avrai comunque l'evidenziazione della sintassi e la possibilità di gestire file più grandi di un arbusto di ~ 45 KB o giù di lì; ma lavora con me qui).

vi ha 26 "marchi" e 26 "registri". Un segno è impostato su qualsiasi posizione del cursore usando il mcomando. Ogni segno è indicato da una singola lettera minuscola. Così maimposta il ' un ' mark to la posizione corrente, e mzimposta la ' z mark'. È possibile passare alla riga contenente un segno utilizzando il 'comando (virgoletta singola). Quindi si 'asposta all'inizio della riga contenente il segno " a ". È possibile spostarsi nella posizione precisa di qualsiasi segno utilizzando il `comando (backquote). Quindi `zsi sposterà direttamente nella posizione esatta del segno ' z '.

Poiché questi sono "movimenti", possono anche essere usati come soggetti per altre "dichiarazioni".

Quindi, un modo per tagliare una selezione arbitraria di testo sarebbe quello di rilasciare un segno (di solito uso ' a ' come il mio "primo" segno, ' z ' come il mio segno successivo, ' b ' come un altro e ' e ' come ancora un altro (non ricordo di aver mai usato in modo interattivo più di quattro marchi in 15 anni di utilizzo di vi ; uno crea le proprie convenzioni su come i segni e i registri vengono utilizzati dalle macro che non disturbano il contesto interattivo). all'altro capo del testo desiderato; possiamo iniziare da entrambe le parti, non importa. Quindi possiamo semplicemente usare d`aper tagliare o y`acopiare. Quindi l'intero processo ha un overhead di 5 tasti (sei se abbiamo iniziato in "inserisci "modalità e necessarioEscmodalità comando fuori). Una volta che abbiamo tagliato o copiato poi incollare in una copia è un solo tasto: p.

Dico che questo è un modo per tagliare o copiare il testo. Tuttavia, è solo uno dei tanti. Spesso possiamo descrivere in modo più succinto l'intervallo di testo senza spostare il cursore e rilasciare un segno. Ad esempio, se mi trovo in un paragrafo di testo, posso usare {e }spostare rispettivamente all'inizio o alla fine del paragrafo. Quindi, per spostare un paragrafo di testo, lo taglio usando { d}(3 battute). (Se mi capita di trovarmi già nella prima o nell'ultima riga del paragrafo, posso semplicemente usare d}o d{rispettivamente.

La nozione di "paragrafo" assume come impostazione predefinita qualcosa che di solito è intuitivamente ragionevole. Quindi funziona spesso sia per il codice che per la prosa.

Spesso conosciamo qualche modello (espressione regolare) che segna un'estremità o l'altra del testo a cui siamo interessati. La ricerca in avanti o all'indietro sono movimenti in vi . Quindi possono anche essere usati come "soggetti" nelle nostre "dichiarazioni". Quindi posso usare d/fooper tagliare dalla riga corrente alla riga successiva contenente la stringa "pippo" e y?barper copiare dalla riga corrente alla riga (precedente) più recente contenente "barra". Se non desidero linee intere, posso comunque usare i movimenti di ricerca (come loro dichiarazioni), rilasciare i miei segni e usare i `xcomandi come descritto in precedenza.

Oltre ai "verbi" e ai "soggetti" vi hanno anche "oggetti" (nel senso grammaticale del termine). Finora ho descritto solo l'uso del registro anonimo. Tuttavia, posso usare uno qualsiasi dei 26 registri "nominati" prefissando il riferimento "oggetto" con "(il modificatore di virgolette doppie). Quindi se uso "addsto tagliando la riga corrente nel registro ' a ' e se uso, "by/foosto tirando una copia del testo da qui alla riga successiva contenente "pippo" nel registro ' b '. Per incollare da un registro ho semplicemente il prefisso incolla con la stessa sequenza di modifica: "apincolla una copia del ' a ' registro '"bPincolla una copia da ' b ' a prima della riga corrente.

Questa nozione di "prefissi" aggiunge anche gli analoghi di "aggettivi" grammaticali e "avverbi" al nostro linguaggio "manipolazione del testo". La maggior parte dei comandi (verbi) e del movimento (verbi o oggetti, a seconda del contesto) possono anche assumere prefissi numerici. 3Jsignifica "unisci le tre righe successive" e d5}significa "elimina dalla riga corrente fino alla fine del quinto paragrafo in basso da qui".

Questo è tutto livello intermedio vi . Niente di tutto questo è specifico di Vim e ci sono trucchi molto più avanzati in vi se sei pronto per impararli. Se dovessi padroneggiare solo questi concetti intermedi, probabilmente scoprirai che raramente hai bisogno di scrivere macro perché il linguaggio di manipolazione del testo è sufficientemente conciso ed espressivo per fare la maggior parte delle cose abbastanza facilmente usando il linguaggio "nativo" dell'editor.


Un campione di trucchi più avanzati:

Esistono numerosi :comandi, in particolare la :% s/foo/bar/gtecnica di sostituzione globale. (Non è avanzato ma :possono esserci altri comandi). L'intero :set di comandi è stata storicamente ereditata dal VI 's precedenti incarnazioni come la cura (line) e successivamente le ex utenze (line estesa). In realtà vi è così chiamato perché è l'interfaccia visiva di ex .

:i comandi normalmente operano su righe di testo. ed e ex stati scritti in un'epoca in cui gli schermi terminali sono rari e molti terminali erano dispositivi "telescriventi" (TTY). Quindi era comune lavorare da copie stampate del testo, usando i comandi attraverso un'interfaccia estremamente concisa (le velocità di connessione comuni erano 110 baud o, approssimativamente, 11 caratteri al secondo - che è più lento di una dattilografa veloce; i ritardi erano comuni su sessioni interattive multiutente; inoltre c'era spesso qualche motivazione per conservare la carta).

Quindi la sintassi della maggior parte dei :comandi include un indirizzo o un intervallo di indirizzi (numero di riga) seguito da un comando. Naturalmente si potrebbero usare i numeri di riga letterali: :127,215 s/foo/barper cambiare la prima occorrenza di "pippo" in "barra" su ogni riga tra 127 e 215. Si potrebbero anche usare alcune abbreviazioni come .o rispettivamente $per le righe correnti e ultime. Si potrebbero anche usare prefissi relativi +e -fare riferimento agli offset dopo o prima della linea di curvatura, rispettivamente. Quindi: :.,$jsignificato "dalla riga corrente all'ultima riga, uniscili tutti in una riga". :%è sinonimo di :1,$(tutte le linee).

I comandi :... ge :... vportano alcune spiegazioni in quanto sono incredibilmente potenti. :... gè un prefisso per "globalmente" applicare un comando successivo a tutte le linee che corrispondono a un modello (espressione regolare) mentre :... vapplica tale comando a tutte le linee che NON corrispondono al modello dato ("v" da "conVerse"). Come con altri comandi ex , questi possono essere prefissati indirizzando i riferimenti / intervallo. Quindi :.,+21g/foo/dsignifica "elimina tutte le righe contenenti la stringa" pippo "da quella corrente attraverso le 21 successive" mentre :.,$v/bar/dsignifica "da qui alla fine del file, elimina tutte le righe che NON contengono la" barra ".

È interessante notare che il comando Unix comune grep in realtà è stato ispirato da questo ex comando (e prende il nome dal modo in cui è stato documentato). Il comando ex:g/re/p (grep) è stato il modo in cui hanno documentato come "stampare" globalmente le righe contenenti una "espressione regolare" (ri). Quando sono stati usati ed ed ex , il :pcomando è stato uno dei primi che qualcuno ha imparato e spesso il primo utilizzato durante la modifica di qualsiasi file. È stato il modo in cui hai stampato i contenuti attuali (di solito solo una pagina alla volta utilizzando :.,+25po alcuni di questi).

Nota che :% g/.../do (la sua controparte reVerse / conVerse: :% v/.../dsono i modelli di utilizzo più comuni. Tuttavia ci sono un paio di altri excomandi che vale la pena ricordare:

Possiamo usare mper spostare le linee e junire le linee. Ad esempio, se hai un elenco e desideri separare tutti gli elementi corrispondenti (o viceversa NON abbinare un modello) senza eliminarli, puoi utilizzare qualcosa del tipo: :% g/foo/m$... e tutte le righe "pippo" saranno state spostate in la fine del file. (Nota l'altro suggerimento sull'uso della fine del file come spazio di lavoro). Ciò avrà preservato l'ordine relativo di tutte le righe "pippo" pur avendo estratto dal resto dell'elenco. (Ciò equivarrebbe a fare qualcosa del tipo: 1G!GGmap!Ggrep foo<ENTER>1G:1,'a g/foo'/d(copia il file nella sua coda, filtra la coda greped elimina tutte le cose dalla testa).

Per unire le linee di solito posso trovare un modello per tutte le linee che devono essere unite al loro predecessore (tutte le linee che iniziano con "^" anziché "^ *" in alcuni elenchi puntati, per esempio). Per quel caso userei: :% g/^ /-1j(per ogni riga corrispondente, salgo una riga e unisciti a loro). (BTW: per le liste di proiettile cercando di cercare per le linee di proiettile e unisciti al prossimo non funziona per un paio di ragioni ... può aderire a una linea proiettile ad un altro, e non sarà unirsi a qualsiasi linea proiettile a tutti di le sue continuazioni; funzionerà solo in coppia sulle partite).

Quasi inutile menzionare che puoi usare il nostro vecchio amico s(sostituto) con i comandi ge v(global / converse-global). Di solito non è necessario farlo. Tuttavia, prendere in considerazione alcuni casi in cui si desidera eseguire una sostituzione solo su righe corrispondenti ad altri pattern. Spesso è possibile utilizzare un modello complicato con acquisizioni e utilizzare i riferimenti posteriori per preservare le parti delle linee che NON si desidera modificare. Tuttavia, sarà spesso più semplice separare la corrispondenza dalla sostituzione: :% g/foo/s/bar/zzz/g- per ogni riga contenente "pippo" sostituisci tutte le "barre" con "zzz". (Qualcosa di simile a:% s/\(.*foo.*\)bar\(.*\)/\1zzz\2/gfunzionerebbe solo per i casi in cui le istanze di "bar" sono state PRECEDATE da "pippo" sulla stessa riga; è già abbastanza sgraziato e dovrebbe essere ulteriormente modificato per catturare tutti i casi in cui "bar" ha preceduto "foo")

Il punto è che ci sono più di semplici p, se drighe nel exset di comandi.

Gli :indirizzi possono anche riferirsi a segni. Quindi puoi usare: :'a,'bg/foo/jper unire qualsiasi linea contenente la stringa foo alla sua linea successiva, se si trova tra le linee tra i segni ' a ' e ' b '. (Sì, tutti i precedenti exesempi di comandi possono essere limitati a sottoinsiemi delle righe del file con il prefisso con questo tipo di espressioni di indirizzamento).

È piuttosto oscuro (ho usato qualcosa del genere solo poche volte negli ultimi 15 anni). Tuttavia, ammetterò liberamente di aver fatto spesso cose in modo iterativo e interattivo che probabilmente avrebbero potuto essere fatte in modo più efficiente se avessi avuto il tempo di pensare al giusto incantesimo.

Un altro comando vi o ex molto utile è :rleggere il contenuto di un altro file. Pertanto: :r fooinserisce il contenuto del file denominato "pippo" nella riga corrente.

Più potente è il :r!comando. Questo legge i risultati di un comando. È lo stesso che sospendere la sessione vi , eseguire un comando, reindirizzare il suo output su un file temporaneo, riprendere la sessione vi e leggere i contenuti dalla temp. file.

Ancora più potenti sono i comandi !(bang) e :... !( ex bang). Eseguono anche comandi esterni e leggono i risultati nel testo corrente. Tuttavia, filtrano anche le selezioni del nostro testo tramite il comando! In questo modo possiamo ordinare tutte le righe nel nostro file usando 1G!Gsort( Gè il comando vi "goto"; il valore predefinito è andare all'ultima riga del file, ma può essere preceduto da un numero di riga, come 1, la prima riga). Ciò equivale alla variante ex:1,$!sort . Gli scrittori usano spesso !con le utility Unix fmt o fold per riformare o "racchiudere in parole" selezioni di testo. Una macro molto comune è{!}fmt(riformatta il paragrafo corrente). I programmatori a volte lo usano per eseguire il loro codice, o solo parti di esso, attraverso rientri o altri strumenti di riformattazione del codice.

L'uso dei comandi :r!e !significa che qualsiasi utility o filtro esterno può essere trattato come un'estensione del nostro editor. Di tanto in tanto li ho usati con script che estraevano dati da un database o con comandi wget o lynx che estraevano dati da un sito Web o comandi ssh che estraevano dati da sistemi remoti.

Un altro ex utile comando è :so(abbreviazione di :source). Questo legge il contenuto di un file come una serie di comandi. Quando si avvia vi normalmente, implicitamente, esegue una :sourcesu ~/.exinitrcfile (e Vim solito fa questo su ~/.vimrc, abbastanza naturalmente). L'uso di questo è che puoi cambiare il tuo profilo dell'editor al volo semplicemente acquistando un nuovo set di macro, abbreviazioni e impostazioni dell'editor. Se sei subdolo si può anche usare questo come un trucco per la memorizzazione di sequenze di ex comandi di modifica da applicare ai file su richiesta.

Ad esempio, ho un file di sette righe (36 caratteri) che esegue un file tramite wc e inserisce un commento in stile C nella parte superiore del file contenente i dati di conteggio delle parole. Posso applicare quella "macro" a un file usando un comando come:vim +'so mymacro.ex' ./mytarget

(Il + opzione della riga di comando per vi e Vim viene normalmente utilizzata per avviare la sessione di modifica in corrispondenza di un determinato numero di riga. Tuttavia è un fatto poco noto che si può seguire il comando +con qualsiasi comando / espressione ex valido , come un comando "source" come Ho fatto qui; per un semplice esempio ho degli script che invocano: vi +'/foo/d|wq!' ~/.ssh/known_hostsper rimuovere una voce dal mio file degli host conosciuti SSH in modo non interattivo mentre sto ri-immaginando un set di server).

Di solito è molto più facile scrivere tali "macro" usando Perl, AWK, sed (che è, in effetti, come grep un'utilità ispirata al comando ed ).

Il @comando è probabilmente il comando vi più oscuro . Nell'insegnare occasionalmente corsi avanzati di amministrazione dei sistemi per quasi un decennio ho incontrato pochissime persone che l'hanno mai usato. @esegue il contenuto di un registro come se fosse un comando vi o ex .
Esempio: utilizzo spesso: :r!locate ...per trovare alcuni file sul mio sistema e leggerne il nome nel mio documento. Da lì elimino qualsiasi hit estraneo, lasciando solo il percorso completo del file che mi interessa. Piuttosto che faticosamente Tabpassare attraverso ogni componente del percorso (o peggio, se mi capita di essere bloccato su una macchina senza supporto per il completamento di Tab nella sua copia di vi ) uso solo:

  1. 0i:r(per trasformare la riga corrente in un comando valido : r ),
  2. "cdd (per eliminare la riga nel registro "c") e
  3. @c eseguire quel comando.

Sono solo 10 sequenze di tasti (e l'espressione "cdd @c è effettivamente una macro per me, quindi posso scriverla quasi altrettanto rapidamente di qualsiasi parola di sei lettere comune).


Un pensiero che fa riflettere

Ho solo graffiato alla superficie del potere di vi e nessuno di ciò che ho descritto qui è anche parte dei "miglioramenti" per i quali vim prende il nome! Tutto ciò che ho descritto qui dovrebbe funzionare su qualsiasi vecchia copia di vi di 20 o 30 anni fa.

Ci sono persone che hanno usato molto più di VI 's potere di quanto io mai.


440
Scimmie del codice sacro, .. questa è una risposta approfondita. La cosa fantastica è che probabilmente hai scritto in vim in circa 10 sequenze di tasti.
EightyOne Unite,

48
@Wahnfieden - grok è esattamente ciò che intendevo: en.wikipedia.org/wiki/Grok (Apparentemente è anche nell'OED --- il più vicino che noi anglofoni abbiamo a un lessico canonico). "Grok" di un editor è ritrovarsi a usare fluentemente i suoi comandi ... come se fosse il tuo linguaggio naturale.
Jim Dennis,

22
wow, una risposta molto ben scritta! non potrei essere più d'accordo, anche se uso molto il @comando (in combinazione con q: record macro)
knittl

63
Superba risposta che riscatta totalmente una domanda davvero orribile. Voterò questa domanda, che normalmente vorrei sottovalutare, solo per rendere più facile trovare questa risposta. (E io sono un ragazzo di Emacs! Ma in questo modo avrò un posto in cui indicare nuove persone che vogliono una buona spiegazione di ciò che gli utenti vi trovano divertenti su vi. Poi parlerò di Emacs e loro potranno decidere.)
Brandon Rodi,

8
Puoi creare un sito Web e inserire questo tutorial lì, in modo che non venga seppellito qui su StackOverflow. Devo ancora leggere una migliore introduzione a vi di questo.
Marko

504

Stai parlando di selezione e copia del testo, penso che dovresti dare un'occhiata alla Vim Visual Mode .

Nella modalità visiva, puoi selezionare il testo usando i comandi Vim, quindi puoi fare quello che vuoi con la selezione.

Considera i seguenti scenari comuni:

È necessario selezionare la parentesi corrispondente successiva.

Potresti fare:

  • v% se il cursore si trova sulla parentesi iniziale / finale
  • vib se il cursore si trova all'interno del blocco tra parentesi

Vuoi selezionare il testo tra virgolette:

  • vi " per virgolette doppie
  • vi ' per virgolette singole

Vuoi selezionare un blocco parentesi graffa (molto comune nei linguaggi in stile C):

  • viB
  • vi{

Vuoi selezionare l'intero file:

  • ggVG

La selezione del blocco visivo è un'altra caratteristica davvero utile, ti consente di selezionare un'area rettangolare di testo, devi solo premere Ctrl- Vper avviarlo, quindi selezionare il blocco di testo desiderato ed eseguire qualsiasi tipo di operazione come yank, delete, incolla, modifica, ecc. È fantastico modificare il testo orientato alla colonna .


2
Ogni editor ha qualcosa del genere, non è specifico per Vim.
Finnw

22
Sì, ma era una lamentela specifica del poster. La modalità visiva è il miglior metodo di Vim per la selezione e la manipolazione diretta del testo. E poiché i metodi di attraversamento del buffer di vim sono eccellenti, trovo che la selezione del testo in vim sia abbastanza piacevole.
pistole

9
Penso che valga la pena menzionare anche Ctrl-V per selezionare un blocco, ovvero un rettangolo arbitrario di testo. Quando ne hai bisogno è un vero toccasana.
Hamish Downer,

6
@viksit: sto usando Camtasia, ma ci sono molte alternative: codinghorror.com/blog/2006/11/screencasting-for-windows.html
CMS

3
Inoltre, se hai una selezione visiva e vuoi regolarla, osalterà dall'altra parte. Quindi puoi spostare l'inizio e la fine della selezione quanto vuoi.
Nathan Long

207

Alcuni consigli sulla produttività:

Movimenti intelligenti

  • *e #cerca la parola sotto il cursore avanti / indietro.
  • w alla parola successiva
  • W alla successiva parola separata dallo spazio
  • b/ eall'inizio / fine della parola corrente. ( B/ solo Eper spazio separato)
  • gg/ Gpassa all'inizio / alla fine del file.
  • % passa alla corrispondenza {..} o (..), ecc.
  • {/ }passa al paragrafo successivo.
  • '. torna all'ultima riga modificata.
  • g; tornare all'ultima posizione modificata.

Comandi di modifica rapida

  • I inserire all'inizio.
  • A aggiungere alla fine.
  • o/ Oapre una nuova riga dopo / prima della corrente.
  • v/ V/ Ctrl+Vmodalità visiva (per selezionare il testo!)
  • Shift+R sostituire il testo
  • C cambia la parte rimanente della linea.

Combinazione di comandi

La maggior parte dei comandi accetta un importo e una direzione, ad esempio:

  • cW = cambia fino alla fine della parola
  • 3cW = cambia 3 parole
  • BcW = per iniziare la parola intera, cambia la parola intera
  • ciW = cambia la parola interiore.
  • ci" = cambia interno tra ".."
  • ci( = cambia testo tra (..)
  • ci< = cambia testo tra <..> (necessita set matchpairs+=<:> in vimrc)
  • 4dd = cancella 4 righe
  • 3x = elimina 3 caratteri.
  • 3s = sostituisce 3 caratteri.

Comandi utili per il programmatore

  • rsostituire un carattere (ad es. rdsostituisce il carattere corrente con d).
  • ~ cambia caso.
  • J unisce due righe
  • Ctrl + A / Ctrl + X incrementa / decrementa un numero.
  • . ripeti l'ultimo comando (una semplice macro)
  • == rientro della riga fissa
  • > rientro (in modalità visiva)
  • < blocco indelebile (in modalità visiva)

Registrazione macro

  • stampa q[ key ] per iniziare la registrazione.
  • Quindi colpisci q per interrompere la registrazione.
  • La macro può essere giocata con @[ key ].

Utilizzando comandi e movimenti molto specifici, VIM può riprodurre quelle azioni esatte per le righe successive. (es. A per append-to-end, b/ eper spostare il cursore rispettivamente all'inizio o alla fine di una parola)

Esempio di impostazioni ben costruite

# reset to vim-defaults
if &compatible          # only if not set before:
  set nocompatible      # use vim-defaults instead of vi-defaults (easier, more user friendly)
endif

# display settings
set background=dark     # enable for dark terminals
set nowrap              # dont wrap lines
set scrolloff=2         # 2 lines above/below cursor when scrolling
set number              # show line numbers
set showmatch           # show matching bracket (briefly jump)
set showmode            # show mode in status bar (insert/replace/...)
set showcmd             # show typed command in status bar
set ruler               # show cursor position in status bar
set title               # show file in titlebar
set wildmenu            # completion with menu
set wildignore=*.o,*.obj,*.bak,*.exe,*.py[co],*.swp,*~,*.pyc,.svn
set laststatus=2        # use 2 lines for the status bar
set matchtime=2         # show matching bracket for 0.2 seconds
set matchpairs+=<:>     # specially for html

# editor settings
set esckeys             # map missed escape sequences (enables keypad keys)
set ignorecase          # case insensitive searching
set smartcase           # but become case sensitive if you type uppercase characters
set smartindent         # smart auto indenting
set smarttab            # smart tab handling for indenting
set magic               # change the way backslashes are used in search patterns
set bs=indent,eol,start # Allow backspacing over everything in insert mode

set tabstop=4           # number of spaces a tab counts for
set shiftwidth=4        # spaces for autoindents
#set expandtab           # turn a tabs into spaces

set fileformat=unix     # file mode is unix
#set fileformats=unix,dos    # only detect unix file format, displays that ^M with dos files

# system settings
set lazyredraw          # no redraws in macros
set confirm             # get a dialog when :q, :w, or :wq fails
set nobackup            # no backup~ files.
set viminfo='20,\"500   # remember copy registers after quitting in the .viminfo file -- 20 jump links, regs up to 500 lines'
set hidden              # remember undo after quitting
set history=50          # keep 50 lines of command history
set mouse=v             # use mouse in visual mode (not normal,insert,command,help mode


# color settings (if terminal/gui supports it)
if &t_Co > 2 || has("gui_running")
  syntax on          # enable colors
  set hlsearch       # highlight search (very useful!)
  set incsearch      # search incremently (search while typing)
endif

# paste mode toggle (needed when using autoindent/smartindent)
map <F10> :set paste<CR>
map <F11> :set nopaste<CR>
imap <F10> <C-O>:set paste<CR>
imap <F11> <nop>
set pastetoggle=<F11>

# Use of the filetype plugins, auto completion and indentation support
filetype plugin indent on

# file type specific settings
if has("autocmd")
  # For debugging
  #set verbose=9

  # if bash is sh.
  let bash_is_sh=1

  # change to directory of current file automatically
  autocmd BufEnter * lcd %:p:h

  # Put these in an autocmd group, so that we can delete them easily.
  augroup mysettings
    au FileType xslt,xml,css,html,xhtml,javascript,sh,config,c,cpp,docbook set smartindent shiftwidth=2 softtabstop=2 expandtab
    au FileType tex set wrap shiftwidth=2 softtabstop=2 expandtab

    # Confirm to PEP8
    au FileType python set tabstop=4 softtabstop=4 expandtab shiftwidth=4 cinwords=if,elif,else,for,while,try,except,finally,def,class
  augroup END

  augroup perl
    # reset (disable previous 'augroup perl' settings)
    au!  

    au BufReadPre,BufNewFile
    \ *.pl,*.pm
    \ set formatoptions=croq smartindent shiftwidth=2 softtabstop=2 cindent cinkeys='0{,0},!^F,o,O,e' " tags=./tags,tags,~/devel/tags,~/devel/C
    # formatoption:
    #   t - wrap text using textwidth
    #   c - wrap comments using textwidth (and auto insert comment leader)
    #   r - auto insert comment leader when pressing <return> in insert mode
    #   o - auto insert comment leader when pressing 'o' or 'O'.
    #   q - allow formatting of comments with "gq"
    #   a - auto formatting for paragraphs
    #   n - auto wrap numbered lists
    #   
  augroup END


  # Always jump to the last known cursor position. 
  # Don't do it when the position is invalid or when inside
  # an event handler (happens when dropping a file on gvim). 
  autocmd BufReadPost * 
    \ if line("'\"") > 0 && line("'\"") <= line("$") | 
    \   exe "normal g`\"" | 
    \ endif 

endif # has("autocmd")

Le impostazioni possono essere archiviate ~/.vimrco a livello di sistema /etc/vimrc.locale quindi leggere dal /etc/vimrcfile usando:

source /etc/vimrc.local

(Dovrai sostituire il #carattere del commento con "per farlo funzionare in VIM, volevo dare la giusta evidenziazione della sintassi qui).

I comandi che ho elencato qui sono piuttosto semplici e quelli principali che uso finora. Mi rendono già molto più produttivo, senza dover conoscere tutte le cose fantasiose.


4
Meglio di '.IS g;, che ritorna attraverso il changelist. Va all'ultima posizione modificata, anziché all'ultima riga modificata
nought101

98

Il meccanismo Control+ Rè molto utile :-) In modalità inserimento o modalità comando (cioè sulla :riga quando si digitano i comandi), continuare con un registro numerato o denominato:

  • a- zi registri nominati
  • " il registro senza nome, contenente il testo dell'ultima cancellazione o yank
  • % il nome del file corrente
  • # il nome del file alternativo
  • * il contenuto degli appunti (X11: selezione primaria)
  • + il contenuto degli appunti
  • / l'ultimo modello di ricerca
  • : l'ultima riga di comando
  • . l'ultimo testo inserito
  • - l'ultimo piccolo (meno di una riga) elimina
  • =5*5 inserire 25 nel testo (mini-calcolatrice)

Vedi :help i_CTRL-Re :help c_CTRL-Rper maggiori dettagli, e fai un giro nelle vicinanze per più bontà CTRL-R.


10
Cordiali saluti, questo si riferisce a Ctrl + R in modalità inserimento . In modalità normale, Ctrl + R viene ripetuto.
vdboor,

2
+1 per il nome del file corrente / alternativo. Control-Afunziona anche in modalità inserimento per l'ultimo testo inserito e Control-@per inserire sia l'ultimo testo inserito sia per passare immediatamente alla modalità normale.
Aryeh Leib Taurog,

91

Plugin Vim

Ci sono molte buone risposte qui, e una straordinaria sulla zen di vi. Una cosa che non vedo menzionato è che vim è estremamente estensibile tramite plugin. Ci sono script e plugin per farlo fare ogni sorta di cose folli che l'autore originale non ha mai considerato. Ecco alcuni esempi di plugin vim incredibilmente utili:

rails.vim

Rails.vim è un plugin scritto da tpope. È uno strumento incredibile per le persone che stanno sviluppando binari. Fa cose magiche sensibili al contesto che ti consentono di passare facilmente da un metodo in un controller alla vista associata, fino a un modello e fino ai test unitari per quel modello. Ha risparmiato dozzine se non centinaia di ore come sviluppatore di rotaie.

gist.vim

Questo plugin consente di selezionare un'area di testo in modalità visiva e digitare un comando rapido per pubblicarlo su gist.github.com . Ciò consente un facile accesso a pastebin, il che è incredibilmente utile se stai collaborando con qualcuno tramite IRC o IM.

space.vim

Questo plugin fornisce funzionalità speciali alla barra spaziatrice. Trasforma la barra spaziatrice in qualcosa di analogo al periodo, ma invece di ripetere azioni ripete movimenti. Questo può essere molto utile per spostarsi rapidamente all'interno di un file in un modo definito al volo.

surround.vim

Questo plugin ti dà la possibilità di lavorare con testo che è delimitato in qualche modo. Ti dà oggetti che indicano cose all'interno di parentesi, cose all'interno di virgolette, ecc. Può tornare utile per manipolare il testo delimitato.

supertab.vim

Questo script porta fantasiose funzionalità di completamento delle schede su Vim. Il materiale per il completamento automatico è già presente nel nucleo di VIM, ma questo lo porta in una scheda rapida anziché in più scorciatoie multikey diverse. Molto utile e incredibilmente divertente da usare. Sebbene non sia l'intellisense di VS, è un grande passo e porta molte funzionalità che ti aspetteresti da uno strumento di completamento delle schede.

syntastic.vim

Questo strumento porta i comandi di controllo della sintassi esterna in vim. Non l'ho usato personalmente, ma ho sentito grandi cose a riguardo e il concetto è difficile da battere. Controllare la sintassi senza doverlo fare manualmente fa risparmiare molto tempo e può aiutarti a catturare i bug sintattici mentre li introduci piuttosto che quando ti fermi per testare.

fugitive.vim

Accesso diretto a git dall'interno di vim. Ancora una volta, non ho usato questo plugin, ma posso vedere l'utilità. Purtroppo sono in una cultura in cui svn è considerato "nuovo", quindi probabilmente non vedrò git al lavoro per un bel po 'di tempo.

nerdtree.vim

Un browser ad albero per vim. Ho iniziato a usarlo di recente ed è davvero utile. Ti consente di inserire una vista ad albero in una divisione verticale e di aprire facilmente i file. Questo è ottimo per un progetto con molti file sorgente tra cui spesso salti.

FuzzyFinderTextmate.vim

Questo è un plugin non mantenuto, ma comunque incredibilmente utile. Offre la possibilità di aprire i file utilizzando una sintassi descrittiva "fuzzy". Significa che in un albero sparso di file devi solo digitare abbastanza caratteri per chiarire i file che ti interessano dal resto della cruft.

Conclusione

Ci sono molti strumenti incredibili disponibili per vim. Sono sicuro di aver solo graffiato la superficie qui, e vale la pena cercare strumenti applicabili al tuo dominio. La combinazione del potente set di strumenti di vi tradizionale, i miglioramenti di vim su di esso e i plugin che estendono ulteriormente vim, è uno dei modi più potenti per modificare il testo mai concepito. Vim è facilmente potente come emacs, eclipse, visual studio e textmate.

Grazie

Grazie a Duwanis per le sue configurazioni vim da cui ho imparato molto e preso in prestito la maggior parte dei plugin elencati qui.


La magica navigazione di prova in classe su rails.vim è una delle cose più generali che vorrei che Vim avesse che TextMate inchiodasse in tutte le lingue: se sto lavorando su Person.scala e faccio Cmd + T, di solito la prima cosa nell'elenco è PersonTest.scala.
Tom Morris,

5
Penso che sia ora che FuzzyFinderTextmate inizi a essere sostituito con github.com/wincent/Command-T
Gavin Gilmour,

2
+1 per Syntastic. Ciò, combinato con JSLint, ha reso il mio Javascript molto meno soggetto a errori. Vedi superuser.com/questions/247012/… su come configurare JSLint per lavorare con Syntastic.
Nathan Long

1
@Benson Ottima lista! Vorrei anche lanciare SnipMate . Automazione molto utile delle cose di codifica comuni. if <tab> instant if block, ecc.
AlG,

2
Penso che il nerdcommenter sia anche un buon plugin: qui . Come dice il nome, serve per commentare il tuo codice.
Stephan,

53

. Ripeti l'ultimo comando di cambio testo

Risparmio molto tempo con questo.

La modalità visiva è stata menzionata in precedenza, ma la modalità visiva a blocchi mi ha risparmiato molto tempo durante la modifica di colonne a dimensione fissa in file di testo. (accessibile con Ctrl-V).


3
Inoltre, se si utilizza un comando conciso (ad es. A per aggiungere alla fine) per modificare il testo, vim può ripetere esattamente la stessa azione per la riga successiva in cui si preme il .tasto.
vdboor

48

gi

Vai all'ultima posizione modificata (molto utile se hai eseguito alcune ricerche e desideri tornare alla modifica)

^ P e ^ N

Completa il testo precedente (^ P) o successivo (^ N).

^ O e ^ I

Vai alla posizione precedente ( ^O- "O"per la vecchia) o alla successiva ( ^I- "I"proprio vicino a "O"). Quando esegui ricerche, modifichi file, ecc., Puoi navigare attraverso questi "salti" avanti e indietro.


4
@Kungi `. ti porterà all'ultima modifica `` ti riporterà nella posizione in cui ti trovavi prima dell'ultimo 'salto' - che / potrebbe / anche essere la posizione dell'ultima modifica.
Grant McLean,


42

CTRL+A aumenta il numero su cui ti trovi.


19
... e decrementi CTRL-X.
innaM

9
È una scorciatoia, ma finora non ho MAI trovato alcun uso.
SolutionYogi,

8
se esegui vim sullo schermo e ti chiedi perché non funziona - ctrl + A, A
matja

13
@SolutionYogi: considera di voler aggiungere il numero di riga all'inizio di ogni riga. Soluzione: ggI1 <spazio> <esc> 0qqyawjP0 <ca> 0q9999 @ q
hcs42

10
Molto utile con Vimperator, dove incrementa (o decrementa, Ctrl-X) l'ultimo numero nell'URL. Utile per navigare rapidamente tra le gallerie di immagini, ecc.
blueyed

38

Tutto in modalità normale:

f <char> per passare all'istanza successiva di un determinato carattere sulla riga corrente e ; ripetere.

F <char> per passare all'istanza precedente di un determinato carattere sulla riga corrente e ;ripetere.

Se usati in modo intelligente, i due precedenti possono farti muovere rapidamente in una linea.

* su una parola per cercare l'istanza successiva.

# su una parola per cercare l'istanza precedente.


6
Whoa, non sapevo del legame * e # (cerca avanti / indietro per la parola sotto il cursore). È fantastico. F / F e t / T e; i comandi sono rapidi salti ai caratteri sulla riga corrente. f / F posiziona il cursore sul carattere indicato mentre t / T lo posiziona appena "su" il carattere (il carattere appena prima o dopo di esso secondo la direzione scelta.; semplicemente ripete l'ultimo f / F / t / T salto (nella stessa direzione)
Jim Dennis

10
:) Il motto nella parte superiore della pagina dei suggerimenti su vim.org: "Riesci a immaginare quante sequenze di tasti avrebbero potuto essere salvate, se avessi saputo il comando" * "in tempo?" - Juergen Salk,
19/01/2001

1
Come ha detto Jim, la combo "t / T" è spesso altrettanto buona, se non migliore, ad esempio, ct(cancellerà la parola e ti metterà in modalità inserimento, ma manterrà le parentesi!
puk

34

Sessione

un. salva sessione

: mks sessionname

b. forzare la sessione di salvataggio

: mks! nomesessione

c. carica sessione

gvim o vim -S nome sessione


Aggiunta e sottrazione

un. Aggiunta e sottrazione

CTRL-A; Aggiungi [conteggio] al numero o al carattere alfabetico sul o dopo il cursore. {non in Vi

CTRL-X; Sottrai [conta] dal numero o dal carattere alfabetico sul o dopo il cursore. {non in Vi}

b. Annullamento della chiave della finestra

Nella finestra, Ctrl-A già mappato per la selezione dell'intero file è necessario annullare l'associazione nel file rc. contrassegnare mswin.vim CTRL-A come parte della mappatura come commento o aggiungere il file rc con unmap

c. Con Macro

Il comando CTRL-A è molto utile in una macro. Esempio: utilizzare i passaggi seguenti per creare un elenco numerato.

  1. Crea la prima voce dell'elenco, assicurati che inizi con un numero.
  2. qa - avvia la registrazione nel buffer 'a'
  3. Y - strattona la voce
  4. p - metti una copia della voce sotto la prima
  5. CTRL-A - incrementa il numero
  6. q - interrompe la registrazione
  7. @a - ripeti i tempi di strappo, inserimento e incremento

1
Hai idea di quali siano le scorciatoie in Windows?
Don Reba,

32

La scorsa settimana al lavoro il nostro progetto ha ereditato molto codice Python da un altro progetto. Sfortunatamente il codice non si adattava alla nostra architettura esistente: era tutto fatto con variabili e funzioni globali, che non funzionavano in un ambiente multi-thread.

Avevamo ~ 80 file che dovevano essere rielaborati per essere orientati agli oggetti: tutte le funzioni sono state spostate in classi, i parametri sono stati modificati, sono state aggiunte istruzioni di importazione, ecc. Avevamo un elenco di circa 20 tipi di correzioni che dovevano essere eseguite su ciascun file. Stimerei che facendolo a mano una persona potrebbe fare forse 2-4 al giorno.

Così ho fatto il primo a mano e poi ho scritto uno script vim per automatizzare le modifiche. La maggior parte era un elenco di comandi vim ad es

" delete an un-needed function "
g/someFunction(/ d

" add wibble parameter to function foo "
%s/foo(/foo( wibble,/

" convert all function calls bar(thing) into method calls thing.bar() "
g/bar(/ normal nmaf(ldi(`aPa.

L'ultimo merita un po 'di spiegazione:

g/bar(/  executes the following command on every line that contains "bar("
normal   execute the following text as if it was typed in in normal mode
n        goes to the next match of "bar(" (since the :g command leaves the cursor position at the start of the line)
ma       saves the cursor position in mark a
f(       moves forward to the next opening bracket
l        moves right one character, so the cursor is now inside the brackets
di(      delete all the text inside the brackets
`a       go back to the position saved as mark a (i.e. the first character of "bar")
P        paste the deleted text before the current cursor position
a.       go into insert mode and add a "." 

Per un paio di trasformazioni più complesse come la generazione di tutte le istruzioni di importazione ho incorporato un po 'di pitone nello script vim.

Dopo alcune ore di lavoro su di esso ho avuto uno script che farà almeno il 95% della conversione. Apro un file in vim, quindi corro :source fixit.vime il file si trasforma in un battito di ciglia.

Abbiamo ancora il lavoro di modificare il restante 5% che non valeva la pena automatizzare e di testare i risultati, ma trascorrendo un giorno a scrivere questo script stimo che abbiamo risparmiato settimane di lavoro.

Ovviamente sarebbe stato possibile automatizzarlo con un linguaggio di scripting come Python o Ruby, ma ci sarebbe voluto molto più tempo per scrivere e sarebbe meno flessibile - l'ultimo esempio sarebbe stato difficile dal momento che regex da solo non sarebbe in grado di gestire parentesi nidificate, ad es. per convertire bar(foo(xxx))in foo(xxx).bar(). Vim era perfetto per il compito.


1
Grazie mille per la condivisione, è davvero bello imparare da macro "utili e non classiche".
Olivier Pons,

%s/\(bar\)(\(.\+\))/\2.\1()/farebbe anche quello. (Gli escape sono compatibili con :set magic.) Solo per la cronaca. :)
Ipsquiggle

1
Se non ti piacciono le fughe in stile vim, usa \ v per attivare Very Magic:%s/\v(bar)\((.+)\)/\2.\1()/
Ipsquiggle

@lpsquiggle: il tuo suggerimento non gestirà espressioni complesse con più set di parentesi. ad esempio if bar(foo(xxx)) or wibble(xxx): diventa if foo(xxx)) or wibble(xxx.bar(): che è completamente sbagliato.
Dave Kirby,

28

Usa l'esploratore di file integrato! Il comando è :Exploree ti permette di navigare nel tuo codice sorgente molto velocemente. Ho questi mapping nel mio .vimrc:

map <silent> <F8>   :Explore<CR>
map <silent> <S-F8> :sp +Explore<CR>

Explorer consente anche di apportare modifiche ai file. Pubblicherò alcuni dei miei tasti preferiti, premendo <F1>verrà visualizzato l'elenco completo:

  • - : il più utile: passa alla directory superiore ( cd ..)
  • mf : segna un file
  • D : Elimina i file contrassegnati o il file su cui si trova il cursore, se nulla è contrassegnato.
  • R : Rinomina il file su cui si trova il cursore.
  • d : crea una nuova directory nella directory corrente
  • % : Crea un nuovo file nella directory corrente

1
Ho sempre pensato che i metodi predefiniti per la navigazione fossero un po 'aspirati per la maggior parte delle cose. Navigare è lento, se sai dove vuoi andare. LustyExplorer dalla sezione script di vim.org è un miglioramento molto necessario.
Svend

La tua seconda mappatura potrebbe essere più semplice: map <silent> <S-F8>: Sexplore <CR>
Taurus Olson,

8
Consiglio NERDtree invece dell'esploratore integrato. Ha cambiato il modo in cui ho usato vim per i progetti e mi ha reso molto più produttivo. Solo Google per questo.
kprobst

Non ho mai sentito il bisogno di esplorare l'albero dei sorgenti, mi basta usare :find, :tage le varie sequenze di tasti relativi a saltare. (Forse perché gli alberi di origine su cui lavoro sono grandi e organizzati diversamente da come avrei fatto? :))
dash-tom-bang

25

Sono un membro dell'American Cryptogram Association. La rivista bimestrale comprende oltre 100 crittogrammi di vario genere. Circa 15 di questi sono "criptaritmi" - vari tipi di problemi aritmetici con lettere sostituite con le cifre. Due o tre di questi sono sudoku, tranne che con lettere anziché numeri. Quando la griglia è completata, le nove lettere distinte spiegheranno una o più parole, su una linea, diagonale, spirale, ecc., Da qualche parte nella griglia.

Piuttosto che lavorare con la matita o scrivere a mano i problemi, scarico i problemi dall'area membri del loro sito web.

Quando lavoro con questi sudoku, uso vi, semplicemente perché sto usando le strutture che vi ha pochi altri editor. Principalmente nel convertire la griglia con lettere in una griglia numerata, perché trovo più facile da risolvere, e poi la griglia numerata completata nella griglia con lettere per trovare la parola o le parole della soluzione.

Il problema è formattato come nove gruppi di nove lettere, con - s che rappresentano gli spazi vuoti, scritti in due righe. Il primo passo è formattare queste in nove righe di nove caratteri ciascuna. Non c'è niente di speciale in questo, inserendo solo otto interruzioni di riga nei punti appropriati.

Il risultato sarà simile al seguente:

T-O-----C
-E-----S-
--AT--N-L
---NASO--
---E-T---
--SPCL---
E-T--OS--
-A-----P-
S-----C-T

Quindi, il primo passo per convertire questo in numeri è creare un elenco di lettere distinte. Per prima cosa, faccio una copia del blocco. Posiziono il cursore nella parte superiore del blocco, quindi digito :y}}p. :mi mette in modalità comando, ystrappa il prossimo comando di movimento. Poiché }è una mossa alla fine del prossimo paragrafo, y}strappa il paragrafo. }quindi sposta il cursore alla fine del paragrafo e pincolla ciò che avevamo strappato subito dopo il cursore. Cosìy}}p crea una copia del paragrafo successivo e finisce con il cursore tra le due copie.

Successivamente, trasformerò una di quelle copie in un elenco di lettere distinte. Questo comando è un po 'più complesso:

:!}tr -cd A-Z | sed 's/\(.\)/\1\n/g' | sort -u | tr -d '\n'

:mi mette di nuovo in modalità comando. !indica che il contenuto dello yank successivo deve essere reindirizzato attraverso una riga di comando. }strappa il paragrafo successivo e la riga di comando utilizza quindi il trcomando per eliminare tutto tranne le lettere maiuscole, il sedcomando per stampare ogni lettera su una singola riga e il sortcomando per ordinare quelle righe, rimuovere i duplicati e quindi treliminare le nuove righe, lasciando le nove lettere distinte in un'unica riga, sostituendo le nove righe che avevano originariamente composto il paragrafo. In questo caso, le lettere sono:ACELNOPST .

Il prossimo passo è fare un'altra copia della griglia. E poi di utilizzare le lettere che ho appena individuato per sostituire ciascuna di queste lettere con una cifra da 1 a 9. Questo è semplice: :!}tr ACELNOPST 0-9. Il risultato è:

8-5-----1
-2-----7-
--08--4-3
---4075--
---2-8---
--7613---
2-8--57--
-0-----6-
7-----1-8

Questo può quindi essere risolto nel solito modo o inserito in qualsiasi risolutore di sudoku che potresti preferire. La soluzione completata può quindi essere riconvertita in lettere con :!}tr 1-9 ACELNOPST.

Vi è potere in vi che è eguagliato da pochissimi altri. Il problema più grande è che solo pochissimi libri tutorial, siti Web, file di aiuto, ecc. Vi fanno molto più che toccare appena la superficie di ciò che è possibile.


e un'irritazione è che alcune distro come Ubuntu hanno degli alias dalla parola "vi" a "vim", quindi le persone non vedranno davvero vi. Ottimo esempio,
devi

1
Vim non controlla il nome con cui è stato avviato in modo che possa apparire nella giusta "modalità"?
dash-tom-bang,

3
Sono sconcertato da questo errore ripetuto: dici che devi :entrare in modalità comando, ma poi invariabilmente specifichi comandi in modalità normale (come y}}p) che non possono funzionare dalla modalità comandi ?!
Sehe

La mia opinione sulla sfida unica dei caratteri: :se tw=1 fo=(preparazione) VG:s/./& /g(inserire spazi), gvgq(dividere in righe separate), V{:sort u(ordinare e rimuovere i duplicati)
vedi

23

Manipolazioni di testo in blocco!

O attraverso le macro:

  • Inizia con la registrazione: qq
  • Fare cose
  • Interrompere la registrazione: q
  • Ripeti: @q(la prima volta),@@ dopo quello.
  • Ripeti 20 volte: 20@@

O attraverso espressioni regolari:

  • Sostituisci roba: :%s/[fo]+/bar/g

(Ma attenzione: se fai quest'ultimo, avrai 2 problemi :).)


5
+1 per il riferimento di Jamie Zawinski . (Nessun punto recuperato per mancato collegamento, anche). :)
Jim Dennis il

1
@Jim non sapevo nemmeno che fosse una citazione di Jamie Zawinski :). Proverò a ricordarmelo d'ora in poi.
jqno,

Trovo il trucco seguente sempre più utile ... per i casi in cui si desidera unire le linee che corrispondono (o che NON corrispondono) un modello alla linea precedente: :% g/foo/-1jo :'a,'z v/bar/-1jper esempio (dove il primo è "tutte le linee e corrisponde al modello" mentre quest'ultimo è "linee tra il segno a e il segno z che non corrispondono al modello"). La parte dopo lo scalpiccio in un comando go vex può essere qualsiasi altro comando ex, -1j è solo un movimento di linea relativa e un comando di join.
Jim Dennis,

ovviamente, se chiami la tua macro '2', quando arriva il momento di usarla, non devi nemmeno spostare il dito dal tasto '@' al tasto 'q'. Probabilmente salva da 50 a 100 millisecondi ogni volta proprio lì. = P
JustJeff

@JustJeff Dipende interamente dal layout della tastiera, il mio tasto @ si trova sull'altro lato della tastiera dal mio tasto 2.
Simon Steele,

23

L'ho scoperto di recente q:. Apre la "finestra di comando" e mostra i comandi ex-mode (command-mode) più recenti. È possibile spostarsi come al solito all'interno della finestra e premendo si <CR>esegue il comando. Puoi anche modificare, ecc. Inestimabile quando stai scherzando con qualche comando complesso o regex e non vuoi riscrivere l'intera cosa, o se la cosa complessa che vuoi fare era 3 comandi indietro. È quasi come Bashset -o vi , ma per Vim stesso (eh!).

Vedere :help q:per bit più interessanti per andare avanti e indietro.


22

Ho appena scoperto l'omnicompletion di Vim l'altro giorno, e mentre ammetto che sono un po 'confuso su ciò che fa, ho avuto risultati sorprendentemente buoni semplicemente schiacciando Ctrl+ x Ctrl+ uo Ctrl+ n/ Ctrl+ pin modalità insert. Non è proprio IntelliSense , ma lo sto ancora imparando.

Provalo! :help ins-completion


20

Queste non sono scorciatoie, ma sono correlate:

  1. Trasforma il capslock in un ESC aggiuntivo (o Ctrl)
  2. map leader a "," (virgola), con questo comando: let mapleader = ","

Aumentano la mia produttività.


Ehi bel suggerimento sul "\"! Molto meglio digitare "," di "\".
Olivier Pons,

2
Per rendere Caps Lock un'ulteriore Esc in Windows (che cos'è una chiave di blocco maiuscole? Una "qualsiasi chiave"?), Prova questo: web.archive.org/web/20100418005858/http://webpages.charter.net/…
R. Martinho Fernandes

Su Mac, hai bisogno di PCKeyboardHack - dettagli su superuser.com/questions/34223/…
Tom Morris

1
Su Windows uso AutoHotKey conCapslock::Escape
Jeromy Anglim il

19

Un'altra utile "scorciatoia" vi che uso frequentemente è 'xp'. Questo sostituirà il carattere sotto il cursore con il carattere successivo.


3
Xpper andare dall'altra parte
tester

5
Intorno al momento in cui è uscito Windows XP, scherzavo dicendo che questo è l'unico buon uso per questo.
kguest

18

<Ctrl> + W, V per dividere lo schermo in verticale
<Ctrl> + W, W per spostarsi tra le finestre

! python% [args] per eseguire lo script che sto modificando in questa finestra

ZF in modalità visiva per piegare linee arbitrarie


2
<Ctrl> + W e j / k ti permetteranno di navigare assolutamente (j su, k giù, come con vim normale). Questo è fantastico quando hai 3+ divisioni.
Andrew Scagnelli,

1
+1 per zf in modalità visiva, mi piace ripiegare il codice, ma non lo sapevo.
coder_tim

2
dopo aver battuto la mia tastiera ho dedotto che <C-w>no <C-w>sè una nuova finestra orizzontale, <C-w>bè una finestra in basso a destra, <C-w>co <C-w>qè una finestra chiusa, <C-w>xè aumentare e quindi ridurre la larghezza della finestra (??), <C-w>pè l'ultima finestra, <C-w>backspaceè spostare la finestra sinistra (ish)
puk

:help ctrl-wFTW ... fatti un favore e sforzati di provare queste cose per almeno 15 minuti!
sjas,

18

Modalità visiva

Come molte altre persone hanno detto, la modalità visiva è la risposta al tuo problema di copia / taglia e incolla. Vim ti dà 'v', 'V' e Cv. La minuscola 'v' in vim è essenzialmente la stessa del tasto Maiusc nel blocco note. La cosa bella è che non devi tenerlo premuto. È possibile utilizzare qualsiasi tecnica di movimento per navigare in modo efficiente fino al punto iniziale (o finale) della selezione. Quindi premi "v" e usa di nuovo tecniche di movimento efficienti per navigare all'altro capo della selezione. Quindi 'd' o 'y' ti consente di tagliare o copiare quella selezione.

Il vantaggio che la modalità visiva di vim ha sulla descrizione di Jim Dennis di tagliare / copiare / incollare in vi è che non è necessario ottenere la posizione esattamente corretta. A volte è più efficiente usare un movimento rapido per arrivare nelle vicinanze generali di dove vuoi andare e poi perfezionarlo con altri movimenti piuttosto che inventare un comando di movimento singolo più complesso che ti porti esattamente dove vuoi andare.

L'aspetto negativo di utilizzare ampiamente la modalità visiva in questo modo è che può diventare una stampella che usi tutto il tempo che ti impedisce di imparare nuovi comandi vi (m) che potrebbero permetterti di fare le cose in modo più efficiente. Tuttavia, se sei molto proattivo sull'apprendimento di nuovi aspetti di vi (m), probabilmente questo non ti influenzerà molto.

Ribadirò inoltre che le modalità della linea visiva e del blocco visivo offrono variazioni su questo stesso tema che possono essere molto potenti ... specialmente la modalità del blocco visivo.

Uso efficiente della tastiera

Sono anche in disaccordo con la tua affermazione che alternare le mani è il modo più veloce di usare la tastiera. Ha un elemento di verità in esso. Parlando in generale, l'uso ripetuto della stessa cosa è lento. Questo esempio più significativo di questo principio è che i tasti consecutivi digitati con lo stesso dito sono molto lenti. La tua affermazione probabilmente deriva dalla naturale tendenza a usare la s / dito / mano / trasformazione su questo modello. In una certa misura è corretto, ma all'estremità estremamente alta dello spettro di efficienza non è corretto.

Basta chiedere a qualsiasi pianista. Chiedi loro se è più veloce suonare una successione di poche note alternando le mani o usando le dita consecutive di una sola mano in sequenza. Il modo più veloce per digitare 4 sequenze di tasti non è alternare le mani, ma digitarle con 4 dita della stessa mano in ordine crescente o decrescente (chiamare "corsa"). Questo dovrebbe essere evidente dopo aver considerato questa possibilità.

Il problema più difficile è l'ottimizzazione per questo. È abbastanza facile da ottimizzare per la distanza assoluta sulla tastiera. Vim lo fa. È molto più difficile ottimizzare a livello di "run", ma vi (m) con il suo editing modale ti dà una possibilità in più di poterlo fare di qualsiasi approccio non modale (ahem, emacs) mai.

Su Emacs

Per evitare che i fanatici degli emacs trascurino completamente il mio intero post a causa dell'ultimo commento tra parentesi, sento di dover descrivere la radice della differenza tra emacs e vim religioni. Non ho mai parlato nelle guerre dell'editor e probabilmente non lo farò mai più, ma non ho mai sentito nessuno descrivere le differenze in questo modo, quindi eccolo qui. La differenza è il seguente compromesso:

Vim offre un'efficacia di modifica del testo grezzo senza eguali Emacs offre una capacità senza pari di personalizzare e programmare l'editor

I fanatici ciechi di Vim affermeranno che Vim ha un linguaggio di scripting. Ma è un linguaggio oscuro e ad hoc che è stato progettato per servire l'editor. Emacs ha Lisp! È stato detto abbastanza. Se non apprezzi il significato di quelle ultime due frasi o hai il desiderio di imparare abbastanza sulla programmazione funzionale e su Lisp per sviluppare quell'apprezzamento, allora dovresti usare vim.

Gli zeloti di emacs affermeranno che emacs ha la modalità vipera, e quindi è un superset di vim. Ma la modalità Viper non è standard. La mia comprensione è che la modalità Viper non è utilizzata dalla maggior parte degli utenti di emacs. Poiché non è l'impostazione predefinita, la maggior parte degli utenti di emacs probabilmente non sviluppa un vero apprezzamento per i vantaggi del paradigma modale.

Secondo me queste differenze sono ortogonali. Credo che i vantaggi di vim ed emacs, come ho affermato, siano entrambi validi. Ciò significa che l'editor definitivo non esiste ancora. Probabilmente è vero che emacs sarebbe la piattaforma più semplice su cui basare l'editor definitivo. Ma l'editing modale non è radicato nella mentalità di emacs. La comunità di emacs potrebbe spostarsi in quel modo in futuro, ma ciò non sembra molto probabile.

Quindi, se si desidera efficienza di modifica non elaborata, utilizzare vim. Se vuoi l'ambiente ideale per lo scripting e la programmazione, il tuo editor usa emacs. Se vuoi un po 'di entrambi con enfasi sulla programmabilità, usa emacs con la modalità Viper (o programma la tua modalità). Se vuoi il meglio di entrambi i mondi, sei sfortunato per ora.


17

Trascorri 30 minuti facendo il tutorial di vim (esegui vimtutor invece di vim nel terminale). Imparerai i movimenti di base e alcuni tasti, questo ti renderà almeno produttivo con vim come con l'editor di testo che hai usato prima. Dopodiché, leggi di nuovo la risposta di Jim Dennis :)


1
Questa è la prima cosa che ho pensato quando ho letto l'OP. È ovvio che il poster non ha mai eseguito questo; L'ho provato quando ho appreso vim due anni fa e mi ha cementato la superiorità di Vim rispetto a qualsiasi altro editor che ho usato (incluso, per me, Emacs poiché le combinazioni di tasti sono fastidiose da usare su un Mac) .
dash-tom-bang,

16

Qual è il modo in cui usi Vim che ti rende più produttivo rispetto a un editor contemporaneo?

Essere in grado di eseguire modifiche complesse e ripetitive con pochissime sequenze di tasti (spesso utilizzando macro ). Dai un'occhiata a VimGolf per assistere al potere di Vim!

Dopo oltre dieci anni di utilizzo quasi quotidiano, è difficile immaginare di utilizzare qualsiasi altro editor.


16

Utilizzare \covunque in una ricerca per ignorare il caso (ignorando le impostazioni di ignorecase o smartcase). Ad esempio, /\cfooo /foo\ccorrisponderà foo, Foo, fOO,FOO , etc.

Utilizzare \Covunque in una ricerca per forzare la corrispondenza dei casi. Ad esempio /\Cfooo /foo\Ccorrisponderà solo a foo.


16

Sono stato sorpreso di trovare nessuno menzionare il tmovimento. Lo uso spesso con elenchi di parametri sotto forma di dt,oyt,


2
o dfx, dFx, dtx, ytx, ecc. dove x è un carattere, +1
hhh

Sì! E non dimenticare ct (cambia in).
markle976,

16

Strano nessuno ha menzionato i tag. Scarica "exuberant ctags" e mettilo davanti alla pessima versione preinstallata che hai già nel tuo percorso di ricerca. Cd alla radice di qualunque cosa tu stia lavorando; ad esempio la distribuzione del kernel Android. Digita "ctags -R." per creare un indice dei file di origine in qualsiasi punto al di sotto della directory in un file denominato "tag". Questo contiene tutti i tag, nomatter la lingua né dove nella directory, in un file, quindi il lavoro multilingue è facile.

Quindi apri vim in quella cartella e leggi: help ctags per alcuni comandi. Alcuni ne uso spesso:

  • Posiziona il cursore su una chiamata del metodo e digita CTRL-] per passare alla definizione del metodo.

  • Digitare: ta name per passare alla definizione di name.


14

Rientro automatico:

gg(vai all'inizio del documento)
=(rientro!)
shift-g (vai alla fine del documento)

Avrai bisogno di 'filetype plug-in indent on' nel tuo .vimrcfile e probabilmente le impostazioni 'shiftwidth' ed 'expandtab' appropriate.


4
O semplicemente usa la funzione ": set ai" (auto-indent), che è stata in vi sin dall'inizio.
xcramps,

14

Hai chiesto scorciatoie produttive, ma penso che la tua vera domanda sia: vim ne vale la pena? La risposta a questa domanda StackOverflow è -> "Sì"

Devi aver notato due cose. Vim è potente e vim è difficile da imparare. Gran parte del suo potere sta nella sua espandibilità e infinita combinazione di comandi. Non sentirti sopraffatto. Vai piano. Un comando, un plugin alla volta. Non esagerare.

Tutto l'investimento che hai messo in vim ti ripagherà mille volte. Sarai all'interno di un editor di testo per molte, molte ore prima di morire. Vim sarà il tuo compagno.


13

Buffer multipli, e in particolare saltare velocemente tra loro per confrontare due file con :bpe :bn(correttamente rimappati in un singolo Shift+ po Shift+ n)

vimdiff modalità (si divide in due buffer verticali, con colori per mostrare le differenze)

Copia area con Ctrl+v

E infine, completamento della scheda degli identificativi (cerca "mosh_tab_or_complete"). Questo è un cambio di vita.


12

Concordato con il poster in alto : il : r! il comando è molto utile.

Molto spesso lo uso per "incollare" cose:

:r!cat
**Ctrl-V to paste from the OS clipboard**
^D

In questo modo non devo giocherellare :set paste.


3
Probabilmente è meglio impostare l' clipboardopzione su unnamed( set clipboard=unnamednel tuo .vimrc) per usare gli appunti di sistema di default. Oppure, se si vuole ancora il sistema degli appunti separati dal registro senza nome, utilizzare il registro appunti nome appropriato: "*p.
R. Martinho Fernandes,

2
Lo adoro! Dopo essere stato esasperato incollando esempi di codice dal web e stavo appena iniziando a sentirmi competente in vim. Questo era il comando che ho immaginato sul posto. Questo è stato quando vim mi ha completamente catturato.
kevpie,

Se stai sviluppando su un Mac, Command + C e Command + V copia e incolla utilizzando gli Appunti di sistema, non è necessario rimappare.
Ben Mordecai,

Solo con GVIm ... Dalla console, incollare senza :set pastenon funziona così bene se l'autoindent è abilitato.
David Wolever,
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.