J'ai beaucoup entendu parler de Vim , à la fois pour et contre. Il semble vraiment que vous devriez (en tant que développeur) être plus rapide avec Vim qu'avec tout autre éditeur. J'utilise Vim pour faire des trucs de base et je suis au mieux 10 fois moins productif avec Vim.

Les deux seules choses dont vous devriez vous soucier lorsque vous parlez de vitesse (vous ne vous en souciez peut-être pas assez, mais vous devriez le faire) sont:

1. Utiliser alternativement les mains gauche et droite est le moyen le plus rapide d'utiliser le clavier.
2. Ne jamais toucher la souris est la deuxième façon d'être aussi rapide que possible. Il faut du temps pour déplacer votre main, saisir la souris, la déplacer et la ramener au clavier (et vous devez souvent regarder le clavier pour être sûr d'avoir bien remis votre main au bon endroit)

Voici deux exemples démontrant pourquoi je suis beaucoup moins productif avec Vim.

Copiez / Coupez et collez. Je le fais tout le temps. Avec tous les éditeurs contemporains, vous appuyez Shift avec la main gauche et vous déplacez le curseur avec votre main droite pour sélectionner le texte. Puis Ctrl+ Ccopies, vous déplacez le curseur et Ctrl+ les Vpâtes.

Avec Vim c'est horrible:

• yy copier une ligne (vous ne voulez presque jamais la ligne entière!)
• [number xx]yypour copier des xxlignes dans le tampon. Mais vous ne savez jamais exactement si vous avez sélectionné ce que vous vouliez. Je dois souvent faire [number xx]ddensuite upour défaire!

Un autre exemple? Rechercher et remplacer.

• Dans PSPad : Ctrl+ fpuis tapez ce que vous recherchez, puis appuyez sur Enter.
• Dans Vim:, /saisissez ce que vous souhaitez rechercher, puis s'il y a des caractères spéciaux \avant chaque caractère spécial, puis appuyez sur Enter.

Et tout avec Vim est comme ça: il semble que je ne sais pas comment le gérer correctement.

NB: J'ai déjà lu la feuille de triche Vim :)

Ma question est:

Quelle est la façon dont vous utilisez Vim qui vous rend plus productif qu'avec un éditeur contemporain?

Votre problème avec Vim est que vous ne grok vi .

Vous mentionnez couper avec yyet vous plaignez que vous ne voulez presque jamais couper des lignes entières. En fait, les programmeurs, éditant du code source, veulent très souvent travailler sur des lignes entières, des plages de lignes et des blocs de code. Cependant, ce yyn'est qu'une des nombreuses façons d'extraire du texte dans le tampon de copie anonyme (ou "s'inscrire" comme on l'appelle dans vi ).

Le "Zen" de vi est que vous parlez une langue. L'initiale yest un verbe. La déclaration yyest synonyme de y_. Le yest doublé pour le rendre plus facile à taper, car il s'agit d'une telle opération courante.

Cela peut également être exprimé par dd P(supprimer la ligne actuelle et coller une copie en place; laisser une copie dans le registre anonyme comme effet secondaire). Les yet d« verbes » prennent tout mouvement comme leur « sujet ». Ainsi, yW"tirez d'ici (le curseur) jusqu'à la fin du mot courant / suivant (gros)" et y'a"tirez d'ici jusqu'à la ligne contenant la marque nommée" a "".

Si vous ne comprenez que les mouvements basiques du curseur vers le haut, le bas, la gauche et la droite, vi ne sera pas plus productif qu'une copie du "bloc-notes" pour vous. (D'accord, vous aurez toujours la mise en évidence de la syntaxe et la capacité de gérer des fichiers plus volumineux qu'un ~ 45 Ko environ; mais travaillez avec moi ici).

vi a 26 "marques" et 26 "registres". Une marque est définie à n'importe quel emplacement du curseur à l'aide de la mcommande. Chaque marque est désignée par une seule lettre minuscule. maDéfinit ainsi la marque « a » à l'emplacement actuel et mzdéfinit la marque « z ». Vous pouvez passer à la ligne contenant une marque à l'aide de la commande '(guillemet simple). Se 'adéplace ainsi au début de la ligne contenant la marque « a ». Vous pouvez vous déplacer vers l'emplacement précis de n'importe quelle marque à l'aide de la `commande (backquote). Ainsi `z, vous vous déplacerez directement à l'emplacement exact de la marque « z ».

Parce que ce sont des «mouvements», ils peuvent également être utilisés comme sujets pour d'autres «déclarations».

Donc, une façon de couper une sélection arbitraire de texte serait de déposer une marque (j'utilise habituellement ' a ' comme ma "première" marque, ' z ' comme ma prochaine marque, ' b ' comme une autre et ' e ' comme encore une autre (je ne me souviens pas avoir utilisé interactivement plus de quatre marques en 15 ans d'utilisation de vi ; on crée ses propres conventions concernant la façon dont les marques et les registres sont utilisés par les macros qui ne perturbent pas le contexte interactif). Ensuite, nous allons à l'autre extrémité de notre texte souhaité; nous pouvons commencer à chaque extrémité, peu importe. Ensuite, nous pouvons simplement utiliser d`apour couper ou y`acopier. Ainsi, l'ensemble du processus a une surcharge de 5 touches (six si nous avons commencé dans "insérer "mode et nécessaire pourEscen mode commande). Une fois que nous avons copié ou coupé puis coller dans une copie est une simple pression de touche: p.

Je dis que c'est une façon de couper ou de copier du texte. Cependant, ce n'est qu'un parmi tant d'autres. Fréquemment, nous pouvons décrire plus succinctement la plage de texte sans déplacer notre curseur et laisser tomber une marque. Par exemple , si je suis dans un paragraphe de texte que je peux utiliser {et }mouvements au début ou à la fin du paragraphe respectivement. Donc, pour déplacer un paragraphe de texte, je le coupe à l'aide de { d}(3 touches). (S'il m'arrive d'être déjà sur la première ou la dernière ligne du paragraphe, je peux alors simplement utiliser d}ou d{respectivement.

La notion de "paragraphe" par défaut est quelque chose qui est généralement intuitivement raisonnable. Ainsi, cela fonctionne souvent pour le code ainsi que pour la prose.

Nous connaissons fréquemment un modèle (expression régulière) qui marque l'une ou l'autre extrémité du texte qui nous intéresse. La recherche en avant ou en arrière sont des mouvements dans vi . Ainsi, ils peuvent également être utilisés comme «sujets» dans nos «déclarations». Je peux donc utiliser d/foopour couper de la ligne actuelle à la ligne suivante contenant la chaîne "foo" et y?barcopier de la ligne actuelle à la ligne la plus récente (précédente) contenant "bar". Si je ne veux pas de lignes entières, je peux toujours utiliser les mouvements de recherche (comme leurs propres déclarations), déposez mes marques et utilisez les `xcommandes comme décrit précédemment.

En plus des "verbes" et des "sujets", vi a également des "objets" (au sens grammatical du terme). Jusqu'à présent, je n'ai décrit que l'utilisation du registre anonyme. Cependant, je peux utiliser n'importe lequel des 26 registres "nommés" en préfixant la référence "objet" avec "(le modificateur de guillemet double). Ainsi, si j'utilise, "addje coupe la ligne actuelle dans le registre « a » et si j'utilise "by/fooalors je tire une copie du texte d'ici à la ligne suivante contenant «foo» dans le registre « b ». Pour coller à partir d' un préfixe simplement j'enregistrer la pâte avec la même séquence de modification: "apcolle une copie du « un » registre »"bPcolle une copie de ' b ' à avant la ligne courante.

Cette notion de «préfixes» ajoute également les analogues des «adjectifs» et des «adverbes» grammaticaux à notre langage de manipulation de texte. «La plupart des commandes (verbes) et du mouvement (verbes ou objets, selon le contexte) peuvent également prendre des préfixes numériques. 3Jsignifie «joindre les trois lignes suivantes» et d5}signifie «supprimer de la ligne actuelle jusqu'à la fin du cinquième paragraphe d'ici».

Tout cela est de niveau intermédiaire vi . Rien de tout cela n'est spécifique à Vim et il existe des astuces bien plus avancées dans vi si vous êtes prêt à les apprendre. Si vous deviez maîtriser uniquement ces concepts intermédiaires, vous constateriez probablement que vous avez rarement besoin d'écrire des macros parce que le langage de manipulation de texte est suffisamment concis et expressif pour faire la plupart des choses assez facilement en utilisant la langue "native" de l'éditeur.

Un échantillon d'astuces plus avancées:

Il existe un certain nombre de :commandes, notamment la :% s/foo/bar/gtechnique de substitution globale. (Ce n'est pas avancé mais d'autres :commandes peuvent l'être). L'ensemble :des commandes a été historiquement hérité des incarnations précédentes de vi en tant qu'utilitaires ed (éditeur de ligne) et plus tard ex (éditeur de ligne étendu). En fait, vi est nommé ainsi parce que c'est l'interface visuelle de ex .

:les commandes fonctionnent normalement sur des lignes de texte. ed et ex ont été écrits à une époque où les écrans de terminaux étaient rares et de nombreux terminaux étaient des appareils "téléscripteurs" (ATS). Il était donc courant de travailler à partir de copies imprimées du texte, en utilisant des commandes via une interface extrêmement laconique (les vitesses de connexion courantes étaient de 110 bauds, ou, en gros, 11 caractères par seconde - ce qui est plus lent qu'une dactylographie rapide; les décalages étaient courants sur sessions interactives multi-utilisateurs; en outre, il y avait souvent une certaine motivation pour économiser le papier).

Ainsi, la syntaxe de la plupart des :commandes comprend une adresse ou une plage d'adresses (numéro de ligne) suivie d'une commande. Naturellement, on pourrait utiliser des numéros de ligne littéraux: :127,215 s/foo/barpour changer la première occurrence de "foo" en "bar" sur chaque ligne entre 127 et 215. On pourrait également utiliser des abréviations telles que .ou $pour les lignes actuelles et dernières respectivement. On pourrait également utiliser des préfixes relatifs +et -faire référence aux décalages après ou avant la ligne actuelle, respectivement. Ainsi: :.,$jsignifiant "de la ligne actuelle à la dernière ligne, joignez-les tous en une seule ligne". :%est synonyme de :1,$(toutes les lignes).

Les commandes :... get :... vportent une explication car elles sont incroyablement puissantes. :... gest un préfixe pour "globalement" appliquer une commande ultérieure à toutes les lignes qui correspondent à un modèle (expression régulière) tandis :... vqu'applique une telle commande à toutes les lignes qui ne correspondent pas au modèle donné ("v" de "conVerse"). Comme pour les autres commandes ex, celles-ci peuvent être préfixées par des références d'adressage / plage. Ainsi :.,+21g/foo/dsignifie "supprimer toutes les lignes contenant la chaîne" foo "de la ligne actuelle aux 21 lignes suivantes" tandis que :.,$v/bar/dsignifie "d'ici à la fin du fichier, supprimez toutes les lignes qui NE contiennent PAS la chaîne" bar ".

Il est intéressant de noter que la commande commune Unix grep a en fait été inspirée par cette commande ex (et est nommée d'après la façon dont elle a été documentée). L' ex commande :g/re/p(grep) était la façon dont ils ont documenté comment "globalement" "imprimer" les lignes contenant une "expression régulière" (re). Lorsque ed et ex étaient utilisés, la :pcommande était l'une des premières que quiconque apprenait et souvent la première utilisée lors de la modification d'un fichier. C'est ainsi que vous avez imprimé le contenu actuel (généralement une seule page à la fois en utilisant :.,+25pou quelque chose comme ça ).

Notez que :% g/.../dor (son homologue reVerse / conVerse: :% v/.../dsont les modèles d'utilisation les plus courants. Cependant, il existe quelques autres excommandes qui méritent d'être rappelées:

Nous pouvons utiliser mpour déplacer des lignes et jpour joindre des lignes. Par exemple, si vous avez une liste et que vous souhaitez séparer tous les éléments correspondant (ou inversement ne correspondant pas à un modèle) sans les supprimer, vous pouvez utiliser quelque chose comme: :% g/foo/m$... et toutes les lignes "foo" auront été déplacées vers la fin du fichier. (Notez l'autre astuce sur l'utilisation de la fin de votre fichier comme espace de travail). Cela aura conservé l'ordre relatif de toutes les lignes "foo" tout en les ayant extraites du reste de la liste. (Cela équivaudrait à faire quelque chose comme: 1G!GGmap!Ggrep foo<ENTER>1G:1,'a g/foo'/d(copier le fichier dans sa propre queue, filtrer la queue à travers grepet supprimer toutes les choses de la tête).

Pour joindre des lignes, je peux généralement trouver un modèle pour toutes les lignes qui doivent être jointes à leur prédécesseur (toutes les lignes qui commencent par "^" plutôt que "^ *" dans une liste à puces, par exemple). Pour ce cas, j'utiliserais: :% g/^ /-1j(pour chaque ligne correspondante, remontez d'une ligne et joignez-les). (BTW: pour les listes de balles en essayant de rechercher les lignes de balles et rejoindre à l'autre ne fonctionne pas pour plusieurs raisons ... il peut se joindre à une ligne de balle à l' autre, et il ne sera pas adhérer à une ligne de balle à tous de ses suites; cela ne fonctionnera que par paires sur les matchs).

Il est presque inutile de mentionner que vous pouvez utiliser notre vieil ami s(substitut) avec les commandes get v(global / converse-global). Vous n'avez généralement pas besoin de le faire. Cependant, considérez un cas où vous souhaitez effectuer une substitution uniquement sur les lignes correspondant à un autre modèle. Souvent, vous pouvez utiliser un modèle compliqué avec des captures et utiliser des références arrières pour conserver les parties des lignes que vous ne voulez PAS modifier. Cependant, il sera souvent plus facile de séparer le match de la substitution: :% g/foo/s/bar/zzz/g- pour chaque ligne contenant "foo" remplacer tous "bar" par "zzz". (Quelque chose comme:% s/\(.*foo.*\)bar\(.*\)/\1zzz\2/gne fonctionnerait que pour les cas où "bar" a été PRÉCÉDÉ par "foo" sur la même ligne; il est déjà assez disgracieux, et devrait être encore modifié pour attraper tous les cas où "bar" a précédé "foo")

Le point est qu'il ya plus que p, set les dlignes du exjeu de commandes.

Les :adresses peuvent également faire référence à des marques. Ainsi, vous pouvez utiliser: :'a,'bg/foo/jpour joindre n'importe quelle ligne contenant la chaîne foo à sa ligne suivante, si elle se situe entre les lignes entre les marques « a » et « b ». (Oui, tous les exexemples de commandes précédents peuvent être limités à des sous-ensembles des lignes du fichier en préfixant ces sortes d'expressions d'adressage).

C'est assez obscur (je n'ai utilisé quelque chose comme ça que quelques fois au cours des 15 dernières années). Cependant, je dois admettre que j'ai souvent fait des choses de manière itérative et interactive qui auraient probablement pu être faites plus efficacement si j'avais pris le temps de réfléchir à la bonne incantation.

Une autre commande vi ou ex très utile consiste :rà lire le contenu d'un autre fichier. Ainsi: :r fooinsère le contenu du fichier nommé "foo" à la ligne courante.

La :r!commande est plus puissante . Ceci lit les résultats d'une commande. Cela revient à suspendre la session vi , à exécuter une commande, à rediriger sa sortie vers un fichier temporaire, à reprendre votre session vi et à lire le contenu de temp. fichier.

Les commandes !(bang) et :... !( ex bang) sont encore plus puissantes . Ceux-ci exécutent également des commandes externes et lisent les résultats dans le texte actuel. Cependant, ils filtrent également les sélections de notre texte via la commande! Ceci, nous pouvons trier toutes les lignes de notre fichier à l'aide de 1G!Gsort( Gest la commande vi "goto"; elle revient par défaut à la dernière ligne du fichier, mais peut être préfixée par un numéro de ligne, tel que 1, la première ligne). C'est équivalent à la variante ex:1,$!sort . Les rédacteurs utilisent souvent !avec les utilitaires fmt ou fold d' Unix pour reformater ou "encapsuler" des sélections de texte. Une macro très courante est{!}fmt(reformater le paragraphe actuel). Les programmeurs l'utilisent parfois pour exécuter leur code, ou seulement des parties de celui-ci, via le retrait ou d'autres outils de reformatage de code.

L'utilisation des commandes :r!et !signifie que tout utilitaire ou filtre externe peut être traité comme une extension de notre éditeur. Je les ai parfois utilisés avec des scripts qui tiraient des données d'une base de données, ou avec des commandes wget ou lynx qui tiraient des données d'un site Web, ou des commandes ssh qui tiraient des données de systèmes distants.

Une autre commande ex utile est :so(abréviation de :source). Cela lit le contenu d'un fichier comme une série de commandes. Lorsque vous démarrez vi normalement, implicitement, effectue une :sourcesur le ~/.exinitrcfichier (et Vim fait généralement sur ~/.vimrc, assez naturellement). L'utilisation de ceci est que vous pouvez changer votre profil d'éditeur à la volée simplement en vous approvisionnant dans un nouvel ensemble de macros, d'abréviations et de paramètres d'éditeur. Si vous êtes sournois, vous pouvez même l'utiliser comme une astuce pour stocker des séquences d' ex commandes d'édition à appliquer aux fichiers à la demande.

Par exemple, j'ai un fichier de sept lignes (36 caractères) qui exécute un fichier via wc et insère un commentaire de style C en haut du fichier contenant ces données de comptage de mots. Je peux appliquer cette "macro" à un fichier en utilisant une commande comme:vim +'so mymacro.ex' ./mytarget

(L' +option de ligne de commande pour vi et Vim est normalement utilisée pour démarrer la session d'édition à un numéro de ligne donné. Cependant, c'est un fait peu connu que l'on peut suivre le +par n'importe quelle commande / expression ex valide , telle qu'une commande "source" comme J'ai fait ici; pour un exemple simple, j'ai des scripts qui invoquent: vi +'/foo/d|wq!' ~/.ssh/known_hostspour supprimer une entrée de mon fichier d'hôtes connus SSH de manière non interactive pendant que je réimagine un ensemble de serveurs).

Habituellement, il est beaucoup plus facile d'écrire de telles "macros" en utilisant Perl, AWK, sed (qui est, en fait, comme grep un utilitaire inspiré de la commande ed ).

La @commande est probablement la commande vi la plus obscure . En enseignant occasionnellement des cours avancés d'administration de systèmes pendant près d'une décennie, j'ai rencontré très peu de gens qui l'ont utilisé. @exécute le contenu d'un registre comme s'il s'agissait d'une commande vi ou ex .
Exemple: J'utilise souvent: :r!locate ...pour trouver un fichier sur mon système et lire son nom dans mon document. À partir de là, je supprime tous les hits superflus, ne laissant que le chemin d'accès complet au fichier qui m'intéresse. Plutôt que de Tabparcourir laborieusement chaque composant du chemin (ou pire, s'il se trouve que je suis bloqué sur une machine sans prise en charge de la tabulation) dans sa copie de vi ) j'utilise juste:

1. 0i:r(pour transformer la ligne courante en une commande valide : r ),
2. "cdd (pour supprimer la ligne dans le registre "c") et
3. @c exécutez cette commande.

Cela ne représente que 10 frappes (et l'expression "cdd @cest en fait une macro de doigt pour moi, donc je peux la saisir presque aussi rapidement que n'importe quel mot de six lettres).

Une pensée qui donne à réfléchir

Je n'ai fait qu'effleurer la puissance de vi et rien de ce que j'ai décrit ici ne fait même partie des "améliorations" pour lesquelles vim est nommé! Tout ce que j'ai décrit ici devrait fonctionner sur n'importe quelle ancienne copie de vi d'il y a 20 ou 30 ans.

Il y a des gens qui ont utilisé beaucoup plus de pouvoir de vi que jamais.

Vous parlez de la sélection et de la copie de texte, je pense que vous devriez jeter un œil au mode visuel Vim .

En mode visuel, vous pouvez sélectionner du texte à l'aide des commandes Vim, puis vous pouvez faire ce que vous voulez avec la sélection.

Considérez les scénarios courants suivants:

Vous devez sélectionner la parenthèse correspondante suivante.

Vous pourriez faire:

• v% si le curseur se trouve sur la parenthèse de début / fin
• vib si le curseur se trouve à l'intérieur du bloc de parenthèses

Vous souhaitez sélectionner du texte entre guillemets:

• vi " pour les guillemets doubles
• vi ' pour les guillemets simples

Vous souhaitez sélectionner un bloc d'accolade (très courant sur les langages de style C):

• viB
• vi{

Vous souhaitez sélectionner l'intégralité du fichier:

• ggVG

La sélection visuelle des blocs est une autre fonctionnalité très utile, elle vous permet de sélectionner une zone rectangulaire de texte, il vous suffit d'appuyer sur Ctrl- Vpour le démarrer, puis de sélectionner le bloc de texte que vous souhaitez et d'effectuer tout type d'opération comme le coup sec, la suppression, coller, éditer, etc. C'est génial d'éditer du texte orienté colonne .

Quelques conseils de productivité:

Mouvements intelligents

• *et #recherchez le mot sous le curseur avant / arrière.
• w au mot suivant
• W au mot suivant séparé par des espaces
• b/ eau début / à la fin du mot actuel. ( B/ Epour les espaces séparés uniquement)
• gg/ Gsaute au début / à la fin du fichier.
• % passer au {..} ou (..) correspondant, etc.
• {/ }passer au paragraphe suivant.
• '. revenir à la dernière ligne modifiée.
• g; revenir à la dernière position modifiée.

Commandes d'édition rapide

• I insérer au début.
• A ajouter à la fin.
• o/ Oouvre une nouvelle ligne après / avant le courant.
• v/ V/ Ctrl+Vmode visuel (pour sélectionner du texte!)
• Shift+R remplacer le texte
• C changer la partie restante de la ligne.

Combinaison de commandes

La plupart des commandes acceptent un montant et une direction, par exemple:

• cW = changer jusqu'à la fin du mot
• 3cW = changer 3 mots
• BcW = pour commencer le mot complet, changer le mot entier
• ciW = changer le mot intérieur.
• ci" = changer l'intérieur entre ".."
• ci( = changer le texte entre (..)
• ci<= changer le texte entre <..> (besoins set matchpairs+=<:>dans vimrc)
• 4dd = supprimer 4 lignes
• 3x = supprimer 3 caractères.
• 3s = remplacer 3 caractères.

Commandes de programmation utiles

• rremplacer un caractère (par exemple, rdremplace le caractère actuel par d).
• ~ change de cas.
• J joint deux lignes
• Ctrl + A / Ctrl + X incrémente / décrémente un nombre.
• . répéter la dernière commande (une simple macro)
• == correction du retrait de ligne
• > bloc de retrait (en mode visuel)
• < bloc indenté (en mode visuel)

Enregistrement macro

• Appuyez q[ key ]pour démarrer l'enregistrement.
• Appuyez ensuite sur qpour arrêter l'enregistrement.
• La macro peut être lue avec @[ key ].

En utilisant des commandes et des mouvements très spécifiques, VIM peut rejouer ces actions exactes pour les lignes suivantes. (par exemple, A pour ajouter à la fin, b/ epour déplacer le curseur respectivement au début ou à la fin d'un mot)

Exemple de paramètres bien construits

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

Les paramètres peuvent être stockés dans ~/.vimrc, ou à l'échelle du système /etc/vimrc.local, puis lus à partir du /etc/vimrcfichier en utilisant:

source /etc/vimrc.local

(vous devrez remplacer le #caractère de commentaire par "pour le faire fonctionner dans VIM, je voulais donner une coloration syntaxique appropriée ici).

Les commandes que j'ai répertoriées ici sont assez basiques, et les principales que j'utilise jusqu'à présent. Ils me rendent déjà beaucoup plus productif, sans avoir à connaître toutes les choses fantaisistes.

Le mécanisme Control+ Rest très utile :-) En mode insertion ou en mode commande (c'est-à-dire sur la :ligne lors de la saisie des commandes), continuez avec un registre numéroté ou nommé:

• a- zles registres nommés
• " le registre sans nom, contenant le texte de la dernière suppression ou copie
  
• % le nom du fichier actuel
  
• # le nom de fichier alternatif
  
• * le contenu du presse-papiers (X11: sélection principale)
  
• + le contenu du presse-papiers
  
• / le dernier modèle de recherche
  
• : la dernière ligne de commande
  
• . le dernier texte inséré
  
• - la dernière petite suppression (moins d'une ligne)
  
• =5*5 insérer 25 dans le texte (mini-calculatrice)

Voir :help i_CTRL-Ret :help c_CTRL-Rpour plus de détails, et fouiner à proximité pour plus de bonté CTRL-R.

Plugins Vim

Il y a beaucoup de bonnes réponses ici, et une étonnante sur le zen de vi. Une chose que je ne vois pas mentionnée est que vim est extrêmement extensible via des plugins. Il existe des scripts et des plugins pour lui faire faire toutes sortes de choses folles que l'auteur original n'a jamais envisagées. Voici quelques exemples de plugins vim incroyablement pratiques:

rails.vim

Rails.vim est un plugin écrit par tpope. C'est un outil incroyable pour les personnes qui développent des rails. Il fait des choses magiques contextuelles qui vous permettent de passer facilement d'une méthode dans un contrôleur à la vue associée, à un modèle et à des tests unitaires pour ce modèle. Il a permis d'économiser des dizaines, voire des centaines d'heures en tant que développeur de rails.

gist.vim

Ce plugin vous permet de sélectionner une région de texte en mode visuel et de taper une commande rapide pour la publier sur gist.github.com . Cela permet un accès facile à coller, ce qui est incroyablement pratique si vous collaborez avec quelqu'un via IRC ou IM.

space.vim

Ce plugin fournit des fonctionnalités spéciales à la barre d'espace. Il transforme la barre d'espace en quelque chose d'analogue à la période, mais au lieu de répéter des actions, il répète des mouvements. Cela peut être très pratique pour parcourir rapidement un fichier d'une manière que vous définissez à la volée.

surround.vim

Ce plugin vous donne la possibilité de travailler avec du texte qui est délimité d'une certaine manière. Il vous donne des objets qui dénotent des choses à l'intérieur de parens, des choses à l'intérieur de guillemets, etc. Il peut être utile pour manipuler du texte délimité.

supertab.vim

Ce script apporte une fonctionnalité de complétion d'onglets sophistiquée à vim. Le truc de saisie semi-automatique est déjà là dans le cœur de vim, mais cela l'amène à un onglet rapide plutôt qu'à plusieurs raccourcis multikey différents. Très pratique et incroyablement amusant à utiliser. Bien que ce ne soit pas l'intellisense de VS, c'est une grande étape et apporte beaucoup de fonctionnalités que vous attendez d'un outil de complétion d'onglets.

syntastic.vim

Cet outil apporte des commandes de vérification de syntaxe externe dans vim. Je ne l'ai pas utilisé personnellement, mais j'ai entendu beaucoup de choses à ce sujet et le concept est difficile à battre. Vérifier la syntaxe sans avoir à le faire manuellement est un excellent gain de temps et peut vous aider à détecter les bogues syntaxiques lorsque vous les introduisez plutôt que lorsque vous vous arrêtez enfin pour tester.

fugitive.vim

Accès direct à git depuis l'intérieur de vim. Encore une fois, je n'ai pas utilisé ce plugin, mais je peux voir l'utilitaire. Malheureusement, je suis dans une culture où svn est considéré comme "nouveau", donc je ne verrai probablement pas git au travail pendant un certain temps.

nerdtree.vim

Un navigateur d'arborescence pour vim. J'ai commencé à l'utiliser récemment, et c'est vraiment pratique. Il vous permet de mettre un treeview dans une division verticale et d'ouvrir facilement des fichiers. C'est très bien pour un projet avec beaucoup de fichiers sources entre lesquels vous passez fréquemment.

FuzzyFinderTextmate.vim

Il s'agit d'un plugin non maintenu, mais toujours incroyablement utile. Il offre la possibilité d'ouvrir des fichiers en utilisant une syntaxe descriptive "floue". Cela signifie que dans une arborescence clairsemée de fichiers, vous n'avez besoin que de taper suffisamment de caractères pour lever l'ambiguïté des autres fichiers.

Conclusion

Il existe de nombreux outils incroyables disponibles pour vim. Je suis sûr que je n'ai fait qu'effleurer la surface ici, et cela vaut la peine de chercher des outils applicables à votre domaine. La combinaison du puissant ensemble d'outils traditionnels de vi, des améliorations de vim et des plugins qui étendent encore plus vim, est l'un des moyens les plus puissants pour éditer du texte jamais conçu. Vim est facilement aussi puissant qu'emacs, eclipse, visual studio et textmate.

Merci

Merci à duwanis pour ses config vim dont j'ai beaucoup appris et emprunté la plupart des plugins listés ici.

. Répéter la dernière commande de modification de texte

Je gagne beaucoup de temps avec celui-ci.

Le mode visuel a été mentionné précédemment, mais le mode visuel de bloc m'a fait gagner beaucoup de temps lors de l'édition de colonnes de taille fixe dans un fichier texte. (accessible avec Ctrl-V).

gi

Aller au dernier emplacement modifié (très utile si vous avez effectué une recherche et que vous souhaitez revenir à l'édition)

^ P et ^ N

Complétez le texte précédent (^ P) ou suivant (^ N).

^ O et ^ I

Aller à l' emplacement précédent ( ^O- "O"pour l'ancien) ou au suivant ( ^I- "I"juste à côté de "O"). Lorsque vous effectuez des recherches, modifiez des fichiers, etc., vous pouvez parcourir ces «sauts» vers l'avant et l'arrière.

J'ai récemment (eu) découvert ce site: http://vimcasts.org/

C'est assez nouveau et vraiment très bon. Le gars qui gère le site est passé de textmate à vim et héberge de très bons et concis castings sur des sujets spécifiques de vim. Vérifiez-le!

CTRL+A incrémente le nombre sur lequel vous vous tenez.

Tout en mode normal:

f <char> pour passer à l'instance suivante d'un caractère particulier sur la ligne courante, et ; répéter.

F <char> pour passer à l'instance précédente d'un caractère particulier sur la ligne actuelle et ; répéter.

S'ils sont utilisés intelligemment, les deux ci-dessus peuvent vous permettre de vous déplacer rapidement en ligne.

* sur un mot pour rechercher l'instance suivante.

# sur un mot pour rechercher l'instance précédente.

Session

une. Sauvegarder la session

: mks sessionname

b. forcer la session de sauvegarde

: mks! nom de session

c. session de chargement

gvim ou vim -S nom de session

Addition et soustraction

une. Addition et soustraction

CTRL-A; Ajoutez [count] au nombre ou au caractère alphabétique au niveau ou après le curseur. {pas à Vi

CTRL-X; Soustrayez [count] du nombre ou du caractère alphabétique au niveau ou après le curseur. {pas à Vi}

b. Démappage des touches de la fenêtre

Dans la fenêtre, Ctrl-A déjà mappé pour la sélection de fichier entière, vous devez démapper dans le fichier rc. marquez la partie de mappage mswin.vim CTRL-A comme commentaire ou ajoutez votre fichier rc avec unmap

c. Avec macro

La commande CTRL-A est très utile dans une macro. Exemple: procédez comme suit pour créer une liste numérotée.

1. Créez la première entrée de liste, assurez-vous qu'elle commence par un nombre.
2. qa - démarrer l'enregistrement dans le tampon 'a'
3. Y - arracher l'entrée
4. p - mettre une copie de l'entrée en dessous de la première
5. CTRL-A - incrémenter le nombre
6. q - arrêter l'enregistrement
7. @a - répéter les temps de coup sec, de mise et d'incrément

La semaine dernière au travail, notre projet a hérité de beaucoup de code Python d'un autre projet. Malheureusement, le code ne correspondait pas à notre architecture existante - tout était fait avec des variables et des fonctions globales, qui ne fonctionneraient pas dans un environnement multithread.

Nous avions environ 80 fichiers qui devaient être retravaillés pour être orientés objet - toutes les fonctions déplacées dans les classes, les paramètres modifiés, les instructions d'importation ajoutées, etc. Nous avions une liste d'environ 20 types de correctifs à faire pour chaque fichier. J'estimerais qu'en le faisant à la main, une personne pourrait en faire 2 à 4 par jour.

J'ai donc fait le premier à la main, puis j'ai écrit un script vim pour automatiser les changements. La plupart était une liste de commandes vim, par exemple

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

Le dernier mérite un peu d'explication:

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

Pour quelques transformations plus complexes telles que la génération de toutes les instructions d'importation, j'ai incorporé du python dans le script vim.

Après quelques heures de travail, j'ai eu un script qui fera au moins 95% de la conversion. Je viens d'ouvrir un fichier dans vim puis d'exécuter :source fixit.vimet le fichier est transformé en un clin d'œil.

Nous avons encore le travail de changer les 5% restants qui ne valaient pas la peine d'être automatisés et de tester les résultats, mais en passant une journée à écrire ce script, j'estime que nous avons économisé des semaines de travail.

Bien sûr, il aurait été possible d'automatiser cela avec un langage de script comme Python ou Ruby, mais cela aurait pris beaucoup plus de temps à écrire et aurait été moins flexible - le dernier exemple aurait été difficile car le regex seul ne serait pas capable de gérer crochets imbriqués, par exemple pour convertir bar(foo(xxx))en foo(xxx).bar(). Vim était parfait pour la tâche.

Utilisez l'explorateur de fichiers intégré! La commande est :Exploreet elle vous permet de naviguer très rapidement dans votre code source. J'ai ces cartographies dans mon .vimrc:

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

L'explorateur vous permet également d'apporter des modifications aux fichiers. Je posterai certaines de mes touches préférées, en appuyant sur vous <F1>obtiendrez la liste complète:

• - : Le plus utile: passer au répertoire supérieur ( cd ..)
• mf : marquer un fichier
• D : Supprimer les fichiers marqués ou le fichier sur lequel se trouve le curseur, si rien n'est marqué.
• R : renommer le fichier sur lequel se trouve le curseur.
• ré : créer un nouveau répertoire dans le répertoire courant
• % : Créer un nouveau fichier dans le répertoire courant

Je suis membre de l'American Cryptogram Association. Le magazine bimensuel comprend plus de 100 cryptogrammes de différentes sortes. Environ 15 d'entre eux sont des "cryptarithmes" - différents types de problèmes arithmétiques avec des lettres substituées aux chiffres. Deux ou trois d'entre eux sont des sudokus, sauf avec des lettres au lieu de chiffres. Lorsque la grille est terminée, les neuf lettres distinctes épeleront un ou plusieurs mots, sur une ligne, une diagonale, une spirale, etc., quelque part dans la grille.

Plutôt que de travailler avec un crayon ou de taper les problèmes à la main, je télécharge les problèmes depuis la zone membres de leur site Web.

Lorsque je travaille avec ces sudokus, j'utilise vi, simplement parce que j'utilise des fonctionnalités que vi possède que peu d'autres éditeurs. Surtout lors de la conversion de la grille lettrée en une grille numérotée, car je trouve plus facile à résoudre, puis la grille numérotée terminée dans la grille lettrée pour trouver le ou les mots de la solution.

Le problème est formaté en neuf groupes de neuf lettres, avec - s représentant les blancs, écrits sur deux lignes. La première étape consiste à les formater en neuf lignes de neuf caractères chacune. Il n'y a rien de spécial à cela, il suffit d'insérer huit sauts de ligne aux endroits appropriés.

Le résultat ressemblera à ceci:

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

Ainsi, la première étape de la conversion en chiffres consiste à dresser une liste des lettres distinctes. Tout d'abord, je fais une copie du bloc. Je positionne le curseur en haut du bloc, puis tape :y}}p. :me met en mode commande, ytire sur la prochaine commande de mouvement. Puisqu'il }s'agit d'un passage à la fin du paragraphe suivant, y}tire le paragraphe. }déplace ensuite le curseur à la fin du paragraphe et pcolle ce que nous avions tiré juste après le curseur. Doncy}}p une copie du paragraphe suivant, et se retrouve avec le curseur entre les deux copies.

Ensuite, je vais transformer l'un de ces exemplaires en une liste de lettres distinctes. Cette commande est un peu plus complexe:

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

:me met à nouveau en mode commande. !indique que le contenu du prochain coup sec doit être acheminé via une ligne de commande. }tire le paragraphe suivant et la ligne de commande utilise ensuite la trcommande pour supprimer tout sauf les lettres majuscules, la sedcommande pour imprimer chaque lettre sur une seule ligne et la sortcommande pour trier ces lignes, supprimer les doublons, puis trsupprimer les nouvelles lignes, laissant les neuf lettres distinctes sur une seule ligne, remplaçant les neuf lignes qui avaient constitué le paragraphe à l'origine. Dans ce cas, les lettres sont: ACELNOPST.

L'étape suivante consiste à faire une autre copie de la grille. Et puis d'utiliser les lettres que je viens de remplacer identifiais chacune de ces lettres par un chiffre de 1 à 9. C'est simple: :!}tr ACELNOPST 0-9. Le résultat est:

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

Cela peut ensuite être résolu de la manière habituelle, ou entré dans n'importe quel solveur sudoku que vous préférez. La solution terminée peut ensuite être reconvertie en lettres avec :!}tr 1-9 ACELNOPST.

Il y a du pouvoir dans vi qui est égalé par très peu d'autres. Le plus gros problème est que seuls quelques livres de didacticiels vi, sites Web, fichiers d'aide, etc., font plus que toucher à peine la surface de ce qui est possible.

Manipulations de texte en masse!

Soit à travers des macros:

• Commencez avec l'enregistrement: qq
• Faire des trucs
• Arrête d'enregistrer: q
• Répétez: @q(la première fois), @@après cela.
• Répétez 20 fois: 20@@

Ou par des expressions régulières:

• Remplacer des trucs: :%s/[fo]+/bar/g

(Mais attention: si vous faites ce dernier, vous aurez 2 problèmes :).)

J'ai découvert récemment q: . Il ouvre la "fenêtre de commande" et affiche vos commandes d'ex-mode (mode de commande) les plus récentes. Vous pouvez vous déplacer comme d'habitude dans la fenêtre et appuyer sur <CR>exécute la commande. Vous pouvez également modifier, etc. Inestimable lorsque vous vous amusez avec une commande ou une expression rationnelle complexe et que vous ne voulez pas retaper le tout, ou si la chose complexe que vous voulez faire était de 3 commandes en arrière. C'est presque comme bashset -o vi , mais pour vim lui-même (heh!).

Voir :help q:pour des bits plus intéressants pour aller et venir.

Je viens de découvrir l'omnicompletion de Vim l'autre jour, et bien que j'admette que je suis un peu flou sur ce qui fait quoi, j'ai eu des résultats étonnamment bons en écrasant soit Ctrl+ x Ctrl+ uou Ctrl+ n/ Ctrl+ pen mode insertion. Ce n'est pas tout à fait IntelliSense , mais je l'apprends toujours.

Essaye le! :help ins-completion

Ce ne sont pas des raccourcis, mais ils sont liés:

1. Faire de capslock un ESC supplémentaire (ou Ctrl)
2. mappez le leader à "," (virgule), avec cette commande: let mapleader = ","

Ils augmentent ma productivité.

Un autre "raccourci" vi utile que j'utilise fréquemment est 'xp'. Cela permutera le caractère sous le curseur avec le caractère suivant.

<Ctrl> + W, V pour diviser l'écran verticalement
<Ctrl> + W, W pour basculer entre les fenêtres

! python% [args] pour exécuter le script que je modifie dans cette fenêtre

ZF en mode visuel pour plier des lignes arbitraires

Mode visuel

Comme plusieurs autres l'ont dit, le mode visuel est la réponse à votre problème de copier / couper et coller. Vim vous donne «v», «V» et Cv. Le «v» minuscule dans vim est essentiellement le même que la touche Maj dans le bloc-notes. La bonne chose est que vous n'avez pas à le maintenir enfoncé. Vous pouvez utiliser n'importe quelle technique de mouvement pour naviguer efficacement jusqu'au point de départ (ou d'arrivée) de votre sélection. Appuyez ensuite sur «v» et utilisez à nouveau des techniques de mouvement efficaces pour naviguer à l'autre extrémité de votre sélection. Ensuite, «d» ou «y» vous permet de couper ou de copier cette sélection.

L'avantage du mode visuel de vim par rapport à la description de Jim Dennis de couper / copier / coller dans vi est que vous n'avez pas besoin d'obtenir l'emplacement exact. Parfois, il est plus efficace d'utiliser un mouvement rapide pour se rendre à proximité de l'endroit où vous voulez aller, puis d'affiner cela avec d'autres mouvements que de penser à une commande de mouvement unique plus complexe qui vous amène exactement où vous voulez aller.

L'inconvénient de l'utilisation intensive du mode visuel de cette manière est qu'il peut devenir une béquille que vous utilisez tout le temps, ce qui vous empêche d'apprendre de nouvelles commandes vi (m) qui pourraient vous permettre de faire les choses plus efficacement. Cependant, si vous êtes très proactif dans l'apprentissage de nouveaux aspects de vi (m), cela ne vous affectera probablement pas beaucoup.

Je soulignerai également que les modes ligne visuelle et bloc visuel vous offrent des variations sur ce même thème qui peuvent être très puissantes ... en particulier le mode bloc visuel.

Sur l'utilisation efficace du clavier

Je suis également en désaccord avec votre affirmation selon laquelle l'alternance des mains est le moyen le plus rapide d'utiliser le clavier. Il contient un élément de vérité. De manière très générale, l'utilisation répétée de la même chose est lente. Cet exemple le plus significatif de ce principe est que les frappes consécutives tapées avec le même doigt sont très lentes. Votre affirmation découle probablement de la tendance naturelle à utiliser la transformation s / doigt / main / sur ce modèle. Dans une certaine mesure, c'est correct, mais à l'extrémité extrêmement élevée du spectre d'efficacité, c'est incorrect.

Demandez à n'importe quel pianiste. Demandez-leur s'il est plus rapide de jouer une succession de quelques notes en alternant les mains ou en utilisant les doigts consécutifs d'une seule main en séquence. Le moyen le plus rapide pour taper 4 touches n'est pas d'alterner les mains, mais de les taper avec 4 doigts de la même main dans l'ordre croissant ou décroissant (appelez cela un "run"). Cela devrait être évident une fois que vous avez envisagé cette possibilité.

Le problème le plus difficile est l'optimisation pour cela. Il est assez facile d'optimiser la distance absolue sur le clavier. Vim fait ça. Il est beaucoup plus difficile à optimiser au niveau "run", mais vi (m) avec son édition modale vous donne une meilleure chance de pouvoir le faire que n'importe quelle approche non modale (ahem, emacs) ne pourrait jamais.

Sur Emacs

De peur que les fanatiques emacs ne négligent complètement mon post en raison de ce dernier commentaire entre parenthèses, je pense que je dois décrire la racine de la différence entre les religions emacs et vim. Je n'ai jamais pris la parole dans les guerres de l'éditeur et je ne le referai probablement pas, mais je n'ai jamais entendu personne décrire les différences de cette façon, alors voilà. La différence est le compromis suivant:

Vim vous offre une efficacité inégalée d'édition de texte brut Emacs vous offre une capacité inégalée de personnaliser et de programmer l'éditeur

Les fanatiques aveugles de vim diront que vim a un langage de script. Mais c'est un langage obscur et ad hoc qui a été conçu pour servir l'éditeur. Emacs a Lisp! Assez dit. Si vous n'appréciez pas la signification de ces deux dernières phrases ou si vous souhaitez en savoir suffisamment sur la programmation fonctionnelle et Lisp pour développer cette appréciation, vous devez utiliser vim.

Les fanatiques emacs prétendent qu'emacs a le mode viper, et c'est donc un surensemble de vim. Mais le mode viper n'est pas standard. Ma compréhension est que le mode viper n'est pas utilisé par la majorité des utilisateurs d'emacs. Comme ce n'est pas la valeur par défaut, la plupart des utilisateurs d'emacs ne développent probablement pas une véritable appréciation des avantages du paradigme modal.

À mon avis, ces différences sont orthogonales. Je crois que les avantages de vim et emacs tels que je les ai énoncés sont tous deux valables. Cela signifie que l'éditeur ultime n'existe pas encore. Il est probablement vrai qu'emacs serait la plate-forme la plus simple sur laquelle baser l'éditeur ultime. Mais l'édition modale n'est pas ancrée dans l'état d'esprit emacs. La communauté emacs pourrait évoluer de cette façon à l'avenir, mais cela ne semble pas très probable.

Donc, si vous voulez une efficacité d'édition brute, utilisez vim. Si vous voulez l'environnement ultime pour l'écriture de scripts et la programmation, utilisez votre éditeur emacs. Si vous voulez certains des deux en mettant l'accent sur la programmabilité, utilisez emacs avec le mode viper (ou programmez votre propre mode). Si vous voulez le meilleur des deux mondes, vous n'avez pas de chance pour l'instant.

Passez 30 minutes à faire le didacticiel vim (exécutez vimtutor au lieu de vim dans le terminal). Vous apprendrez les mouvements de base et quelques touches, cela vous rendra au moins aussi productif avec vim qu'avec l'éditeur de texte que vous avez utilisé auparavant. Après cela, eh bien, relisez la réponse de Jim Dennis :)

Quelle est la façon dont vous utilisez Vim qui vous rend plus productif qu'avec un éditeur contemporain?

Être capable d'exécuter des modifications complexes et répétitives avec très peu de touches (souvent à l'aide de macros ). Jetez un œil à VimGolf pour être témoin de la puissance de Vim!

Après plus de dix ans d'utilisation presque quotidienne, il est difficile d'imaginer utiliser un autre éditeur.

Utilisez \cn'importe où dans une recherche pour ignorer la casse (en remplaçant vos paramètres d'ignorecase ou de smartcase). Par exemple , /\cfooou /foo\ccorrespondent foo, Foo, fOO, FOO, etc.

Utilisez-le \Cn'importe où dans une recherche pour forcer la correspondance de casse. Par exemple, /\Cfooou /foo\Cne correspondra qu'à foo.

J'ai été surpris de ne voir personne mentionner le tmouvement. Je l'utilise fréquemment avec des listes de paramètres sous la forme dt,ouyt,

Personne étrange n'a mentionné les ctags. Téléchargez "ctags exubérants" et placez-le devant la version préinstallée merdique que vous avez déjà dans votre chemin de recherche. Cd à la racine de tout ce sur quoi vous travaillez; par exemple la distribution du noyau Android. Tapez "ctags -R." pour construire un index des fichiers source n'importe où sous ce répertoire dans un fichier nommé "tags". Celui-ci contient toutes les balises, nomatter la langue ni où dans le répertoire, dans un seul fichier, donc le travail cross-langue est facile.

Ouvrez ensuite vim dans ce dossier et lisez: help ctags pour certaines commandes. J'en utilise souvent:

• Placez le curseur sur un appel de méthode et tapez CTRL-] pour accéder à la définition de méthode.

• Tapez: un nom pour accéder à la définition du nom.

Indentation automatique:

gg(aller au début du document)
=(temps de retrait!)
shift-g(aller à la fin du document)

Vous aurez besoin du «plugin de type de .vimrcfichier mis en retrait» dans votre fichier, et probablement des paramètres «shiftwidth» et «expandtab» appropriés.

Vous avez posé des questions sur les raccourcis productifs, mais je pense que votre vraie question est: est-ce que vim en vaut la peine? La réponse à cette question de stackoverflow est -> "Oui"

Vous devez avoir remarqué deux choses. Vim est puissant et vim est difficile à apprendre. Une grande partie de sa puissance réside dans son extensibilité et sa combinaison infinie de commandes. Ne vous sentez pas dépassé. Va lentement. Une commande, un plugin à la fois. N'en faites pas trop.

Tout cet investissement que vous investissez dans vim sera remboursé mille fois. Vous allez être dans un éditeur de texte pendant de nombreuses heures avant de mourir. Vim sera votre compagnon.

Plusieurs tampons, et en particulier un saut rapide entre eux pour comparer deux fichiers avec :bpet :bn(correctement remappés en un seul Shift+p ou Shift+ n)

vimdiff mode (se divise en deux tampons verticaux, avec des couleurs pour montrer les différences)

Copie de zone avec Ctrl +v

Et enfin, tabulation des identifiants (recherchez "mosh_tab_or_complete"). C'est ça qui change la vie.

D'accord avec l'affiche du haut - le : r! la commande est très utile.

Le plus souvent, je l'utilise pour "coller" des choses:

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

De cette façon, je n'ai pas à jouer avec :set paste.