Mots-clé : vi

vim – astuces / cheatsheet

Vim

Séparation par fenêtres

:split Split horizontal
:vsplit Split vertical
:res XX Hauteur fenêtre = XX lignes
:vertical resize XX Largeur fenêtre courante = XX caractères
:30winc > Vertical : 30 caractères à droite
:30winc < Vertical : 30 caractères à gauche
:30winc + Horizontal : 30 caractères à droite
:30winc - Horizontal : 30 caractères à gauche
30[CTRL]W > Décaler de 30 caractères à droite
30[CTRL]W < Décaler de 30 caractères à gauche

Macros

:%s/\%(^ *\)\@<= /\&nbsp;/g Remplacer tous les espaces de début par &nbsp;

Vim: comment remplacer tous les mots par celui sous le curseur?

Je n’ai pas été bien loin, vous trouverez la version anglaise ici.

:%s/mot/<c-r><c-a>/g

Remplacer chaque occurrence de ‘mot’ avec le mot sous le curseur (le mot est délimité par des espaces ou des retours à la ligne).

<c-r><c-a> signifie qu’il faut appuyer sur Ctrl et R puis sur Ctrl et A.

Le mot sous le curseur sera automatiquement inséré dans la ligne de commande exactement comme il apparaît à l’écran.

Le côté génial, c’est que vous pouvez enregistrer cela dans une macro et il se souviendra du principe !

Exemple concret : j’ai une centaine de partenaires auquels je dois appliquer la même opération SQL. Voilà comment je me suis servi de la fonctionnalité :

  • J’ai mis toute la liste des partenaires dans un fichier, un partenaire par ligne ;
  • J’ai crée une seule fois, pour le partenaire 1, la série de commandes SQL ;
  • Ensuite, j’ai copié collé une centaine de fois cette même série pour tous les partenaires (sous vim: « chiffre+@a » et il joue chiffre fois la macro « a », donc ça ne m’a pris que le temps de taper une dizaine de touches) ;
  • J’ai enregistré la macro suivante, que je vous explique en français : «sélectionne la série de commande courante, monte d’une ligne pour aller sur le nom du partenaire courant, et remplace toutes les occurences de «partenaire1» par le mot sous le curseur.

Ensuite, une fois la macro enregistrée, j’ai tapé « 100@a » = jouer 100 fois la macro « a ».

Et voilà.

Beaucoup de temps de gagné !

Vi / vim : comment remplacer des espaces par des espaces insécables (&nbsp;)

Tout est dans le titre.

J’ai souvent ce problème : je fais copier coller de code dans un article WordPress que je veux publier, je mets le code entre <code></code> mais le problème, c’est que les espaces de début sont ignorés et l’indentation est perdue.

Voici donc l’astuce, sous vi, pour remplacer tous les espaces uniquement au début de la ligne par &nbsp;.

C’est à dire que :

     extend: 'Ext.panel.Panel',

devient :


extend: 'Ext.panel.Panel',

Ce que je ne veux pas bien évidemment.

J’ai posé la question ici : vim-regexp-help-change-spaces-to-nbsp.

Et je vous laisse y lire les réponses, mais la solution que j’ai retenue :


:%s/^ \+/\=repeat("&nbsp;",strlen(submatch(0)))

Site des vimgolfers : http://vimgolf.com/.

vim : mettre en surbrillance les espaces inutiles en fin de code

Vous en avez marre des espaces en fin de code qui ne servent à rien ?
Vous voulez vous conformer à beaucoup de pratiques classiques (Apache, horde, etc.) ?

Voici le petit truc qu’il vous manque, à ajouter dans votre fichier vim :

" Ce code mettra en surbrillance rouge vif
" tous les espaces inutiles après la fin de code :
highlight WhitespaceEOL ctermbg=red guibg=red
match WhitespaceEOL /\s\+$/

Ce code de configuration vim va mettre en rouge tous les espaces inutiles en fin de code.

Fabuleux non ? 😉

Merci à ce site.

vim : exemple concret de conversion de fichier C en fichier Pascal

Voici un aperçu des petites choses possibles avec les macros vim.
J’avais un énorme fichier include (fichier fmod.h) à convertir en Pascal, afin de pouvoir accéder à l’extraordinaire librairie de fmod. Pour information, cette librairie est gratuite et redistribuable en tant que telle si votre produit est gratuit et ne vous rapporte rien. Donc profitez en c’est une librairie aussi simple d’utilisation que puissante et stable.

Je vous explique juste le principe de base, avec un exemple concret, et vous verrez qu’il vous suffit de faire pareil pour les quelques autres conversions, et vous gagnerez quelques minutes, voire comme dans mon cas, quelques heures de travail (que vous auriez inévitablement perdues avec un autre éditeur) :

Voici un exemple de déclaration C :

typedef FMOD_RESULT
  (F_CALLBACK *FMOD_FILE_OPENCALLBACK)
    (const char *name, int unicode,
      unsigned int *filesize, void **handle, void **userdata);

La fonction finale déclarée en Pascal doit être ainsi :

FMOD_FILE_OPENCALLBACK =
  function (
    const name:Pchar; unicode:Integer;
    var filesize: Cardinal; handle:Pointer;
    userdata:Pointer):FMOD_RESULT;

Je vais vous expliquer les premiers pas : il faut convertir ces paramètres :
void **handle, void **userdata)
en :
handle:Pointer; userdata:Pointer)

Le principe des macros avec les expressions régulières est très simple, je vais la construire pas à pas :

– Va chercher la première chaine qui est void ** :
void \*\*\
Notez bien que comme les étoiles * sont des caractères d’expression régulière, il faut mettre un antislash \ pour qu’elles ne soient pas interprétées.

– Va chercher la première chaine qui est void ** et qui est suivie d’une chaine composée de au moins un caractère minuscule comprise entre a et z :
void \*\*\([a-z]\+\)
Au même titre que les étoiles *, et les antislashes \, les parenthèses () sont des caractères d’expression régulière, il faut mettre un antislash \ pour qu’elles ne soient pas interprétées.
Oui je le concède ça rend la lecture un peu difficile. Mais le temps gagné en vaut la chandelle croyez moi.
– Va chercher la première chaine qui est void ** et qui est suivie d’une chaine composée de au moins un caractère minuscule comprise entre a et z, et qui se termine par une virgule :
void \*\*\([a-z]\+\)\(,\{1\}\)
Ici aussi notez le \{1\} : ici, les crochets \{\} sont des caractères d’expression régulière donc il ne faudrait pas mettre d’antislash, mais comme il sont dans une expression qu’on recherche, il les faut. Bref, essayez une fois avec, une fois sans, et l’un des deux fonctionnera !

Expression finale :

Remplace toutes les chaines de type void **[caractères de a à z], par [caractères de a à z]: Pointer;  :
:%s/void \*\*\([a-z]\+\)\(,\{1\}\)/\1: Pointer;/g

Ainsi :
void **handle,
donnera :
handle: Pointer;.

Mais (et c’est là où c’est génial) :
void **autrenomdevariable,
donnera :
autrenomdevariable: Pointer;.

Et cela s’appliquera sur tout le fichier, quel que soit le nom de la variable.

Ensuite, il vous suffit de vous concocter toute votre séance de petites macros, et de les mettre dans un fichier.
Puis vous appelez :

vim -s macro_vim.cmd [nom du fichier]

et vim jouera la macro dessus.

vim : expressions régulières rechercher remplacer (mémo)

Ci-suit une série d’expressions régulières qui fonctionnent sous vim, et dont j’ai fait la traduction en langue Française, afin que vous puissiez comprendre les subtilités :

  • /^ \+$ : rechercher toutes les lignes qui commencent et finissent par une suite de minimum un ou plus d’espaces (un antislash avant le « + »)
  • /^ *$ : rechercher toutes les lignes qui commencent et finissent par une suite de minimum zéro ou plus d’espaces (pas d’antislash avant le « * »)
  • /^ \*$ : rechercher toutes les lignes qui commencent par un espace et finissent par le caractère « * » (un antislash avant le « * »)
  • /^ \{1,1\}$ : rechercher toutes les lignes qui contiennent un et un seul espace (ne pas oublier l’antislash avant les « {} »)

Et maintenant une expression complexe qui m’a été très utile :
Si vous tapez exactement cela :

:%s/\($this->[a-z]\+\)\(_\)\(.\)/\1\u\3/g

Vous aurez tous les ordres du type :

$this->Sejour_deb

Qui seront transformés en :

$this->SejourDeb

Très très utile.
Explication :

:%s/\($this->[a-z]\+\)\(_\)\(.\)/\1\u\3/g
: = exécuter un ordre ;
% = appliquer sur la totalité du document ;
s = appliquer sur la chaine (ici ligne par ligne) ;
\($this->[a-z]\+\) = groupe qui a $this-> puis une série de lettres ;
\(_\) = groupe qui a un tiret bas ;
\(.\) = groupe qui contient un caractère quel qu’il soit ;
On voit qu’il y a trois groupes, ils sont accessibles via antislash puis le numéro du groupe, exemple : »\1« , et le cas concret :
/ = remplacer par… ;

  • \1 le groupe numéro 1 ;
  • \u mettre en majuscule ;
  • \3 le groupe numéro 3 ;

/g faire toutes les occurrences trouvées.

Uzbl : un browser Web entièrement en ligne de commande !

C’est ici que vous pourrez voir cet « ovni » du monde Internet : http://www.uzbl.org/.

Il est en plusieurs parties : le coeur même du système, et un programme qui interagit avec lui, lui envoie des messages, et affiche son résultat de retour. Comme le coeur semble extrêmement bien fait, on est censé pouvoir faire tout un tas de choses, automatiquement : un cas concret, c’est l’exemple du second programme qui interagit avec le coeur : en pratique on a un navigateur. Et puis il a rajouté une troisième couche, un troisième programme qui interagit avec le second, et qui donne la possibilité de tout gérer par onglets. Comme tout est open source, et apparemment très bien écrit, il est possible de faire plein de choses.

Le second programme, il a décidé de faire en sorte que son comportement soit du style « vi », à savoir : tout se fait au clavier, il y a un mode « navigation » où les touches se comportement d’une certaine façon, et il y a le mode édition (touche « i » comme sur vi, pour les connaisseurs), où on peut entrer des informations dans les formulaires.

Dans la vidéo, sur le site, on voit qu’il va déjà bien plus vite en tapant sur son clavier qu’en utilisant la souris. Je pense que lorsqu’on va toujours sur des sites qu’on connait bien, on doit au final gagner beaucoup de temps.