De Linuxmemo.

(Différences entre les versions)

Version du 7 décembre 2012 à 13:48

Sommaire

1 Commandes de bases
2 Les mouvements
3 Suppression
4 Remplacement
5 Macro
6 Options pour les substitutions
7 Action sur recherche
8 Astuces
9 Liens externes
10 Intervale
11 Memo total

Commandes de bases

Commande	Alternative	Explication
k	↑	Se déplacer vers le haut
j	↓	Se déplacer vers le bas
h	←	Se déplacer vers la gauche
l	→	Se déplacer vers la droite

Les mouvements

Commande	Alternative	Explication
`$`		Aller en fin de ligne
`0`		Aller en début de ligne
`^`		Aller au premier caractère qui n'est pas un espace ou une tab de la ligne
`gg`		Aller en début de document
`G`		Aller en fin de document
:`<n>`		Aller à la ligne `<n>` (où `<n>` est un nombre entier)
f`<s>`		Jusqu'au caractère `<s>` en allant vers l'avant
F`<s>`		Jusqu'au caractère `<s>` en allant vers l'arrière
t`<s>`		Jusqu'au caractère `<s>` en allant vers l'avant et en s'arrêtant juste avant
T`<s>`		Jusqu'au caractère `<s>` en allant vers l'arrière et en s'arrêtant juste avant

Suppression

Commande	Alternative	Explication
x		Le caractère sous le curseur
s		Comme `x` mais entre en mode insertion après
dd		La ligne sous le curseur
dw		Le mot sous le curseur
d$	D	Supprime jusqu'à la fin de la ligne
d`<mouvement>`		Du curseur à la cible du déplacement
d`<sélection>`		La sélection précisée
c		Se comporte comme `d` mais entre en mode insertion après la suppression
u		Annulation de la dernière action
CTRL+R		Remettre (annuler l'annulation)

Remplacement

Le caractère sous le curseur r puis le caractère que l'on veut mettre. Exemple: sur le mot "lepin", se positionner sur le "e", puis faire un ra remplacera le "e" par un "a".

Entrer en mode remplacement: <Insert><Insert> (double appui sur la touche <Insert>) vous permettra d'entrer en mode remplacement, c'est à dire que le texte que vous saisirez remplacera ce qu'il y a en dessous du curseur. La touche R permet également de le faire.

Macro

Nous ouvrons ce fichier avec vim, puis, pour déclencher l'enregistrement de la macro, nous tapons :

qa

q = enregistrement de la macro

a = nom de la macro

Un avis : Enregistrement survient et tout ce que nous tapons à présent est l'enregistrement de cette macro nommée “a”. Nous pouvons voir en direct sur le texte ce que notre commande vim exécute sur la ligne visée. Terminer la macro par :

En cas d'erreur, il suffit de quitter la macro par :

puis, d'utiliser la lettre :

pour restaurer la ligne et recommencer la macro différemment, en la nommant de manière identique. Pour relancer cette macro nommée “a”, tapons :

@a

2@a

2 = exécuter 2 fois. À noter que le nombre 2 de la répétition s'adapte aux nombres de lignes que nous voulons modifier. Il peut être supérieur à l'exemple présenté ici. @a = la macro nommée “a”

Et sur validation, les lignes visées seront modifiées.

Il est possible de modifier les macros ! Il suffit de manipuler les registres (registers) qui stockent (entre autres) le contenu des macros. Pour les voir, faites :

:registers

Pour faire appel à ces registres il faut taper " suivi du nom du registre. Par exemple pour coller le registre t dans le document courant je peux faire :

"tp

Il est alors possible d'opérer à toute sorte de changements sur cette ligne pour finalement la recopier dans le registre :

"ty

Voilà, vous savez maintenant comment modifier vos macros.

Options pour les substitutions

: %s/foo/bar/g :

globale

: %s/foo/bar/gc :

globale et demande confirmation

: %s/foo/bar/gci :

globale, demande confirmation et ignore la caste

: %s/foo/bar/gcI :

globale, demande confirmation et respect la caste

range:
{number}	an absolute line number
.		the current line			  *:.*
$		the last line in the file		  *:$*
%		equal to 1,$ (the entire file)		  *:%*
*		equal to '<,'> (the Visual area)	  *:star*
't		position of mark t (lower case)		  *:'*
/{pattern}[/]	the next line where {pattern} matches	  *:/*
?{pattern}[?]	the previous line where {pattern} matches *:?*
\/		the next line where the previously used search
		pattern matches
\?		the previous line where the previously used search
		pattern matches
\&		the next line where the previously used substitute

pattern matches

Action sur recherche

:g/search pattern/command

exemple supprimer les lignes vides
:g/^$/d

Astuces

Afficher les numéros de lignes:

:set nu et :set nu! (pour les cacher)

Liens externes

(fr) vim.dindinx.net - Traduction de la documentation de Vim.
(fr) [http://vim-fr.org/index.php/Commandes_de_bases vim-fr.org - Commandes de bases

Intervale

On peut donner un intervalle à toute les fonctions du mode Ex (ou command), celles qui commencent par : pour être clair. La combinaison d3w est une commande du mode normal, donc si tu lui donner un intervalle tu dois utiliser la commande :normal pour exécuter des commandes du mode normal dans le mode Ex:

:10,20 normal d3w

Memo total

source: http://tnerual.eriogerg.free.fr/vimqrc-fr.html

VIM - CARTE DE RÉFÉRENCE RAPIDE

Mouvement simple
`h l k j`	lettre à gauche, droite ; ligne en haut, bas
`b w`	mot à gauche, droite
`ge e`	fin du mot à gauche, droite
`{ }`	début du paragraphe précédent, suivant
`( )`	début de la phrase précédente, suivante
`0 gm`	début, milieu de ligne
`^ $`	première, dernière lettre de la ligne
`nG ngg`	ligne n, par défaut la dernière, première
`n%`	pourcentage n du document (<i>n</i> obligatoire)
`n\|`	colonne n de la ligne courante
`%`	autre parenthèse, crochet, commentaire, `#define`
`nH nL`	ligne n depuis le début, la fin de la fenêtre
`M`	milieu de la fenêtre
Insertion & remplacement → mode insertion
`i a`	insertion avant, après le curseur
`I A`	insertion au début, fin de ligne
`gI`	insertion à la première colonne
`o O`	nouvelle ligne au dessous, dessus du curseur
`rc`	remplace la lettre sous le curseur par c
`grc`	comme `r`, mais sans changer le formattage
`R`	remplace le texte à partir du curseur
`gR`	comme `R`, mais sans changer le formattage
`cm`	remplace le texte du mouvement m
`cc or S`	remplace la ligne courante
`C`	remplace jusqu'à la fin de la ligne
`s`	remplace un caractère et insère
`~`	change la casse et avance d'une lettre
`g~m`	change la casse du mouvement m
`gum gUm`	→ minusc., majusc. le texte du mvt. m
`<m >m`	décale à gauche, droite le texte du mvt. m
`n<< n>>`	décale n lignes à gauche, droite
Suppression
`x X`	supprime le caractère sous, avant le curseur
`dm`	supprime le texte du mouvement m
`dd D`	supprime la ligne courante, la fin de la ligne
`J gJ`	jointe la ligne courante et suivante, sans espace
`:rd↵`	supprime les lignes d'intervalle r
`:rdx↵`	supprime l'intervalle r dans le registre x
Mode insertion
`^Vc ^Vn`	insère le car. c littéralement, valeur déc. n
`^A`	insère le texte précédemment inséré
`^@`	comme `^A` & stoppe l'insertion → mode commande
`^Rx ^R^Rx`	insère le contenu du reg. x, littéralement
`^N ^P`	saisie automatique avant, après le curseur
`^W`	supprime le mot avant le curseur
`^U`	supprime le texte inséré dans la ligne en cours
`^D ^T`	décale à gauche, droite d'une tabulation
`^Kc1c2 or c1←c2`	saisie le digraphe \c1,c2\
`^Oc`	exécute c en mode commande temporaire
`^X^E ^X^Y`	défilement haut, bas
`<esc> or ^[`	abandonne l'édition → mode commande
Copie
`"x`	utilise le registre x pour la prochaine action
`:reg↵`	affiche le contenu de tous les registres
`:reg x↵`	affiche le contenu du/des registre(s) x
`ym`	copie le texte de la commande de mouvement m
`yy or Y`	copie la ligne courante
`p P`	colle après, avant la position du curseur
`]p [p`	comme `p`, `P`, avec ajustement de l'indentation
`gp gP`	comme `p`, `P`, avec le curseur à la fin du texte
Insertion avancée
`g?m`	encode en rot13 le texte de mouvement m
`n^A n^X`	+n, -n au nombre sous le curseur
`gqm`	justifie le texte du mouvement m
`:rce w↵`	centre les lignes r à la largeur w
`:rle i↵`	aligne à la colonne i les lignes r
`:rri w↵`	aligne à droite les lignes r à la largeur w
`!mc↵`	filtre les lignes du mvt. m avec la cmd. c
`n!!c↵`	filtre n lignes avec la commande c
`:r!c↵`	filtre l'intervalle r avec la commande c
Mode visuel
`v V ^V`	sélectionne des lettres, lignes, blocs
`o`	échange le curseur avec le début de la sélection
`gv`	démarre la sélection à la position de la précédente
`aw as ap`	sélectionne un(e) mot, phrase, paragraphe
`ab aB`	sélectionne un bloc ( ), un bloc `{` `}`
Annulation, répétition & registres
`u U`	annule une commande, restaure la ligne
`. ^R`	répète une commande, annule l'annulation
`n.`	répète la commande avec le nombre n
`qc qC`	enregistre, ajoute la frappe au registre c
`q`	stoppe l'enregistrement
`@c`	exécute le contenu du registre c
`@@`	répète la commande `@` précédente
`:@c↵`	exécute le registre c comme une commande Ex
`:rg/p/c↵`	exécute la commande Ex c
	sur l'intervalle r où le motif p correspond
Mouvement complexe
`- +`	ligne en haut, bas sur le 1er caractère non blanc
`B W`	mot séparé par un espace à gauche, droite
`gE E`	fin du mot séparé par un espace à gauche, droite
`n_`	n-1 lignes en bas sur le 1er caractère non blanc
`g0`	début de ligne d'écran
`g^ g$`	premier, dernier caractère de la ligne d'écran
`gk gj`	ligne d'écran en haut, bas
`fc Fc`	caractère c suivant, précédent
`tc Tc`	avant le caractère c suivant, précédent
`; ,`	répète le dernier `fFtT` en sens opposé
`[[ ]]`	début de section en arrière, avant
`[] ][`	fin de section en arrière, avant
`[( ])`	(, ) en arrière, avant
`[{ ]}`	`{`, `}` en arrière, avant
`[m ]m`	début de méthode Java en arrière, avant
`[# ]#`	`#if`, `#else`, `#endif` en arrière, avant
`[* ]*`	début, fin de bloc `/* */` en arrière, avant
Recherche & substitution
`/s↵ ?s↵`	cherche s en avant, arrière
`/s/o↵ ?s?o↵`	idem, avec un décalage o
`n or /↵`	répète en avant la dernière recherche
`N or ?↵`	répète en arrière la dernière recherche
`# *`	recherche en arrière, avant le mot sous le curseur
`g# g*`	idem, avec les correspondances partielles
`gd gD`	définition locale, globale du mot sous le curseur
`:rs/f/t/x↵`	substitue f par t dans l'intervalle r
	x: `g`-toutes les occurrences, `c`-confirme
`:rs x↵`	répète la subst. avec de nouveaux r & x
Caractères spéciaux de recherche
`. ^ $`	tout caractère unique, début, fin de ligne
`\< \>`	début, fin de mot
`[c1-c2]`	un caractère unique dans l'intervalle c1..c2
`[^c1-c2]`	un caractère unique hors intervalle
`\i \f \I \F`	un identificateur, mot-clé ; sans chiffres
`\f \p \F \P`	un fichier, car. imprim. ; sans chiffres
`\s \S`	un espace simple, autre espacement
`\e \t \r \b`	<esc>, <tab>, <↵>, <←>
`\= * \+`	0..1, 0..∞, 1..∞ des atomes précédents
`\\|`	sépare deux branches ( ≡ ou)
``	groupe plusieurs éléments dans un atome
`\& \n`	le motif entier, nieme groupe `()`
`\u \l`	le caractère suivant en majuscule, minuscule
`\c \C`	ignore, respecte la casse
Décalage de recherche
`n or +n`	n lignes en avant en colonne 1
`-n`	n lignes en arrière en colonne 1
`e+n e-n`	n caractères à droite, gauche de la fin
`s+n s-n`	n caractères à droite, gauche du début
`;sc`	exécute la recherche sc suivante
Marques et déplacement
`mc`	marque la position courante avec c ∈[a..Z]
`c `C	va à la marque c, C dans n'importe quel fichier
`0..9	va à la dernière position en sortie
`` `"	va à la position avant le saut, dernière édition
`[ `]	va au début, fin du texte préc. manipulé
`:marks↵`	affiche la liste des marques actives
`:jumps↵`	affiche la liste des sauts
`n^O`	va au nieme dernier saut dans la liste
`n^I`	va au nieme premier saut dans la liste
Allocation de touches & abbréviation
`:map c e↵`	alloue c ↦ e en mode normal & visuel
`:map! c e↵`	alloue c ↦ e en mode insertion & cmd.
`:unmap c↵ :unmap! c↵`	supprime l'alloc. pour c
`:mk f↵`	sauvegarde les paramètres dans le fichier f
`:ab c e↵`	ajoute l'abbréviation pour c ↦ e
`:ab c↵`	liste les abbréviations commençant par c
`:una c↵`	supprime l'abbréviation pour c
Étiquettes
`:ta t↵`	va à l'étiquette t
`:nta↵`	va à la nieme nouvelle étiquette
`^] ^T`	va à l'étiquette sous le curseur, revient
`:ts t↵`	liste les étiquettes pour sélection
`:tj t↵`	va à l'étiquette ou sélectionne si plusieurs
`:tags↵`	affiche la liste des étiquettes
`:npo↵ :n^T↵`	revient de, va à la nieme dernière
`:tl↵`	va à la dernière étiquette utilisée
`^W} :pt t↵`	prévisualise l'étiquette sous le curseur, t
`^W]`	sépare la fenêtre et montre l'étiq. sous le curseur
`^Wz or :pc↵`	ferme la fenêtre de prévisualisation
Défilement & multi-fenêtrage
`^E ^Y`	défile une ligne en haut, bas
`^D ^U`	défile une demi-page en haut, bas
`^F ^B`	défile une page en haut, bas
`zt or z↵`	place la ligne courante en haut de la fenêtre
`zz or z.`	place la ligne courante au centre de la fenêtre
`zb or z-`	place la ligne courante au bas de la fenêtre
`zh zl`	défile un caractère à droite, gauche
`zH zL`	défile une demi-fenêtre à droite, gauche
`^Ws or :split↵`	sépare la fenêtre courante en deux
`^Wn or :new↵`	créé une nouvelle fenêtre vide
`^Wo or :on↵`	agrandit la fenêtre courante
`^Wj ^Wk`	va à la fenêtre au dessous, dessus
`^Ww ^W^W`	va à la fenêtre au dessous, dessus (enroule)
Commandes Ex (↵)
`:e f`	édite le fichier f, sauf si changements
`:e! f`	édite le fichier f (par défaut celui en cours)
`:wn :wN`	sauve le fichier et édite le suivant, précédent
`:n :N`	édite le fichier suivant, précédent dans la liste
`:rw`	sauvegarde l'intervalle r dans le fichier en cours
`:rw f`	sauvegarde l'intervalle r dans le fichier f
`:rw>>f`	ajoute l'intervalle r au fichier f
`:q :q!`	quitte et confirme, quitte sans sauvegarder
`:wq or :x or ZZ`	sauvegarde et quitte
`<up> <down>`	rappele les cmd. comme celle en cours
`:r f`	insère le fichier f sous le curseur
`:r! c`	insère le résultat de la cmd. c sous le curseur
`:args`	affiche la liste des arguments
`:rco a rm a`	copie, déplace l'interv. r après la ligne a
Intervalles Ex
`, ;`	sépare deux lignes, la première ligne
`n`	un numéro de ligne absolu n
`. $`	la ligne courante, la dernière ligne
`% *`	le fichier entier, la sélection visuelle
`'t`	la position de la marque t
`/p/ ?p?`	la ligne suivante, précédente où p correspond
`+n -n`	+n, -n au numéro de ligne précédent
Pliage
`zfm`	créé un pli avec le mouvement m
`:rfo`	créé un pli sur l'intervalle r
`zd zE`	supprime le pli sous le curseur, tous
`zo zc zO zC`	ouvre, ferme un pli, récursivement
`[z ]z`	début, fin du pli ouvert en cours
`zj zk`	début, fin du pli suivant, précédent
Divers
`:sh↵ :!c↵`	lance un shell, exécute c dans un shell
`K`	affiche l'aide `man` du mot-clé sous le curseur
`:make↵`	lance `make`, lit les erreurs et va à la 1ère
`:cn↵ :cp↵`	affiche l'erreur suivante, précédente
`:cl↵ :cf↵`	liste les erreurs, depuis un fichier
`^L ^G`	ré-affiche l'écran, nom de fichier et position
`g^G`	montre la position détaillée du curseur
`ga`	montre la valeur ASCII du caractère
`gf`	ouvre le fichier sous le curseur
`:redir>f↵`	redirige la sortie dans le fichier f
`:mkview [f]`	sauve la config. [dans le fichier f]
`:loadview [f]`	charge la config. [depuis le fichier f]
`^@ ^K ^_ \ Fn ^Fn`	touches inusitées

Copyright (C) 2005 by Laurent GRÉGOIRE (<a href="mailto:laurent.gregoire@icam.fr">laurent.gregoire@icam.fr</a>)
Translated from English by Laurent Grégoire
Converted from vimqrc-fr.tex using a <a href="http://www.python.org">Python</a> script.
You can find the latest revision at <a href="http://tnerual.eriogerg.free.fr">http://tnerual.eriogerg.free.fr</a>

Vim