sponsor Vim development Vim logo Vim Book Ad

AdvancedSorters : Sorting of certain areas or by special needs.

 script karma  Rating 13/4, Downloaded by 708  Comments, bugs, improvements  Vim wiki

created by
Ingo Karkat
script type
The built-in :sort command is powerful, but it still is line-based. It
doesn't take into account folded lines, nor can it sort entire blocks like
function definitions, paragraphs, etc. But often, one needs to sort exactly
such areas as single entities, i.e. without changing the line order within
them. A workaround in Vim is condensing each block into a single line,
performing the sorting, and then expanding again. (External, more powerful
sort commands could be used, too.)

This plugin implements this workaround and encapsulates the three separate
steps in one handy command.

While :sort has several flags for sorting on various numbers, and a
/{pattern}/ can be specified to skip or sort on, it doesn't allow arbitrary
(Vimscript) expressions.

This plugin offers extension commands that evaluate an expression per line,
put that number in front of the line, do a numerical sort, and then remove the
temporary number again. Specializations handle the common sort by number of
characters and by the line's display width.

- :SortUnfolded inspired by
- :SortRangesByRange inspired by
- :SortByExpr inspired by
- :SortWORDs inspired by

- The LineJuggler.vim plugin (vimscript #4140) offers many quick mappings to
  move around (blocks of) lines. For small data sets, manual shifting may be
  quicker than coming up with a correct sort command.

:[range]SortUnfolded[!] [i][u][r][n][x][o] [/{pattern}/]
                        Sort visible lines in the buffer / [range]. Lines
                        inside closed folds are kept intact; sorting is done
                        on all lines of the fold as one unit; i.e. the order
                        of the other lines inside the fold does _not_ change!

:[range]SortRangesByHeader[!] /{expr}/ [i][u][r][n][x][o] [/{pattern}/]
                        Each match of {expr} (in the buffer / [range]) starts
                        a new area that sorts as one unit; i.e. the order of
                        the other lines inside the area does _not_ change!

:[range]SortRangesByMatch[!] /{expr}/ [i][u][r][n][x][o] [/{pattern}/]
                        Each (multi-line) match of {expr} (in the buffer /
                        [range]) defines an area that sorts as one unit.
                        Non-matching lines are sorted individually.

:[range]SortRangesByRange[!] {range} [i][u][r][n][x][o] [/{pattern}/]
                        Each {range} (in the buffer / [range]) defines an area
                        that sorts as one unit.
                        Note: For this command, /{pattern}/ must be separated
                        from the {range} by a [i][u][r][n][x][o] flag or a
                        space; you cannot directly concatenate them.

                        Note: The text must not contain embedded <Nul>
                        characters (^@) for the above commands!

:[range]SortByExpr[!] {expr}
                        Sort lines in [range] by the {expr}, which should take
                        the current line as input via v:val and return a
                        number. With [!] the order is reversed.

:[range]SortByExprUnique[!] {expr}
                        Sort lines in [range] by the {expr}; only the first
                        line that gets a certain number from {expr} is kept.
                        With [!] the order is reversed.

                        Sort lines in [range] by the number of characters.

                        Sort lines in [range] by the display width.

:[range]SortWORDs[!] [i][u][r][n][x][o] [/{pattern}/]
                        Sort individual (whitespace-delimited) WORDs in the
                        current line / [range].

:[range]Uniq[!] [i][r] [/{pattern}/]
                        Remove lines in [range] that have already been
                        encountered earlier (not necessarily adjacent).
                        With [i] case is ignored.
                        When /{pattern}/ is specified and there is no [r] flag
                        the text matched with {pattern} is ignored.
                        With [r] only the matching {pattern} is considered;
                        the rest is ignored.
                        If a {pattern} is used, any lines which don't have a
                        match for {pattern} are kept.

We're taking any Vimscript file with multiple function definitions as an
example, and show how to sort whole functions according to function name (and

To use folding, we first have to define the folds, then trigger the sorting:

If we don't care about including any lines after the "endfunction", we can
just base the areas on the function start:
    :SortRangesByHeader /^function/
But we'll get better results with an explicit end. One way is to define a
multi-line pattern that covers the entire function:
    :SortRangesByMatch /^function\_.\{-}\nendfunction$/
Another way spans up a range, similar to what we've done above to define the
    :SortRangesByRange /^function/,/^endfunction$/
install details
This script is packaged as a vimball. If you have the "gunzip" decompressor
in your PATH, simply edit the *.vmb.gz package in Vim; otherwise, decompress
the archive first, e.g. using WinZip. Inside Vim, install by sourcing the
vimball or via the :UseVimball command.
    vim AdvancedSorters*.vmb.gz
    :so %
To uninstall, use the :RmVimball command.

- Requires Vim 7.0 or higher.
- Requires the ingo-library.vim plugin (vimscript #4433), version 1.022 or

rate this script Life Changing Helpful Unfulfilling 
script versions (upload new version)

Click on the package to download.

package script version date Vim version user release notes
AdvancedSorters-1.21.vmb.gz 1.21 2016-10-26 7.0 Ingo Karkat - BUG: :SortUnfolded and :SortRangedBy... remove comment sigils (like "#") when 'formatoptions' contains "j". Temporarily reset 'formatoptions' to avoid interference of user settings. Thanks to Holger Mitschke for reporting this!
AdvancedSorters-1.20.vmb.gz 1.20 2015-02-09 7.0 Ingo Karkat - Add :Uniq command.
- Also support [/{pattern}/] [i][u][r][n][x][o] :sort argument order (and mixed).
- FIX: Include missing Words.vim module that prevented the :SortWORDs command introduced in the previous version 1.10 from functioning.
AdvancedSorters-1.10.vmb.gz 1.10 2014-12-23 7.0 Ingo Karkat - Add :SortWORDs command.
AdvancedSorters-1.02.vmb.gz 1.02 2014-11-06 7.0 Ingo Karkat - BUG: :.SortRangesBy... doesn't work correctly on a closed fold; need to use ingo#range#NetStart(). *** You need to update to ingo-library (vimscript #4433) version 1.022! ***
AdvancedSorters-1.01.vmb.gz 1.01 2014-07-10 7.0 Ingo Karkat - Make :SortRangesByRange work for Vim versions before 7.4.218 that don't have uniq(). *** You need to update to ingo-library (vimscript #4433) version 1.021! ***
AdvancedSorters-1.00.vmb.gz 1.00 2014-06-11 7.0 Ingo Karkat Initial upload
ip used for rating:

If you have questions or remarks about this site, visit the vimonline development pages. Please use this site responsibly.
Questions about Vim should go to the maillist. Help Bram help Uganda.
OSDN.net Logo