How can I open the next/previous file alphabetically?

Question

Say I have a bunch of files, ordered alphabetically: 1.txt, 2.txt, 3.txt, etc. (In a typical situation, I have hundreds of these, ordered by date.) If I open file 2, is there a quick way for me to open file 1? (Or, 3?)

Ideally, I'd like to be able to do this with a single keystroke. (Holding modifiers is ok.)

---

Edit: One thing I forgot to mention was that there are multiple folders that have these files in them. It's common for me to be in a directory (e.g. /, and then need to edit files in /tmp/a and /tmp/b.) Although not a deal-breaker, it would be nice if I could change between /tmp/a/2.txt and /tmp/a/1.txt without having to reload vim.

Answer 1

My EditSimilar plugin has :EditPrevious and :EditNext, which go alphabetically through files in the current directory. There are also :EditMinus / :EditPlus for numbers in files, and other, generic :EditSubstitute, :EditRoot, as well as :Split..., :VSplit... variants. You can easily define mappings quick mappings to those commands.

The unimpaired.vim plugin has (among many other, largely unrelated) [f / ]f mappings that work like :EditPrevious / :EditNext (but aren't as robust last time I've checked).

Answer 2

if all your files have a similar extension (.txt, .c, .py), place them in a folder and cd then vim *.text, vim *.c, vim *.py

All the files will get added to args list, open the list by :args to see the added files. These files can be navigated using :n for next file and :N for previous. This could then be mapped to F7,F8 as so

map <F7> :N<CR>, map <F8> :n<CR>

for single keystroke operation

Answer 3

Following up on my comment…

I've created 1000 files named 1.txt to 1000.txt with the following command:

$ touch {1..1000}.txt

In Vim, I could use :args *.txt to load each of them in the argument list but the order will be less than optimal:

1.txt
10.txt
100.txt
1000.txt
101.txt
102.txt
103.txt
104.txt
105.txt
106.txt
107.txt
...

Instead, we could use :help backtick-expansion:

:args `ls\|sort -g`

Which gives us a more usable order:

1.txt
2.txt
3.txt
4.txt
5.txt
6.txt
7.txt
8.txt
9.txt
10.txt
11.txt
...

From there, you can use argument-related commands to move around:

:n    " next argument
:N    " previous argument

And map them if that's still too much typing:

nnoremap <Right> :n<CR>
nnoremap <Left>  :N<CR>

Since we are at it, why not map our custom :args command, too?

nnoremap <key> :args `ls\|sort -g`<CR>

NOTE: Feeding the argument list with hundreds of files (from plain *.txt to structured *.rb or whatever) is nearly instantaneous and Vim can perfectly handle thousands of buffers so you don't have to fear performance issues.

--- edit ---

Unlike the buffer list, argument lists can be local. This allows you to have different argument lists in different tab pages (or windows, but I find tab pages to be easier to reason about in such a scenario and… that's pretty much their intended use):

$ vim
:arglocal `ls /tmp/a\|sort -g`
:tabnew
:arglocal `ls /tmp/b\|sort -g`

With such a setup, :n and :N will cycle through the first argument list in the first tab page and the second argument list in the second tab page.