Mirmo Dynamics - Tag - vim

Automatically cd to a symfony project's root in vim

Geoffrey — Wed, 18 Mar 2009 14:10:00 +0100

I made a little vimscript to automatically cd to the project root of a symfony project. It makes it easier for me to use the ctags :-)

"-------------------------------------------------------------------------------
"  Description: Finds and cd to the symfony root of the project
"    Copyright: Copyright (C) 2009 Geoffrey Bachelet
"   Maintainer: Geoffrey Bachelet
"      Version: 1.0
"-------------------------------------------------------------------------------

if exists('find_symfony_root_loaded')
  finish
endif

let find_symfony_root_loaded = 1

if ! exists('find_symfony_root_symfony_executable')
  let find_symfony_root_symfony_executable = 'symfony'
endif

" root detection when opening a new vim seems to work
" only if these two events are bound. not sure why.
autocmd BufWinEnter,BufRead * call FindSymfonyRoot()

function FindSymfonyRoot()
  let l:cwd = GetAbsoluteDirname(@%)
  let l:symfony_root = findfile(g:find_symfony_root_symfony_executable, l:cwd.';')
  let l:symfony_root = GetAbsoluteDirname(l:symfony_root)
  if strlen(l:symfony_root) != 0
    execute 'cd '.l:symfony_root
  endif
endfunction

function GetAbsoluteDirname(path)
  let l:path = a:path
  " gets the dirname
  if !isdirectory(l:path)
    let l:path = strpart(l:path, 0, strridx(l:path, '/'))
  endif

  " makes it absolute
  if match(l:path, '/') != 0
    let l:path = getcwd().'/'.l:path
  endif

  return l:path
endfunction

note for later: add vimscript support to geshi

Or see the highlighted version on gist.

having fun with vim, an event tracker

Geoffrey — Sun, 08 Mar 2009 21:16:00 +0100

The idea of this script came by realizing that the main reason I (almost) never fill my timesheet, is because I just forget it. How easier could it be if my editor (namely vim) could fill it for me ? Or at least, help me fill it. This script is meant to help this process. It will hook to every configured event (in the code below, BufRead and BufNewFile) and add a log line to the log file. Easy heh ? Of course, the script it self won't be of much use, I'll have to add some more events to track as well as writting some kind of frontend for it, with reporting & all.

if exists('trackloaded')
  finish
endif

" list of autocmd events:
" http://www.vim.org/htmldoc/autocmd.html#autocmd-events
let trackevents = ['BufRead', 'BufNewFile', 'BufEnter', 'BufWrite', 'BufLeave']
let trackfile   = '/tmp/timetrack.dat'
let trackloaded = 1

for event in trackevents
  execute 'autocmd '.event.' * call Track("'.event.'")'
endfor

unlet event

function Track(event)
  let l:filename = @%
  if l:filename != g:trackfile
    if match(l:filename, '/') != 0
      let l:filename = getcwd().'/'.l:filename
    endif
    silent execute '!echo `date +\%s` '.a:event.' '.l:filename.' >> '.g:trackfile
  endif
endfunction

You might note from this snippet that I'm not very comfortable with vimscripting :-) If you have a better way of doing this (I'm thinking mostly about the file writting here), don't hesitate to tell me.

Mass vim file opening reloaded

Geoffrey — Thu, 16 Oct 2008 21:20:00 +0200

Thinking about it, the snippet I posted earlier was a bit silly as vim can open by itself multiple files way more efficiently. The only benefit from my script is that I don't have to type the --servername and --remote-silent-tab.

So let's add some usefulness ! First, when I need this script, it's often that I first grepped the files, and then decide that I want to edit them all. From this point of view, having to pass them as arguments is not that handy, so we'll add a way to pass them via STDIN.

Also, what if I want to send them to another vim server ? We'll add this ability too.

Here is the resulting script:

#!/usr/bin/env bash

# set a default SERVERNAME
SERVERNAME="ash0"

# look for files on stdin
if ! [ -t 0 ]; then
  FILES=`cat /dev/stdin`
else
  exit;
fi;

# now let's check if we want a specific vim server
if ! [ -z $1 ]; then
  SERVERNAME=$1
fi;

# we can now open the files
/usr/bin/gvim --servername $SERVERNAME --remote-silent-tab $FILES

Tada !

You can now do the followings:

grep foo | sendtovim
grep foo | sendtovim grep0

Mass vim file opening

Geoffrey — Tue, 14 Oct 2008 19:40:00 +0200

Remember my old post about vim and rox-filer ? Well I've got one tiny and silly addition to it now, I can mass open files from any shell command line, with this little script placed in my ~/bin/ (don't forget to chmod +x):

for i in $*; do
  /usr/bin/gvim --servername ash0 --remote-silent-tab $i
  sleep 1
done;

The sleep 1 is necessary as vim does not seem to like being flooded with files.

Example usage:

sendtovim `grep foo *`

Opens in vim all files containing "foo" in the current directory. Who said handy ?

Note: I know have an updated and useful version of this script

Remplacer un caractère par un "Carriage Return" dans vim

Geoffrey — Wed, 03 Jan 2007 11:04:00 +0100

Par exemple, imaginons qu'on récupère une query string, et qu'on veuille l'exploser sur plusieurs lignes, on peut faire:

:s/&/\="\<CR>"/g

le \="" annonce à VIM que la chaine de substitution sera une chaine a interpréter avant utilisation, et le \<CR> représente tout simplement le Carriage Return.

Linux + gVim + Rox-filer = Mon IDE.

Geoffrey — Tue, 28 Nov 2006 22:39:00 +0100

Une des questions cruciales qui se pose à tout développeur à au moins un moment de sa vie (souvent plusieurs en fait) est le choix d'un environnement de développement. J'en ai testé pas mal, plus ou moins longtemps, et bien que je ne sois jamais complètement satisfait, l'idée de perdre du temps à développer le mien m'indispose. J'ai donc opté pour l'environnement qui me va le mieux: Linux + gVim + Rox-filer.

Note: je ne couvre pas ici les fonctionnalités de débuging avancé, que je n'utilise pas encore, mais pour lesquelles j'ai déjà en tête des solutions qui me conviendront bien mieux que les outils intégrés à un quelconque IDE (je pense fortement à Xdebug).

Comment définir un IDE ?

Commençons par le début: qu'est-ce qu'un IDE ? Acronyme de Integrated Development Environment, le terme peut prendre pas mal de signification selon la personne à laquelle on s'adresse. Pour certains, le plus c'est le mieux, alors que pour d'autre, le moins c'est le pas plus mal finalement. On pourra citer quelques exemples connus d'IDE full-featured, tels que les incournables Zend Studio, Eclipse et autres phpEdit, mais ce n'est pas le but de cet article. Ici, je vais vous expliquer pourquoi et comment j'utilise quotidiennement gVim et Rox-filer, et le tout sous Ubuntu.

Revenons en à nos moutons, un environnement de développement, c'est constitué de quelques briques primordiales:

Un éditeur de code
Un navigateur de fichier
Un truc qui fait tourner tout ça

Peu importe qu'ils soient intégrés ou non, finalement. Personnellement, je suis un fervent adepte du précepte une tâche, un outil, donc je preferre qu'ils soient dissociés.

L'éditeur de code: gVim

Certains perdent leurs moyens à la simple évocation de son nom, vim n'est pourtant rien de plus que le plus puissant des éditeurs de fichier aujourd'hui disponible dans le monde (un troll s'est malicieusement glissé dans cette affirmation, saurez-vous le retrouver ?). Ce qui déroute au premier abord dans vim, c'est finalement ce qui fait toute sa puissance: le mode commande. J'ai longtemps utilisé bluefish, et finalement las de ses quelques bugs bien énervants (wtf syntax color ?), j'ai décidé de faire le grand pas, et d'utiliser vim. J'avais bien sur déjà une expérience de cet éditeur, mais retenez bien que le meilleur moyen de maitriser un outil aussi puissant que vim, ce n'est pas de se jeter à corps perdu dans la doc, mais c'est d'investir du temps incrémentiellement: commencer à utiliser vim, et quand on souhaite faire quelque chose qu'on ne sait pas faire, lire la doc correspondante^[1]. Pour finir, j'ai traduit il y a quelque temps un excellent tutoriel sur vim: L'édition efficace avec vim, donc n'hésitez pas.

Un .vimrc qu'il est joli

Comme la plupart des applications *nix, vim autorise l'utilisation d'un fichier ~/.vimrc. S'il peut paraitre compliqué au premier abord d'élaborer un .vimrc efficace, il ne faut pas se décourager, car comme d'habitude, il y a tout ce qu'il faut sur le net. J'en veux pour preuve les excellents articles de Tobias Schlitt à ce sujet.

Pour info, quelques directives de configuration utiles qu'on peut trouver dans mon .vimrc:

" Supprime un buffer de la mémoire via le raccourci clavier Ctrl+W
noremap <C-W> :bdel!<CR>

" Active l'indentation automatique
set autoindent

" Active les plugins de type de fichier
filetype plugin on

" Active la coloration syntaxique
syntax on

" Thème de couleur pour gVim
colorscheme desert

" Utiliser des tabs de 4 caractères pour l'indentation
set noexpandtab tabstop=4 shiftwidth=4

" Activer la souris (molette, sélection, etc)
set mouse=a

" Afficher des infos dans la barre de status
set ruler
set laststatus=2

" Activer la numérotation des lignes
set number

" Utiliser la recherche incrémentielle
set incsearch

" Ne pas surligner les résultats de recherche
set nohlsearch

Quelques unes (beaucoup en fait) de ces directives sont tirées du .vimrc de Tobias.

Dernier détail pour les réfractaires de la ligne de commande, gVim s'execute en mode graphique, avec une interface GTK conviviale qui permet d'apprendre les raccourcis aisément, et qui gère la souris (défilement à la molette, etc, et d'ailleurs, même en console ça gère la souris, il suffit d'un :set mouse="a" pour l'activer).

Un ftplugin pour le PHP

Ce qu'on appelle ftplugin dans vim permet de configurer vim en fonction du type de fichier que l'on édite. Tobias fournit un ftplugin spécialisé dans l'édition du PHP plutôt bien foutu, qui gère la plupart des features convi-enabled des soit disants IDE évolués:

Complétion des fonctions
Complétion des mots-clés
Auto-fermeture des crochets, parenthèses, etc.
Auto-génération des docblocks PHPDoc
Vérification de syntaxe du fichier édité
Et d'autres trucs merveilleux !

La classe non ?

Un navigateur de fichier kirox (tm)

C'est pas moi qui le dit, en fait c'est comme le port-salut, rox-filer rox, c'est tout. Pour ceux que ma puissance de persuasion ne suffit pas, et bien rox-filer offre tout ce que vous pourriez attendre d'un gestionnaire de fichier moderne:

Navigation spatiale avec technologie oupas (tm)
Prévisualisation des images
Personnalisation (aisée !) des applications utilisées pour lancer les fichiers (en fonction du mimetype)
Navigation one-click (oupas (tm))
Navigation aisée au clavier
Monitorage des fichiers en cours d'utilisation (ils apparaissent en gras, ce qui est pratique).
Et j'en passe et des meilleurs.

Bref, il fait tout ce que ferait un filebrowser intégré, mais en mieux, puisqu'il est dédié dès le début à cette tache. Afin de le faire interragir au mieux avec gVim, j'utilise la Run action suivante sur le mimetype text/*:

gvim --servername ash0 --remote-silent-tab "$@"

Qui permet d'ouvrir le fichier dans un nouveau tab de vim, en créant une instance d'un server vim à la volée si il n'existe pas déjà (ici le server s'appelle ash0, mais vous pouvez bien évidemment en changer le nom).

Une distribution du bien: Ubuntu

Et parcequ'il faut bien faire tourner tout ça, j'utilise un système d'exploitation du bien (tm): GNU/Linux. Mais comme j'ai la flemme, j'utilise une configuration convi-enabled: Ubuntu. Pas besoin de s'étaler je pense, Ubuntu c'est bien, tout le monde en conviendra.

Un window-manager léger et puissant: fluxbox

Le choix du gestionnaire de fenêtre peut par contre préter a controverse. En effet, c'est ici avant tout une question de gout et de puissance de machine. J'ai personellement un penchant pour les logiciels puissants et légers. Là je vous vois venir avec vos gros sabots: tout le monde veut ce genre de logiciel. Et bien j'ai envie de répondre que non. La majorité des neo-geeks de la génération Ubuntu s'en donnent à coeur joie sous Gnome et/ou KDE, qui est loin de ce qu'il convient d'appeler un logiciel puissant et léger, sous prétexte que les autres WM (à part KDE), saitrocomplicai. Bon là ok, j'amalgame surement un peu (beaucoup même, tous les gens sous Gnome ne sont pas des neo-geek, et l'inverse également), mais il manquait un peu de trollitude dans cet article. Bref, quand on veut, on peut, et comme les gens ne switchent pas de Gnome à un WM plus puissant et plus léger, j'en conclus (peut-être à tord hein) qu'ils ne veulent pas.

Tout ça pour dire que j'utilise fluxbox, et ce depuis ma plus tendre enfance. Fluxbox est léger (osez prétendre le contraire...) et puissant: il permet:

de reconfigurer l'intégralité du comportement de vos fenêtres
une gestion fine et puissante des raccourcis claviers (j'ai pu reconfigurer les touches convi de mon clavier convi en quelques minutes dans mon .fluxbox/keys grâce à xev).
de controler facilement quelles applications se lancent au démarrage
de controler encore plus facilement sur quels bureaux se lancent les sus-citées applications

Par exemple, mon .fluxbox/startup démarre sur le premier bureau quelques terminaux, un gaim et un exaile; sur le deuxième bureau un firefox sur le troisième bureau: sylphee, et sur le quatrième bureau, un rox-filer. A coté de ça, je dispose de raccourcis claviers conviviaux pour lancer mes logiciels favoris: le terminal (Mod4^[2]+e), rox-filer (Mod4+r), etc. J'ai également à ma disposition des raccourcis claviers pour gérer mes fenêtres: maximiser (horizontalement (Ctrl+Alt+H), verticalement -Ctrl+Alt+V), ou les deux (Ctrl+Alt+M)), enrouler (Mod4+S), sticker (Ctrl+Alt+S), enlever les décorations (Ctrl+Alt+T), et j'en passe.

Enfin, et le plus important pour moi, fluxbox est non-intrusif. Par défaut, un bureau standard de mon fluxbox ne contient rien. Pas de barre des taches, pas d'icones, pas de menu, rien. Question de gout je vous l'accorde, mais là encore, notez que "c'est faisable": fluxbox ne vous impose rien, et surtout pas les choix discutables car subjectifs des développeurs.

Subversion en ligne de commande

Enfin, j'utilise le client subversion en ligne de commande. D'une part parceque je ne connais pas de client digne de ce nom en GTK (ma religion m'interdit d'utiliser Qt), d'autre part pour profiter pleinement de la puissance qu'offre un shell quand on sait un minimum s'en servir. Pouvoir passer mes commandes svn dans des awk, sed, et autres grep (surtout grep en fait), ça n'a pas de prix, et je pense vraiment qu'aucune interface graphique n'arrivera jamais à la cheville de la puissance d'un shell.

Deuxième avantage à utiliser svn en ligne de commande: le jour où je serais obligé de le faire, je saurais le faire.

Conclusion

Voilà, vous savez (presque) tout de mes habitudes de travail (il reste pas mal de domaines à couvrir quand même, je n'ai pas parlé par exemple de mes extensions firefox favorites, ni de mon utilisation intensive de trac, et encore moins des tests unitaires, peut-être une prochaine fois), et j'espère vous avoir donné l'envie de regarder d'un peu plus près ces outils à la réputation peut-être un peu geek, mais d'une puissance incomparable une fois maitrisés :-)

Notes

[1] :help commande est en général d'une grande utilité

[2] Le petit nom de la touche Windows

Gestion des charset sous vim

Geoffrey — Wed, 12 Jul 2006 12:50:00 +0200

Ne vous attendez pas a trouver un guide exhaustif de la gestion des encodages de caractères sous VIM dans ce billet, d'autres sites et surtout la doc fait ça beaucoup mieux que moi. Je m'en vais juste vous présenter le minimum vital pour vous dépatouiller dans ce foutoire que sont les charset. Le saint graal est consistué de deux variables de configuration: encoding et fileencoding. Les plus perspicaces auront déjà compris les quelques explications qui suivent.

encoding est la variable qui détermine l'encodage des caractères en cours d'édition, tandis que fileencoding contient l'encodage qui sera utilisé à la sauvegarde du fichier.

Concrétement, si vous tapez:

:set encoding=utf-8
:set fileencoding=iso-8859-15

Vous pouvez copier/coller du texte en UTF-8, et quand vous sauvegarderez votre fichier (:w par exemple), vos données seront automatiquement convertie et sauvegardée en ISO-8859-15.

Trop utiliser VIM peut rendre dépendant.

Geoffrey — Mon, 26 Jun 2006 10:58:34 +0000

geoffrey@PROD000005:~$ ls
bin   Desktop      helloworld.jpg     openvpn      tmp   xml
code  Documents    Network            public_html  tmp2
dc2   Extractions  OnRefaitMatch.xml  tests        :w

Ce n'est pas un fake. Et pour ceux qui ne comprennent pas, tant pis pour vous.

L'édition efficace avec vim

Geoffrey — Sat, 08 May 2004 23:20:02 +0000

Encore une traduction d'un article de Jonathan McPherson ! Cette fois l'article porte sur vim, l'éditeur de texte des décideurs pressés. Les remerciements vont cette fois à Grégoire Gilbert qui m'a traduit plus de la moitié de l'article quand même :)

"To me, vi is Zen.
To use vi is to practice zen.
Every command is a koan.
Profound to the user,
unintelligible to the uninitiated.
You discover truth every time you use it."

--reddy@lion.austin.com

Ce tutoriel recquiert des connaissances de base de vim -- mode insertion, mode commande, charger et sauver des fichiers, etc. Il a pour but d'aider les novices à développer leurs compétences pour utiliser vi efficacement.

Dans ce tutoriel, <C-X> signifie Ctrl-X -- c'est à dire, gardez la touche Ctrl enfoncée et appuyez sur X. Vous pouvez obtenir de l'aide sur la plupart des commandes utilisées en tapant :help command dans vim, en remplaçant command par ce sur quoi vous voulez de l'aide.

Se déplacer efficacement

Rester en dehors du mode insertion

En général, vous voulez passer le moins de temps possible dans le mode insertion de vim, car ce mode fait agir vim comme un stupide éditeur de texte. C'est pourquoi la plupart des novices passent tant de temps en mode insertion -- il rend vim facile à utiliser. Mais la vraie puissance de vim réside dans le mode commande ! Vous verrez que mieux vous connaitrez vim, moins vous passerez de temps en mode insertion.

Utilisez h, j, k et l

Le premier pas vers l'édition efficace avec vim est de vous sevrer des touches flèches. Un des avantages du design de vim est que vous n'avez pas constamment besoin de bouger vos mains entre les touches flèches et les touches lettres; quand vous êtes en mode commande, les lettres h, j, k et l correspondent aux directions gauche, bas, haut et gauche respectivement. Cela nécessite un peu d'entraïnement pour s'y habituer, mais vous verrez la différence quand vous y serez habitué.

Quand vous éditez un e-mail ou un autre texte formatté par paragraphes, vous remarquerez peut-être que les touches de direction sautent plus de lignes que vous ne le voudriez. C'est parceque vos paragraphes apparaissent comme une seule longue ligne dans vim. Tapez g avant h, j, k ou l pour bouger d'une ligne écran plutôt que d'une ligne virtuelle.

Utilisez les mouvements pour déplacer le curseur dans la ligne courante

La plupart des éditeurs n'ont que des commandes simples pour déplacer le curseur (gauche, haut, droite, bas, au début/à la fin de la ligne, etc). vim possède des commandes de déplacement très avancée; ces commandes sont appelées mouvements (NdT: motions). Quand le curseur bouge d'un point à un autre, le texte entre les points (points inclus) est considéré comme étant parcouru (C'est important pour plus tard).

Voici quelques uns des mouvements les plus utiles:

fx: Déplace le curseur en avant jusqu'à la prochaine occurence du caractère x (bien entendu, x peut-être n'importe quel caractère). C'est une commande extèmement utile. Vous pouvez taper ; pour répéter la dernière commande f.
tx: Pareil que f, mais bouge le curseur juste avant le caractère, pas juste dessus (Très utile, vraiment).
Fx: Déplace le curseur en arrière jusqu'à la prochaine occurence de x sur la ligne courante.
w: Déplace le curseur en avant d'un mot.
b: Déplace le curseur en arrière d'un mot.
0: Déplace le curseur au début de la ligne courante.
^: Déplace le curseur sur le premier caractère de la ligne courante.
$: Déplace le curseur à la fin de la ligne courante.
): Déplace le curseur en avant jusqu'à la prochaine phrase (Utile quand vous éditez un e-mail ou des documents textes).
(: Déplace le curseur en arrière jusqu'à la prochaine phrase.

Se déplacer efficacement dans le fichier édité

vim possède de nombreuses commandes qui peuvent vous transporter où vous le souhaitez dans votre fichier -- il est rare que l'on ait à le parcourir manuellement. Les combinaisons de touches ci-dessous ne correspondent pas techniquement à des déplacements, si on considère qu'elles servent à se déplacer dans le fichier et non pas dans une ligne.

<C-F>: Fait avancer le curseur à l'écran de texte suivant.
<C-B>: Fait reculer le curseur à l'écran de texte précédent.
numG: Place le curseur à la ligne num. (Par exemple, 10G déplace à la ligne 10.)
gg: Déplace le curseur au début du fichier.
G: Déplace le curseur à la fin du fichier.
H: Déplace le curseur en haut de l'écran.
M: Déplace le curseur au milieu de l'écran.
L: Déplace le curseur en bas de l'écran.
*: Lis la chaîne de caractères sous le curseur et déplace ce dernier à l'endroit suivant où elle apparait de nouveau. (Par exemple, si votre curseur se trouvait sur le mot bob, le curseur se déplacerait jusqu'à la prochaine occurence de bob dans votre fichier.)
#: Même chose que ci-dessus, sauf qu'il déplace le curseur sur l'occurence précédente.
/text: A partir de la position du curseur, trouve l'occurence suivante de la chaîne de caractères text et s'y rend. Vous devrez presser la touche Entrée pour exécuter la recherche. Pour ré-exécuter votre dernière recherche, tapez n (pour next occurance (NdT: occurence suivante).)
?text: Même chose que /, mais cherche dans la direction opposée.
ma: Crée un signet nommé "a" référant à la position actuelle du curseur. Un signet peut être nommé par nimporte quelle lettre en minuscule. Vous ne voyez pas le signet, mais il est là !
`a: Aller au signet a. Important: c'est une backquote et non pas une quote simple. La touche backquote s'obtient à l'aide de la combinaison de touches alt+7 (pavé principal) sur un clavier azerty.
`.: Aller à la dernière ligne que vous avez éditée. Cette fonction est très utile ! Si vous avez besoin de parcourir le fichier pour regarder quelque chose, vous pouvez revenir à l'endroit où vous vous trouviez sans avoir à utiliser de signet, en utilisant `.

Saisir efficacement

Utiliser la complétion de mots

vim a un système de complétion de mots très pratique. Cela signifie que vous pouvez ne taper qu'une partie d'un long mot, presser une touche, et vim fini de l'écrire pour vous. Par exemple, si vous avez une variable nommée JeSuisUneVariableAvecUnNomImbuvable quelque part dans votre code, vous ne voudrez probablement pas taper son nom en entier à chaque fois que vous souhaitez l'utiliser.

Pour utiliser la complétion de mots, tapez simplement les quelques premières lettres de la chaîne (pour notre exemple: JeSuisUn) et pressez <C-N> (cela signifie que vous devez maintenir enfoncé Ctrl et taper N) ou <C-P>. Si vim ne vous donne pas le mot que vous souhaitez du premier coup, continuez d'essayer -- vim vous proposera toutes les complétions possibles qu'il trouvera.

Entrez intelligemment dans le mode d'insertion

La plupart des nouveaux utilisateurs de vim, entrent dans le mode d'insertion en tapant i. Ca marche, mais c'est souvent inefficace car vi a un jeu de commandes permettant de basculer l'éditeur en mode d'insertion. Voici quelqu'unes des plus populaires:

i: Insère du texte à gauche du caractère courant.
I: Insère du texte au début de la ligne courante.
a: Insère du texte à droite du caractère courant.
A: Insère du texte à la fin de la ligne courante.
o: Crée une nouvelle ligne sous la ligne courante et y insère du texte.
O: Crée une nouvelle ligne au dessus de la ligne courante et y insère du texte.
c{déplacement}: Efface (change) le texte parcouru par le {déplacement} et insère du texte pour le remplacer. Par exemple, c$ effacera le texte du curseur à la fin de la ligne et entrera en mode d'insertion. ct! effacera le texte à partir du curseur jusqu'au point d'exclamation suivant (sans l'inclure) et entrera en mode d'insertion. Le texte effacé est copié dans le presse-papier et peut être collé.
d{motion}: Efface le texte parcouru par le {déplacement} -- comme c{déplacement}, mais n'entre pas en mode d'insertion.

Déplacer efficacement des blocs de texte

Utiliser la sélection visuelle et les modes de sélection appropriés

A la différence de l'original vi, vim vous laisse mettre en exergue du texte et y exécuter des opérations. Il y a trois modes de sélection visuelle principaux (ce sont les modes de mise en exergue). Ces modes sont les suivants:

v: Sélection par caractère. C'est le mode de sélection que la plupart des gens utilisent, donc entraînez-vous avec avant d'essayer les autres.
V: Sélection par ligne. Sélectionnera toujours des lignes entières. Plus pratique que le mode par caractère quand vous désirez copier ou déplacer un groupe de ligne.
<C-V>: Sélection par bloc. Extrêmement puissant et disponible dans très peu d'éditeurs. Vous pouvez sélectionner un bloc rectangulaire et tout le texte se trouvant à l'intérieur sera mis en exergue.

Toutes les touches de mouvement habituelles peuvent être utilisées -- donc, par exemple, vwww entrera dans le mode de sélection visuelle et mettra en exergue les trois mots suivants. Vjj entrera dans le mode de sélection visuelle par ligne et mettra en exergue la ligne courante et les deux sous cette dernière.

Couper et copier à partir de sélections visuelles

Une fois que vous avez une sélection mise en exergue, vous voulez probablement en faire quelque chose. Quelques-une des commandes les plus utiles que vous pouvez utiliser quand une partie d'un texte est mise en évidence:

d: Coupe (efface) le texte mis en exergue et le met dans le presse-papier.
y: Copie (ou yank (NdT: couper sec) qui est un terme vim-èsque pour copier) le texte mis en exergue dans le presse-papier.
c: Coupe le texte mis en exergue et le met dans le presse-papier. Comme d, à l'exception qu'il laisse l'éditeur en mode d'insertion.

Couper et copier à partir de sélections non-visuelles

Si vous savez exactement ce que vous voulez copier ou couper, vous pouvez le faire sans entrer dans le mode visuel. Vous gagnerez du temps.

d{déplacement}: Coupe le texte parcouru par le {déplacement} vers le presse-papier. Par exemple, dw coupera un mot et dfS coupera du curseur jusqu'à (en l'incluant) la prochaine lettre S en majuscule de la ligne courante.
y{déplacement}: Copie le texte parcouru par le {déplacement}.
c{déplacement}: Coupe le texte parcouru par le {déplacement} et laisse l'éditeur en mode d'insertion.
dd: Coupe la ligne courante.
yy: Copie la ligne courante.
cc: Coupe la ligne courante et laisse l'éditeur en mode d'insertion.
D: Coupe du curseur à la fin de la ligne courante.
Y: Yank la ligne entière, comme yy. (Oui, c'est contradictoire! Vous pouvez utiliser y$ pour faire ce que vous attendiez d' Y.)
C: Coupe du curseur à la fin de la ligne courante et laisse l'éditeur en mode d'insertion.
x: Coupe le caractère courant. (C'est, en quelque sorte, la touche d'effacement arrière du mode-commande.)
s: Coupe le caractère courant et laisse l'éditeur en mode d'insertion.

Coller

Coller est une chose simple. Mettez le curseur à l'endroit où vous voulez coller du texte et tapez p.

Utiliser plusieurs presses-papier.

La plupart des éditeurs ont un seul presse-papier. vim en a bien plus; les presse-papiers dans vim sont appellés registres. Vous pouvez lister tous les registres définis actuellement et leurs contenus en tapant :reg. Typiquement, vous utiliserez des registres en lettres minuscules; les autres étant utilisés par vim en internes et ne sont que rarement utiles.

Pour utiliser un registre spécifique pour une opération de type copier/coller, tapez simplement "a avant la commande, où a est le registre que vous voulez utiliser.

Par exemple, pour copier la ligne courante dans le registre k, vous pouvez taper "kyy. (Vous pouvez aussi taper V"ky. Pourquoi pas ?). Cette ligne restera dans le registre k jusqu'a ce que vous copiez spécifiquement quelque chose d'autre dans ce registre. Vous pouvez maintenant utiliser "kp pour coller le texte se trouvant dans le registre k.

Eviter les répétitions.

La stupéfiante commande .

Sous vi, taper . (un point) répettera la derniere commande que vous avez executé. Par exemple, si votre dernière commande était dw (effacement de mot (NdT: delete word), vi effacera un autre mot.

Utiliser les compteurs

Les compteurs sont une des plus puissantes et économiques (en temps) fonctionnalités de vim. Nimporte quelle commande peut être précédée d'un nombre. Le nombre dira à vim combien de fois exécuter la commande. Voici quelques exemples:

3j déplacera le curseur vers le bas, de trois lignes. 10dd effacera dix lignes.

y3&quote; copiera (yank) du curseur jusqu'à la troisième quotation mark (NDT: je laisse l'expression originale pour que vous puissiez comprendre la commande, mais il s'agit de guillemets) après le curseur, sur la ligne courante. Les compteurs sont utiles pour augmenter l'étendu d'un déplacement.

Enregistrement de macros

Occasionnellement, vous vous retrouverez à faire la même chose encore et encore sur des blocs de texte de votre document. vim vous laisse enregistrer une macro ad-hoc pour exécuter l'opération.

qregister: Commence l'enregistrement de macro dans le registre nommé register. Par exemple, qa commence l'enregistrement et met la macro dans le registre a.
q: Fin de l'enregistrement.
@register: Rejoue la macro stockée dans le registre register. Par exemple, @a rejoue la macro du registre a.

Gardez en tête que les macros enregistrent simplement vos pressions de touches pour les rejouer ensuite. Il n'y a rien de magique. Enregistrer des macros est presque une forme d'art car il y a tellement de commandes qui accomplissent une tâche donnée sous vim, et vous devez choisir avec attention les commandes que vous utilisez pendant que votre macro enregistre, afin qu'elles marchent aux endroits où vous avez prévu d'utiliser la-dite macro.

Ecrire du code sous vim

vim est un excellent éditeur de code source car il a de nombreuses fonctionnalités qui ont été spécifiquement conçues pour aider les développeurs. Voici quelques-unes des plus utiles:

]p: Comme pour p, mais ajuste automatiquement l'indentation du code collé pour correspondre au code dans lequel vous avez inséré. Essayez!
%: Mettre le curseur sur une acolade, un crochet ou une parenthèse et presser % enverra le curseur à l'acolade, au crochet ou à la parenthèse correspondant(e). C'est très pratique pour résoudre les problèmes de parsing liés à de multiples blocs de code imbriqués.
>>: Indente le code mis en exergue. (Voir la section plus haut, concernant la séléction efficace de texte. Si il n'y a pas de texte sélectionné, la ligne courante est indentée.)
<<: Comme >>, mais dés-indente.
gd: Aller à la ligne de définition (ou de déclaration) d'une variable
K: Aller à la page de manuel pour le mot actuellement sous le curseur. (Par exemple, si votre curseur est sur le mot sleep, vous verrez la page de documentation de sleep s'afficher.)