Mesclar várias linhas (dois blocos) no Vim

Eu gostaria de mesclar dois blocos de linhas no Vim, ou seja, pegar linhas n..me anexá-las às linhas a..b. Se você preferir uma explicação de pseudocódigo:[a[i] + b[i] for i in min(len(a), len(b))]

Exemplo:

abc
def
...

123
45
...

Deve se tornar

abc123
def45

Existe uma boa maneira de fazer isso sem copiar e colar manualmente?

Você certamente pode fazer tudo isso com uma única cópia / pasta (usando a seleção do modo de bloco), mas acho que não é isso que você deseja.

Se você quiser fazer isso apenas com comandos Ex

:5,8del | let l=split(@") | 1,4s/$/\=remove(l,0)/

vai transformar

work it 
make it 
do it 
makes us 
harder
better
faster
stronger
~

para dentro

work it harder
make it better
do it faster
makes us stronger
~

ATUALIZAÇÃO: Uma resposta com tantos votos positivos merece uma explicação mais completa.

No Vim, você pode usar o caractere de barra vertical ( |) para encadear vários comandos Ex, portanto, o acima é equivalente a

:5,8del
:let l=split(@")
:1,4s/$/\=remove(l,0)/

Muitos comandos Ex aceitam um intervalo de linhas como argumento de prefixo - no caso acima, o 5,8antes dele o 1,4antes da s///especificação de quais linhas os comandos operam.

delexclui as linhas fornecidas. Pode levar um argumento de registro, mas quando um não é fornecido, ele despeja as linhas no registro sem nome @", assim como a exclusão no modo normal. let l=split(@")depois divide as linhas excluídas em uma lista, usando o delimitador padrão: espaço em branco. Para funcionar corretamente em entradas com espaços em branco nas linhas excluídas, como:

more than 
hour 
our 
never 
ever
after
work is
over
~

tínhamos necessidade de especificar um delimitador diferente, para evitar que "o trabalho é" de ser dividido em dois elementos da lista: let l=split(@","\n").

Finalmente, na substituição s/$/\=remove(l,0)/, substituímos o final de cada linha ( $) pelo valor da expressão remove(l,0). remove(l,0)altera a lista l, excluindo e retornando seu primeiro elemento. Isso nos permite substituir as linhas excluídas na ordem em que as lemos. Em vez disso, poderíamos substituir as linhas excluídas na ordem inversa usando remove(l,-1).

Um comando elegante e conciso Ex resolver o problema pode ser obtido através da combinação das :global, :movee :joincomandos. Supondo que o primeiro bloco de linhas inicie na primeira linha do buffer e que o cursor esteja localizado na linha imediatamente anterior à primeira linha do segundo bloco, o comando é o seguinte.

:1,g/^/''+m.|-j!

Para uma explicação detalhada dessa técnica, consulte minha resposta para uma pergunta semelhante “ Vim colar comportamento de d '' fora da caixa? ”.

Para unir blocos de linha, você deve executar as seguintes etapas:

1. Vá para a terceira linha: jj
2. Entre no modo de bloqueio visual: CTRL-v
3. Ancore o cursor no final da linha (importante para linhas de comprimento diferente): $
4. Vá para o final: CTRL-END
5. Corte o bloco: x
6. Vá para o final da primeira linha: kk$
7. Cole o bloco aqui: p

O movimento não é o melhor (não sou especialista), mas funciona como você queria. Espero que haja uma versão mais curta dele.

Aqui estão os pré-requisitos para que essa técnica funcione bem:

• Todas as linhas do bloco inicial (no exemplo da pergunta abce def) têm o mesmo comprimento XOR
• a primeira linha do bloco inicial é a mais longa e você não se importa com os espaços adicionais intermediários) XOR
• A primeira linha do bloco inicial não é a mais longa e você coloca espaços adicionais até o fim.

Aqui está como eu faria isso (com o cursor na primeira linha):

qama:5<CR>y$'a$p:5<CR>dd'ajq3@a

Você precisa saber duas coisas:

• O número da linha na qual a primeira linha do segundo grupo inicia (5 no meu caso) e
• o número de linhas em cada grupo (3 no meu exemplo).

Aqui está o que está acontecendo:

• qaregistra tudo até o próximo qem um "buffer" em a.
• ma cria uma marca na linha atual.
• :5<CR> vai para o próximo grupo.
• y$ puxa o resto da linha.
• 'a retorna à marca, defina anteriormente.
• $p pastas no final da linha.
• :5<CR> retorna à primeira linha do segundo grupo.
• dd exclui.
• 'a retorna à marca.
• jq desce uma linha e para de gravar.
• 3@a repete a ação para cada linha (3 no meu caso)

Como mencionado em outro lugar, a seleção de blocos é o caminho a percorrer. Mas você também pode usar qualquer variante de:

:!tail -n -6 % | paste -d '\0' % - | head -n 5

Este método depende da linha de comandos do UNIX. O pasteutilitário foi criado para lidar com esse tipo de mesclagem de linhas.

PASTE(1)                  BSD General Commands Manual                 PASTE(1)

NAME
     paste -- merge corresponding or subsequent lines of files

SYNOPSIS
     paste [-s] [-d list] file ...

DESCRIPTION
     The paste utility concatenates the corresponding lines of the given input files, replacing all but the last file's newline characters with a single tab character,
     and writes the resulting lines to standard output.  If end-of-file is reached on an input file while other input files still contain data, the file is treated as if
     it were an endless source of empty lines.

Os dados de amostra são os mesmos que os de rampion.

:1,4s/$/\=getline(line('.')+4)/ | 5,8d

Eu não acho que tornaria isso muito complicado. Gostaria apenas de definir virtualedit em
( :set virtualedit=all)
Selecione o bloco 123 e tudo abaixo.
Coloque-o após a primeira coluna:

abc    123
def    45
...    ...

e remova o espaço múltiplo entre 1 espaço:

:%s/\s\{2,}/ /g

Eu usaria repetições complexas :)

Dado isto:

aaa
bbb
ccc

AAA
BBB
CCC

Com o cursor na primeira linha, pressione o seguinte:

qa}jdd''pkJxjq

e pressione @a(e você poderá usá-lo posteriormente @@) quantas vezes for necessário.

Você deve terminar com:

aaaAAA
bbbBBB
cccCCC

(Mais uma nova linha.)

Explicação:

• qa começa a gravar uma repetição complexa em a

• } pula para a próxima linha vazia

• jdd exclui a próxima linha

• '' volta à posição anterior ao último salto

• p cole a linha excluída sob a atual

• kJ anexar a linha atual ao final da linha anterior

• xexclua o espaço que Jadiciona entre as linhas combinadas; você pode omitir isso se quiser o espaço

• j vá para a próxima linha

• q terminar a gravação repetida complexa

Depois disso, você usaria @apara executar a repetição complexa armazenada ae, em seguida, poderá @@executar novamente a última repetição complexa executada.

Pode haver várias maneiras de conseguir isso. Mesclarei dois blocos de texto usando qualquer um dos dois métodos a seguir.

suponha que o primeiro bloco esteja na linha 1 e o segundo bloco comece na linha 10 com a posição inicial do cursor na linha número 1.

(\ n significa pressionar a tecla Enter.)

1. abc
   def
   ghi        

10. 123
    456
    789

com uma macro usando os comandos: copiar, colar e participar.

qaqqa: + 9y \ npkJjq2 @ a10G3dd

com uma macro usando os comandos, mova uma linha no enésimo número da linha e junte-se.

qcqqc: 10m. \ nkJjq2 @ c