Quels sont les coins sombres de Vim, ta mère ne t'a jamais parlé?
Il existe une pléthore de questions dans lesquelles les gens parlent d’astuces courantes, notamment " astuces Vim + ctags ".
Cependant, je ne fais pas référence aux raccourcis couramment utilisés que quelqu'un de nouveau chez Vim trouverait cool. Je parle d'un utilisateur Unix expérimenté (développeur, administrateur, les deux, etc.) qui pense savoir quelque chose que 99% d'entre nous n'ont jamais entendu parler ou dont il n'a jamais rêvé. Quelque chose qui facilite non seulement leur travail, mais aussi COOL et hackish . Après tout, Vim réside dans le système d’exploitation le plus sombre du monde, il devrait donc comporter des subtilités que seuls quelques privilégiés connaissent et souhaitent partager avec nous.
Il se peut que 99% des utilisateurs de Vim ne le sachent pas, mais c'est quelque chose que j'utilise quotidiennement et que tout utilisateur puissant de Linux + Vim doit savoir.
Commande basique, pourtant extrêmement utile.
:w !Sudo tee %
J'oublie souvent de Sudo avant de modifier un fichier sur lequel je ne dispose pas de droits en écriture. Lorsque je viens pour enregistrer ce fichier et obtenir une erreur d'autorisation, je viens d'émettre cette commande vim afin de sauvegarder le fichier sans avoir besoin de l'enregistrer dans un fichier temporaire, puis de le copier à nouveau.
Vous devez évidemment être sur un système avec Sudo installé et avoir les droits de Sudo.
Quelque chose que je viens de découvrir récemment et que je trouvais très cool:
:earlier 15m
Rétablit le document comme il était il y a 15 minutes. Peut prendre différents arguments pour le temps que vous souhaitez annuler et dépend de la non-nivellement. Peut être inversé avec la commande opposée :later
:! [command] exécute une commande externe lorsque vous êtes dans Vim.
Mais ajoutez un point après le deux-points, :.! [command], et le résultat de la commande sera affiché dans votre fenêtre actuelle. C'est : . !
Par exemple:
:.! ls
J'utilise beaucoup cela pour des tâches telles que l'ajout de la date du jour dans un document en cours de frappe:
:.! date
Pas exactement obscur, mais il y a plusieurs commandes "delete in" qui sont extrêmement utiles, comme ..
diwpour supprimer le mot actuel- _
di(_ à supprimer dans les parenthèses actuelles - _
di"_ pour supprimer le texte entre guillemets
D'autres peuvent être trouvés sur :help text-objects
de Supprimez tout jusqu'à la fin du mot en appuyant sur. au désir de votre coeur.
ci (xyz [Esc] - Ceci est étrange. Ici, le 'i' ne signifie pas mode insertion, mais signifie entre parenthèses. Cette séquence coupe donc le texte entre parenthèses ' re debout et le remplace par "xyz". Il fonctionne également entre crochets et crochets - faites juste ci [ou ci {en conséquence. Naturellement, vous pouvez faire di (si vous voulez juste supprimer tout le texte sans rien taper. Vous pouvez aussi faire a au lieu de i si vous souhaitez également supprimer les parenthèses et pas uniquement le texte qu'elles contiennent.
ci " - coupe le texte entre guillemets
ciw - coupe le mot actuel. Cela fonctionne comme le précédent sauf que ( est remplacé par w.
C - coupe le reste de la ligne et passe en mode insertion.
ZZ - enregistre et ferme le fichier en cours (beaucoup plus rapidement que Ctrl-F4 pour fermer l'onglet en cours!)
ddp - déplace la ligne actuelle d'une ligne vers le bas
xp - déplace le caractère actuel d'une position vers la droite
U - majuscule, donc viwU surclasse le mot
~ - change de casse, donc viw~ retournera la casse de tout le mot
Ctrl + u/Ctrl + d faire défiler la page d'un demi-écran vers le haut ou le bas. Cela semble être plus utile que la pagination habituelle en plein écran, car il est plus facile de voir le rapport entre les deux écrans. Pour ceux qui veulent toujours faire défiler tout l'écran à la fois, il y a Ctrl + f pour En avant et Ctrl + b pour En arrière. Ctrl + Y et Ctrl + E font défiler une ligne à la fois.
la commande folle mais très utile est zz - elle fait défiler l'écran pour faire apparaître cette ligne au milieu. C'est excellent pour placer le morceau de code sur lequel vous travaillez au centre de votre attention. Les commandes jumelles - zt et zb - font de cette ligne la ligne du haut ou celle du bas de l'écran, ce qui n'est pas aussi utile.
% trouve et saute à la parenthèse correspondante.
de - efface du curseur jusqu'à la fin du mot (vous pouvez aussi faire dE pour effacer jusqu'au prochain espace)
bde - supprime le mot actuel, délimiteur de gauche à droite
df [space] - Supprime jusqu'au prochain espace inclus
dt. - efface jusqu'au point suivant
dd - efface toute la ligne
ye (ou yE) - tire le texte d'ici à la fin de la Parole
ce - coupe la fin du mot
au revoir - copie Word actuel (me fait me demander ce que "salut" fait!)
yy - copie la ligne en cours
cc - coupe la ligne courante, vous pouvez aussi faire S à la place. Il y a aussi une limite inférieure s qui coupe le caractère actuel et passe en mode insertion.
viwy ou viwc. Tirez ou changez le mot actuel. Appuyez sur w plusieurs fois pour continuer à sélectionner chaque mot suivant, utilisez b pour revenir en arrière
vi { - sélectionne tout le texte entre crochets. va {- sélectionne tout le texte, y compris {} s
vi (p - met en évidence tout ce qui se trouve à l'intérieur du () et le remplace par le texte collé
b et e déplacent le curseur mot par mot, comme Ctrl + Flèches le font normalement. La définition de Word est toutefois un peu différente, car plusieurs délimiteurs consécutifs sont traités comme un seul mot. Si vous commencez au milieu d'un mot, une pression sur b vous mènera toujours au début du mot actuel, et chaque b consécutif ira au début du mot suivant. De même, et facile à retenir, e place le curseur à la fin du mot courant, ainsi que de chaque mot suivant.
semblable à b/e, majuscule B et E déplace le curseur mot par mot en utilisant uniquement des espaces comme délimiteurs.
majuscule D (souffle profond) Supprime le reste de la ligne à droite du curseur, comme pour Maj + Fin/Suppr dans les éditeurs normaux (remarquez 2 pressions de touche - Maj + D - à la place de 3)
Un des tutoriels que je trouve rarement dans la plupart des tutoriels de Vim, mais c’EST INCROYABLEMENT utile (du moins pour moi), c’est le
g; and g,
pour avancer (en avant, en arrière) dans la liste des modifications.
Laissez-moi vous montrer comment je l'utilise. Parfois, j'ai besoin de copier et coller un morceau de code ou une chaîne, disons un code couleur hexagonal dans un fichier CSS, alors je cherche, saute (je ne me soucie pas de la correspondance), le copie, puis je retourne (g;) à où J'étais en train de modifier le code pour le coller enfin. Pas besoin de créer des marques. Plus simple.
Juste mes 2cents.
:%!xxd
Faites de vim un éditeur hexadécimal.
:%!xxd -r
Revenir.
Attention: si vous n'éditez pas avec binaire (-b), vous pourriez endommager le fichier. - Josh Lee dans les commentaires.
gv
Resélectionne la dernière sélection visuelle.
Parfois, un paramètre de votre fichier .vimrc sera remplacé par un plugin ou une autocommande. Pour résoudre ce problème, une astuce utile consiste à utiliser la commande: verbose en conjonction avec: set. Par exemple, pour savoir où cindent a été activé/désactivé:
:verbose set cindent?
Cela produira quelque chose comme:
cindent
Last set from /usr/share/vim/vim71/indent/c.vim
Cela fonctionne également avec des cartes et des faits saillants. (Merci, joeytwiddle, de l'avoir signalé.) Par exemple:
:verbose nmap U
n U <C-R>
Last set from ~/.vimrc
:verbose highlight Normal
Normal xxx guifg=#dddddd guibg=#111111 font=Inconsolata Medium 14
Last set from ~/src/vim-holodark/colors/holodark.vim
:%TOhtml
Crée un rendu HTML du fichier actuel.
Je ne sais pas si cela compte comme un coin sombre, mais je viens juste de l'apprendre ...
:g/match/y A
jettera (copiera) toutes les lignes contenant "match" dans le registre "a/@a. (La capitalisation sous la forme A rend vim append yankings au lieu de remplacer le contenu du registre précédent.) Je l'ai beaucoup utilisée récemment lors de la création de feuilles de style Internet Explorer.
Voulez-vous regarder votre: historique des commandes?
q:
Puis parcourez, éditez et enfin exécutez la commande.
Avez-vous déjà apporté des modifications similaires à deux fichiers et basculé entre eux? (Dites, fichiers source et en-tête?)
:set hidden
:map <TAB> :e#<CR>
Ensuite, faites la navette entre ces fichiers.
Vim ouvrira une URL, par exemple
vim http://stackoverflow.com/
Bien quand vous avez besoin de trouver la source d'une page pour référence.
Les macros peuvent appeler d'autres macros et peuvent également s'appeler elles-mêmes.
par exemple:
qq0dwj@qq@q
... supprimera le premier mot de chaque ligne jusqu'à la fin du fichier.
Ceci est un exemple assez simple mais il montre une fonctionnalité très puissante de vim
En supposant que Perl et/ou Ruby soient compilés, :rubydo et :perldo exécutent un Ruby ou Perl one-liner sur chaque ligne d'une plage. (par défaut, tout le tampon), avec $_ lié au texte de la ligne en cours (moins la nouvelle ligne). Manipuler $_ changera le texte de cette ligne.
Vous pouvez l'utiliser pour faire certaines choses faciles à faire dans un langage de script, mais pas si évidentes à l'aide des fonctions intégrées de Vim. Par exemple, pour inverser l'ordre des mots d'une ligne:
:perldo $_ = join ' ', reverse split
Pour insérer une chaîne aléatoire de 8 caractères (A à Z) à la fin de chaque ligne:
:rubydo $_ += ' ' + (1..8).collect{('A'..'Z').to_a[Rand 26]}.join
Vous êtes limité à agir sur une ligne à la fois et vous ne pouvez pas ajouter de nouvelles lignes.
^ O et ^ I
Aller à la position plus ancienne/plus récente. Lorsque vous vous déplacez dans le fichier (en cherchant, en déplaçant des commandes, etc.), mémorisez ces "sauts" afin que vous puissiez répéter ces sauts en arrière (^ O - O pour ancien) et en avant (^ I - juste à côté de I sur le clavier). ) Je trouve cela très utile pour écrire du code et effectuer beaucoup de recherches.
gi
Aller à la position où le mode Insertion a été arrêté en dernier. Je me trouve souvent en train d’éditer puis de chercher quelque chose. Pour revenir au lieu d'édition, appuyez sur gi.
gf
placez le curseur sur le nom du fichier (par exemple, inclure le fichier d'en-tête), appuyez sur gf et le fichier est ouvert
gF
semblable à gf mais reconnaît le format "[nom du fichier]: [numéro de ligne]". Appuyez sur gF pour ouvrir [nom du fichier] et régler le curseur sur [numéro de ligne].
^ P et ^ N
Terminer automatiquement le texte lors de l'édition (^ P - correspondance précédente et ^ N correspondance suivante)
^ X ^ L
Pendant que l’édition se termine sur la même ligne (utile pour la programmation). Vous écrivez du code et ensuite vous vous rappelez que vous avez le même code quelque part dans le fichier. Appuyez simplement sur ^ X ^ L et la ligne complète est terminée.
^ X ^ F
Noms de fichiers complets. Vous écrivez "/ etc/pass" Hmm. Vous avez oublié le nom du fichier. Appuyez simplement sur ^ X ^ F et le nom du fichier est terminé
^ Z ou: sh
Déplacement temporaire vers le shell. Si vous avez besoin d'un coup bas rapide:
- appuyez sur ^ Z (pour mettre vi en arrière-plan) pour revenir au shell d'origine et appuyez sur fg pour revenir à vim
- appuyez sur: sh pour aller au sous-shell et appuyez sur ^ D/exit pour revenir à vi
C'est une bonne astuce pour rouvrir le fichier actuel avec un encodage différent:
:e ++enc=cp1250 %:p
Utile lorsque vous devez travailler avec des encodages hérités. Les codages pris en charge sont répertoriés dans un tableau sous encoding-values (voir helpencoding-values). Le même principe fonctionne également pour ++ff, afin que vous puissiez rouvrir le fichier avec la fin de ligne Windows/Unix si vous vous trompez pour la première fois (voir helpff).
" insert range ip's
"
" ( O O )
" =======oOO=(_)==OOo======
:for i in range(1,255) | .put='10.0.0.'.i | endfor
Taper == corrigera l'indentation de la ligne en cours en fonction de la ligne ci-dessus.
En fait, vous pouvez faire un signe = suivi de n’importe quelle commande de mouvement. = {mouvement}
Par exemple, vous pouvez utiliser le% mouvement qui se déplace entre les accolades correspondantes. Positionnez le curseur sur le {dans le code suivant:
if (thisA == that) {
//not indented
if (some == other) {
x = y;
}
}
Et appuyez sur =% pour obtenir instantanément ceci:
if (thisA == that) {
//not indented
if (some == other) {
x = y;
}
}
Alternativement, vous pourriez faire = a { dans le bloc de code, plutôt que de vous positionner directement sur le caractère {.
imap jj <esc>
Voyons une jolie petite IDE éditeur faire la transposition de colonnes.
:%s/\(.*\)^I\(.*\)/\2^I\1/
Explication
\( et \) est comment rappelez-vous tout ce qui se trouve dans regex-land. Et \1, \2 etc est comment récupérer le contenu mémorisé.
>>> \(.*\)^I\(.*\)
Rappelez-vous de tout suivi de ^I (onglet) suivi de tout.
>>> \2^I\1
Remplacez les éléments ci-dessus par "2e élément dont vous vous êtes souvenu" suivi de "1er élément dont vous vous souveniez" - essentiellement une transposition.
Ce n'est pas vraiment un secret obscur, mais j'aime bien mettre le mappage suivant dans mon fichier .vimrc afin de pouvoir appuyer sur "-" (moins) à tout moment pour ouvrir l'explorateur de fichiers afin d'afficher les fichiers adjacent à celui que je viens d'éditer. Dans l'explorateur de fichiers, je peux utiliser un autre "-" pour accéder à un répertoire, ce qui permet de naviguer de manière transparente dans une structure de répertoires complexe (comme celle utilisée par les frameworks MVC):
map - :Explore<cr>
Ceux-ci peuvent également être utiles à quelqu'un. J'aime faire défiler l'écran et faire avancer le curseur en même temps:
map <c-j> j<c-e>
map <c-k> k<c-y>
Navigation dans les onglets: j'adore les onglets et je dois facilement me déplacer entre eux:
map <c-l> :tabnext<enter>
map <c-h> :tabprevious<enter>
Uniquement sous Mac OS X: navigation par onglet à la Safari:
map <S-D-Right> :tabnext<cr>
map <S-D-Left> :tabprevious<cr>
J'aime utiliser 'Sudo bash', et mon administrateur système déteste ça. Il a verrouillé 'Sudo' afin qu'il ne puisse être utilisé qu'avec une poignée de commandes (ls, chmod, chown, vi, etc.), mais j'ai néanmoins pu utiliser vim pour obtenir un shell racine:
bash$ Sudo vi +'silent !bash' +q
Password: ******
root#
Souvent, j'aime changer de répertoire en cours d’édition. Je dois donc spécifier moins de chemins.
cd %:h
J'utilise souvent de nombreuses fenêtres lorsque je travaille sur un projet et j'ai parfois besoin de les redimensionner. Voici ce que j'utilise:
map + <C-W>+
map - <C-W>-
Ces mappages permettent d’augmenter et de diminuer la taille de la fenêtre en cours. C'est assez simple mais c'est rapide.
:r! <command>
colle la sortie d'une commande externe dans la mémoire tampon.
Faites des calculs et obtenez le résultat directement dans le texte:
:r! echo $((3 + 5 + 8))
Obtenir la liste des fichiers à compiler lors de l'écriture d'un Makefile:
:r! ls *.c
Ne cherchez pas ce que vous avez lu sur wikipedia, faites-le coller directement dans le document que vous écrivez:
:r! lynx -dump http://en.wikipedia.org/wiki/Whatever
Ce n'est pas une fonctionnalité obscure, mais très utile et qui fait gagner du temps.
Si vous souhaitez enregistrer une session de vos tampons ouverts, onglets, marqueurs et autres paramètres, vous pouvez générer les éléments suivants:
mksession session.vim
Vous pouvez ouvrir votre session en utilisant:
vim -S session.vim
Carte F5 pour rapidement ROT13 votre tampon:
map <F5> ggg?G``
Vous pouvez l'utiliser comme clé de patron :).
Je viens de trouver celui-ci aujourd'hui via NSFAQ :
Blocs de code de commentaire.
Passez en mode visuel bloc en appuyant sur CTRL-V.
Marquez le bloc que vous souhaitez commenter.
Hit I (majuscule I) et entrez votre chaîne de commentaires au début de la ligne. (// pour C++)
Appuyez sur ECHAP et toutes les lignes sélectionnées auront // préchargées au début de la ligne.
J'utilise vim pour pratiquement toutes les modifications de texte que je fais, aussi je me sers souvent de copier/coller. Le problème est que vim par défaut déformera souvent le texte importé via coller. La façon d'arrêter cela est d'utiliser
:set paste
avant de coller dans vos données. Cela l'empêchera de tout gâcher.
Notez que vous devrez émettre :set nopaste pour récupérer l'indentation automatique. Les registres du presse-papiers (* et +) et :r!cat (vous devez terminer le fragment collé avec ^ D) sont des méthodes alternatives de collage de texte préformaté.
Il est également parfois utile d'activer un jeu de couleurs à contraste élevé. Cela peut être fait avec
:color blue
J'ai remarqué que cela ne fonctionne pas sur toutes les versions de vim que j'utilise mais que cela fonctionne la plupart du temps.
Voici quelque chose de pas évident. Si vous avez beaucoup de plugins/extensions personnalisés dans votre $ HOME et que vous devez parfois utiliser su/Sudo/..., cela peut être utile.
Dans votre ~/.bashrc:
export VIMINIT=":so $HOME/.vimrc"
Dans votre ~/.vimrc:
if $HOME=='/root'
if $USER=='root'
if isdirectory('/home/your_typical_username')
let rtuser = 'your_typical_username'
elseif isdirectory('/home/your_other_username')
let rtuser = 'your_other_username'
endif
else
let rtuser = $USER
endif
let &runtimepath = substitute(&runtimepath, $HOME, '/home/'.rtuser, 'g')
endifCela permettra à vos plugins locaux de se charger - quelle que soit la méthode utilisée pour changer d'utilisateur.
Vous voudrez peut-être aussi extraire les fichiers * .swp de votre chemin actuel et les placer dans ~/vimtmp (cela se trouve dans .vimrc):
if ! isdirectory(expand('~/vimtmp'))
call mkdir(expand('~/vimtmp'))
endif
if isdirectory(expand('~/vimtmp'))
set directory=~/vimtmp
else
set directory=.,/var/tmp,/tmp
endif
En outre, certains mappages que j'utilise pour faciliter l'édition - permettent à ctrl + s de fonctionner comme un échappement et ctrl + h/l modifient les onglets:
inoremap <C-s> <ESC>
vnoremap <C-s> <ESC>
noremap <C-l> gt
noremap <C-h> gTCtrl-n en mode insertion complétera automatiquement le mot que vous tapez en fonction de tous les mots qui se trouvent dans les tampons ouverts. S'il y a plus d'une correspondance, cela vous donnera une liste de mots possibles que vous pouvez parcourir en utilisant ctrl-n et ctrl-p.
gg=G
Corrige l'indentation pour tout le fichier. Il me manquait mon fidèle <C-a><C-i> dans Eclipse, mais je viens de découvrir que vim le gère bien.
Possibilité d'exécuter Vim sur un mode basé sur le client/serveur.
Par exemple, supposons que vous travailliez sur un projet comportant de nombreux tampons, onglets et autres informations enregistrés dans un fichier de session appelé session.vim.
Vous pouvez ouvrir votre session et créer un serveur en lançant la commande suivante:
vim --servername SAMPLESERVER -S session.vim
Notez que vous pouvez ouvrir des fichiers texte normaux si vous voulez créer un serveur et que cela ne doit pas nécessairement être une session.
Supposons maintenant que vous êtes dans un autre terminal et que vous devez ouvrir un autre fichier. Si vous l'ouvrez régulièrement en émettant:
vim new_file.txt
Votre fichier serait ouvert dans un tampon Vim séparé, ce qui rend difficile les interactions avec les fichiers de votre session. Afin d'ouvrir new_file.txt dans un nouvel onglet de votre serveur, utilisez cette commande:
vim --servername SAMPLESERVER --remote-tab-silent new_file.txt
Si aucun serveur n'est en cours d'exécution, ce fichier sera ouvert comme un fichier normal.
Comme il est très fastidieux de fournir ces indicateurs à chaque fois que vous souhaitez les exécuter, vous pouvez créer un alias distinct pour la création du client et du serveur.
J'ai placé les éléments suivants sur mon fichier bashrc:
alias vims='vim --servername SAMPLESERVER'
alias vimc='vim --servername SAMPLESERVER --remote-tab-silent'
Vous pouvez trouver plus d'informations à ce sujet sur: http://vimdoc.sourceforge.net/htmldoc/remote.html
Vous voulez un IDE?
:make exécutera le fichier Make dans le répertoire en cours, analysera la sortie du compilateur. Vous pourrez ensuite utiliser :cn et :cp pour parcourir les erreurs du compilateur en ouvrant chaque fichier et en cherchant le numéro de ligne dans question.
:syntax on active la coloration syntaxique de vim.
Je souhaite souvent mettre en évidence un nom de mot/fonction particulier, mais je ne souhaite pas encore rechercher l'instance suivante:
map m* *#
Variation de Sudo écrire:
en .vimrc
cmap w!! w !Sudo tee % >/dev/null
Après avoir rechargé vim, vous pouvez faire "Sudo save" en tant que
:w!!
HOWTO: Ctags à complétion automatique lors de l'utilisation de Vim dans Bash. Pour ceux qui utilisent Vim et Ctags, j'ai écrit une petite fonction de compléteur automatique pour Bash. Ajoutez ce qui suit dans votre fichier ~/.bash_completion (créez-le s'il n'existe pas):
Merci à styliste pour ses nombreuses corrections et améliorations.
_vim_ctags() {
local cur prev
COMPREPLY=()
cur="${COMP_WORDS[COMP_CWORD]}"
prev="${COMP_WORDS[COMP_CWORD-1]}"
case "${prev}" in
-t)
# Avoid the complaint message when no tags file exists
if [ ! -r ./tags ]
then
return
fi
# Escape slashes to avoid confusing awk
cur=${cur////\\/}
COMPREPLY=( $(compgen -W "`awk -vORS=" " "/^${cur}/ { print \\$1 }" tags`" ) )
;;
*)
_filedir_xspec
;;
esac
}
# Files matching this pattern are excluded
excludelist='*.@(o|O|so|SO|so.!(conf)|SO.!(CONF)|a|A|rpm|RPM|deb|DEB|gif|GIF|jp?(e)g|JP?(E)G|mp3|MP3|mp?(e)g|MP?(E)G|avi|AVI|asf|ASF|ogg|OGG|class|CLASS)'
complete -F _vim_ctags -f -X "${excludelist}" vi vim gvim rvim view rview rgvim rgview gview
Une fois que vous redémarrez votre session Bash (ou en créez une nouvelle), vous pouvez taper:
Code:
~$ vim -t MyC<tab key>
et il complétera automatiquement la balise de la même manière que pour les fichiers et les répertoires:
Code:
MyClass MyClassFactory
~$ vim -t MyC
Je trouve cela très utile lorsque je saute dans une correction de bogue rapide.
% est également utile lorsque vous souhaitez différencier des fichiers sur deux copies différentes d'un projet sans user les pinkies (à partir de la racine du projet1):
:vert diffs /project2/root/%
: autoread setlocal
Recharge automatique du tampon en cours .. particulièrement utile lors de la visualisation des fichiers journaux et sert presque à la fonctionnalité du programme "tail" sous unix depuis vim.
Vérifier les erreurs de compilation à partir de vim. définir la variable makeprg en fonction de la langue, disons pour Perl
: setlocal makeprg = Perl\-c \%
Pour PHP
définir makeprg = php\-l \%
set errorformat =% m\in \% f\on\line \% l
La publication de ": make" exécute le makeprg associé et affiche les erreurs/avertissements de compilation dans la fenêtre de correction rapide et permet de naviguer facilement vers les numéros de ligne correspondants.
J'utilise Vim pour tout. Lorsque je modifie un message électronique, j'utilise:
gqap (ou gwap)
largement pour reformater facilement et correctement paragraphe par paragraphe, même avec des caractères de tête de citation. Afin de réaliser cette fonctionnalité, j'ajoute également:
-c 'set fo=tcrq' -c 'set tw=76'
à la commande pour appeler l'éditeur en externe. Un ajout remarquable serait d'ajouter "a" au paramètre fo (formatoptions). Cela reformatera automatiquement le paragraphe au fur et à mesure que vous tapez et naviguez dans le contenu, mais peut gênera ou causera des problèmes de formatage errant ou impair contenu dans le message.
J'étais sûr que quelqu'un l'aurait déjà posté, mais voilà.
Prenez n'importe quel système de construction qui vous convient; faire, mvn, ant, peu importe. À la racine du répertoire du projet, créez un fichier contenant les commandes que vous utilisez tout le temps, comme suit:
mVN installer
mvn clean install
... et ainsi de suite
Pour faire un build, placez le curseur sur la ligne et tapez !! sh. C'est à dire. filtrer cette ligne; écrivez-le dans un shell et remplacez-le par les résultats.
Le journal de construction remplace la ligne, prêt au défilement, à la recherche, peu importe.
Lorsque vous avez terminé de consulter le journal, tapez u pour annuler et vous revenez à votre fichier de commandes.
En raison de la latence et du manque de couleurs (j'adore les jeux de couleurs :), je n'aime pas programmer sur des machines distantes dans PuTTY . J'ai donc développé cette astuce pour contourner ce problème. Je l'utilise sous Windows.
Vous aurez besoin de
- 1x gVim
- 1x rsync sur les machines distantes et locales
- 1x authentification de clé privée SSH sur la machine distante pour que vous n'ayez pas besoin de taper le mot de passe
- 1x Pageant
- 1x mastic
Configuration de la machine distante
Configurez rsync pour rendre votre répertoire de travail accessible. J'utilise un tunnel SSH et n'autorise que les connexions à partir du tunnel:
address = 127.0.0.1
hosts allow = 127.0.0.1
port = 40000
use chroot = false
[bledge_ce]
path = /home/xplasil/divine/bledge_ce
read only = false
Puis lancez rsyncd: rsync --daemon --config = rsyncd.conf
Configuration de la machine locale
Installez rsync à partir de Cygwin. Lancez Pageant et chargez votre clé privée pour la machine distante. Si vous utilisez le tuning SSH, démarrez PuTTY pour créer le tunnel. Créez un fichier de commandes Push.bat dans votre répertoire de travail qui téléchargera les fichiers modifiés sur la machine distante à l'aide de rsync:
rsync --blocking-io *.cc *.h SConstruct rsync://localhost:40001/bledge_ce
SConstruct est un fichier de construction pour scons. Modifiez la liste des fichiers en fonction de vos besoins. Remplacez localhost par le nom de la machine distante si vous n'utilisez pas le tunelling SSH.
Configurer Vim C'est maintenant facile. Nous allons utiliser la fonctionnalité de correction rapide (: make et error list), mais la compilation sera exécutée sur la machine distante. Nous devons donc définir makeprg:
set makeprg=Push\ &&\ plink\ -batch\ [email protected]\ \"cd\ /home/xplasil/divine/bledge_ce\ &&\ scons\ -j\ 2\"
Cela démarrera d'abord la tâche Push.bat pour télécharger les fichiers, puis exécutera les commandes sur une machine distante à l'aide de SSH ( Plink à partir de la suite PuTTY). La commande change d'abord le répertoire dans le répertoire de travail, puis lance la construction (j'utilise scons).
Les résultats de la construction apparaîtront dans votre liste d’erreurs gVim locale.
Entrez un caractère à partir de sa valeur hexadécimale (mode insertion):
<C-Q>x[type the hexadecimal byte]
Mettez ceci dans votre fichier .vimrc pour avoir une commande permettant d’imprimer joliment xml:
function FormatXml()
%s:\(\S\)\(<[^/]\)\|\(>\)\(</\):\1\3\r\2\4:g
set filetype=xml
normal gg=G
endfunction
command FormatXml :call FormatXml()
=========================================== ============= En mode normal ======================== ================================= gf .......... ...... ouvrir le fichier sous le curseur dans la même fenêtre -> voir: h chemin Ctrl-w f .......... ouvrir le fichier sous le curseur dans une nouvelle fenêtre Ctrl-w q .......... fermer la fenêtre en cours Ctrl-w 6 .......... ouvrir un fichier alternatif -> voir: h # gi ................ mode d'insertion init dans la dernière position d'insertion '0 ................ place le curseur où il se trouvait lors de la dernière édition du fichier
set colorcolumn=+1 ou set cc=+1 pour vim 7.3
Lorsque vous travaillez sur un projet où le processus de construction est lent, je construis toujours en arrière-plan et dirige la sortie vers un fichier appelé errors.err (quelque chose comme make debug 2>&1 | tee errors.err). Cela me permet de continuer à éditer ou à revoir le code source pendant le processus de construction. Quand il est prêt (en utilisant pynotify sur GTK pour m'informer qu'il est complet), je peux regarder le résultat dans vim en utilisant correction rapide . Commencez par émettre: cf [ile] qui lit le fichier d’erreur et saute à la première erreur. Personnellement, j'aime bien utiliser cwindow pour obtenir le résultat de la construction dans une fenêtre séparée.
:sp %:h - liste de répertoire/sélecteur de fichier utilisant le répertoire du fichier actuel
(appartient en tant que commentaire sous le conseil de rampion cd, mais je n'ai pas encore de droits de commentaire)
Juste avant de copier et coller dans stackoverflow:
:retab 1
:% s/^I/ /g
:% s/^/ /
Maintenant, copiez et collez le code.
Comme demandé dans les commentaires:
retab 1. Ceci définit la taille de l'onglet à un. Mais il parcourt également le code et ajoute des tabulations et des espaces supplémentaires, de sorte que la mise en forme ne déplace aucun élément du texte (le texte a exactement la même apparence après ratab).
% s/^ I// g: Notez que ^ I est le résultat de la frappe sur l'onglet. Ceci recherche tous les onglets et les remplace par un seul espace. Comme nous venons de procéder à une retabulation, cela ne devrait pas entraîner de modification de la mise en forme, mais comme il est inutile de placer des onglets sur un site Web, il est bon de les supprimer.
% s/^//: remplace le début de la ligne par quatre espaces. Étant donné que vous ne pouvez pas remplacer le début de la ligne par quoi que ce soit, il insère quatre espaces au début de la ligne (ceci est nécessaire pour la mise en forme SO afin de faire ressortir le code).
Quelques utiles:
:set nu # displays lines
:44 # go to line 44
'. # go to last modification line
Mon favori: Ctrl + n Mot achèvement!
In Insert mode
<C-A> - Increments the number under cursor
<C-X> - Decrements the number under cursor
Cela sera très utile si nous voulons générer des nombres séquentiels dans vim
Disons si nous voulons insérer les lignes 1 à 10 avec des nombres de 1 à 10 [comme "1" à la première ligne, "2" à la deuxième ligne ...]
insérez "0" sur la première ligne et copiez la ligne et les 9 dernières fois afin que toutes les lignes affichent "0".
Exécutez la commande Ex suivante
:g/^/exe "norm " . line(".") . "\<C-A>"
Pour que vim ressemble un peu plus à un éditeur IDE:
- set nu - pour les numéros de ligne dans la marge de gauche.
- set cul - met en surbrillance la ligne contenant le curseur.
J'aime: la commande.
macros de carte
Je trouve assez souvent utile de définir à la volée un mappage de clé comme on définirait une macro. La torsion ici est que le mappage est récursif et est exécuté jusqu'à ce qu'il échoue.
Exemple:
enum ProcStats
{
ps_pid,
ps_comm,
ps_state,
ps_ppid,
ps_pgrp,
:map X /ps_<CR>3xixy<Esc>X
Donne:
enum ProcStats
{
xypid,
xycomm,
xystate,
xyppid,
xypgrp,
Juste un exemple idiot :).
Je suis tout à fait au courant de tous les inconvénients - il se trouve que je l’ai trouvé plutôt utile à certaines occasions. En outre, il peut être intéressant de le regarder au travail;).
En mode insertion, ctrl+x, ctrl+p complétera (avec le menu des complétions possibles si c'est ce que vous aimez) l'identifiant long actuel que vous tapez.
if (SomeCall(LONG_ID_ <-- type c-x c-p here
[LONG_ID_I_CANT_POSSIBLY_REMEMBER]
LONG_ID_BUT_I_NEW_IT_WASNT_THIS_ONE
LONG_ID_GOSH_FORGOT_THIS
LONG_ID_ETC
∶
Réutilisation
Motions à mélanger avec d'autres commandes, plus ici .
tx
fx
Fx
Utilisez vos outils préférés dans Vim.
:r !python anything you want or awk or Y something
Répétez en mode visuel, puissant lorsqu'il est combiné avec les conseils ci-dessus.
;
Remplace tout
:%s/oldtext/newtext/igc
Donnez à remplacer tout :)
Afin de copier un texte de Vim dans votre presse-papiers pour pouvoir être utilisé par une autre application, sélectionnez le texte que vous souhaitez copier en mode visuel, puis appuyez sur "+ y. Ainsi, vous pourrez facilement coller votre texte dans d'autres applications.
Ceci est particulièrement utile si vous avez scindé la fenêtre verticalement et que vous souhaitez copier quelque chose de la fenêtre de droite. Utiliser set mouse = r ne vous aidera pas dans cette situation car il sélectionnera également tout dans la fenêtre de gauche.
Notez que votre vim doit être compilé avec le support xterm.
J'ai recueilli ces au fil des ans.
" Pasting in normal mode should append to the right of cursor
nmap <C-V> a<C-V><ESC>
" Saving
imap <C-S> <C-o>:up<CR>
nmap <C-S> :up<CR>
" Insert mode control delete
imap <C-Backspace> <C-W>
imap <C-Delete> <C-O>dw
nmap <Leader>o o<ESC>k
nmap <Leader>O O<ESC>j
" tired of my typo
nmap :W :w
Utilisez le bouton droit de la souris pour activer le mode d’insertion dans gVim avec les paramètres suivants dans ~/.gvimrc:
"
"------------------------------------------------------------------
" toggle insert mode <--> 'normal mode with the <RightMouse>-key
"------------------------------------------------------------------
nnoremap <RightMouse> <Insert>
inoremap <RightMouse> <ESC>
"
Créez une fonction pour exécuter le tampon actuel en utilisant Shebang (en supposant que celui-ci soit défini) et appelez-le avec crtl-x.
map <C-X> :call CallInterpreter()<CR>
au BufEnter *
\ if match (getline(1) , '^\#!') == 0 |
\ execute("let b:interpreter = getline(1)[2:]") |
\ endif
fun! CallInterpreter()
if exists("b:interpreter")
exec("! ".b:interpreter." %")
endif
endfun
Essayez d’utiliser perltidy pour formater avec = commande en mode normal
:set equalprg=perltidy
Aucun des éléments suivants n'est vraiment inflexible, mais je le trouve extrêmement utile.
Liaisons triviales, mais je ne peux tout simplement pas vivre sans. Il active le mouvement de style hjkl en mode insertion (à l'aide de la touche ctrl). En mode normal: ctrl-k/j fait défiler la moitié d'un écran vers le haut et vers le bas et ctrl-l/h permet d'accéder au tampon suivant/précédent. Les mappages µ et ù sont spécialement conçus pour un clavier AZERTY et permettent de passer à l'erreur suivante/précédente.
imap <c-j> <Down>
imap <c-k> <Up>
imap <c-h> <Left>
imap <c-l> <Right>
nmap <c-j> <c-d>
nmap <c-k> <c-u>
nmap <c-h> <c-left>
nmap <c-l> <c-right>
nmap ù :cp<RETURN>
nmap µ :cn<RETURN>
Une petite fonction que j'ai écrite pour mettre en évidence des fonctions, des globales, des macros, des structs et des typedefs. (Peut être lent sur les très gros fichiers). Chaque type est mis en surbrillance (voir ": help group-name" pour avoir une idée des paramètres actuels de votre couleur) Utilisation: enregistrez le fichier avec ww (valeur par défaut "\ ww"). Vous avez besoin de balises pour cela.
nmap <Leader>ww :call SaveCtagsHighlight()<CR>
"Based on: http://stackoverflow.com/questions/736701/class-function-names-highlighting-in-vim
function SaveCtagsHighlight()
write
let extension = expand("%:e")
if extension!="c" && extension!="cpp" && extension!="h" && extension!="hpp"
return
endif
silent !ctags --fields=+KS *
redraw!
let list = taglist('.*')
for item in list
let kind = item.kind
if kind == 'member'
let kw = 'Identifier'
elseif kind == 'function'
let kw = 'Function'
elseif kind == 'macro'
let kw = 'Macro'
elseif kind == 'struct'
let kw = 'Structure'
elseif kind == 'typedef'
let kw = 'Typedef'
else
continue
endif
let name = item.name
if name != 'operator=' && name != 'operator ='
exec 'syntax keyword '.kw.' '.name
endif
endfor
echo expand("%")." written, tags updated"
endfunction
J'ai l'habitude d'écrire beaucoup de code et de fonctions et je n'aime pas écrire de prototypes pour eux. J'ai donc créé une fonction pour générer une liste de prototypes dans un fichier source de style C. Il existe deux variantes: l'une qui supprime le nom du paramètre formel et l'autre le conservant. Je viens d'actualiser la liste complète chaque fois que je dois mettre à jour les prototypes. Cela évite d'avoir des prototypes désynchronisés et des définitions de fonctions. A également besoin de balises.
"Usage: in normal mode, where you want the prototypes to be pasted:
":call GenerateProptotypes()
function GeneratePrototypes()
execute "silent !ctags --fields=+KS ".expand("%")
redraw!
let list = taglist('.*')
let line = line(".")
for item in list
if item.kind == "function" && item.name != "main"
let name = item.name
let retType = item.cmd
let retType = substitute( retType, '^/\^\s*','','' )
let retType = substitute( retType, '\s*'.name.'.*', '', '' )
if has_key( item, 'signature' )
let sig = item.signature
let sig = substitute( sig, '\s*\w\+\s*,', ',', 'g')
let sig = substitute( sig, '\s*\w\+\(\s)\)', '\1', '' )
else
let sig = '()'
endif
let proto = retType . "\t" . name . sig . ';'
call append( line, proto )
let line = line + 1
endif
endfor
endfunction
function GeneratePrototypesFullSignature()
"execute "silent !ctags --fields=+KS ".expand("%")
let dir = expand("%:p:h");
execute "silent !ctags --fields=+KSi --extra=+q".dir."/* "
redraw!
let list = taglist('.*')
let line = line(".")
for item in list
if item.kind == "function" && item.name != "main"
let name = item.name
let retType = item.cmd
let retType = substitute( retType, '^/\^\s*','','' )
let retType = substitute( retType, '\s*'.name.'.*', '', '' )
if has_key( item, 'signature' )
let sig = item.signature
else
let sig = '(void)'
endif
let proto = retType . "\t" . name . sig . ';'
call append( line, proto )
let line = line + 1
endif
endfor
endfunction
Ma recette préférée pour passer d'une fenêtre à l'autre:
function! SwitchPrevWin()
let l:winnr_index = winnr()
if l:winnr_index > 1
let l:winnr_index -= 1
else
"set winnr_index to max window open
let l:winnr_index = winnr('$')
endif
exe l:winnr_index . "wincmd w"
endfunction
nmap <M-z> :call SwitchPrevWin()
imap <M-z> <ESC>:call SwitchPrevWin()
nmap <C-z> :wincmd w
imap <C-z> <ESC>:wincmd w
Je voudrais organiser certains de mes propres fichiers de configuration dans after-directory . C'est particulièrement utile pour ftplugin .
Vous pouvez éviter d'écrire une longue liste de augroup dans votre fichier .vimrc au lieu de fichiers distincts pour chaque type.
Mais, évidemment, le répertoire .vim/ftplugin fait la même chose que .vim/after/ftplugin, mais je préférerais laisser le répertoire .vim aux plugins vim.
par ceci fil
Pour préfixer un ensemble de lignes, j'utilise l'une des deux approches suivantes:
Une approche est la sélection de bloc (mentionnée par qch). En général, vous pouvez sélectionner une région rectangulaire avec ctrl-V suivi du mouvement du curseur. Une fois que vous avez mis un rectangle en surbrillance, appuyez sur Maj-Je vais insérer des caractères sur le côté gauche du rectangle, ou sur Maj-A pour les ajouter sur le côté droit du rectangle. Vous pouvez donc utiliser cette technique pour créer un rectangle contenant la colonne la plus à gauche des lignes que vous souhaitez préfixer, appuyez sur shift-I, tapez le préfixe, puis appuyez sur échap.
L'autre approche consiste à utiliser une substitution (comme mentionné par Brian Agnew). La substitution de Brian affectera le fichier entier (le% dans la commande signifie "toutes les lignes"). Pour ne toucher que quelques lignes, l’approche la plus simple consiste à appuyer sur shift-V (ce qui active le mode ligne visuelle) sur la première/dernière ligne, puis à passer à la dernière/première ligne. Puis tapez:
: s/^/VOTRE PRÉFIXE /
Le ^ est une regex (dans ce cas, le début de la ligne). En tapant ceci en mode ligne visuelle, vous verrez que '<,'> est inséré avant le s automatiquement. Cela signifie que la plage de substitution sera la sélection visuelle.
Conseil supplémentaire: si votre préfixe contient des barres obliques, vous pouvez les échapper avec une barre oblique inverse ou vous pouvez utiliser un caractère de ponctuation différent comme séparateur dans la commande. Par exemple, pour ajouter des commentaires de ligne C++, j'écris habituellement:
: s: ^: //:
Pour ajouter un suffixe, l’approche de substitution est généralement plus facile à moins que toutes vos lignes aient exactement la même longueur. Utilisez simplement $ pour le motif à la place de ^ et votre chaîne sera ajoutée à la place de pré-suspendue.
Si vous voulez ajouter un préfixe et un suffixe simultanément, vous pouvez faire quelque chose comme ceci:
: s /.*/ PREFIX & SUFFIX /
Le. * Correspond à toute la ligne. Le & dans le remplacement renvoie le texte correspondant (la ligne entière), mais votre préfixe et suffixe seront désormais ajoutés.
BTW: lorsque vous commentez du code, vous voudrez probablement le supprimer plus tard. Vous pouvez utiliser visual-block (ctrl-V) pour sélectionner les barres obliques, puis appuyer sur d pour les supprimer, ou vous pouvez utiliser une substitution (probablement avec une sélection de ligne visuelle, faite avec shift-V) pour supprimer les barres obliques majeures comme celle-ci. :
: s: // ::
Des mappages pour faire en sorte que les mouvements fonctionnent sur la ligne d'écran actuelle en mode Habillage. J'ai découvert cela dans un commentaire sur un conseil de Vim il y a quelque temps, et il s'est révélé très pratique.
function! ScreenMovement(movement)
if &wrap
return "g" . a:movement
else
return a:movement
endif
endfunction
onoremap <silent> <expr> j ScreenMovement("j")
onoremap <silent> <expr> k ScreenMovement("k")
onoremap <silent> <expr> 0 ScreenMovement("0")
onoremap <silent> <expr> ^ ScreenMovement("^")
onoremap <silent> <expr> $ ScreenMovement("$")
nnoremap <silent> <expr> j ScreenMovement("j")
nnoremap <silent> <expr> k ScreenMovement("k")
nnoremap <silent> <expr> 0 ScreenMovement("0")
nnoremap <silent> <expr> ^ ScreenMovement("^")
nnoremap <silent> <expr> $ ScreenMovement("$")
Certains de mes must-have sont:
cscope + ctags + vim, disponibles sur le Web.
Quelques abréviations pour démarrer rapidement de nouveaux fichiers de code tels que:
ab cpph #include <iostream><CR>#include <string><CR>#include <cstdlib><CR>#include <cassert><CR>#include <vector><CR>#include <
stdexcept><CR>using namespace std;<CR>int main(int argc, char *argv[]) {
ab perlh #!/usr/bin/Perl<CR>use strict;<CR>use warnings;<CR>
ab chdr #include <stdio.h><CR>#include <sys/types.h><CR>#include <unistd.h><CR>#include <stdlib.h><CR>#include <sys/stat.h><CR>
#include <sys/wait.h><CR>#include <string.h><CR>int main(int argc, char *argv[]) {
ab xhtmlhdr <?xml version="1.0" encoding="UTF-8"?><CR><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.o
rg/TR/xhtml1/DTD/xhtml1-strict.dtd"><CR><html xmlns="http://www.w3.org/1999/xhtml"><CR> <head><CR> <title></title><CR><link h
ref="style.css" rel="STYLESHEET" type="text/css"><CR></head>
Par exemple, cpph insérera un squelette de base d’un fichier main.cc
Il y a aussi ma cartographie des touches de fonction:
map <F1> <Esc>:w<CR>:Perl $e = `./error.pl`; my ($f,$l,@w) = split(":",$e); my $w=join(":",@w); $curwin->Cursor($l,0); VIM::Msg($w);<CR>
map <F2> :wincmd w<CR>
map <F3> :wincmd s<CR>
map <F4> :wincmd v<CR>
map <F5> :wincmd o<CR>
map <F6> :sball<CR>
map <F7> :wq<CR>
map <F8> :wincmd q<CR>
map <F9> :wincmd -<CR>
map <F10> :wincmd +<CR>
map <F11> :wincmd <<CR>
map <F12> :wincmd ><CR>
Dans ce cas, ma F1 est mappée pour placer le curseur sur la prochaine erreur à corriger pour une migration de code source.
map _ ebi"^[ea"^[
Cette carte ferait _ citer une chaîne
Mine utilise des macros au lieu de recherches - la combinaison d'une macro avec le mode visuel est parfois plus efficace.