В этом ответе ( Как я могу удалить первую строку файла с помощью sed? ) Есть два способа удалить первую запись в файле:

sed '1d' $file >> headerless.txt

** ---------------- ИЛИ ----------------**

tail -n +2 $file >> headerless.txt

Лично я думаю, что этот tailвариант косметически более приятен и более читабелен, но, вероятно, потому, что мне бросают вызов.

Какой метод самый быстрый?

Производительность sedvs. tailубрать первую строку файла

TL; DR

• sed очень мощный и универсальный, но именно это делает его медленным, особенно для больших файлов с большим количеством строк.

• tail делает только одну простую вещь, но она делает это хорошо и быстро, даже для больших файлов с множеством строк.

Для файлов малого и среднего размера sedи tailвыполняются одинаково быстро (или медленно, в зависимости от ваших ожиданий). Однако для больших входных файлов (несколько МБ) разница в производительности значительно возрастает (на порядок для файлов в диапазоне сотен МБ) с tailявно более высокими показателями sed.

эксперимент

Общие препараты:

Наши команды для анализа:

sed '1d' testfile > /dev/null
tail -n +2 testfile > /dev/null

Обратите внимание, что /dev/nullкаждый раз я отправляю выходные данные, чтобы устранить вывод терминала или запись в файл как узкое место в производительности.

Давайте настроим RAM-диск для устранения дискового ввода-вывода как потенциального узкого места. Лично у меня есть tmpfsнавесное устройство, /tmpпоэтому я просто разместил свой testfileтам для этого эксперимента.

Затем я однажды создаю случайный тестовый файл, содержащий определенное количество строк $numoflinesсо случайной длиной строки и случайными данными, используя эту команду (обратите внимание, что она определенно не оптимальна, она становится действительно медленной примерно для> 2 миллионов строк, но кого это волнует, это не что мы анализируем)

cat /dev/urandom | base64 -w0 | tr 'n' '\n'| head -n "$numoflines" > testfile

О, кстати. мой тестовый ноутбук работает под управлением Ubuntu 16.04, 64-разрядная версия на процессоре Intel i5-6200U. Просто для сравнения.

Сроки больших файлов:

Настройка огромная testfile:

Выполнение вышеуказанной команды с numoflines=10000000получением случайного файла, содержащего 10M строк, занимающих чуть более 600 МБ - это довольно много, но давайте начнем с этого, потому что мы можем:

$ wc -l testfile 
10000000 testfile

$ du -h testfile 
611M    testfile

$ head -n 3 testfile 
qOWrzWppWJxx0e59o2uuvkrfjQbzos8Z0RWcCQPMGFPueRKqoy1mpgjHcSgtsRXLrZ8S4CU8w6O6pxkKa3JbJD7QNyiHb4o95TSKkdTBYs8uUOCRKPu6BbvG
NklpTCRzUgZK
O/lcQwmJXl1CGr5vQAbpM7TRNkx6XusYrO

Выполните запуски по времени с нашим огромным testfile:

Теперь давайте сначала выполним однократный запуск обеих команд, чтобы оценить, с какими величинами мы работаем.

$ time sed '1d' testfile > /dev/null
real    0m2.104s
user    0m1.944s
sys     0m0.156s

$ time tail -n +2 testfile > /dev/null
real    0m0.181s
user    0m0.044s
sys     0m0.132s

Мы уже видим действительно четкий результат для больших файлов, tailэто на порядок быстрее, чем sed. Но просто для удовольствия и чтобы убедиться, что нет никаких случайных побочных эффектов, имеющих большое значение, давайте сделаем это 100 раз:

$ time for i in {1..100}; do sed '1d' testfile > /dev/null; done
real    3m36.756s
user    3m19.756s
sys     0m15.792s

$ time for i in {1..100}; do tail -n +2 testfile > /dev/null; done
real    0m14.573s
user    0m1.876s
sys     0m12.420s

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

И да, я знаю, что циклические конструкции Bash медленны, но мы делаем здесь лишь относительно немного итераций, и время, которое занимает простой цикл, не так существенно по сравнению с sed/ tailruntime.

Сроки небольших файлов:

Настройка небольшая testfile:

Теперь для полноты давайте рассмотрим более распространенный случай, когда у вас есть небольшой входной файл в диапазоне кБ. Давайте создадим случайный входной файл numoflines=100, который выглядит следующим образом:

$ wc -l testfile 
100 testfile

$ du -h testfile 
8,0K    testfile

$ head -n 3 testfile 
tYMWxhi7GqV0DjWd
pemd0y3NgfBK4G4ho/
aItY/8crld2tZvsU5ly

Выполните запуск по времени с нашим маленьким testfile:

Исходя из опыта, мы можем ожидать, что время для таких маленьких файлов будет в пределах нескольких миллисекунд, давайте сразу сделаем 1000 итераций:

$ time for i in {1..1000}; do sed '1d' testfile > /dev/null; done
real    0m7.811s
user    0m0.412s
sys     0m7.020s

$ time for i in {1..1000}; do tail -n +2 testfile > /dev/null; done
real    0m7.485s
user    0m0.292s
sys     0m6.020s

Как видите, сроки очень похожи, толковать или удивляться особо нечему. Для небольших файлов оба инструмента одинаково хорошо подходят.

Вот еще один вариант, использующий только встроенные команды bash и cat:

{ read ; cat > headerless.txt; } < $file

$fileперенаправляется в { }группировку команд. readПросто читает и сбрасывает первую строку. Затем остальная часть потока передается по каналу, в catкоторый записывается в файл назначения.

На моем Ubuntu 16.04 производительность этого и tailрешения очень похожи. Я создал большой тестовый файл с seq:

$ seq 100000000 > 100M.txt
$ ls -l 100M.txt 
-rw-rw-r-- 1 ubuntu ubuntu 888888898 Dec 20 17:04 100M.txt
$

tail решение:

$ time tail -n +2 100M.txt > headerless.txt

real    0m1.469s
user    0m0.052s
sys 0m0.784s
$ 

cat/ скобное решение:

$ time { read ; cat > headerless.txt; } < 100M.txt 

real    0m1.877s
user    0m0.000s
sys 0m0.736s
$ 

Хотя сейчас у меня есть только Ubuntu VM, и я видел значительные различия во времени обоих, хотя они все находятся на одной площадке.

Попробовав в своей системе и добавив к каждой команде префикс, timeя получил следующие результаты:

СЭД:

real    0m0.129s
user    0m0.012s
sys     0m0.000s

и хвост:

real    0m0.003s
user    0m0.000s
sys     0m0.000s

что говорит о том, что на моей системе хотя бы AMD FX 8250 с Ubuntu 16.04 хвост значительно быстрее. Тестовый файл имел 10 000 строк размером 540 КБ. Файл был прочитан с жесткого диска.

Нет объективного способа сказать, что лучше, потому что sedи tailэто не единственные вещи, которые запускаются в системе во время выполнения программы. Множество факторов, таких как дисковый ввод-вывод, сетевой ввод-вывод, прерывания процессора для процессов с более высоким приоритетом, влияют на скорость выполнения вашей программы.

Они оба написаны на C, так что это не языковая проблема, а скорее экологическая. Например, у меня есть SSD, и в моей системе это займет время в микросекундах, но для того же файла на жестком диске это займет больше времени, потому что жесткие диски значительно медленнее. Таким образом, аппаратная часть играет роль в этом тоже.

Есть несколько вещей, которые вы можете иметь в виду при выборе команды:

• Какова ваша цель? sedпотоковый редактор для преобразования текста. tailдля вывода определенных строк текста. Если вы хотите разобраться со строками и только распечатать их, используйте tail. Если вы хотите редактировать текст, используйте sed.
• tailимеет гораздо более простой синтаксис, чем sed, поэтому используйте то, что вы можете прочитать сами, а что могут читать другие.

Другим важным фактором является объем данных, которые вы обрабатываете. Маленькие файлы не дадут вам никакой разницы в производительности. Картина становится интересной, когда вы имеете дело с большими файлами. С помощью файла BIGFILE.txt размером 2 ГБ мы видим, что в sedнем гораздо больше системных вызовов, чем он tail, и он работает значительно медленнее.

bash-4.3$ du -sh BIGFILE.txt 
2.0G    BIGFILE.txt
bash-4.3$ strace -c  sed '1d' ./BIGFILE.txt  > /dev/null
% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
 59.38    0.079781           0    517051           read
 40.62    0.054570           0    517042           write
  0.00    0.000000           0        10         1 open
  0.00    0.000000           0        11           close
  0.00    0.000000           0        10           fstat
  0.00    0.000000           0        19           mmap
  0.00    0.000000           0        12           mprotect
  0.00    0.000000           0         1           munmap
  0.00    0.000000           0         3           brk
  0.00    0.000000           0         2           rt_sigaction
  0.00    0.000000           0         1           rt_sigprocmask
  0.00    0.000000           0         1         1 ioctl
  0.00    0.000000           0         7         7 access
  0.00    0.000000           0         1           execve
  0.00    0.000000           0         1           getrlimit
  0.00    0.000000           0         2         2 statfs
  0.00    0.000000           0         1           arch_prctl
  0.00    0.000000           0         1           set_tid_address
  0.00    0.000000           0         1           set_robust_list
------ ----------- ----------- --------- --------- ----------------
100.00    0.134351               1034177        11 total
bash-4.3$ strace -c  tail  -n +2 ./BIGFILE.txt  > /dev/null
% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
 62.30    0.148821           0    517042           write
 37.70    0.090044           0    258525           read
  0.00    0.000000           0         9         3 open
  0.00    0.000000           0         8           close
  0.00    0.000000           0         7           fstat
  0.00    0.000000           0        10           mmap
  0.00    0.000000           0         4           mprotect
  0.00    0.000000           0         1           munmap
  0.00    0.000000           0         3           brk
  0.00    0.000000           0         1         1 ioctl
  0.00    0.000000           0         3         3 access
  0.00    0.000000           0         1           execve
  0.00    0.000000           0         1           arch_prctl
------ ----------- ----------- --------- --------- ----------------
100.00    0.238865                775615         7 total

Топ ответ не принимал во внимание диск > /dev/null

если у вас большой файл и вы не хотите создавать временную копию на вашем диске, попробуйте vim -c

$ cat /dev/urandom | base64 -w0 | tr 'n' '\n'| head -n 10000000 > testfile
$ time sed -i '1d' testfile

real    0m59.053s
user    0m9.625s
sys     0m48.952s

$ cat /dev/urandom | base64 -w0 | tr 'n' '\n'| head -n 10000000 > testfile
$ time vim -e -s testfile -c ':1d' -c ':wq'

real    0m8.259s
user    0m3.640s
sys     0m3.093s

Изменить: если файл больше, чем доступная память vim -cне работает, похоже, что он не достаточно умен, чтобы сделать дополнительную загрузку файла

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