Como posso extrair um intervalo predeterminado de linhas de um arquivo de texto no Unix?

Eu tenho um despejo de SQL ~ 23000 linhas contendo vários bancos de dados no valor de dados. Eu preciso extrair uma certa seção deste arquivo (ou seja, os dados para um único banco de dados) e colocá-lo em um novo arquivo. Conheço os números das linhas inicial e final dos dados que desejo.

Alguém conhece um comando Unix (ou série de comandos) para extrair todas as linhas de um arquivo entre as linhas 16224 e 16482 e, em seguida, redirecioná-las para um novo arquivo?

sed -n '16224,16482p;16483q' filename > newfile

No manual sed :

p - Imprima o espaço do padrão (na saída padrão). Esse comando geralmente é usado apenas em conjunto com a opção de linha de comando -n.

n - Se a impressão automática não estiver desativada, imprima o espaço do padrão e, independentemente, substitua o espaço do padrão pela próxima linha de entrada. Se não houver mais entrada, o sed sai sem processar mais nenhum comando.

q - Saia sedsem processar mais nenhum comando ou entrada. Observe que o espaço padrão atual é impresso se a impressão automática não estiver desativada com a opção -n.

e

Os endereços em um script sed podem estar em qualquer uma das seguintes formas:

número A especificação de um número de linha corresponderá apenas a essa linha na entrada.

Um intervalo de endereços pode ser especificado especificando dois endereços separados por vírgula (,). Um intervalo de endereços corresponde a linhas começando de onde o primeiro endereço corresponde e continua até o segundo endereço corresponder (inclusive).

sed -n '16224,16482 p' orig-data-file > new-file

Onde 16224,16482 são o número da linha inicial e o número da linha final, inclusive. Isso é indexado em 1. -nsuprime o eco da entrada como saída, o que você claramente não deseja; os números indicam o intervalo de linhas para que o seguinte comando opere; o comando pimprime as linhas relevantes.

Muito simples usando cabeça / cauda:

head -16482 in.sql | tail -258 > out.sql

usando sed:

sed -n '16482,16482p' in.sql > out.sql

usando awk:

awk 'NR>=10&&NR<=20' in.sql > out.sql

Você pode usar 'vi' e, em seguida, o seguinte comando:

:16224,16482w!/tmp/some-file

Alternativamente:

cat file | head -n 16482 | tail -n 258

EDIT: - Apenas para adicionar uma explicação, use o comando -n 16482 para exibir as primeiras 16482 linhas e, em seguida, use o tail -n 258 para obter as últimas 258 linhas da primeira saída.

Há outra abordagem com awk:

awk 'NR==16224, NR==16482' file

Se o arquivo for grande, pode ser bom exitdepois de ler a última linha desejada. Dessa forma, ele não lerá as seguintes linhas desnecessariamente:

awk 'NR==16224, NR==16482-1; NR==16482 {print; exit}' file

awk 'NR==16224, NR==16482; NR==16482 {exit}' file

perl -ne 'print if 16224..16482' file.txt > new_file.txt

 # print section of file based on line numbers
 sed -n '16224 ,16482p'               # method 1
 sed '16224,16482!d'                 # method 2

cat dump.txt | head -16224 | tail -258

deve fazer o truque. A desvantagem dessa abordagem é que você precisa fazer a aritmética para determinar o argumento da cauda e explicar se deseja que o 'entre' inclua a linha final ou não.

De pé sobre os ombros de boxxar, eu gosto deste:

sed -n '<first line>,$p;<last line>q' input

por exemplo

sed -n '16224,$p;16482q' input

Como $significa "última linha", o primeiro comando faz com que sedtodas as linhas sejam impressas começando com a linha 16224e o segundo comando é sedencerrado após a impressão da linha 16428. (Adicionando 1para oq Parece não ser necessário intervalo na solução de boxxar.)

Eu gosto dessa variante porque não preciso especificar o número da linha final duas vezes. E eu medi que o uso $não tem efeitos prejudiciais no desempenho.

sed -n '16224,16482p' < dump.sql

Rapido e sujo:

head -16428 < file.in | tail -259 > file.out

Provavelmente não é a melhor maneira de fazê-lo, mas deve funcionar.

BTW: 259 = 16482-16224 + 1.

Eu escrevi um programa Haskell chamado splitter que faz exatamente isso: leia a publicação do meu blog de lançamento .

Você pode usar o programa da seguinte maneira:

$ cat somefile | splitter 16224-16482

E isso é tudo o que há para isso. Você precisará do Haskell para instalá-lo. Somente:

$ cabal install splitter

E você terminou. Espero que você ache este programa útil.

Mesmo nós podemos fazer isso para verificar na linha de comando:

cat filename|sed 'n1,n2!d' > abc.txt

Por exemplo:

cat foo.pl|sed '100,200!d' > abc.txt

Usando ruby:

ruby -ne 'puts "#{$.}: #{$_}" if $. >= 32613500 && $. <= 32614500' < GND.rdf > GND.extract.rdf

Eu estava prestes a postar o truque de cabeça / cauda, ​​mas na verdade eu provavelmente iria iniciar o emacs. ;-)

1. esc- xlinha goto ret16224
2. marca ( ctrl- space)
3. esc- xlinha goto ret16482
4. esc-w

abra o novo arquivo de saída, salve ctl-y

Vamos ver o que está acontecendo.

Eu usaria:

awk 'FNR >= 16224 && FNR <= 16482' my_file > extracted.txt

FNR contém o número do registro (linha) da linha que está sendo lida no arquivo.

Eu queria fazer a mesma coisa a partir de um script usando uma variável e consegui-o colocando aspas em torno da variável $ para separar o nome da variável do p:

sed -n "$first","$count"p imagelist.txt >"$imageblock"

Eu queria dividir uma lista em pastas separadas e encontrei a pergunta inicial e respondi a uma etapa útil. (comando split não é uma opção no sistema operacional antigo para o qual tenho que portar o código).

Eu escrevi um pequeno script bash que você pode executar a partir da linha de comando, desde que atualize seu PATH para incluir seu diretório (ou você pode colocá-lo em um diretório que já esteja contido no PATH).

Uso: $ pinch filename start-line end-line

#!/bin/bash
# Display line number ranges of a file to the terminal.
# Usage: $ pinch filename start-line end-line
# By Evan J. Coon

FILENAME=$1
START=$2
END=$3

ERROR="[PINCH ERROR]"

# Check that the number of arguments is 3
if [ $# -lt 3 ]; then
    echo "$ERROR Need three arguments: Filename Start-line End-line"
    exit 1
fi

# Check that the file exists.
if [ ! -f "$FILENAME" ]; then
    echo -e "$ERROR File does not exist. \n\t$FILENAME"
    exit 1
fi

# Check that start-line is not greater than end-line
if [ "$START" -gt "$END" ]; then
    echo -e "$ERROR Start line is greater than End line."
    exit 1
fi

# Check that start-line is positive.
if [ "$START" -lt 0 ]; then
    echo -e "$ERROR Start line is less than 0."
    exit 1
fi

# Check that end-line is positive.
if [ "$END" -lt 0 ]; then
    echo -e "$ERROR End line is less than 0."
    exit 1
fi

NUMOFLINES=$(wc -l < "$FILENAME")

# Check that end-line is not greater than the number of lines in the file.
if [ "$END" -gt "$NUMOFLINES" ]; then
    echo -e "$ERROR End line is greater than number of lines in file."
    exit 1
fi

# The distance from the end of the file to end-line
ENDDIFF=$(( NUMOFLINES - END ))

# For larger files, this will run more quickly. If the distance from the
# end of the file to the end-line is less than the distance from the
# start of the file to the start-line, then start pinching from the
# bottom as opposed to the top.
if [ "$START" -lt "$ENDDIFF" ]; then
    < "$FILENAME" head -n $END | tail -n +$START
else
    < "$FILENAME" tail -n +$START | head -n $(( END-START+1 ))
fi

# Success
exit 0

Isso pode funcionar para você (GNU sed):

sed -ne '16224,16482w newfile' -e '16482q' file

ou aproveitando o bash:

sed -n $'16224,16482w newfile\n16482q' file

Usando ed:

ed -s infile <<<'16224,16482p'

-ssuprime a saída de diagnóstico; os comandos reais estão em uma string here. Especificamente, 16224,16482pexecuta o pcomando (impressão) no intervalo de endereços de linha desejado.

O -n nas respostas de aceitação funciona. Aqui está outra maneira, caso você esteja inclinado.

cat $filename | sed "${linenum}p;d";

Isso faz o seguinte:

1. canalize o conteúdo de um arquivo (ou alimente o texto da maneira que desejar).
2. sed seleciona a linha especificada, imprime-a
3. d é necessário para excluir linhas, caso contrário, o sed assumirá que todas as linhas serão impressas. ou seja, sem o d, todas as linhas impressas pela linha selecionada serão impressas duas vezes, porque você tem a parte $ {clothum} p solicitando a impressão. Tenho certeza de que o -n está basicamente fazendo a mesma coisa que o d aqui.

Como estamos falando de extrair linhas de texto de um arquivo de texto, darei um caso especial em que você deseja extrair todas as linhas que correspondem a um determinado padrão.

myfile content:
=====================
line1 not needed
line2 also discarded
[Data]
first data line
second data line
=====================
sed -n '/Data/,$p' myfile

Irá imprimir a linha [Dados] e o restante. Se você quiser o texto da linha1 para o padrão, digite: sed -n '1, / Data / p' myfile. Além disso, se você conhece dois padrões (melhor ser exclusivo em seu texto), tanto a linha inicial quanto a final do intervalo podem ser especificadas com correspondências.

sed -n '/BEGIN_MARK/,/END_MARK/p' myfile