Como posso usar um arquivo em um comando e redirecionar a saída para o mesmo arquivo sem truncá-lo?

Basicamente, quero pegar como texto de entrada de um arquivo, remover uma linha desse arquivo e enviar a saída de volta para o mesmo arquivo. Algo nessa linha se isso torna mais claro.

grep -v 'seg[0-9]\{1,\}\.[0-9]\{1\}' file_name > file_name

entretanto, quando faço isso, acabo com um arquivo em branco. Alguma ideia?

Você não pode fazer isso porque o bash processa os redirecionamentos primeiro e, em seguida, executa o comando. Então, no momento em que grep olha para file_name, ele já está vazio. Você pode usar um arquivo temporário.

#!/bin/sh
tmpfile=$(mktemp)
grep -v 'seg[0-9]\{1,\}\.[0-9]\{1\}' file_name > ${tmpfile}
cat ${tmpfile} > file_name
rm -f ${tmpfile}

assim, considere usar mktemppara criar o tmpfile, mas observe que não é POSIX.

Use uma esponja para este tipo de tarefas. É parte do moreutils.

Tente este comando:

 grep -v 'seg[0-9]\{1,\}\.[0-9]\{1\}' file_name | sponge file_name

Em vez disso, use sed:

sed -i '/seg[0-9]\{1,\}\.[0-9]\{1\}/d' file_name

tente este simples

grep -v 'seg[0-9]\{1,\}\.[0-9]\{1\}' file_name | tee file_name

Seu arquivo não ficará em branco desta vez :) e sua saída também será impressa em seu terminal.

Você não pode usar o operador de redirecionamento ( >ou >>) para o mesmo arquivo, porque ele tem uma precedência mais alta e irá criar / truncar o arquivo antes mesmo de o comando ser invocado. Para evitar isso, você deve usar as ferramentas adequadas, tais como tee, sponge, sed -iou qualquer outra ferramenta que pode escrever resultados para o arquivo (por exemplo sort file -o file).

Basicamente, redirecionar a entrada para o mesmo arquivo original não faz sentido e você deve usar editores apropriados no local para isso, por exemplo, editor Ex (parte do Vim):

ex '+g/seg[0-9]\{1,\}\.[0-9]\{1\}/d' -scwq file_name

Onde:

• '+cmd'/ -c- executa qualquer comando Ex / Vim
• g/pattern/d- remove as linhas que correspondem a um padrão usando global ( help :g)
• -s- modo silencioso ( man ex)
• -c wq- executar :writee :quitcomandos

Você pode usar sedpara atingir o mesmo (como já demonstrado em outras respostas), no entanto in-place ( -i) é a extensão FreeBSD não-padrão (pode funcionar de forma diferente entre Unix / Linux) e, basicamente, é uma s tream ed itor, não um editor de arquivos . Veja: O modo Ex tem alguma utilidade prática?

Uma alternativa de linha - defina o conteúdo do arquivo como variável:

VAR=`cat file_name`; echo "$VAR"|grep -v 'seg[0-9]\{1,\}\.[0-9]\{1\}' > file_name

Uma vez que esta pergunta é o principal resultado nos motores de busca, aqui está um one-liner baseado em https://serverfault.com/a/547331 que usa um subshell em vez de sponge(que geralmente não faz parte de uma instalação vanilla como o OS X) :

echo "$(grep -v 'seg[0-9]\{1,\}\.[0-9]\{1\}' file_name)" > file_name

O caso geral é:

echo "$(cat file_name)" > file_name

Editar, a solução acima tem algumas ressalvas:

• printf '%s' <string>deve ser usado em vez de echo <string>para que os arquivos que contenham -nnão causem comportamento indesejado.
• A substituição de comandos remove novas linhas ( este é um bug / recurso de shells como o bash ), então devemos anexar um caractere pós-fixado como xà saída e removê-lo do lado de fora via expansão de parâmetro de uma variável temporária como ${v%x}.
• O uso de uma variável temporária $vpisa o valor de qualquer variável existente $vno ambiente shell atual, portanto, devemos aninhar a expressão inteira entre parênteses para preservar o valor anterior.
• Outro bug / recurso de shells como o bash é que a substituição do comando remove caracteres não imprimíveis, como nullna saída. Eu verifiquei isso chamando dd if=/dev/zero bs=1 count=1 >> file_namee visualizando em hexadecimal com cat file_name | xxd -p. Mas echo $(cat file_name) | xxd -pestá despojado. Portanto, esta resposta não deve ser usada em arquivos binários ou qualquer coisa que use caracteres não imprimíveis, como Lynch apontou .

A solução geral (albiet ligeiramente mais lento, mais memória intensiva e ainda removendo caracteres não imprimíveis) é:

(v=$(cat file_name; printf x); printf '%s' ${v%x} > file_name)

Teste em https://askubuntu.com/a/752451 :

printf "hello\nworld\n" > file_uniquely_named.txt && for ((i=0; i<1000; i++)); do (v=$(cat file_uniquely_named.txt; printf x); printf '%s' ${v%x} > file_uniquely_named.txt); done; cat file_uniquely_named.txt; rm file_uniquely_named.txt

Deve imprimir:

hello
world

Enquanto chamando cat file_uniquely_named.txt > file_uniquely_named.txto shell atual:

printf "hello\nworld\n" > file_uniquely_named.txt && for ((i=0; i<1000; i++)); do cat file_uniquely_named.txt > file_uniquely_named.txt; done; cat file_uniquely_named.txt; rm file_uniquely_named.txt

Imprime uma string vazia.

Não testei isso em arquivos grandes (provavelmente com mais de 2 ou 4 GB).

Peguei emprestada essa resposta de Hart Simha e kos .

Também existe ed(como alternativa a sed -i):

# cf. http://wiki.bash-hackers.org/howto/edit-ed
printf '%s\n' H 'g/seg[0-9]\{1,\}\.[0-9]\{1\}/d' wq |  ed -s file_name

Você pode fazer isso usando a substituição de processo .

É um pouco um hack, já que o bash abre todos os canais de forma assíncrona e temos que contornar isso usando sleepYMMV.

No seu exemplo:

grep -v 'seg[0-9]\{1,\}\.[0-9]\{1\}' file_name > >(sleep 1 && cat > file_name)

• >(sleep 1 && cat > file_name) cria um arquivo temporário que recebe a saída do grep
• sleep 1 demora por um segundo para dar tempo ao grep para analisar o arquivo de entrada
• finalmente cat > file_nameescreve a saída

Você pode usar slurp com POSIX Awk:

!/seg[0-9]\{1,\}\.[0-9]\{1\}/ {
  q = q ? q RS $0 : $0
}
END {
  print q > ARGV[1]
}

Exemplo

Isso é muito possível, você só precisa ter certeza de que, no momento de escrever a saída, está gravando em um arquivo diferente. Isso pode ser feito removendo o arquivo depois de abrir um descritor de arquivo nele, mas antes de gravá-lo:

exec 3<file ; rm file; COMMAND <&3 >file ;  exec 3>&-

Ou linha por linha, para entender melhor:

exec 3<file       # open a file descriptor reading 'file'
rm file           # remove file (but fd3 will still point to the removed file)
COMMAND <&3 >file # run command, with the removed file as input
exec 3>&-         # close the file descriptor

Ainda é uma coisa arriscada de se fazer, porque se COMMAND não funcionar corretamente, você perderá o conteúdo do arquivo. Isso pode ser atenuado restaurando o arquivo se COMMAND retornar um código de saída diferente de zero:

exec 3<file ; rm file; COMMAND <&3 >file || cat <&3 >file ; exec 3>&-

Também podemos definir uma função shell para torná-la mais fácil de usar:

# Usage: replace FILE COMMAND
replace() { exec 3<$1 ; rm $1; ${@:2} <&3 >$1 || cat <&3 >$1 ; exec 3>&- }

Exemplo:

$ echo aaa > test
$ replace test tr a b
$ cat test
bbb

Além disso, observe que isso manterá uma cópia completa do arquivo original (até que o terceiro descritor de arquivo seja fechado). Se você estiver usando Linux e o arquivo no qual está processando for muito grande para caber duas vezes no disco, você pode verificar este script que canalizará o arquivo para o comando especificado bloco a bloco enquanto desaloca o já processado blocos. Como sempre, leia os avisos na página de uso.

Tente isto

echo -e "AAA\nBBB\nCCC" > testfile

cat testfile
AAA
BBB
CCC

echo "$(grep -v 'AAA' testfile)" > testfile
cat testfile
BBB
CCC

O seguinte realizará a mesma coisa sponge, sem exigir moreutils:

    shuf --output=file --random-source=/dev/zero 

A --random-source=/dev/zeroparte funciona como um truque shufsem fazer qualquer embaralhamento, portanto, armazenará em buffer sua entrada sem alterá-la.

No entanto, é verdade que usar um arquivo temporário é melhor, por motivos de desempenho. Então, aqui está uma função que escrevi que fará isso para você de uma forma generalizada:

# Pipes a file into a command, and pipes the output of that command
# back into the same file, ensuring that the file is not truncated.
# Parameters:
#    $1: the file.
#    $2: the command. (With $3... being its arguments.)
# See https://stackoverflow.com/a/55655338/773113

function siphon
{
    local tmp=$(mktemp)
    local file="$1"
    shift
    $* < "$file" > "$tmp"
    mv "$tmp" "$file"
}

Eu costumo usar o programa tee para fazer isso:

grep -v 'seg[0-9]\{1,\}\.[0-9]\{1\}' file_name | tee file_name

Ele cria e remove um arquivo temporário sozinho.