Quelle est la manière la plus efficace d'utiliser les tampons?

Dernièrement, j'ai considérablement réduit le nombre de plugins que j'utilise, donc je cherche des réponses en utilisant uniquement les fonctionnalités Vim intégrées.

J'ai remarqué une faille dans mon flux de travail lorsque j'édite beaucoup de tampons: je suis sur un tampon et je veux passer à un autre dont je ne me souviens pas du nom et qui n'est pas le tampon alternatif . Il :b#n'est donc pas possible d'utiliser l'achèvement avec la commande :b.

Pour ce faire, je faisais ce qui suit:

• Première utilisation :bufferspour obtenir la liste des tampons ouverts
• Rappelez-vous le numéro du tampon que je veux utiliser
• Appuyez Enterpour fermer la liste des tampons
• Utilisez :bXavec Xle numéro du tampon à utiliser.

Ce flux de travail m'a semblé assez lourd, j'ai donc ajouté les lignes suivantes à mon .vimrc:

" Improve the navigation in the buffers 
nnoremap <Leader><S-b> :B<CR> 
command! B call Buffers() 

function! Buffers() 
    execute "buffers" 
    let buffer=input("Enter a buffer:") 
    execute "b" . buffer 
endfunction 

Cela me donne une commande :B(et un mappage) qui appelle la fonction :buffersattendre une entrée et enfin appelle :bsuivie de l'entrée.

Cela fonctionne bien, mais je suis surpris d'avoir dû développer une telle fonction: généralement, Vim a un flux de travail par défaut assez efficace, donc je me demande s'il y a une meilleure façon de passer à un tampon dont je ne sais rien sauf qu'il a déjà été ouvert dans ma session d'édition.

J'ai remarqué une faille dans mon flux de travail lorsque j'édite beaucoup de tampons: je suis sur un tampon et je veux passer à un autre dont je ne me souviens plus du nom et qui n'est pas le tampon alternatif . Il :b#n'est donc pas possible d'utiliser l'achèvement avec la commande :b.

Au contraire, je trouve que la tabulation est extrêmement pratique. Définir les bonnes options sur des valeurs qui fonctionnent pour vous peut être très utile. Ce sont les lignes pertinentes de mon vimrc (elles fonctionnent pour moi mais elles peuvent ne pas fonctionner pour vous, alors ne vous contentez pas de les copier) :

nnoremap ,b :buffer *
set wildmenu
set wildignore+=*.swp,*.bak
set wildignore+=*.pyc,*.class,*.sln,*.Master,*.csproj,*.csproj.user,*.cache,*.dll,*.pdb,*.min.*
set wildignore+=*/.git/**/*,*/.hg/**/*,*/.svn/**/*
set wildignore+=*/min/*,*/vendor/*,*/node_modules/*,*/bower_components/*
set wildignore+=tags,cscope.*
set wildignore+=*.tar.*
set wildignorecase
set wildmode=full

Avec cela, le bon tampon est rarement à plus de cinq ou six frappes:

Cela me donne une commande :B(et un mappage) qui appelle la fonction :buffersattendre une entrée et enfin appelle :bsuivie de l'entrée.

Barry Arthur a proposé il y a des années une solution beaucoup plus simple qui est devenue très populaire depuis lors:

nnoremap <leader>b :ls<CR>:b<Space>

dont j'ai proposé il y a quelques années une variante un peu plus polyvalente:

nnoremap gb :ls<CR>:b

Puisque nous parlons de vimscript, voici une jolie petite fonction que j'ai écrite qui "remplit automatiquement" la ligne de commande avec le bon bout de commande après des commandes de type liste comme :lsou :ilist. L'avantage de cette fonction par rapport aux mappages ci-dessus est que je n'ai pas à me souvenir de mappages spécifiques. Cela fonctionne exactement comme Vim, mais avec une petite touche .

" smooth listing
cnoremap <expr> <CR> <SID>CCR()

function! s:CCR()
    if getcmdtype() == ":"
        let cmdline = getcmdline()
            if cmdline =~ '\v\C^(dli|il)' | return "\<CR>:" . cmdline[0] . "jump  " . split(cmdline, " ")[1] . "\<S-Left>\<Left>"
        elseif cmdline =~ '\v\C^(cli|lli)' | return "\<CR>:silent " . repeat(cmdline[0], 2) . "\<Space>"
        elseif cmdline =~ '\C^changes' | set nomore | return "\<CR>:sil se more|norm! g;\<S-Left>"
        elseif cmdline =~ '\C^ju' | set nomore | return "\<CR>:sil se more|norm! \<C-o>\<S-Left>"
        elseif cmdline =~ '\C^ol' | set nomore | return "\<CR>:sil se more|e #<"
        elseif cmdline =~ '\C^undol' | return "\<CR>:u "
        elseif cmdline =~ '\C^ls' | return "\<CR>:b"
        elseif cmdline =~ '/#$' | return "\<CR>:"
        else | return "\<CR>" | endif
    else | return "\<CR>" | endif
endfunction

Cela dit, je suis un grand partisan de la "navigation basée sur les symboles" plutôt que de la "navigation basée sur les fichiers". Le cas échéant, la navigation par symboles est beaucoup plus rapide et beaucoup plus économique que la navigation par fichiers.

Le dernier GIF montre un moyen de navigation basée sur les symboles, soit dit en passant. L'exemple est idiot mais… eh bien.

J'ai rencontré le même problème il y a quelque temps et j'ai trouvé une solution:

nnoremap <leader>b :buffers<CR>:buffer<space>

Cela ouvrira la liste des tampons et sans la cacher, vous donnera la possibilité de changer de tampon.

Je pense qu'il est logique que Vim ne dispose pas d'une option "lister et sélectionner" ici, ce sont deux actions distinctes. Mais Vim est assez puissant pour combiner la commande ensemble.

Considérez-la comme la philosophie Unix: faites une chose et faites-la bien.

:buffersrépertorie les tampons et :buffer xxxvous permet d'en sélectionner un.

Pendant un certain temps, j'ai utilisé la technique de nobe4 comme ceci:

nnoremap <Leader>b :set nomore<Bar>:ls<Bar>:set more<CR>:b<Space>

Ensuite, j'ai commencé à utiliser Tab-complètement avec cela (comme le suggère romainl)

Mais plus récemment, j'ai trouvé que la méthode la plus rapide avec le moins de touches est d'utiliser:

{count} CTRL-^

Ce n'est pas si différent de :b#<Enter> mais comme vous le dites, vous devez connaître le numéro de tampon!

Donc pour ça je lance le plugin MiniBufExplorer , qui affiche une liste de noms de fichiers en haut (comme presque tous les autres éditeurs). Je suis sûr qu'il existe de nombreuses alternatives.

Enfin, comme Ctrl-^c'est un peu un étirement pour mes doigts, et c'est une opération très courante, je l'ai déplacé vers Ctrl-E. L' implémentation pour cela n'est pas trop complexe:

nnoremap <C-E> :<C-U>call SwitchToBuffer()<CR>

function! SwitchToBuffer()
  if v:count > 0
    exec v:count . "b"
    return
  endif

  " Whatever you want to do if you didn't provide a count
  " In this case, fall back to nobe4's technique:
  call feedkeys(":ls\n:b ")
endfunction

Donc, mon processus de commutation de tampon actuel ressemble à ceci:

1. Regardez MiniBufExplorer
2. Frappé 3 Ctrl-E

Malheureusement, MBE et le script ci-dessus ne sont pas des builds Vim, comme vous l'avez demandé. Quand je suis sur une machine distante sans config, j'utilise simplement :b [partial]et Tab-Completion.