Как я могу прочитать первые n и последние n строк из файла?

Скорее всего, вы захотите что-то вроде:

... | awk -v OFS='\n' '{a[NR]=$0} END{print a[1], a[2], a[NR-1], a[NR]}'

или если вам нужно указать число и принять во внимание проницательное замечание @Wintermute о том, что вам не нужно буферизовать весь файл, что-то вроде этого - это то, что вам действительно нужно:

... | awk -v n=2 'NR<=n{print;next} {buf[((NR-1)%n)+1]=$0}
         END{for (i=1;i<=n;i++) print buf[((NR+i-1)%n)+1]}'

Я думаю, что математика в этом правильная - надеюсь, вы поняли идею использовать вращающийся буфер, индексированный NR, модифицированный размером буфера и настроенный на использование индексов в диапазоне 1-n вместо 0-(n-1) .

Чтобы помочь с пониманием оператора модуля, используемого в индексации выше, вот пример с промежуточными операторами печати, чтобы показать логику по мере ее выполнения:

$ cat file   
1
2
3
4
5
6
7
8

.

$ cat tst.awk                
BEGIN {
    print "Populating array by index ((NR-1)%n)+1:"
}
{
    buf[((NR-1)%n)+1] = $0

    printf "NR=%d, n=%d: ((NR-1 = %d) %%n = %d) +1 = %d -> buf[%d] = %s\n",
        NR, n, NR-1, (NR-1)%n, ((NR-1)%n)+1, ((NR-1)%n)+1, buf[((NR-1)%n)+1]

}
END { 
    print "\nAccessing array by index ((NR+i-1)%n)+1:"
    for (i=1;i<=n;i++) {
        printf "NR=%d, i=%d, n=%d: (((NR+i = %d) - 1 = %d) %%n = %d) +1 = %d -> buf[%d] = %s\n",
            NR, i, n, NR+i, NR+i-1, (NR+i-1)%n, ((NR+i-1)%n)+1, ((NR+i-1)%n)+1, buf[((NR+i-1)%n)+1]
    }
}
$ 
$ awk -v n=3 -f tst.awk file
Populating array by index ((NR-1)%n)+1:
NR=1, n=3: ((NR-1 = 0) %n = 0) +1 = 1 -> buf[1] = 1
NR=2, n=3: ((NR-1 = 1) %n = 1) +1 = 2 -> buf[2] = 2
NR=3, n=3: ((NR-1 = 2) %n = 2) +1 = 3 -> buf[3] = 3
NR=4, n=3: ((NR-1 = 3) %n = 0) +1 = 1 -> buf[1] = 4
NR=5, n=3: ((NR-1 = 4) %n = 1) +1 = 2 -> buf[2] = 5
NR=6, n=3: ((NR-1 = 5) %n = 2) +1 = 3 -> buf[3] = 6
NR=7, n=3: ((NR-1 = 6) %n = 0) +1 = 1 -> buf[1] = 7
NR=8, n=3: ((NR-1 = 7) %n = 1) +1 = 2 -> buf[2] = 8

Accessing array by index ((NR+i-1)%n)+1:
NR=8, i=1, n=3: (((NR+i = 9) - 1 = 8) %n = 2) +1 = 3 -> buf[3] = 6
NR=8, i=2, n=3: (((NR+i = 10) - 1 = 9) %n = 0) +1 = 1 -> buf[1] = 7
NR=8, i=3, n=3: (((NR+i = 11) - 1 = 10) %n = 1) +1 = 2 -> buf[2] = 8

Это может сработать для вас (GNU sed):

sed -n ':a;N;s/[^\n]*/&/2;Ta;2p;$p;D' file

Это сохраняет окно из 2 (замените 2 на n) строк, а затем печатает первые 2 строки, а в конце файла печатает окно, т.е. последние 2 строки.

Вот однострочный код GNU sed, который печатает первые 10 и последние 10 строк:

gsed -ne'1,10{p;b};:a;$p;N;21,$D;ba'

Если вы хотите напечатать разделитель «--» между ними:

gsed -ne'1,9{p;b};10{x;s/$/--/;x;G;p;b};:a;$p;N;21,$D;ba'

Если вы работаете на Mac и у вас нет GNU sed, вы не сможете сжать так много:

sed -ne'1,9{' -e'p;b' -e'}' -e'10{' -e'x;s/$/--/;x;G;p;b' -e'}' -e':a' -e'$p;N;21,$D;ba'

Объяснение

gsed -ne' вызвать sed без автоматической печати шаблона пространства

-e'1,9{p;b}' напечатать первые 9 строк

-e'10{x;s/$/--/;x;G;p;b}' вывести строку 10 с добавленным разделителем '--'

-e':a;$p;N;21,$D;ba' напечатать последние 10 строк

awk -v n=4 'NR<=n; {b = b "\n" $0} NR>=n {sub(/[^\n]*\n/,"",b)} END {print b}'

Первые n строк покрыты NR<=n;. Для последних n строк мы просто отслеживаем буфер, содержащий последние n строк, постоянно добавляя одну в конец и удаляя одну впереди (после первых n).

Можно сделать это более эффективно, используя массив строк вместо одного буфера, но даже с гигабайтами ввода вы, вероятно, потратите больше мозгового времени на его запись, чем сэкономите компьютерного времени, выполняя его.

ETA: Поскольку приведенная выше оценка времени вызвала некоторое обсуждение в (теперь удаленных) комментариях, я добавлю анекдоты, опробованные на практике.

С огромным файлом (100 миллионов строк, 3,9 ГиБ, n = 5) это заняло 454 секунды, по сравнению с решением @EdMorton с линейным буфером, которое выполнялось всего за 30 секунд. С более скромными входными данными (просто миллионы строк) соотношение аналогичное: 4,7 секунды против 0,53 секунды.

Почти все это дополнительное время в этом решении, по-видимому, потрачено на функцию sub(); крошечная часть также происходит из-за того, что конкатенация строк выполняется медленнее, чем просто замена члена массива.

Если вы используете оболочку, которая поддерживает подстановку процессов, еще один способ добиться этого — записать в несколько процессов, один для head, а другой для tail. Предположим для этого примера, что ваш ввод поступает из канала, который подает вам контент неизвестной длины. Вы хотите использовать только первые 5 строк и последние 10 строк и передать их другому каналу:

cat | { tee >(head -5) >(tail -10) 1>/dev/null} | cat

Использование {} собирает выходные данные внутри группы (будут две разные программы, записывающие в stdout внутри оболочек процессов). 1>/dev/null состоит в том, чтобы избавиться от дополнительной копии, которую tee попытается записать в собственный стандартный вывод.

Это демонстрирует концепцию и все движущиеся части, но на практике ее можно немного упростить, используя поток STDOUT tee вместо его отбрасывания. Обратите внимание, что здесь по-прежнему необходима группировка команд для передачи вывода через следующий канал!

cat | { tee >(head -5) | tail -15 } | cat

Очевидно, замените cat в конвейере тем, что вы на самом деле делаете. Если ваш ввод может обрабатывать один и тот же контент для записи в несколько файлов, вы можете полностью отказаться от использования tee, а также от использования STDOUT. Допустим, у вас есть команда, которая принимает несколько флагов имени выходного файла -o:

{ mycommand -o >(head -5) -o >(tail -10)} | cat

Используйте параллель GNU. Чтобы напечатать первые три строки и последние три строки:

parallel {} -n 3 file ::: head tail

На основе dcaswell, следующий скрипт sed печатает первую и последнюю 10 строк файла:

# Make a test file first
testit=$(mktemp -u)
seq 1 100 > $testit
# This sed script:
sed -n ':a;1,10h;N;${x;p;i\
-----
;x;p};11,$D;ba' $testit
rm $testit

Выдает это:

1
2
3
4
5
6
7
8
9
10
-----
90
91
92
93
94
95
96
97
98
99
100

Вот еще один скрипт AWK. Предполагая, что может быть перекрытие головы и хвоста.

Файл script.awk

BEGIN {range = 3} # Define the head and tail range
NR <= range {print} # Output the head; for the first lines in range
{ arr[NR % range] = $0} # Store the current line in a rotating array
END { # Last line reached
    for (row = NR - range + 1; row <= NR; row++) { # Reread the last range lines from array
        print arr[row % range];
    }
}

Запуск скрипта

seq 1 7 | awk -f script.awk

Выход

1
2
3
5
6
7

Для перекрытия головы и хвоста:

seq 1 5 |awk -f script.awk


1
2
3
3
4
5