Complete Solution for Moving Entire Lines Up and Down in Vim

Basic Methods for Line Movement in Vim

There are multiple approaches to move entire lines in Vim, each with specific use cases and limitations. Understanding the principles behind these methods is crucial for selecting the most appropriate solution.

Delete and Paste Approach

The most fundamental method for line movement uses combinations of delete and paste commands. To move the current line upward, use the ddkP command sequence:

ddkP

This command sequence works as follows: first, dd deletes the current line and stores its content in the default register; then k moves the cursor to the previous line; finally P pastes the register content above the current line.

Correspondingly, to move the current line downward, use ddp command:

ddp

While this method is straightforward, it has significant limitations. When moving the first line upward or the last line downward, issues such as line disappearance or abnormal jumping occur, which can be problematic in practical usage.

:move Command Method

Vim provides the dedicated :move command for line movement, which doesn't affect register contents and supports moving multiple line ranges.

The basic syntax is as follows:

:m +1  " Move down 1 line
:m -2  " Move up 1 line

It's important to note that for upward movement, -2 must be used instead of -1. This is because the semantics of the :move command place the specified lines below the target line. -1 means moving to below the line above the current line, effectively leaving the position unchanged, thus requiring -2 to achieve the intended upward movement.

For moving multiple lines, you can first use V to enter visual mode and select multiple lines, then execute commands like :m +1 or :m -2.

Script-Based Solution

To address edge case issues, Vim script functions can be written to provide more robust movement functionality. Here's a complete solution:

function! s:swap_lines(n1, n2)
    let line1 = getline(a:n1)
    let line2 = getline(a:n2)
    call setline(a:n1, line2)
    call setline(a:n2, line1)
endfunction

function! s:swap_up()
    let n = line('.')
    if n == 1
        return
    endif
    call s:swap_lines(n, n - 1)
    exec n - 1
endfunction

function! s:swap_down()
    let n = line('.')
    if n == line('$')
        return
    endif
    call s:swap_lines(n, n + 1)
    exec n + 1
endfunction

The core idea of this solution is to directly exchange the contents of two lines, rather than using delete and paste operations. The s:swap_lines function handles swapping the contents of two specified lines, while s:swap_up and s:swap_down functions manage the logic for upward and downward movement respectively, gracefully returning in edge cases to prevent errors.

Key Mapping Configuration

Mapping these functions to familiar keyboard shortcuts can significantly improve editing efficiency. The following configuration maps Ctrl+Shift+Up and Ctrl+Shift+Down to the corresponding movement functions:

noremap <silent> <c-s-up> :call <SID>swap_up()<CR>
noremap <silent> <c-s-down> :call <SID>swap_down()<CR>

The <silent> option ensures that no information is displayed in the command line during execution, providing a smoother user experience. <SID> is used to correctly reference script-local functions.

Advanced Configuration Options

For users with specific requirements, the following advanced configuration can be considered:

nnoremap <A-j> :m .+1<CR>==
noremap <A-k> :m .-2<CR>==
inoremap <A-j> <Esc>:m .+1<CR>==gi
inoremap <A-k> <Esc>:m .-2<CR>==gi
vnoremap <A-j> :m '>+1<CR>gv=gv
vnoremap <A-k> :m '<-2<CR>gv=gv

This configuration supports line movement using Alt+j and Alt+k in normal mode, insert mode, and visual mode. == is used for automatic indentation adjustment, while gv=gv maintains selection and reformats indentation after movement in visual mode.

Error Handling and Edge Cases

Proper handling of edge cases is crucial in practical usage. The script solution avoids invalid operations by checking the relationship between the current line number and file boundaries:

• When the cursor is on the first line, upward movement is ignored
• When the cursor is on the last line, downward movement is ignored
• After movement, the cursor automatically positions to the new location, maintaining editing continuity

This design ensures operational stability and consistent user experience.

Performance Considerations

For large files, different movement methods exhibit varying performance characteristics. The script solution typically shows better performance by directly manipulating line contents and avoiding register operations. The :move command is more efficient when handling multiple line movements, particularly when moving large code segments.

Practical Application Scenarios

Line movement functionality is extremely useful in scenarios such as code refactoring and document organization. With appropriate key mappings, developers can quickly adjust code structures and improve development efficiency. Users are recommended to choose the configuration that best suits their personal habits and workflow requirements.