Quali sono gli angoli bui di Vim la tua mamma non ti ha mai detto a riguardo?

Ci sono una pletora di domande dove la gente parla di trucchi comuni, in particolare “Vim+ctags consigli e trucchi“.

Tuttavia, non si riferiscono a comunemente usato scorciatoie che qualcuno di nuovo a Vim vorresti trovare fresco. Sto parlando di un esperto utente di Unix (siano essi di uno sviluppatore, amministratore, sia, etc.), che pensano di sapere qualcosa di 99% di noi mai sentito parlare o sognato. Qualcosa che non solo rende il loro lavoro più facile, ma è FRESCO e hackish. Dopo tutto, Vim risiede in più buie di un angolo ricco di OS del mondo, quindi dovrebbe avere complessità che solo pochi privilegiati conoscere e vuole condividere con noi.

  • Lancio un altro editor o comandi utilizzando !nomecomando
  • :Sesso Dividere la finestra e aprire il file explorer integrato (orizzontale)
  • Questa è la domanda che sembra essere abbastanza costruttivo – cercando il numero di upvotes… , ha deliberato di riaprire, forse alcuni ancora più interessante la risposta arriva – che può essere con voto positivo se utile, dando così più valore a SOF. Ordinare le risposte dai voti che ho imparato un sacco di cose interessanti in soli 5 minuti… davvero roba preziosa qui, perché chiudere qualcosa di così prezioso ? Come questo non è costruttivo ?
  • Ecco qualche oscuro consigli che mi vengono in mente: pastebin.com/BGGkBmVw
  • Ridicolo che la questione è chiusa. Parlare di “legalismo”.
  • Credo che questa domanda è molto costruttivo, ma, più adatto a Quora.
  • :Vex Dividere la finestra e aprire il file explorer integrato (divisione verticale)
  • Perché ci sono 2(come ora) voti per cancellare questa domanda? Cosa buona sarebbe possibile fare?
  • Invece di votare per cancellare, un “NOTA: Questa domanda NON è in-topic per Stack Overflow. Non chiedere domande simili in futuro.” dovrebbe essere sufficiente.

 

70 Replies
  1. 769

    Potrebbe non essere quello che il 99% di Vim utenti non conosciamo il nome, ma è qualcosa che uso quotidianamente e che qualsiasi Linux+Vim poweruser deve sapere.

    Comandi di base, ma estremamente utile.

    :w !sudo tee %
    

    Spesso dimentico di sudo prima di modificare un file che non ho i permessi di scrittura su. Quando mi vieni a salvare il file ed ottenere un permesso di errore, ho solo il problema che vim comando per salvare il file senza la necessità di salvare in un file temporaneo e poi copiarlo di nuovo.

    Ovviamente, hanno di essere su un sistema con installato sudo e sudo diritti.

    • Questa è la mia preferita po ‘ di vi voodo, giù le mani.
    • Grande comando, ho perso il conto del numero di volte che questo è successo a me da quando mi sono trasferito a Ubuntu da Slackware.
    • Non funziona con VIM per me. Dopo circa 2 secondi la richiesta di password e restituisce un errore. <pre> [sudo] password per l’utente: shell restituito 1 </pre>
    • questo può aiutare solo se si dispone già di un sudo, cioè ha fatto qualcosa nella sessione corrente.
    • Probabilmente, anche per meglio di esecuzione vim come root! Con voto positivo!
    • Ancora meglio, utilizzando sudoedit, in primo luogo. In caso contrario, mi piacerebbe usare “:w !sudo dd of=%” dal momento che non bombardare con il file che si sta salvando in fase di gatto a stdout.
    • Per un noob, che cosa fa esattamente tee fare? Qualcuno mente parseing questo comando per me?
    • tee crea una t-shirt svincolo in uscita. È possibile l’output sullo schermo, e un file, per esempio. Migliore di ricerca o google per una risposta più dettagliata. O chiedere una domanda!
    • Per la mappa x!! per scrivere sudo e smettere di usare: cmap x!! w !sudo tee %<CR><CR>:q!<CR>
    • cmap w!! w !sudo tee %
    • Non si dovrebbe mai eseguire sudo vim. Invece si dovrebbe esportare EDITOR come vim ed eseguire sudoedit.
    • Sono un principiante vim utente e anche io non so questo comando, penso che sia un comando comune.Il suo un top rated comando commandlinefu
    • Qualcuno può per favore spiegare % dopo il tee?
    • vim sostituisce % da il nome del buffer corrente/file.
    • wow, grazie per il link a commandlinefu.com ; che Cosa un fantastico sito!
    • Correlate: Come salvare un file per il quale non ho i permessi di scrittura? a Vim SE
    • Controllare spiegazione qui!

  2. 605

    Qualcosa che ho scoperto solo di recente che ho pensato è stata molto cool:

    :earlier 15m
    

    Torna il documento torna a come era 15 minuti fa. Possono prendere vari argomenti, per la quantità di tempo che si desidera ripristinare e dipende undolevels. Può essere invertito con il comando opposto :later

    • Come forzare funziona dopo :modificare di nuovo il file?
    • Se si annulla e quindi apportare ulteriori modifiche dal disciolto stato, si perde rifare la storia. Questo consente di tornare ad uno stato che non è più in stack di annullamento.
    • Anche molto utile è g+ e g – per andare indietro e avanti nel tempo. Questo è tanto più potente di un undo/redo stack poiché non perdere la storia, e quando si fa qualcosa dopo un annullamento.
    • Non perdere l’rifare la storia se si apporta una modifica dopo un annullamento. Non è facilmente accessibile. Ci sono plugin per visualizzare questo, come Gundo.vim
    • Wow, così ora posso solo fare :later 8h e ho finito per oggi? 😛
    • Il comando presuppone una volontà di dedicare almeno 15 minuti in vim!
    • Correlate: Come posso tranquillamente annullare le modifiche che mi può o non può aver fatto? a Vim SE
    • undofile

  3. 404

    :! [command] esegue un comando esterno, mentre sei in Vim.

    Ma aggiungere un punto dopo i due punti, :.! [command], e scaricare l’output del comando nella finestra corrente. Che : . !

    Per esempio:

    :.! ls
    

    Io uso un sacco di cose come aggiungere la data corrente in un documento che sto scrivendo:

    :.! date
    
    • Un altro comando — non voglio aprire un nuovo reply: Se si dispone di una finestra divisa (:sp [nome file] o :vert split [filename) è possibile scambiare i vetri della finestra con ^w r
    • Questo è molto simile a :r! L’unica differenza per quanto mi riguarda posso dire è che :r! si apre una nuova linea, :.! sovrascrive l’attuale linea.
    • Questo è così cool. Grazie!
    • Grazie… @saffsd: Che differenza solo è una grande cosa: Ora posso passare le linee di sed o awk e lo hanno sostituito con i trattati di uscita…
    • Un’alternativa per :.!date è quello di scrivere “date”: “in una riga e quindi eseguire !$sh (in alternativa, avere il comando, seguito da una riga vuota, ed eseguire !jsh). Questo tubo di linea per la “sh” shell e sostituire con l’output del comando.
    • :.! è in realtà un caso particolare di :{range}!, che filtra una serie di righe (l’attuale linea quando l’intervallo è .) tramite un comando e sostituisce quelle linee con l’uscita. Trovo :%! utile per filtrare tutto il buffer.
    • Perché passare una linea per sed, quando è possibile utilizzare il simile built-in ed/ex comandi? Provare a eseguire :.s/old/new/g 😉
    • E, inoltre, che ‘!’ è come ‘y’, ‘d’, ‘c’, etc. per esempio, si può fare: !!, numero!!!!, !il movimento (ad esempio !Gshell_command<cr> sostituire l’attuale linea alla fine del file (‘G’) con uscita di shell_command).
    • Correlate: l’immagine di output dal comando esterno in editor? a Vim SE
    • Lo sapevate che è possibile fare doppio bang (!!) per compilare automaticamente il :.!? Molto utile quando non ti va di scrivere tutto ciò che fuori. Funziona anche in vim -u none

  4. 309

    Non esattamente oscuro, ma ci sono diversi “eliminare” i comandi che sono estremamente utili, come..

    • diw per eliminare la parola corrente
    • di( per eliminare entro il corrente parens
    • di" per eliminare il testo tra le virgolette

    Altri possono essere trovate sul :testo guida-oggetti

    • Sapevo che il primo 🙂
    • di( cancella il contenuto all’interno delle parentesi quadre. Come è possibile eliminare solo le staffe? Ti ricordo che è possibile anche questo.
    • jholloway7: Grazie, detto che la pagina di aiuto e legato al testo-oggetti vim docs. Masi: Non è sicuro, daw eliminare le parentesi quadre+contenuti, il comando più vicino che posso pensare è xf)x (eliminare staffa, salta al successivo ) e cancellare di nuovo)
    • dab “eliminare arounb staffe”, daB per circa parentesi graffe, t per il tipo xml i tag, le combinazioni con i normali comandi sono come previsto cib/yaB/dit/partita iva ecc
    • yi(va(p cancella solo le staffe
    • Questo è forse il motivo più grande per me stare con Vim. Che e il suo equivalente “cambiare” comandi: ciw , ci( , ci” , così come dt<spazio> e ct<spazio>
    • Perché non dW/cW invece di dt<spazio>?
    • Con il surround plugin: ds(.
    • Wow! questi sono impressionanti!
    • +1 per diw, mai si è verificato a me di usare i/a su parole, usato solo per (), <>, {} fino ad ora. ^^

  5. 235

    de Cancellare tutto, fino alla fine della parola premendo . al desiderio del vostro cuore.

    ci(xyz[Esc] — Questo è uno strano. Qui, l ‘” io ” non significa che la modalità di inserimento. Invece significa che all’interno della parentesi. Quindi questa sequenza di tagli il testo all’interno di parentesi si sta in piedi e si sostituisce con “xyz”. Funziona anche all’interno di piazza e la figura parentesi quadre — basta che non ci[ o ci{ corrispondentemente. Naturalmente, si può fare di (se si desidera solo per eliminare tutto il testo senza digitare nulla. Si può anche fare a invece di i se si desidera eliminare le parentesi, come bene e non solo con il testo al loro interno.

    ci” – tagli il testo quotazioni attuali

    ciw – tagli la parola corrente. Questo funziona esattamente come quello precedente tranne che ( è sostituito con w.

    C – tagliare il resto della linea e passa alla modalità di inserimento.

    ZZ — salvare e chiudere il file corrente (MODO più veloce Ctrl + F4 per chiudere la scheda corrente!)

    ddp – spostare attuale linea di una riga verso il basso

    xp — spostare attuale carattere di una posizione a destra

    U maiuscole, così viwU upercases la parola

    ~ – interruttori di caso, in modo da viw~ invertire la carcassa di tutta la parola

    Ctrl+u Ctrl+d scorrere la pagina a metà-un-schermo in alto o in basso. Questo sembra essere più utile del solito a tutto schermo di paging in quanto rende più facile vedere come i due schermi si riferiscono. Per chi vuole ancora di scorrimento a schermo intero a una volta che c’è Ctrl+f per la marcia Avanti e Ctrl+b per Indietro. Ctrl+Y Ctrl+E scorrere verso il basso o in alto di una riga alla volta.

    Pazzo, ma è molto utile comando zz — si scorre lo schermo per rendere questa linea vengono visualizzati al centro. Questo è eccellente per mettere il pezzo di codice che si sta lavorando nel centro della vostra attenzione. Fratello comandi — zt e zb — rendono questa linea l’alto o il basso sullo schermo che non è molto utile.

    % trova e salti per la corrispondente parentesi.

    de — cancella dal cursore alla fine della parola (si può anche fare dE per eliminare fino al successivo spazio)

    bde — eliminare la parola corrente, da sinistra a destra delimitatore

    df[spazio] — delete fino e compreso il successivo spazio

    dt. — elimina fino al prossimo dot

    dd — eliminare questa intera linea

    voi (o voi) — inserisce il testo da qui alla fine della parola

    ce – tagli fino alla fine della parola

    bye — copie corrente di word (mi domando che cosa è “ciao” fa!)

    aa — copia la riga corrente

    cc — taglia la corrente di linea, si può anche fare S invece. C’è anche inferiore cap s che i tagli di carattere corrente e passa alla modalità di inserimento.

    viwy o viwc. Yank o cambiare la parola corrente. Hit w più volte per mantenere la selezione di ogni successiva word, utilizzare b per spostare indietro

    vi{ – selezionare tutto il testo nella figura staffe. va{ – selezionare tutto il testo, tra cui {}s

    vi(p – evidenziare tutto all’interno della (e)s e sostituire con il testo incollato

    b e e spostare il cursore di parola, allo stesso modo di come Ctrl+Frecce normalmente. La definizione della parola è un po ‘ diverso, però, come una serie consecutiva di delmiters sono considerate come un’unica parola. Se si inizia a mezzo di una parola, la pressione di b sarà sempre all’inizio della parola corrente, e ogni consecutivi b si salta all’inizio della parola successiva. Allo stesso modo, e facile da ricordare, e ottiene il cursore alla fine della corrente, e di ogni successiva, parola.

    simili a b/e, capitale B e E spostare il cursore di parola utilizzando solo spazi come delimitatori.

    capitale D (prendere un respiro profondo) Elimina il resto della riga a destra del cursore, come Maiusc+Fine/Del normale editor (avviso 2 tasti — Shift+D — invece di 3)

    • zt è molto utile se si utilizza all’inizio di una funzione o di una definizione di classe.
    • vity e vitc può essere ridotto a yit e cit rispettivamente.
    • viwy potrebbe anche essere yiw. viwc potrebbe anche essere ciw. Ma vi… probabilmente è più facile da ricordare perché si utilizza in un sacco di casi.
    • C’è anche la “H” per portare il cursore sulla riga superiore del display, “M” per prendere per il medio, e “L” per metterlo su quello inferiore. Da non confondere con il “gg” e “G”, che porterà per la parte superiore o inferiore del buffer.
    • Tutte le cose che si chiama “taglio” è “cambiamento”. ad esempio: C è cambiare fino alla fine della riga. Vim equivalente di “taglio” è “eliminare”, fatto con d/D. La differenza principale tra la modifica e la cancellazione è che elimina foglie in modalità normale, ma il cambiamento si mette in una sorta di modalità di inserimento (se siete ancora in comando modifica che è utile in quanto l’intero cambio può essere ripetuto con .).
    • inoltre, zt e zb diventare proprio come indispensabili come zz con un’impostazione di scrolloff=2
    • Ho pensato che questo era per un elenco di cose che non molte persone conoscono. yy è molto comune, avrei pensato.
    • bye non funziona quando si è in primo carattere della parola. yiw fa sempre.
    • Direi che la maggior parte di questi non sono in angoli bui, ogni vim utente dovrebbe sapere che la maggior parte di questi comandi di base.
    • se C non yank così. E ‘ fondamentalmente lo stesso come d* poi i. Inoltre, l’aiuto non chiamare in modo esplicito che “il cambiamento” – è quella ufficiale?
    • Sì, conosco il c operatore copia il testo di registro prima di eliminare. Come ho detto “La differenza principale tra la modifica e la cancellazione è che elimina foglie in modalità normale, ma il cambiamento si mette in una sorta di modalità di inserimento (se siete ancora in comando modifica che è utile in quanto tutto il cambiamento può essere ripetuto .)” In realtà, un’altra differenza è che cosa succede se si ha la $ bandiera in cpoptions abilitato. “Change” è il mnemonico ho imparato da vi, e sembra essere piuttosto comune. Vedere stackoverflow.com/questions/7409134/…
    • Guardando indietro a questa risposta, di un elenco di una combinazione casuale di operatori e di movimento, oggetto di comandi è difficilmente “angoli bui” di vim. Se pensate di questi singoli comandi, quindi si sta facendo male. c, d, y e v sono gli operatori. e, w, t, f sono movimenti. i(, ip, iw, ho”, e lo stesso con un invece mi sono oggetti. (Questi sono tutti i sottoinsiemi di ciò che vim offre in realtà, sto solo menzionare quelle che appaiono in questa risposta) Combinano un operatore con una mozione o di un oggetto (o autonomo, escluso v) per creare un comando. Da solo quelli che ho elencato si possono fare più di 50 comandi.
    • Migliore di sempre consigli ho visto
    • Vorrei dare un voto positivo per ZZ da solo, ma il resto è quasi angolo buio.
    • Solo per la cronaca, si può fare cw (cambia parola) invece di ciw.
    • Mi piace davvero molto questo, perché avete elencato così posso leggere e provare e ripetere
    • Impressionante Grazie

  6. 200

    Uno che raramente trovano nella maggior parte Vim tutorial, ma è INCREDIBILMENTE utile (almeno per me), è il

    g; and g,

    al movimento (avanti, indietro) attraverso la changelist.

    Mi permetta di mostrare come lo utilizzo. A volte ho bisogno di copiare e incollare un pezzo di codice o di una stringa, dire un colore hex codice in un file CSS, così ho ricerca, saltare (non importa dove la partita è), copiarlo e poi tornare (g,) per cui stavo modificando il codice, infine, incolla. Non c’è bisogno di creare marchi. Più semplice.

    Solo i miei 2cents un.

    • allo stesso modo, '. andrà all’ultima riga modificata, E `. andrà alla ultima modifica di posizione
    • Ctrl + O e Ctrl + I (scheda) funzionano in modo simile, ma non uguale. Si muovono avanti e indietro, in “jump list”, che è possibile visualizzare da fare :salti o :ju Per ulteriori informazioni fare un :aiuto jumplist
    • È possibile elencare l’elenco dei cambiamenti da fare :modifiche
    • Caldo dang che utile. Io uso <C-o>/<C-i> per questo per tutto il tempo – o la marcatura mio posto.
  7. 184
    :%!xxd
    

    Vim in un hex editor.

    :%!xxd -r
    

    Ripristinare.

    Avvertenza: Se non si modifica con binario (-b), si potrebbe danneggiare il file. – Josh Lee nei commenti.

    • E come si fa a tornare indietro?
    • :!xxd -r //tornare da ESADECIMALE
    • Io in realtà penso che sia :%!xxd -r per tornare indietro
    • Se si è attenti a non attraversare i ritorni a capo, è sicuro di non usare l’opzione-b? Lo chiedo perchè a volte voglio fare un hex cambiare, ma non voglio chiudere e riaprire il file per farlo.
    • Se non si desidera chiudere/riaprire il file che si può fare :set di binari
    • Correlate: Come modificare i file binari con Vim? a Vim SE
    • Non riesco mai a ottenere xxd -r per ripristinare correttamente. Ogni volta che lo faccio, danneggia il binario e il 99% dei file mancanti. Sto indovinando che è a causa di un NUL byte che appare da qualche parte, e le stringhe null-terminated. Questo succede anche se ho impostato il binario e noeol dall’interno di vim. Così, grazie @JoshLee per il vim -b suggerimento, ma io ancora non fidarti di :%!xxd -r.

  8. 118

    A volte da una impostazione .vimrc otterrà sostituiti da un plugin o autocommand. Per il debug di questo trucchetto è quello di utilizzare l’ :verbose in collaborazione con :set. Per esempio, per capire dove cindent ha set/unset:

    :verbose set cindent?
    

    Questo risultato sarà qualcosa di simile:

    cindent
        Last set from /usr/share/vim/vim71/indent/c.vim
    

    Questo funziona anche con le mappe e le luci. (Grazie joeytwiddle per la precisazione.) Per esempio:

    :verbose nmap U
    n  U             <C-R>
            Last set from ~/.vimrc
    
    :verbose highlight Normal
    Normal         xxx guifg=#dddddd guibg=#111111 font=Inconsolata Medium 14
            Last set from ~/src/vim-holodark/colors/holodark.vim
    
    • Ottimo suggerimento – esattamente quello che stavo cercando oggi.
    • Ottimo suggerimento uomo! Come fai a conoscere questi geek cose?
    • :verbose può essere utilizzato anche prima di nmap l o highlight Normal per scoprire dove il l tastiera o il Normal evidenziare l’ultimo sono stati definiti. Molto utile per il debug!
    • Grazie! Ho aggiunto che info per la risposta.
    • Durante la creazione di custom mapping, questo verrà salvato il culo tante volte, probabilmente uno di quelli più utili qui (IMO)!
  9. 98

    Non so se questo conta come dark-angolo-ish, ma ho appena imparato…

    :g/match/y A
    

    si copia (copia) tutte le righe che contengono “match” in "a/@a registro. (La capitalizzazione A fa vim aggiungere yankings invece di sostituire il precedente registro contenuto.) Ho usato un sacco di recente, quando Internet Explorer fogli di stile.

    • conta, conta come non ho visto questo 🙂
    • Una bella. Mai sentito parlare… Potrebbe essere utile 😛
    • È possibile utilizzare :g! per trovare le righe che non corrispondono a un modello e.x. :g!/set/normale dd (cancellare tutte le linee che non contengono set)
    • A volte è meglio fare ciò che tsukimi detto e basta filtrare le righe che non corrispondono il vostro modello. Una versione abbreviata di questo comando però: :v/PATTERN/d Spiegazione: :v è un’abbreviazione per :g!, e il :g comando si applica a qualsiasi comando ex di linee. :y[ank] opere e così non :normal, ma qui la cosa più naturale da fare è solo :d[elete].
    • Si può anche fare :g/match/normal "Ayy — il normal parola chiave consente di dirgli di eseguire le normali modalità comandi (che si sono probabilmente più familiarità con).
  10. 91

    Desidera guardare a :comando di storia?

    q:
    

    Poi sfogliare, modificare e, infine, per eseguire il comando.

    Mai fare modifiche simili a due file e passare avanti e indietro tra di loro? (Dire, di origine e file di intestazione?)

    :set hidden
    :map <TAB> :e#<CR>
    

    Quindi la scheda avanti e indietro tra questi file.

    • Mi ha colpito q: per caso per tutto il tempo…
    • In alternativa, dall’ex editor (:), si può fare CTRL-f per visualizzare la cronologia dei comandi finestra.
    • anche a me. Ho quasi odio questo comando, solo perché io lo uso accidentalmente in modo troppo.
    • q/ e q? può essere usato per fare una cosa simile per la tua ricerca di modelli.
    • Colpire <C-f> dopo : o / (o ogni volta che sei in modalità di comando) per richiamare la stessa storia di menu. Così si può rimappare q: se si preme accidentalmente un sacco e ancora accedere a questo fantastico modalità.
    • la scheda è davvero utile 😀
    • Non avevo idea di cosa stava tirando su quella finestra. Finalmente ho capito!
    • per la seconda punta, c’è <C-^> che passa tra gli ultimi due buffer, quindi tutto quello che ho è di rimappare la chiave su <tab>. E se si sta modificando un file C/C++, potrai passare intestazione. Per ulteriori informazioni, :help alternate
    • vedere :help cmdwin

  11. 79

    Vim aprire un URL, ad esempio

    vim http://stackoverflow.com/
    

    Bello quando hai bisogno di tirare su il sorgente di una pagina di riferimento.

    • Per me non open source, invece, a quanto pare utilizzato elinks per eseguire il dump pagina renderizzata in un buffer e poi aperto.
    • non c’è errore quando viene eseguito questo comando
    • Funziona meglio con una barra alla fine. Trucchetto!
    • Sarebbe utile se avete inviato il vostro errore. Se è questo: “errore (netrw) né il wget né il comando fetch è disponibile” ovviamente c’è bisogno di fare uno di quegli strumenti disponibili dalla variabile di ambiente PATH.
    • Trovo che questo sia particolarmente utile quando la gente inviare il link ad una pasta di servizio e si è dimenticato di selezionare una evidenziazione della sintassi, io di solito basta aprire il link in vim dopo l’aggiunta di “&raw”.
  12. 68

    Le macro possono chiamare altre macro, e può anche chiamare se stesso.

    ad esempio:

    [email protected]@q
    

    …elimina la prima parola di ogni riga fino alla fine del file.

    Questo è un semplice esempio, ma si dimostra un potente funzionalità di vim

    • Non sapevo macro in grado di ripetere se stessi. Cool. Nota: qx avvia la registrazione nel registro x (usa qq per registrare q). 0 si sposta all’inizio della riga. dw delets una parola. j si sposta in basso di una riga. @q per eseguire la macro di nuovo (la definizione di un ciclo). Ma si è dimenticato di terminare la registrazione con un finale “q”, poi effettivamente eseguire la macro digitando @q.
    • Penso che sia intenzionale, come nidificati e ricorsiva macro.
    • qqqqqifuu<Esc>[email protected]@q
    • Un altro modo per ottenerlo è quello di registrare una macro a registrare un che fa un po ‘ la trasformazione di una singola linea, quindi linewise evidenziare un gruppo di righe con il V e il tipo di :normal! @a per applyyour macro per ogni riga nella selezione.
    • Ho trovato questo post su google ricorsiva VIM macro. Non ho trovato nessun modo per interrompere la macro altro che uccidere il processo VIM.
    • ricorsiva macro fine quando hanno letto la fine del file. ctrl D è una scorciatoia per iniettare questo è la maggior parte dei programmi.
    • Ho usato le macro per oltre 20 anni e mai saputo di questo risparmio di tempo festure. Mi chiedo se è supportato in originale SysV versione di se stesso o un’estensione di Vim.
    • Macro di essere utilizzato in modo ricorsivo è sicuramente una scelta di design, e continueranno a farlo fino a quando hanno colpito la fine del buffer. Se la macro è ricorsiva e bloccato in un ciclo infinito, premere ctrl+c per interrompere piuttosto che uccidere il vostro intero processo vim.

  13. 55

    Supponendo di avere Perl e/o Ruby compilato con il supporto, :rubydo e :perldo per l’esecuzione di un Rubino o Perl one-liner su ogni riga in un intervallo (di default intero buffer), con $_ legato al testo della riga corrente (meno il carattere di nuova riga). La manipolazione $_ cambierà il testo della riga.

    È possibile utilizzare questo per fare certe cose che sono facili da fare, in un linguaggio di scripting, ma non in modo evidente con Vim builtins. Per esempio per invertire l’ordine delle parole in una riga:

    :perldo $_ = join ' ', reverse split
    

    Per inserire una stringa casuale di 8 caratteri (A-Z) alla fine di ogni riga:

    :rubydo $_ += ' ' + (1..8).collect{('A'..'Z').to_a[rand 26]}.join
    

    Si sono limitati ad agire su una riga alla volta e non è possibile aggiungere i ritorni a capo.

    • cosa succede se voglio solo perldo per l’esecuzione di una determinata linea? o di un paio di righe?
    • Si può dare un intervallo come un qualsiasi altro comando. Per esempio :1,5 perldo solo operare su linee 1-5.
    • Si potrebbe fare $_ += ‘\nNEWLINE!!!’ per ottenere un a capo dopo la corrente?
    • Purtroppo, si aggiunge solo un funky di controllo caratteri di fine riga. È quindi possibile utilizzare un Vim cerca/sostituisci per modificare tutti quei caratteri di controllo reale a capo, però.
    • o mio dio questa è la cosa più bella
    • Allo stesso modo, pydo e py3do di lavoro per python se si dispone di richiesta compilato con il supporto.
    • Inoltre luado per Lua, se avete compilato con il supporto per
    • ruby ruby dooooo…ruby ruby doooo. Cantare come Megan Draper https://www.youtube.com/watch?v=DKol_ThaMWc

  14. 54

    ^O e ^I

    Andare per anziani/nuova posizione.
    Quando si spostano attraverso il file (ricerca, spostando i comandi etc.) vim rammemorare questi “salti”, in modo da poter ripetere questi salti all’indietro (^O – O per i vecchi) e in avanti (^ho fatto io sulla tastiera). Io trovo molto utile durante la scrittura del codice e l’esecuzione di un sacco di ricerche.

    gi

    Andare alla posizione in cui la modalità di Inserimento è stato arrestato lo scorso.
    Mi trovo spesso a modifica e quindi alla ricerca di qualcosa. Per tornare a modificare posto premere gi.

    gf

    posizionare il cursore sul nome del file (ad esempio, includere il file di intestazione), premere il gf e il file viene aperto

    gF

    simili a gf, ma riconosce il formato “[file] nome:[numero di linea]”. Premendo gF sarà aperto [nome file] e impostare il cursore su [numero di riga].

    ^P e ^N

    Completamento automatico del testo durante l’editing (^P – partita precedente e ^N prossima partita)

    ^X^L

    Durante la modifica completa della stessa linea (utile per la programmazione).
    È possibile scrivere il codice e poi ti ricordo che è lo stesso codice da qualche parte nel file. Basta premere ^X^L e la linea completa completato

    ^X^F

    Nomi di file completi.
    Tu scrivi “/etc/pass” Hmm. Hai dimenticato il nome del file. Basta premere ^X^F e il nome del file è completato

    ^Z o :sh

    Spostamento temporaneo per la shell. Se avete bisogno di un rapido bashing:

    • premere ^Z (mettere in vi in background) per tornare alla shell originale e premete fg per tornare a vim indietro
    • stampa :sh per andare di sotto-shell e premere ^D/exit per tornare alla vi torna
    • Con ^X^F il mio cruccio è che i nomi di file includono = segni, rendendo fare marcio cose in molte occasioni (ini file makefile, ecc). Io uso se isfname-== alla fine che fastidio
    • +1 il built-in di completamento automatico è appena seduto lì in attesa di essere scoperto.
  15. 47

    Questo è un bel trucco per riaprire il file corrente con una codifica diversa:

    :e ++enc=cp1250 %:p
    

    Utile quando si deve lavorare con i precedenti codifiche. Le codifiche supportate sono elencati in una tabella sotto encoding-values (vedi help encoding-values). Una cosa simile funziona anche per ++ff, in modo che è possibile riaprire il file con Windows/Unix linea termina se si sbaglia, per la prima volta (vedi help ff).

    • Non ha mai avuto a utilizzare questo tipo di cosa, ma ci sarà certamente aggiungere al mio arsenale di trucchi…
    • ottimo suggerimento, grazie. Per i punti bonus, aggiungere un elenco di comuni valido codifiche.
    • Ho usato questo oggi, ma penso che non ho bisogno di specificare “%:p”; basta aprire il file e di :e ++enc=cp1250 era più che sufficiente. Io
    • sarebbe :codifica del set=cp1250, hanno lo stesso effetto?
    • no, ‘encoding’ opzione definisce la codifica che Vim utilizza per memorizzare tutti i propri dati interni, come testo nel buffer, registri, etc. ‘fileencoding’ definisce la codifica del buffer corrente. Ma se si imposta “fenc’ dopo l’apertura di un file, Vim convertire il file dalla corrente di codifica per il nuovo. Così, l’unico modo per aprire il file utilizzando la codifica specifica è quello di utilizzare ++enc opzione.
    • `:e +b %’ allo stesso modo è utile per la riapertura in modalità binaria (non munging di ritorni a capo)

  16. 47
    " insert range ip's
    "
    "          ( O O )
    " =======oOO=(_)==OOo======
    
    :for i in range(1,255) | .put='10.0.0.'.i | endfor
    
    • Non vedo che questo è un bene per (oltre a guardare come una battuta di risposta). Può chiunque altro che mi illumini?
    • aprire vim e poi fare “:for i in range(1,255) | .mettere=’10.0.0.’.i | endfor”
    • riempimento /etc/hosts forse
    • Questa è una formidabile risposta. Non la parte sulla creazione di indirizzi IP, ma il bit che implica che VIM possibile utilizzare per loop di comandi.
    • Senza ex-modalità: i10.0.0.1<Esc>Y254p$<C-v>}g<C-a>
    • l’ultimo g dovrebbe essere G (vai all’ultima riga)? <C-a> solo l’incremento di uno, così vi ritroverete con 10.0.0.1 sulla prima riga, e 10.0.0.2 sul prossimo 254 linee.
    • va all’ultimo carattere ultima riga, invece di G che va al primo carattere all’ultima riga. g<C-a> è una gamma di incremento – incrementa la prima riga di 1, il prossimo 2 e così via..
    • ah, ho perso il }, mi dispiace. :help v_g_CTRL-A mostra il aiutare per incrementare di oltre. Grazie per la spiegazione!

  17. 46

    Digitando == correggere il rientro dell’attuale linea basata sulla linea di cui sopra.

    In realtà, si può fare un segno = seguito da un comando di movimento. ={movimento}

    Per esempio, è possibile utilizzare la % di movimento che si muove tra la corrispondenza tra parentesi graffe. Posizionare il cursore sull’ { nel codice seguente:

    if (thisA == that) {
    //not indented
    if (some == other) {
    x = y;
    }
    }
    

    E premere =% per ottenere subito questo:

    if (thisA == that) {
        //not indented
        if (some == other) {
            x = y;
        }
    }
    

    In alternativa, si potrebbe fare =a{ all’interno del blocco di codice, invece di posizionarsi a destra il { carattere.

    • Hm, non sapevo di questo circa il rientro.
    • Non c’è bisogno, di solito, per essere esattamente le parentesi graffe. Il pensiero spesso mi basta =} o vaBaB= perché è meno dipendente. Inoltre, v}}:!astyle -bj corrisponde il mio codice stile migliore, ma posso tornare indietro nel vostro stile con un semplice %!astyle -aj
    • gg=G è molto pulito, quando si incolla in qualcosa.
    • Correlate: Re-rientro male il codice indentato a Vim SE
    • Oh, io ho fatto come ggVG=.
  18. 41
    imap jj <esc>
    
    • questo cosa comporta?
    • Sarà uscire dalla modalità di modifica quando si preme il tasto “jj”
    • come sarà il tipo jj quindi? 😛
    • Come spesso è di tipo jj? In inglese almeno?
    • È possibile digitare lentamente, troppo, e funziona. Eccellente suggerimento.
    • Non posso vivere senza il jj di mappatura. Ho tipo il mio jjs con j<C-v>j
    • Ho rimappato capslock per esc invece, in quanto è un inutile chiave. La mia mappatura è stata OS ampia, però, così si ha il vantaggio di non doversi preoccupare di colpire accidentalmente esso. L’unico inconveniente È la SUA più DIFFICILE DI URLARE ALLA GENTE. 🙂
    • sicuramente, capslock è la morte. “aspetta, wtf? oh, che era ZZ?….merda.”
    • facile, da inserire in modalità jhjjrja
    • che non è davvero un problema, basta vim "+'0" (uso undofile e viminfo per aggiunto bonus). Ora, ZQ è essere un incidente, ma non è così probabile che accada per caso
    • Non sono sicuro di come molte persone mai proprio codice di matlab in Vim, ma ii e jj sono comunemente usati per contrastare le variabili, perché i e j sono riservati per i numeri complessi.
    • Io uso jk per uscire 🙂
    • Ho usato control-c per uscire dalla modalità di inserimento, l’unico vincolare è che non posso utilizzare control-c dopo che ho inserito il testo in Visual modalità di blocco. Ho bisogno di utilizzare esc per questo caso.
    • Ho quasi la stessa mappatura: imap kj <esc> io lo trovo più veloce di jj e più naturale di jk probabilmente perché ho più forza nel mio dito medio. Il modello dito medio, poi il dito indice è più semplice. Questo semplice mapping è uno dei miei preferiti finora.
    • Il migliore è: inoremap <c-i> <ESC><ESC>
    • Mentre <esc> è davvero male, ho trovato ctrl-[ abbastanza comodo non guardare per le sostituzioni. Sentivo un po ‘ strano in un primo momento, ma ora è una seconda natura.
    • jk – una volta che si va jk, non uso altro. Ho Shift+Space per attivare la modalità di inserimento, a livello di sistema di tappi di esc, jj e built-in C-[. Ma jk li batte tutti. Ho letto in vim wikia, ma ignorato, perché non sarei in grado di scrivere jk! E ‘ passato del tempo da allora e non l’ha mai avuto bisogno di scrivere jk letteralmente. Dovrebbe essere un vim default 🙂 imap jk <ESC> vmap jk <ESC> (uscita di visual mode!)
    • non sono il tipo jj. Ctrl-c è la modalità normale.. In effetti questo è il modo più veloce per la modalità di commutazione e di sicurezza così pochi a farlo.
    • Sono d’accordo con @freeo che jk è meglio. Mi trovo spesso solo facendo jkjkjkjk più e più ora, mentre il pensiero. Non avvitare la posizione del cursore, e mi permette di sapere cosa/finestra riquadro sto sul. Ho mappato jk e kj di fuga. Per me, jj è inferiore perché il cursore è quindi 2 linee di basso.
    • rimappato capslock per esc invece, in quanto è un inutile chiave.” È anche un bastardo di un tasto. Quante volte hai provato ad usare vim senza sapere caps lock era? Tenta di colpire u e lo fa merda strano che U fa. Provare a spostare a destra e si va a fondo pagina. E pasticci con voi fino a quando si tenta di inserire con i, che porta all’inizio della riga, anziché a dove ti trovi, e poi IL testo digitato VIENE FUORI COME QUESTO. C’è un altro motivo per ri – o onu-mappa caps lock.

  19. 37

    Vediamo qualche graziosa IDE editor colonna di recepimento.

    :%s/\(.*\)^I\(.*\)/\2^I\1/
    

    Spiegazione

    \( e \) è come ricordare roba in regex-terra. E \1, \2 ecc è come recuperare il ricordato roba.

    >>> \(.*\)^I\(.*\)
    

    Ricordare tutto seguito da ^I (scheda) seguita da tutto.

    >>> \2^I\1
    

    Sostituire le cose di cui sopra con “2 ° la roba che hai ricordato”, seguito da “1 ° la roba che hai ricordato” – essenzialmente facendo una trasposizione.

    • Che cosa fa esattamente?
    • Passa una coppia di colonne separato da tabulazione (separatore arbitrario, è tutto regex) con a vicenda.
    • I ^I è pensato per essere una scheda, per inciso.
    • Questa è solo una regex; un sacco di Ide hanno regex di ricerca e sostituzione.
    • Si tratta di quanto è buono il motore regex nell’IDE. Vim espressioni regolari sono abbastanza potenti; gli altri.. non tanto a volte.
    • Questo è un grande trucco!
    • Il * è avido, così questa regex presuppone che si hanno solo due colonne. Se si desidera essere nongreedy utilizzare { – } invece di * (vedi :aiutare i non-greedy per ulteriori informazioni su {} moltiplicatore)
    • Se tutti si desidera fare è la colonna di recepimento, quindi non avete bisogno di un potente motore regex. Solo dicendo.
    • Di corso. Ma non ho mai trovato che per essere tutto quello che volevo. 🙂
    • Questo è in realtà una semplice espressione regolare, è solo la fuga del gruppo, tra parentesi, che la fa sembrare complicato.

  20. 30

    Non è esattamente un segreto oscuro, ma mi piace mettere la seguente mappatura in mio .file vimrc, così posso colpire “-” (meno) in qualsiasi momento per aprire il file explorer per visualizzare i file adiacente a quella che ho appena modificare. In esplora file, posso colpire un altro “-” per passare alla directory, fornire una perfetta navigazione di un complesso di strutture di directory (come quelli usati dai MVC framework di oggi):

    map - :Explore<cr>
    

    Questi possono essere anche utili per qualcuno. Mi piace scorrere lo schermo e spostare il cursore al tempo stesso:

    map <c-j> j<c-e>
    map <c-k> k<c-y>
    

    Scheda di navigazione in – amore di schede e ho bisogno di spostarsi facilmente tra di loro:

    map <c-l> :tabnext<enter>
    map <c-h> :tabprevious<enter>
    

    Solo su Mac OS X: Safari-come scheda di navigazione:

    map <S-D-Right> :tabnext<cr>
    map <S-D-Left> :tabprevious<cr>
    
    • È anche possibile sfogliare i file all’interno di Vim, usando :Esplorare
    • Ciao Romano, questo è esattamente ciò che questa mappatura, ma assegna a un “hot key”. 🙂
  21. 27

    Mi piace usare “sudo bash’, e il mio sysadmin odiano per questo. Ha bloccato ‘sudo’, quindi può essere utilizzato solo con una manciata di comandi (ls, chmod, chown, vi, ecc), ma sono stato in grado di usare vim per ottenere una shell di root, comunque:

    bash$ sudo vi +'silent !bash' +q
    Password: ******
    root#
    
    • FWIW, sudoedit (o sudo -e) modifiche privilegiato file ma si corre il vostro editor come utente normale.
    • Che è stato furbo. 🙂
    • sì… mi dispiacerebbe troppo 😉 si dovrebbe solo bisogno di una shell di root, MOLTO RARAMENTE, a meno che non hai già l’abitudine di correre troppi comandi come utente root, il che significa che le autorizzazioni sono tutti avvitati.
    • Perché il tuo sysadmin, anche se la radice? 😀
  22. 26

    Spesso, mi piace cambiare directory corrente durante la modifica l’ho per specificare i percorsi meno.

    cd %:h
    
    • Questo cosa comporta? E funziona con il autchdir?
    • Suppongo che sarebbe ignorare autochdir temporaneamente (fino a che si passa da un buffer di nuovo). In sostanza, cambia la directory di root directory del file corrente. Mi dà un po ‘ di più il controllo manuale di autochdir fa.
    • :set autochdir //questo serve anche la stessa funzionalità e cambia la directory corrente che di file nel buffer
  23. 24

    Mi capita spesso di utilizzare il numero di finestre quando lavoro su un progetto e, a volte ho bisogno di ridimensionarle. Ecco quello che io uso:

    map + <C-W>+
    map - <C-W>-
    

    Questi mapping permettono di aumentare e diminuire la dimensione della finestra corrente. E ‘ abbastanza semplice, ma è veloce.

    • C’è anche Ctrl-W =, che rende le finestre di uguale larghezza.
    • Non dimenticate che è possibile aggiungere numeri di eseguire un’azione più volte in Vim. Quindi, per espandere la finestra corrente in altezza da 8 linee: 8<C-W>+
  24. 22
    :r! <command>
    

    incolla l’output di un comando esterno nel buffer.

    Fare un po ‘ di matematica e di ottenere il risultato direttamente nel testo:

    :r! echo $((3 + 5 + 8))
    

    Ottenere l’elenco dei file da compilare durante la scrittura di un Makefile:

    :r! ls *.c
    

    Non cercano che di fatto si legge su wikipedia, direttamente incollato nel documento che si sta scrivendo:

    :r! lynx -dump http://en.wikipedia.org/wiki/Whatever
    
  25. 22

    Non un oscuro, ma molto utile e risparmio di tempo.

    Se si desidera salvare una sessione di buffer, schede, i marcatori e le altre impostazioni, è possibile eseguire le operazioni seguenti:

    mksession session.vim
    

    È possibile aprire la sessione con:

    vim -S session.vim
    
    • È inoltre possibile :so session.vim all’interno di vim.
  26. 21

    Mappa F5 rapidamente ROT13 buffer:

    map <F5> ggg?G``
    

    Si può usare come un boss key :).

    • Non so che cosa che si sta scrivendo… Ma sicuramente, il mio capo sarebbe più curioso il fatto che quando mi ha visto scrivere in ROT13 jumble 🙂
    • o falsificare i tuoi amici: nmap i ggg?G`` . O diabolico: nmap i ggg?G``i!
    • 2 ° uno è in loop infinito, utilizzare nnoremap
  27. 19

    Ho appena trovato questo di oggi, via NSFAQ:

    Commento blocchi di codice.

    Inserire Blockwise modalità Visuale premendo CTRL-V.

    Marchio di blocco che si desidera commentare.

    Colpire I (I maiuscola) e inserisci il tuo commento stringa all’inizio della riga. (//per C++)

    Premere ESC e tutte le linee selezionati avranno //anteposta alla parte anteriore della linea.

    • Ho aggiunto # a commento di un blocco di codice in ruby. Come posso fare per annullare l’operazione.
    • beh, se non avete fatto nulla per il file, si può semplicemente digitare u per annullare. In caso contrario, non ho capito che ancora.
    • Si può semplicemente premere ctrl+v, contrassegnare la //’s e premere x per “commento”
    • Io uso NERDCommenter per questo.
    • si può annullare premendo CTR+V, selezionare la colonna di #’s e premere x per rimuoverli.
    • NERDCommentor è la via da seguire per il commento. \cc – riga di commento. 5\cc commento 5 linee. 5\ci invertire commento del prossimo 5 righe (righe di commento che sarà commentata, e vice-versa). 5\cs – blocco di commento il prossimo 5 righe di codice. ecc. ecc.
    • Commentato il codice è probabilmente uno dei peggiori tipi di commento che si potrebbe mettere nel vostro codice. Ci sono un uso migliore per il mitico blocco di inserire.
    • perché dici questo? quali sono quelli che meglio utilizza impressionante per blocco di inserire
    • perché commentato il codice è dead code. Codice morto non serve e crea solo confusione. È credo sei preservare il codice si potrebbe desiderare di portare in un secondo momento, ma c’è sempre un modo migliore. È possibile utilizzare la vostra cronologia, è possibile ingannare il file, oppure è possibile utilizzare git, che dispone di questa funzionalità incorporate (git checkout). Come per usi migliori per blocco di inserire, non ci sono i set-in-pietra. Si usano solo quando si dispone di più linee in cui si desidera inserire la stessa sequenza di caratteri nello stesso luogo.
    • Io direi una bugia se dicessi che non ho mai commentare il codice. Io sono colpevole di tanto in tanto, troppo. Ma riconosco che è una pessima abitudine, e ho un serio punto di eliminarlo o portarlo indietro quando mi sono fatto con qualsiasi esperimento che sto facendo al momento.

  28. 17

    Io uso vim per appena circa qualsiasi modifica del testo, così io spesso uso il copia e incolla. Il problema è che vim, per impostazione predefinita, spesso distorcono testo importato via incolla. Il modo per fermare questo è quello di utilizzare

    :set paste
    

    prima di incollare i tuoi dati. Questo gli permetterà di fare pasticci.

    Di notare che è necessario per il rilascio :set nopaste per recuperare rientro automatico. Modi alternativi di incollare testo pre-formattato sono appunti registri (* e +), e :r!cat (si avrà alla fine il frammento incollato con ^D).

    A volte è anche utile per accendere un alto contrasto di colori. Questo può essere fatto con

    :color blue
    

    Ho notato che non funziona su tutte le versioni di vim io la uso ma non di più.

    • La “distorsione” sta accadendo, perché si dispone di una qualche forma di indentazione automatica attivata. Utilizzando set paste o specificare una chiave per la pastetoggle opzione è un modo comune per aggirare questo, ma lo stesso effetto può essere ottenuto con set mouse=a come poi Vim sa che l’alluvione del testo si vede è una pasta attivato con il mouse.
    • Se si dispone di gvim installato è spesso possibile (anche se dipende da che cosa le vostre opzioni distro compila vim) utilizzare X appunti direttamente da vim attraverso l’ * registrare. Per esempio "*p per incollare X xlipboard. (Funziona da terminale vim, troppo, è solo che potrebbe essere necessario l’gvim pacchetto se sono separati)
    • per la cronaca, * è il PRIMARY (“medio-fare clic su” registro. Il appunti è +
  29. 11

    Qui c’è qualcosa di non ovvio. Se si dispone di un sacco di plugin /estensioni in $HOME e avete bisogno di lavorare da su /sudo /… a volte, quindi questo potrebbe essere utile.

    Nel tuo ~/.bashrc:

    export VIMINIT=":so $HOME/.vimrc"

    Nel tuo ~/.vimrc:

    if $HOME=='/root'
            if $USER=='root'
                    if isdirectory('/home/your_typical_username')
                            let rtuser = 'your_typical_username'
                    elseif isdirectory('/home/your_other_username')
                            let rtuser = 'your_other_username'
                    endif
            else
                    let rtuser = $USER
            endif
            let &runtimepath = substitute(&runtimepath, $HOME, '/home/'.rtuser, 'g')
    endif

    Permetterà il vostro locale plugin da caricare – in qualunque modo la si utilizza per modificare l’utente.

    Potresti anche prendere l’ *.i file swp fuori il tuo percorso attuale e in ~/vimtmp (questo va in .vimrc):

    if ! isdirectory(expand('~/vimtmp'))
       call mkdir(expand('~/vimtmp'))
    endif
    if isdirectory(expand('~/vimtmp'))
       set directory=~/vimtmp
    else
       set directory=.,/var/tmp,/tmp
    endif
    

    Inoltre, alcune mappature io uso per rendere più semplice l’editing – rende ctrl+s il lavoro come fuga e ctrl+h/l interruttore di schede:

    inoremap <C-s> <ESC>
    vnoremap <C-s> <ESC>
    noremap <C-l> gt
    noremap <C-h> gT

    • Solo nel caso non si sapesse già, ctrl+c funziona già come fuga.
    • Io preferisco non eseguire vim come root/sotto sudo – e sarebbe solo eseguire il comando da vim ad esempio :!sudo tee %, :!sudo mv % /etc o anche lanciare una shell di login :!sudo -i
  30. 11

    Ctrl-n, mentre in modalità di inserimento automatico completo qualunque sia la parola che si sta digitando sulla base di tutte le parole che sono in aperto buffer. Se c’è più di una corrispondenza vi darà un elenco di parole che si possono scorrere utilizzando ctrl + n ctrl-p.

  31. 10
    gg=G
    

    Corregge rientro per l’intero file. Mi mancava il mio fidato <C-a><C-i> in Eclipse, ma appena scoperto di vim gestisce bene.

    • Trovo G=gg più facile da digitare.
    • =% dovrebbe farlo troppo.
  32. 10

    Vuoi un IDE?

    :make verrà eseguito il makefile nella directory corrente, analizzare l’output del compilatore, è quindi possibile utilizzare :cn e :cp per il passaggio attraverso gli errori del compilatore in apertura di ogni file e cercare il numero di riga in questione.

    :syntax on si accende di vim evidenziazione della sintassi.

  33. 9

    Possibilità di eseguire Vim su un client/server basata modalità.

    Per esempio, supponiamo che si sta lavorando su un progetto con un sacco di buffer, schede e altre informazioni salvate su un file di sessione chiamato sessione.vim.

    È possibile aprire la sessione e creare un server con il seguente comando:

    vim --servername SAMPLESERVER -S session.vim
    

    Di notare che è possibile aprire file di testo normali, se si desidera creare un server e non deve essere necessariamente una sessione.

    Ora, supponiamo che tu stia in un altro terminale e la necessità di aprire un altro file. Se si apre regolarmente con il comando:

    vim new_file.txt
    

    Il file verrà aperto in una separata Vim buffer, che è difficile da fare interazioni con i file sulla vostra sessione. Per aprire new_file.txt in una nuova scheda sul tuo server, utilizzare questo comando:

    vim --servername SAMPLESERVER --remote-tab-silent new_file.txt
    

    Se non c’è un server in esecuzione, questo file verrà aperto proprio come un normale file.

    Dal fornire quelle bandiere ogni volta che si desidera eseguire è molto noioso, è possibile creare un alias per la creazione di client e server.

    Ho messo le seguenti sul mio bashrc:

    alias vims='vim --servername SAMPLESERVER'
    alias vimc='vim --servername SAMPLESERVER --remote-tab-silent'
    

    È possibile trovare ulteriori informazioni su: http://vimdoc.sourceforge.net/htmldoc/remote.html

  34. 9

    Variazione di scrivere sudo:

    in .vimrc

    cmap w!! w !sudo tee % >/dev/null
    

    Dopo la ricarica vim si può fare “sudo salvare” come

    :w!!
    
  35. 9

    Spesso vuole evidenziare una particolare parola/funzione di nome, ma non la voglia di cercare il prossimo istanza di sicurezza:

    map m* *#
    
    • Non capisco questo.
    • Provare:) fondamentalmente, Si evidenzia una parola data, senza spostare il cursore al prossimo evento (come * sarebbe).
    • Si può fare lo stesso con “nnoremap m* :lasciate @/ = ‘\<‘ . espandi(‘<cword>’) . ‘\>'<cr>”
  36. 8

    HOWTO: completamento Automatico Ctags quando usando Vim in Bash.
    Per chiunque utilizzi Vim e Ctags, ho scritto un piccolo auto-completer funzione per Bash. Aggiungere il seguente nel tuo ~/.bash_completion file (crearla se non esiste):

    Grazie a stylishpants per i suoi molti miglioramenti e correzioni.

    _vim_ctags() {
        local cur prev
    
        COMPREPLY=()
        cur="${COMP_WORDS[COMP_CWORD]}"
        prev="${COMP_WORDS[COMP_CWORD-1]}"
    
        case "${prev}" in
            -t)
                # Avoid the complaint message when no tags file exists
                if [ ! -r ./tags ]
                then
                    return
                fi
    
                # Escape slashes to avoid confusing awk
                cur=${cur////\\/}
    
                COMPREPLY=( $(compgen -W "`awk -vORS=" "  "/^${cur}/{ print \\$1 }" tags`" ) )
                ;;
            *)
                _filedir_xspec
                ;;
        esac
    }
    
    # Files matching this pattern are excluded
    excludelist='*[email protected](o|O|so|SO|so.!(conf)|SO.!(CONF)|a|A|rpm|RPM|deb|DEB|gif|GIF|jp?(e)g|JP?(E)G|mp3|MP3|mp?(e)g|MP?(E)G|avi|AVI|asf|ASF|ogg|OGG|class|CLASS)'
    
    complete -F _vim_ctags -f -X "${excludelist}" vi vim gvim rvim view rview rgvim rgview gview
    

    Una volta che si riavvia la sessione di Bash (o crearne uno nuovo) è possibile digitare:

    Codice:

    ~$ vim -t MyC<tab key>
    

    e si auto-completa il tag stesso modo in cui lo fa per file e directory:

    Codice:

    MyClass MyClassFactory
    ~$ vim -t MyC
    

    La trovo davvero utile quando sto saltando in una veloce correzione di bug.

    • Incredibile….Avevo proprio bisogno
    • puoi riassumere? Se la pagina esterna va via, questa risposta è inutile. 🙁
    • Riassunto – permette ctags completamento automatico dal prompt di bash per l’apertura di file con vim.
  37. 7

    % è anche un bene quando si desidera i file diff tra due diverse copie di un progetto senza indossare il mignoli (dalla radice di progetto1):

    :vert diffs /project2/root/%
    
  38. 7

    :setlocal autoread

    Auto ricarica il buffer corrente..particolarmente utile durante la visualizzazione dei file di log e quasi serve la funzionalità di “coda” in programma a unix dall’interno di vim.

    Controllo per errori di compilazione da all’interno di vim.
    impostare il makeprg variabile a seconda della lingua diciamo per perl

    :setlocal makeprg = perl\ -c \ %

    Per PHP

    set makeprg=php\ -l\ %

    set errorformat=%m\ in\ %f\ in\ line\ %l

    Di emissione “:rendere” corre associato makeprg e visualizza gli errori di compilazione/avvertimenti in quickfix finestra e può facilmente accedere ai corrispondenti numeri di riga.

  39. 7

    Io uso Vim per tutto. Quando sto modificando un messaggio di posta elettronica, utilizzo:

    gqap (o gwap)

    ampiamente facilmente e correttamente riformattare un paragrafo per paragrafo, anche con quote leadin caratteri. Per ottenere questa funzionalità, inoltre aggiungo:

    -c 'set fo=tcrq' -c 'set tw=76'

    al comando per richiamare l’editor esterno. Si segnala, inoltre, aggiungere ‘un‘ al fo (formatoptions) parametro. Questo verrà automaticamente riformattare il paragrafo come tipo e navigare il contenuto, ma può interferire o causare problemi di ventura o dispari formattazione contenute nel messaggio.

    • autocmd FileType mail set tw=76 fo=tcrq nel ~/.vimrc anche di lavoro, se non è possibile modificare l’editor esterno di comando.
  40. 6

    Input un carattere dal suo valore esadecimale (modalità di inserimento):

    <C-Q>x[type the hexadecimal byte]
    
    • <C-V> è il più generico di comando che funziona sia in modalità testo e grafica
    • E ‘ solo <C-q> se si utilizza il terribile mswin.vim (o mappato in voi stessi).
  41. 6

    Mettere questo nel .vimrc di avere un comando a bella stampa xml:

    function FormatXml()
        %s:\(\S\)\(<[^/]\)\|\(>\)\(</\):\1\3\r\2\4:g
        set filetype=xml
        normal gg=G
    endfunction
    
    command FormatXml :call FormatXml()
    
    • Su sistemi linux (dove xmllint è abbastanza comunemente installati) io di solito basta fare :%! xmllint – per questo.
  42. 6

    Ero sicuro che qualcuno avrebbe postato questo già, ma qui va.

    Prendere qualsiasi sistema di creazione, si prega di; fare, mvn, di formica, di qualunque cosa. Nella root della directory del progetto, creare un file di comandi che si usano tutto il tempo, come questo:

    mvn install

    mvn clean install

    … e così via

    Per fare costruire, posizionare il cursore sulla linea e il tipo !!sh. I. e. filtro di linea; scrivere una shell e sostituire con i risultati.

    Il build log sostituisce la linea, pronto a scorrimento, di ricerca, di qualunque cosa.

    Quando hai finito di guardare il log, tipo u per annullare e sei di nuovo al vostro file di comandi.

    • Questo non mi sembra di volare sul mio sistema. Si può mostrare solo un esempio, utilizzando il comando ls?
    • !!ls sostituisce la riga corrente output ls (aggiungere ulteriori righe se necessario).
    • Perché non basta impostare makeprg per il corretto strumento da utilizzare per la compilazione (se non è già impostata) e quindi utilizzare :make? :copen mostrerà il risultato di costruire oltre a permettere di saltare per eventuali avvisi/errori.
  43. 6
    ========================================================== 
    In modalità normale 
    ========================================================== 
    gf ................ aprire il file sotto il cursore nella stessa finestra --> vedi :h percorso 
    Ctrl-w f .......... aprire il file sotto il cursore in una nuova finestra 
    Ctrl-w q .......... chiudere la finestra corrente 
    Ctrl-w 6 .......... aprire il file alternativo --> vedi :h # 
    gi ................ init modalità di inserimento in ultima posizione di inserimento 
    '0 ................ posizionare il cursore dove era quando il file è stato modificato 
    
    • Credo sia <C-w> c per chiudere una finestra, in realtà. :h ctrl-w
  44. 6

    A causa della latenza e la mancanza di colori (io amo i colori 🙂 non mi piace la programmazione su macchine remote Stucco. Così ho sviluppato questo trucco per aggirare questo problema. Io lo uso su Windows.

    È necessario

    • 1x gVim
    • 1x rsync su remoto e locale macchine
    • 1x chiave SSH privata auth alla macchina remota, quindi non c’è bisogno di digitare la password
    • 1x Concorso
    • 1x Stucco

    Impostazione della macchina remota

    Configurare rsync per rendere la vostra directory di lavoro accessibile. Io uso un tunnel SSH e solo consentire le connessioni dal tunnel:

    address = 127.0.0.1
    hosts allow = 127.0.0.1
    port = 40000
    use chroot = false
    [bledge_ce]
        path = /home/xplasil/divine/bledge_ce
        read only = false
    

    Quindi avviare rsyncd:
    rsync –daemon –config=rsyncd.conf

    Impostazione della macchina locale

    Installare rsync da Cygwin. Inizio Concorso e caricare la propria chiave privata per la macchina remota. Se stai usando SSH tunelling, start Stucco per creare il tunnel. Creare un file batch push.bat nella directory di lavoro, che verranno caricati i file modificati al computer remoto utilizzando rsync:

    rsync --blocking-io *.cc *.h SConstruct rsync://localhost:40001/bledge_ce
    

    SConstruct è un file di build per scons. Modificare l’elenco dei file per soddisfare le vostre esigenze. Sostituire localhost con il nome della macchina remota se non si usa SSH tunelling.

    Configurazione Di Vim
    Che ora è facile. Useremo il quickfix funzione:fare e di errore di lista), ma la compilazione verrà eseguito sulla macchina remota. Quindi, abbiamo bisogno di impostare makeprg:

    set makeprg=push\ &&\ plink\ -batch\ [email protected]\ \"cd\ /home/xplasil/divine/bledge_ce\ &&\ scons\ -j\ 2\"
    

    Questo inizia il push.bat compito di caricare il file e quindi eseguire i comandi sulla macchina remota tramite SSH (Plink dalla suite PuTTY). Il comando di prima cambia la directory di lavoro, in dir e poi inizia a costruire (io uso scons).

    I risultati di costruire mostrerà convenientemente nel tuo locale gVim errori elenco.

    • Una soluzione molto più semplice sarebbe quella di utilizzare bcvi: sshmenu.sourceforge.net/articles/bcvi
    • cmder è molto più facile e più semplice, si tratta anche con il proprio client ssh
  45. 5

    set colorcolumn=+1 o set cc=+1 per vim 7.3

    • Una breve spiegazione sarebbe apprezzato… l’ho provato e potrebbe essere molto utile! Si può anche fare qualcosa di simile set colorcolumn=+1,+10,+20 🙂
    • Se avete provato perché non lei di fornire una spiegazione?
    • colorcolumn consente di specificare le colonne evidenziate (è ideale per rendere sicuro il vostro righe non troppo a lungo). Nell’originale risposta, set cc=+1 evidenzia la colonna dopo textwidth. Vedi la documentazione per ulteriori informazioni.
  46. 4

    :sp %:h – elenco directory /file-selezione utilizzando l’attuale directory del file

    (appartiene come un commento sotto raperonzoli del cd suggerimento, ma non ho commenti dei diritti di sicurezza)

    • “:e .” non è la stessa cosa per le directory di lavoro corrente che sarà la stessa del tuo attuale file della directory, se si imposta autochdir
  47. 4

    Appena prima di copiare e incollare per stackoverflow:

    :retab 1
    :% s/^I//g
    :% s/^/   /
    

    Ora copia e incolla il codice.

    Come richiesto nei commenti:

    retab 1. Questo imposta la scheda di dimensione uno. Ma passa anche attraverso il codice e aggiunge schede aggiuntive e spazi, in modo che la formattazione non spostare il testo vero e proprio (cioè il testo sembra la stessa, dopo ratab).

    % s/^I//g: Nota i ^I è il risultato di colpire scheda. In questo modo si cerca per tutte le schede e li sostituisce con un unico spazio. Dal momento che abbiamo appena fatto un retab questo non dovrebbe causare la formattazione a cambiare, ma mettendo le schede in un sito web è colpito e perdere, è bene rimuoverli.

    % s/^/    /: Sostituire inizio della riga con quattro spazi. Dal momento che si può effettivamente sostituire inizio della riga con tutto ciò si inserisce in quattro spazi all’iniziare della linea (questa operazione è necessaria COSÌ la formattazione per rendere il codice stand out).

    • spiegare per favore…
    • quindi, credo che questo non funziona se si utilizza il ‘set expandtab’ per forza tutte le schede di spazi.
    • Le prime due righe non si applica. L’ultima linea farà in modo che si può solo tagliare e incollare in MODO.
    • Si noti che è possibile ottenere la stessa cosa con cat <file> | awk '{print " " $line}'. In modo da provare :w ! awk '{print " " $line}' | xclip -i. Che dovrebbe essere di quattro spazi tra le ""
  48. 4

    Quando si lavora su un progetto in cui il processo di costruzione è lento ho sempre costruire in background e pipe l’output in un file chiamato errori.err (qualcosa di simile make debug 2>&1 | tee errors.err). Questo rende possibile per me per continuare la modifica o la revisione di codice sorgente, durante il processo di generazione. Quando è pronto (utilizzando pynotify su GTK per informare che è completo) posso guardare il risultato in vim utilizzando quickfix. Inizio con il comando :cf[ile] che legge il file di errore e salta il primo errore. Personalmente mi piace usare cwindow per ottenere il costruire il risultato in una finestra separata.

  49. 4

    Un paio di utili:

    :set nu # displays lines
    :44     # go to line 44
    '.      # go to last modification line
    

    Il mio preferito: Ctrl + n il COMPLETAMENTO della PAROLA!

  50. 3

    Per la realizzazione di vim un po ‘ di più come un IDE editor:

    • set nu – per i numeri di riga nel margine sinistro.
    • set cul – evidenzia la riga che contiene il cursore.
    • Come si fa Vim più come un IDE ??
    • Io ho detto “un po’” 🙂 Ma è qualcosa che molte Idi fare, e alcune persone come, ad esempio: eclipse.org/screenshots/images/JavaPerspective-WinXP.png
    • Sì, ma questo è come dire copia/incolla funzioni di un editor “un po ‘” più come un IDE. Quelle sono funzioni di editor. Praticamente tutto ciò che va con l’editor che riguarda la modifica del testo e di quella particolare zona è un editor di funzione. IDE di funzioni, per esempio, del progetto/gestione file, connettività, con compilatore,&il linker error reporting, la costruzione di strumenti di automazione, debugger … cioè roba che in realtà non fare nulla con la modifica del testo. Vim ha alcune funzioni & plugin in modo che egli può gravitare un po ‘ di più verso l’essere un IDE, ma questi non sono quelli in questione.
    • Dopo tutto, un IDE = editor + compilatore + debugger + strumenti di costruzione di + …
    • Inoltre, cordiali saluti, vim ha un’opzione per impostare invnumber. In questo modo non si hanno per “nu” e “nonu”, cioè il ricordo di due funzioni – si può solo passare.
    • Lo stesso vale per cursorline … e molti altri ancora.
    • questo cursore linea caratteristica rende VIM brutto, lento, in realtà inutilizzabile

  51. 3

    Mi piace :comando ls.

    • Bene, cosa fa?
    • dà il nome del file corrente aperto ?
    • :ls elenca tutti attualmente aperto buffer. :be apre un file in un nuovo buffer, :bn va a buffer successivo, :bp al precedente, :b filename apre il buffer nome del file (auto-completa di troppo). i buffer sono distinte schede, mi hanno detto che sono più simile a quello di vista.
  52. 3

    mappa macro

    Io invece spesso utile per on-the-fly definire la mappatura dei tasti, proprio come uno potrebbe definire una macro. Qui la torsione è che la mappatura è ricorsiva e viene eseguito fino a quando non riesce.

    Esempio:

    enum ProcStats
    {
            ps_pid,
            ps_comm,
            ps_state,
            ps_ppid,
            ps_pgrp,
    :map X /ps_<CR>3xixy<Esc>X
    

    Dà:

    enum ProcStats
    {
            xypid,
            xycomm,
            xystate,
            xyppid,
            xypgrp,
    

    Solo un esempio stupido :).

    Io sono completamente a conoscenza di tutti gli svantaggi – così succede che l’ho trovato piuttosto utile in alcune occasioni. Inoltre può essere interessante vedere all’opera ;).

    • Le macro sono anche permesso di essere ricorsiva, e funziona praticamente allo stesso modo, quando ci sono, quindi non è particolarmente necessario per utilizzare la mappatura per questo.
  53. 3

    Riutilizzo

    Movimenti a mescolare con altri comandi, più qui.

    tx
    fx
    Fx
    

    Usare i tuoi strumenti preferiti in Vim.

    :r !python anything you want or awk or Y something
    

    Ripetere in modalità visiva, potente, quando combinato con i suggerimenti di cui sopra.

    ;
    
  54. 3
    In Insert mode 
    <C-A>   - Increments the number under cursor 
    <C-X>   - Decrements the number under cursor
    

    Sarà molto utile se si desidera generare una sequenza di numeri in vim

    Diciamo che se vogliamo inserire righe da 1 a 10 con i numeri da 1 a 10 [come “1” sulla linea 1,”2″, 2 ° linea..]

    inserire “0” sulla prima riga e copiare la riga e passato 9 volte
    In modo che tutte le linee visualizzerà “0”.

    Eseguire il seguente comando Ex

    :g/^/exe "norm " . line(".") . "\<C-A>"
    
    • certo che questo funziona in modalità di comando troppo.
  55. 3

    In modalità di inserimento, ctrl+x, ctrl+p viene completata (con menu di possibili completamenti, se vi piace di più) la corrente lungo l’identificatore che si sta digitando.

    if (SomeCall(LONG_ID_ <-- type c-x c-p here
                [LONG_ID_I_CANT_POSSIBLY_REMEMBER]
                 LONG_ID_BUT_I_NEW_IT_WASNT_THIS_ONE
                 LONG_ID_GOSH_FORGOT_THIS
                 LONG_ID_ETC
                 ∶
    
    • ho tipo <kbd>ctrl</kbd>+<kbd>p</kbd> un po ‘ troppo per un incidente mentre cercando di colpire <kbd>ctrl</kbd>+<kbd>[</kbd> ><
  56. 2

    Utilizzare il tasto destro del mouse per attivare la modalità di inserimento in gVim con le seguenti impostazioni
    in ~/.gvimrc :

    "
    "------------------------------------------------------------------
    " toggle insert mode <--> 'normal mode with the <RightMouse>-key
    "------------------------------------------------------------------
    nnoremap  <RightMouse> <Insert>
    inoremap  <RightMouse> <ESC>
    "
    
    • Questo è stupido. Sconfigge i guadagni di produttività da non utilizzando il mouse.
    • Forse mgf ha testa gesti mappati ai clic del mouse.
  57. 2

    Sostituire tutti

      :%s/oldtext/newtext/igc
    

    Dare a sostituire a tutti 🙂

    • o meglio ancora, invece di digitare a, basta rimuovere il c. c significa confermare la sostituzione
  58. 2

    Nessuno dei seguenti è davvero irriducibili, ma io la trovo estremamente utile.

    Banale associazioni, ma non posso vivere senza. Esso consente hjkl stile di movimento in modalità di inserimento (utilizzando il tasto ctrl). In modalità normale: ctrl-k/j scorre metà schermo up/down e ctrl-l/h si passa alla successiva/precedente buffer. La µ e-mapping sono soprattutto per un AZERTY-tastiera e passare alla successiva/precedente errore.

    imap <c-j> <Down>
    imap <c-k> <Up>
    imap <c-h> <Left>
    imap <c-l> <Right>
    nmap <c-j> <c-d>
    nmap <c-k> <c-u>
    nmap <c-h> <c-left>
    nmap <c-l> <c-right>
    
    nmap ù :cp<RETURN>
    nmap µ :cn<RETURN>
    

    Una piccola funzione che ho scritto per evidenziare le funzioni, le variabili globali, macro, le strutture e typedef. (Potrebbe essere lento su file molto grandi). Ogni tipo di ottiene diversi evidenziando (vedere “:aiutare a nome del gruppo” per avere un’idea del vostro attuale colortheme impostazioni)
    Utilizzo: salvare il file con ww (di default “\ww”). Hai bisogno di ctags per questo.

    nmap <Leader>ww :call SaveCtagsHighlight()<CR>
    
    "Based on: http://stackoverflow.com/questions/736701/class-function-names-highlighting-in-vim
    function SaveCtagsHighlight()
        write
    
        let extension = expand("%:e")
        if extension!="c" && extension!="cpp" && extension!="h" && extension!="hpp"
            return
        endif
    
        silent !ctags --fields=+KS *
        redraw!
    
        let list = taglist('.*')
        for item in list
            let kind = item.kind
    
            if     kind == 'member'
                let kw = 'Identifier'
            elseif kind == 'function'
                let kw = 'Function'
            elseif kind == 'macro'
                let kw = 'Macro'
            elseif kind == 'struct'
                let kw = 'Structure'
            elseif kind == 'typedef'
                let kw = 'Typedef'
            else
                continue
            endif
    
            let name = item.name
            if name != 'operator=' && name != 'operator ='
                exec 'syntax keyword '.kw.' '.name
            endif
        endfor
        echo expand("%")." written, tags updated"
    endfunction
    

    Ho l’abitudine di scrivere un sacco di codice e funzioni e non mi piace scrivere prototipi per loro. Così ho fatto qualche funzione per generare un elenco di prototipi all’interno di un C-stile sourcefile. Si tratta di due tipi: uno che toglie il parametro formale di nome e di uno che la conserva.
    Ho appena aggiornare la lista ogni volta che ho bisogno di aggiornare i prototipi. Si evita di avere sincronizzati i prototipi e le definizioni di funzione. Ha anche bisogno di ctags.

    "Usage: in normal mode, where you want the prototypes to be pasted:
    ":call GenerateProptotypes()
    function GeneratePrototypes()
        execute "silent !ctags --fields=+KS ".expand("%")
        redraw!
        let list = taglist('.*')
        let line = line(".")
        for item in list
            if item.kind == "function"  &&  item.name != "main"
                let name = item.name
                let retType = item.cmd
                let retType = substitute( retType, '^/\^\s*','','' )
                let retType = substitute( retType, '\s*'.name.'.*', '', '' ) 
    
                if has_key( item, 'signature' )
                    let sig = item.signature
                    let sig = substitute( sig, '\s*\w\+\s*,',        ',',   'g')
                    let sig = substitute( sig, '\s*\w\+\(\s)\)', '\1', '' )
                else
                    let sig = '()'
                endif
                let proto = retType . "\t" . name . sig . ';'
                call append( line, proto )
                let line = line + 1
            endif
        endfor
    endfunction
    
    
    function GeneratePrototypesFullSignature()
        "execute "silent !ctags --fields=+KS ".expand("%")
        let dir = expand("%:p:h");
        execute "silent !ctags --fields=+KSi --extra=+q".dir."/* "
        redraw!
        let list = taglist('.*')
        let line = line(".")
        for item in list
            if item.kind == "function"  &&  item.name != "main"
                let name = item.name
                let retType = item.cmd
                let retType = substitute( retType, '^/\^\s*','','' )
                let retType = substitute( retType, '\s*'.name.'.*', '', '' ) 
    
                if has_key( item, 'signature' )
                    let sig = item.signature
                else
                    let sig = '(void)'
                endif
                let proto = retType . "\t" . name . sig . ';'
                call append( line, proto )
                let line = line + 1
            endif
        endfor
    endfunction
    
  59. 2

    Ho raccolto questi nel corso degli anni.

    " Pasting in normal mode should append to the right of cursor
    nmap <C-V>      a<C-V><ESC>
    " Saving
    imap <C-S>      <C-o>:up<CR>
    nmap <C-S>      :up<CR>
    " Insert mode control delete
    imap <C-Backspace> <C-W>
    imap <C-Delete> <C-O>dw
    nmap    <Leader>o       o<ESC>k
    nmap    <Leader>O       O<ESC>j
    " tired of my typo
    nmap :W     :w
    
  60. 2

    Creare una funzione per eseguire il buffer corrente utilizzando è inserita (supponendo che si è imposta) e chiamare con ctrl-x.

    map <C-X> :call CallInterpreter()<CR>
    
    au BufEnter *
    \ if match (getline(1) , '^\#!') == 0 |
    \   execute("let b:interpreter = getline(1)[2:]") |
    \ endif
    
    fun! CallInterpreter()
        if exists("b:interpreter")
            exec("! ".b:interpreter." %")
        endif
    endfun
    
  61. 2

    Per copiare un testo da Vim negli appunti per altre applicazioni da utilizzare, selezionare il testo che si desidera copiare in modalità visuale, e quindi premere il tasto “+y. In questo modo, si può facilmente incollare il testo in altre applicazioni.

    Questo è particolarmente utile, se hai diviso verticalmente alla finestra e si desidera copiare qualcosa dalla finestra di destra. Utilizzando il mouse set=r, non vi aiuterà con questa situazione, dal momento che selezionerà tutto sulla finestra di sinistra pure.

    Nota che il vim deve essere compilato con xterm supporto.

    • Per verificare se la vostra versione di vim è compilato con appunti, fare vim --version | grep clipboard e si dovrebbe avere le seguenti argomenti: +clipboard e +xterm_clipboard.
  62. 2

    Provare a utilizzare perltidy per la formattazione = normale-modalità di comando

    :set equalprg=perltidy
    
  63. 1

    Alcuni dei miei must sono:

    cscope + ctags + vim, che può essere trovato sul web.

    Alcune abbreviazioni per avviare più velocemente il nuovo file di codice come:

    ab cpph #include <iostream><CR>#include <string><CR>#include <cstdlib><CR>#include <cassert><CR>#include <vector><CR>#include <
    stdexcept><CR>using namespace std;<CR>int main(int argc, char *argv[]) {
    ab perlh #!/usr/bin/perl<CR>use strict;<CR>use warnings;<CR>
    ab chdr #include <stdio.h><CR>#include <sys/types.h><CR>#include <unistd.h><CR>#include <stdlib.h><CR>#include <sys/stat.h><CR>
    #include <sys/wait.h><CR>#include <string.h><CR>int main(int argc, char *argv[]) {
    ab xhtmlhdr <?xml version="1.0" encoding="UTF-8"?><CR><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.o
    rg/TR/xhtml1/DTD/xhtml1-strict.dtd"><CR><html xmlns="http://www.w3.org/1999/xhtml"><CR>  <head><CR>  <title></title><CR><link h
    ref="style.css"  type="text/css"><CR></head>
    

    Per esempio cpph viene inserito uno scheletro di base di un main.cc file

    C’è anche la mia mappatura dei tasti funzione:

    map <F1> <Esc>:w<CR>:perl $e = `./error.pl`; my ($f,$l,@w) = split(":",$e); my $w=join(":",@w); $curwin->Cursor($l,0); VIM::Msg($w);<CR>
    map <F2> :wincmd w<CR>
    map <F3> :wincmd s<CR>
    map <F4> :wincmd v<CR>
    map <F5> :wincmd o<CR>
    map <F6> :sball<CR>
    map <F7> :wq<CR>
    map <F8> :wincmd q<CR>
    map <F9> :wincmd -<CR>
    map <F10> :wincmd +<CR>
    map <F11> :wincmd <<CR>
    map <F12> :wincmd ><CR>
    

    In questo caso il mio F1 è mappato a mettere il cursore sul successivo errore che deve essere corretto per il codice di migrazione.

    map _ ebi"^[ea"^[
    

    Questa mappa farebbe _ il preventivo di una stringa

  64. 1

    Mapping per rendere i movimenti operare nella schermata corrente di linea in funzione di a capo automatico. L’ho scoperto in un commento per Vim suggerimento di qualche tempo fa, e si è dimostrato molto utile.

    function! ScreenMovement(movement)
      if &wrap
        return "g" . a:movement
      else
        return a:movement
      endif
    endfunction
    onoremap <silent> <expr> j ScreenMovement("j")
    onoremap <silent> <expr> k ScreenMovement("k")
    onoremap <silent> <expr> 0 ScreenMovement("0")
    onoremap <silent> <expr> ^ ScreenMovement("^")
    onoremap <silent> <expr> $ ScreenMovement("$")
    nnoremap <silent> <expr> j ScreenMovement("j")
    nnoremap <silent> <expr> k ScreenMovement("k")
    nnoremap <silent> <expr> 0 ScreenMovement("0")
    nnoremap <silent> <expr> ^ ScreenMovement("^")
    nnoremap <silent> <expr> $ ScreenMovement("$")
    
  65. 1

    Il mio è l’utilizzo delle macro invece di ricerca – combinando una macro con la modalità visuale è a volte più efficiente.

  66. 1

    per questo thread

    Per il prefisso di un insieme di linee di utilizzare due differenti approcci:

    Un approccio è il blocco di selezionare (citata da sth). In generale, è possibile selezionare un’area rettangolare con ctrl-V seguito da freccia-movimento. Una volta evidenziato un rettangolo, premendo shift-inserisco i caratteri a sinistra del rettangolo, o shift-Un aggiungerà loro sul lato destro del rettangolo. Quindi è possibile utilizzare questa tecnica per fare un rettangolo che include la colonna più a sinistra delle righe che si desidera prefisso, premete shift-I, digitare il prefisso, quindi premere il tasto escape.

    L’altro approccio è quello di utilizzare una sostituzione (come detto da Brian Agnew). Brian sostituzione interesserà l’intero file (l’ % nel comando significa “tutte le linee”). Per interessare poche righe, l’approccio più semplice è quello di premere shift-V (che consente di visual-line mode) mentre al primo/ultimo, e quindi spostare l’ultima/prima linea. Quindi digitare:

    :s/^/IL PREFISSO/

    I ^ è una regex (in questo caso, l’inizio della riga). Digitando questo in linea di visual modalità vedrete ‘<‘> inserito prima il s automaticamente. Questo significa che l’intervallo di sostituzione sarà la selezione visiva.

    Suggerimento Extra: se il tuo prefisso contiene barre, è possibile sfuggire loro, con barra rovesciata, oppure è possibile utilizzare una punteggiatura diversa carattere come separatore nel comando. Per esempio, per aggiungere C++ commenti, di solito scrivo:

    :s:^://:

    Per l’aggiunta di un suffisso il metodo della sostituzione è generalmente più facile a meno che non tutte le linee sono esattamente la stessa lunghezza. Basta usare $ per il modello invece di ^ e la stringa verrà aggiunto invece che precede.

    Se si desidera aggiungere un prefisso e un suffisso contemporaneamente, si può fare qualcosa di simile a questo:

    :s/.*/PREFISSO & il SUFFISSO/

    L’ .* le partite di tutta la linea. Il & in sostituzione mette il testo corrispondente (tutta la linea) ma ora avrà il prefisso e il suffisso aggiunto.

    BTW: quando commentando il codice che probabilmente si desidera rimuovere il commento più tardi. È possibile utilizzare visual-block (ctrl-V) per selezionare le barre e poi premere d per eliminare loro, oppure è possibile utilizzare una sostituzione (probabilmente con una linea visiva di selezione, effettuata con shift-V) per rimuovere la slash ( /) come questo:

    :s://::

  67. 1

    La mia ricetta preferita per passare avanti e indietro tra le finestre:

    function! SwitchPrevWin()
        let l:winnr_index = winnr()
        if l:winnr_index > 1
           let l:winnr_index -= 1
        else
           "set winnr_index to max window open
            let l:winnr_index = winnr('$')
        endif
        exe l:winnr_index . "wincmd w" 
    endfunction
    

    nmap <M-z> :call SwitchPrevWin()
    imap <M-z> <ESC>:call SwitchPrevWin()
    

    nmap <C-z> :wincmd w
    imap <C-z> <ESC>:wincmd w
    
    • e perché non usare <C-w>* comandi?
    • troppi tasti da premere… lol. comunque io uso raramente, quasi mai, di un altro script che contribuiscono a me move a numerato finestra premendo il <leader>numero.
    • <c-w><left> o <c-w><right>… non è che terribile.
    • Fantastico!!! di non essere a conoscenza su di esso
  68. 1

    Mi piacerebbe organizzare un po ‘ del mio file di configurazione in dopo directory. È particolarmente utile per ftplugin.

    Si può evitare di scrivere un lungo elenco di augroup per .file vimrc invece di un file separato per ciascun tipo.

    Ma, ovviamente, .vim/ftplugin directory fare la stessa cosa .vim/dopo/ftplugin, ma io preferisco lasciare .vim directory vim plugin.

Lascia un commento