Trabalhar com arquivos enormes no VIM

Tentei abrir um arquivo enorme (~ 2 GB) no VIM, mas engasgou. Na verdade, não preciso editar o arquivo, apenas pular de maneira eficiente.

Como posso trabalhar com arquivos muito grandes no VIM?

Eu tinha um arquivo de 12 GB para editar hoje. O plugin vim LargeFile não funcionou para mim. Ele ainda usou toda a minha memória e, em seguida, imprimiu uma mensagem de erro :-(. Não consegui usar hexedit para nenhum dos dois, pois ele não pode inserir nada, apenas substituir. Aqui está uma abordagem alternativa:

Você divide o arquivo, edita as partes e então o recombina. Você ainda precisa de duas vezes o espaço em disco.

• Pesquise algo ao redor da linha que você gostaria de editar:

  grep -n 'something' HUGEFILE | head -n 1
  

• Extraia esse intervalo do arquivo. Digamos que as linhas que você deseja editar estejam nas linhas 4 e 5. Em seguida, faça:

  sed -n -e '4,5p' -e '5q' HUGEFILE > SMALLPART
  

  • A -nopção é necessária para suprimir o comportamento padrão do sed para imprimir tudo
  • 4,5p imprime as linhas 4 e 5
  • 5q aborta o sed após a linha de processamento 5

• Edite SMALLPARTusando seu editor favorito.

• Combine o arquivo:

  (head -n 3 HUGEFILE; cat SMALLPART; sed -e '1,5d' HUGEFILE) > HUGEFILE.new 
  

  • ou seja: escolha todas as linhas antes das linhas editadas do HUGEFILE (que neste caso são as 3 linhas principais), combine-as com as linhas editadas (neste caso as linhas 4 e 5) e use este conjunto combinado de linhas para substituir o equivalente (neste caso, as 5 primeiras linhas) no HUGEFILE e grave tudo em um novo arquivo.

  HUGEFILE.newagora será seu arquivo editado, você pode excluir o original HUGEFILE.

Esta tem sido uma questão recorrente por muitos anos. (Os números estão sempre mudando, mas o conceito é o mesmo: como faço para visualizar ou editar arquivos maiores do que a memória?)

Obviamente, moreou lesssão boas abordagens para meramente ler os arquivos --- lessaté ofertas vicomo atalhos de teclado para rolar e pesquisar.

Uma pesquisa do Freshmeat em "arquivos grandes" sugere que dois editores seriam particularmente adequados às suas necessidades.

Um seria: lfhex ... um grande editor hexadecimal de arquivo (que depende do Qt). Esse, obviamente, envolve o uso de uma GUI.

Outro parece ser adequado para uso em console: hed ... e afirma ter uma viminterface semelhante (incluindo um exmodo?).

Tenho certeza de que já vi outros editores para Linux / UNIX que conseguiram folhear os arquivos sem carregar totalmente na memória. No entanto, não me lembro de nenhum de seus nomes. Estou tornando esta resposta uma entrada de "wiki" para incentivar outras pessoas a adicionar seus links a esses editores. (Sim, estou familiarizado com as maneiras de contornar o problema usando splite cat; mas estou pensando em editores, especialmente editores de console / curses, que podem dispensar isso e nos poupar tempo / latências e sobrecarga de espaço em disco que tais abordagens acarretam) .

Já que você não precisa realmente editar o arquivo:

1. view(ou vim -R) deve funcionar razoavelmente bem em arquivos grandes.
2. Ou você pode usar moreouless

Escrevi um pequeno script baseado na resposta de Florian que usa nano (meu editor favorito):

#!/bin/sh

if [ "$#" -ne 3 ]; then
  echo "Usage: $0 hugeFilePath startLine endLine" >&2
  exit 1
fi

sed -n -e $2','$3'p' -e $3'q' $1 > hfnano_temporary_file
nano hfnano_temporary_file
(head -n `expr $2 - 1` $1; cat hfnano_temporary_file; sed -e '1,'$3'd' $1) > hfnano_temporary_file2
cat hfnano_temporary_file2 > $1
rm hfnano_temporary_file hfnano_temporary_file2

Use-o assim:

sh hfnano yourHugeFile 3 8

Nesse exemplo, o nano abrirá as linhas de 3 a 8, você pode editá-las e, ao salvar e sair, essas linhas no arquivo enorme serão substituídas automaticamente pelas linhas salvas.

Eu tive o mesmo problema, mas era um dump do mysql de 300 GB e eu queria me livrar do DROPe mudar CREATE TABLEpara, CREATE TABLE IF NOT EXISTSentão não queria executar duas invocações de sed. Escrevi este rápido script Ruby para enganar o arquivo com essas alterações:

#!/usr/bin/env ruby

matchers={
    %q/^CREATE TABLE `foo`/ => %q/CREATE TABLE IF NOT EXISTS `foo`/,
    %q/^DROP TABLE IF EXISTS `foo`;.*$/ => "-- DROP TABLE IF EXISTS `foo`;"
}

matchers.each_pair { |m,r|
    STDERR.puts "%s: %s" % [ m, r ]
}

STDIN.each { |line|
    #STDERR.puts "line=#{line}"
    line.chomp!
    unless matchers.length == 0
        matchers.each_pair { |m,r|
            re=/#{m}/
            next if line[re].nil?
            line.sub!(re,r)
            STDERR.puts "Matched: #{m} -> #{r}"
            matchers.delete(m)
            break
        }
    end
    puts line
}

Invocado como

./mreplace.rb < foo.sql > foo_two.sql

Para one-liners enormes (imprime caracteres de 1a 99):

cut -c 1-99 filename

Já é tarde, mas se você quiser apenas navegar pelo arquivo sem editá-lo, catpode fazer o trabalho também.

% cat filename | less

ou alternativamente simples:

% less filename

O emacs funciona muito bem com arquivos na casa dos 100 megabytes, usei-o em arquivos de log sem muitos problemas.

Mas geralmente, quando tenho algum tipo de tarefa de análise, acho que escrever um script perl é uma escolha melhor.

Tópico antigo. Mas mesmo assim (trocadilho :)).

 $less filename

funciona menos eficientemente se você não quiser editar e apenas dar uma olhada, o que é o caso de examinar arquivos de log enormes.

Pesquisar em menos funciona como vi

Melhor parte, ele está disponível por padrão na maioria das distros. Portanto, não será problema para o ambiente de produção também.

isso é antigo, mas use nano, vim ou gvim