De Linuxmemo.

(Différences entre les versions)

Version actuelle en date du 31 mai 2017 à 09:59

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

[modifier] 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

[modifier] 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

[modifier] 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)

[modifier] 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.

[modifier] 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.

[modifier] 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

[modifier] Action sur recherche

:g/search pattern/command

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

[modifier] Astuces

Afficher les numéros de lignes:

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

Convertir tout en minuscules

ggVGu
Explication :
GG - va à la première ligne de texte
V - tourne sur une sélection visuelle, en mode ligne
G - va à la fin du fichier (en ce moment que vous avez sélectionné tout le texte)
u - minuscule zone sélectionnée

Convertir tout en majuscules

ggVG[shift]u

Changer la case

sous le caractère courant: ~
sous le mot courant: g~w
sous les 3 mots courant: g~3w
sous la ligne courante: guu ou gUU

Afficher les caractères invisibles

:set list
:set list!

Dans le paramétrage par défaut on à les caractères spéciaux de défini ainsi :

: ctrl+v suivi du code du caractère. Par exemple, ctrl+v u 0 3 b 4 donnera δ. (u pour unicode, 03b4 est l'identifiant numérique du delta minuscule dans la norme unicode). 
Tabulation : ^I (^I s'obtenant comme il est dit ci dessus: Ctrl V + Ctrl i)
Saut de ligne : $

Mais on peut personnaliser ces caractères avec la commande set listchars.

Les caractère spéciaux invisibles personnalisables sont :

Saut de ligne : eol
Tabulation : tab
Espaces de fin de ligne : trail
Espace insécable : nbsp

Suppression des lignes commençant par un #

:g/^#/d

Supprimer des lignes vides

:g/^$/d

Se positionner directement sur un nom de variable à l'ouverture d'un fichier de config

vim +/nom_variable /etc/fichier_de_conf

Commenter de la ligne courante jusqu’à la fin du fichier

:.,$s/^/#/

Les opérateurs ^et $ indiquent des positions (début et fin de ligne) et pas des caractères, c'est pour ça qu'il ne faut pas les reprendre dans le deuxième argument.

Commenter plusieurs lignes d’un coup

1)_ CTRL+V sur le premier caractère de la première ligne à commenter,
2)_ puis sélectionner toutes les lignes voulues avec la flèche du bas ou la touche J
3)_ Maj+i (I majuscule)
4)_ Insérer le caractère de commentaire (# ou // ou n’importe quoi d’autre )
5)_ Esc, Esc

[modifier] 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
http://www.linux-note.com/vim-raccourcis-clavier-en-mode-normale-en-mode-visuel/ -les raccourcis clavier

[modifier] 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

[modifier] 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