Существует ли способ изменить оперативный файл?

Можно использовать sed для редактирования файлов на месте (но это действительно создает промежуточный временный файл):

Удалить все строки, содержащие foo:

sed -i '/foo/d' myfile

Сохранять все строки, содержащие foo:

sed -i '/foo/!d' myfile

Я предположу, что Ваша команда фильтрации - то, что я назову фильтром уменьшения префикса, который имеет свойство, что байт N в выводе никогда не пишется прежде считал, по крайней мере, N байты входа. grep имеет это свойство (как долго, поскольку оно только фильтрует и не делает другие вещи как добавление номеров строки для соответствий). С таким фильтром можно перезаписать вход, как Вы продвигаетесь. Конечно, необходимо быть уверены в не делании любой ошибки, так как перезаписанная часть в начале файла будет потеряна навсегда.

Большинство инструментов Unix только дает выбор добавления в файл или усечения его без возможности перезаписи его. Одно исключение на стандартной панели инструментов dd, которому можно сказать не усечь его выходной файл. Таким образом, план состоит в том, чтобы проникнуть команду в dd conv=notrunc. Это не изменяет размер файла, таким образом, мы также захватываем длину нового содержания и усекаем файл к той длине (снова с dd). Обратите внимание, что эта задача по сути неустойчива — если ошибка происходит, Вы самостоятельно.

export LC_ALL=C
n=$({ grep -v foo <big_file |
      tee /dev/fd/3 |
      dd of=big_file conv=notrunc; } 3>&1 | wc -c)
dd if=/dev/null of=big_file bs=1 seek=$n

Можно записать примерно эквивалентный Perl. Вот быстрая реализация, которая не пытается быть эффективной. Конечно, можно хотеть сделать начальную букву, фильтрующую непосредственно на том языке также.

grep -v foo <big_file | perl -e '
  close STDOUT;
  open STDOUT, "+<", $ARGV[0] or die;
  while (<STDIN>) {print}
  truncate STDOUT, tell STDOUT or die
' big_file

С любой оболочкой типа Борна:

{
  cat < bigfile | grep -v to-exclude
  perl -e 'truncate STDOUT, tell STDOUT'
} 1<> bigfile

По какой-то причине кажется, что люди склонны забывать об этом 40-летнем¹ и стандартном операторе перенаправления чтения+записи.

Мы открываем bigfile в режиме чтение+запись и (что здесь наиболее важно) без усечения на stdout, в то время как bigfile открывается (отдельно) на cat stdin. После того, как grep закончился, и если он удалил несколько линий, stdout теперь указывает где-то в пределах bigfile, нам нужно избавиться от того, что находится за этой точкой. Поэтому команда perl, которая усекает файл (усекает STDOUT) в текущей позиции (как возвращается командой tell STDOUT).

(параметр cat предназначен для GNU grep, который в противном случае будет жаловаться, если stdin и stdout указывают на один и тот же файл).

^{¹ Ну, хотя <> находилась в оболочке Борна с самого начала в конце семидесятых годов, первоначально она была недокументирована и не была реализована должным образом . Он не был в первоначальной реализации ash с 1989 года и, хотя это POSIX sh оператор перенаправления (с начала 90-х годов, так как POSIX sh основан на ksh88, который всегда им обладал), например, она не добавлялась во FreeBSD sh до 2000 года, так что портативно 15-летняя , вероятно, более точна. Также обратите внимание, что дескриптор файла по умолчанию, когда он не указан, это <> во всех оболочках, за исключением того, что в ksh93 в 2010 году он изменился с 0 до 1 в ksh93t+ (нарушение обратной совместимости и соответствия POSIX)}

Хотя это старый вопрос, мне кажется, что это вечный вопрос, и доступно более общее и более четкое решение, чем предлагалось до сих пор . Кредит, если необходимо: я не уверен, что придумал бы его, не учитывая упоминание Стефана Шазеласа об операторе обновления <> .

Открытие файла для обновления в оболочке Bourne имеет ограниченную полезность. Оболочка не дает вам возможности искать в файле и устанавливать его новую длину (если она короче старой). Но это легко исправить, поэтому я удивлен, что ее нет среди стандартных утилит в / usr / bin .

Это работает:

$ grep -n foo T
8:foo
$ (exec 4<>T; grep foo T >&4 && ftruncate 4) && nl T; 
     1  foo

Как и это (подсказка Стефану):

$ { grep foo T && ftruncate; } 1<>T  && nl T; 
     1  foo

(Я использую GNU grep. Возможно, что-то изменилось с тех пор, как он написал свой ответ.)

За исключением того, что у вас нет ] / usr / bin / ftruncate . Пару десятков строк на C вы можете увидеть ниже. Эта утилита ftruncate усекает произвольный дескриптор файла до произвольной длины, по умолчанию используется стандартный вывод и текущая позиция.

Приведенная выше команда (1-й пример)

• открывает файловый дескриптор 4 на T для обновления. Как и в случае с open (2), при открытии файла текущее смещение устанавливается на 0.
• grep затем нормально обрабатывает T , а оболочка перенаправляет свой вывод на T через дескриптор 4.
• ftruncate вызывает ftruncate (2) на дескрипторе 4, устанавливая длину равной текущему смещению (именно там, где grep оставил его).

Подоболочка завершается, закрывая дескриптор 4. Вот ftruncate :

#include <err.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int
main( int argc, char *argv[] ) {
  off_t i, fd=1, len=0;
  off_t *addrs[2] = { &fd, &len };

  for( i=0; i < argc-1; i++ ) {
    if( sscanf(argv[i+1], "%lu", addrs[i]) < 1 ) {
      err(EXIT_FAILURE, "could not parse %s as number", argv[i+1]);
    }
  }

  if( argc < 3 && (len = lseek(fd, 0, SEEK_CUR)) == -1 ) {
    err(EXIT_FAILURE, "could not ftell fd %d as number", (int)fd);
  }


  if( 0 != ftruncate((int)fd, len) ) {
    err(EXIT_FAILURE, argc > 1? argv[1] : "stdout");
  }

  return EXIT_SUCCESS;
}

Обратите внимание, ftruncate (2) непереносится при таком использовании. Для абсолютной общности прочтите последний записанный байт, повторно откройте файл O_WRONLY, выполните поиск, запишите байт и закройте.

Учитывая, что этому вопросу 5 лет, я скажу, что это решение неочевидно.Он использует преимущества exec для открытия нового дескриптора и оператора <> , оба из которых являются загадочными. Я не могу придумать стандартную утилиту, которая манипулирует индексом дескриптора файла. (Синтаксис может быть ftruncate> & 4 , но я не уверен, что это улучшение.) Это значительно короче, чем компетентный исследовательский ответ camh. Это просто немного яснее, чем у Стефана, ИМО, если только вам не нравится Perl больше, чем мне. Надеюсь, кому-то это пригодится.

Другой способ сделать то же самое - исполняемая версия lseek (2), которая сообщает текущее смещение; вывод может быть использован для / usr / bin / truncate , который предоставляют некоторые Linuxi.

ed вероятно, правильный выбор отредактировать оперативный файл:

ed my_big_file << END_OF_ED_COMMANDS
g/foo:/d
w
q 
END_OF_ED_COMMANDS

Можно использовать дескриптор файла чтения-записи удара для открытия файла (для перезаписи его на месте), затем sed и truncate ... но конечно, никогда не позволяйте Вашим изменениям быть больше, чем чтение объема данных до сих пор.

Вот сценарий (использование: колотите переменный $BASHPID),

# Create a test file
  echo "going abc"  >junk
  echo "going def" >>junk
  echo "# ORIGINAL file";cat junk |tee >( wc=($(wc)); echo "# ${wc[0]} lines, ${wc[2]} bytes" ;echo )
#
# Assign file to fd 3, and open it r/w
  exec 3<> junk  
#
# Choose a unique filename to hold the new file size  and the pid 
# of the semi-asynchrounous process to which 'tee' streams the new file..  
  [[ ! -d "/tmp/$USER" ]] && mkdir "/tmp/$USER" 
  f_pid_size="/tmp/$USER/pid_size.$(date '+%N')" # %N is a GNU extension: nanoseconds
  [[ -f "$f_pid_size" ]] && { echo "ERROR: Work file already exists: '$f_pid_size'" ;exit 1 ; }
#
# run 'sed' output to 'tee' ... 
#  to modify the file in-situ, and to count the bytes  
  <junk sed -e "s/going //" |tee >(echo -n "$BASHPID " >"$f_pid_size" ;wc -c >>"$f_pid_size") >&3
#
#@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
# The byte-counting process is not a child-process, 
# so 'wait' doesn't work... but wait we must...  
  pid_size=($(cat "$f_pid_size")) ;pid=${pid_size[0]}  
  # $f_pid_size may initially contain only the pid... 
  # get the size when pid termination is assured
  while [[ "$pid" != "" ]] ; do
    if ! kill -0 "$pid" 2>/dev/null; then
       pid=""  # pid has terminated. get the byte count
       pid_size=($(cat "$f_pid_size")) ;size=${pid_size[1]}
    fi
  done
  rm "$f_pid_size"
#@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
#
  exec 3>&- # close fd 3.
  newsize=$(cat newsize)
  echo "# MODIFIED file (before truncating)";cat junk |tee >( wc=($(wc)); echo "# ${wc[0]} lines, ${wc[2]} bytes" ;echo )  cat junk
#
 truncate -s $newsize junk
 echo "# NEW (truncated) file";cat junk |tee >( wc=($(wc)); echo "# ${wc[0]} lines, ${wc[2]} bytes" ;echo )  cat junk
#
exit

Вот тестовый вывод

# ORIGINAL file
going abc
going def
# 2 lines, 20 bytes

# MODIFIED file (before truncating)
abc
def
c
going def
# 4 lines, 20 bytes

# NEW (truncated) file
abc
def
# 2 lines, 8 bytes

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

echo -e "$(grep pattern bigfile)" >bigfile