Come posso utilizzare un file in un comando e reindirizzare l'output allo stesso file senza troncarlo?

Fondamentalmente voglio prendere come testo di input da un file, rimuovere una riga da quel file e inviare l'output allo stesso file. Qualcosa del genere se questo lo rende più chiaro.

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

tuttavia, quando lo faccio mi ritrovo con un file vuoto. qualche idea?

Non puoi farlo perché bash elabora prima i reindirizzamenti, quindi esegue il comando. Quindi quando grep guarda nome_file, è già vuoto. Tuttavia, puoi utilizzare un file temporaneo.

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

in questo modo, considera l'utilizzo mktempper creare il tmpfile ma nota che non è POSIX.

Usa una spugna per questo tipo di attività. Fa parte di moreutils.

Prova questo comando:

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

Usa sed invece:

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

prova questo semplice

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

Questa volta il file non sarà vuoto :) e anche l'output verrà stampato sul terminale.

Non è possibile utilizzare l'operatore di reindirizzamento ( >o >>) allo stesso file, perché ha una precedenza maggiore e creerà / troncerà il file prima ancora che il comando venga invocato. Per evitare questo, si dovrebbe utilizzare strumenti appropriati come tee, sponge, sed -io qualsiasi altro strumento che può scrivere i risultati al file (ad esempio sort file -o file).

Fondamentalmente reindirizzare l'input allo stesso file originale non ha senso e dovresti usare editor sul posto appropriati per questo, ad esempio editor Ex (parte di Vim):

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

dove:

• '+cmd'/ -c- esegue qualsiasi comando Ex / Vim
• g/pattern/d- rimuove le linee che corrispondono a un modello usando global ( help :g)
• -s- modalità silenziosa ( man ex)
• -c wq- eseguire :writee :quitcomandi

Puoi usare sedper ottenere lo stesso risultato (come già mostrato in altre risposte), tuttavia in-place ( -i) è un'estensione di FreeBSD non standard (può funzionare in modo diverso tra Unix / Linux) e fondamentalmente è un s tream ed itor , non un editor di file . Vedi: La modalità Ex ha qualche utilità pratica?

Un'alternativa di riga: imposta il contenuto del file come variabile:

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

Poiché questa domanda è il miglior risultato nei motori di ricerca, ecco un one-liner basato su https://serverfault.com/a/547331 che utilizza una subshell invece di sponge(che spesso non fa parte di un'installazione vanilla come OS X) :

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

Il caso generale è:

echo "$(cat file_name)" > file_name

Modifica, la soluzione sopra ha alcuni avvertimenti:

• printf '%s' <string>dovrebbe essere usato al posto di in echo <string>modo che i file contenenti -nnon causino comportamenti indesiderati.
• La sostituzione del comando elimina le nuove righe finali ( questo è un bug / caratteristica di shell come bash ) quindi dovremmo aggiungere un carattere postfisso come xl'output e rimuoverlo all'esterno tramite l' espansione dei parametri di una variabile temporanea come ${v%x}.
• L'uso di una variabile temporanea $vcalpesta il valore di qualsiasi variabile esistente $vnell'ambiente shell corrente, quindi dovremmo annidare l'intera espressione tra parentesi per preservare il valore precedente.
• Un altro bug / caratteristica di shell come bash è che la sostituzione del comando rimuove i caratteri non stampabili come nulldall'output. L'ho verificato chiamando dd if=/dev/zero bs=1 count=1 >> file_namee visualizzandolo in esadecimale con cat file_name | xxd -p. Ma echo $(cat file_name) | xxd -pè spogliato. Quindi questa risposta non dovrebbe essere utilizzata su file binari o qualsiasi cosa che utilizzi caratteri non stampabili, come ha sottolineato Lynch .

La soluzione generale (anche se leggermente più lenta, più dispendiosa in termini di memoria e ancora eliminando i caratteri non stampabili) è:

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

Prova da 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

Dovrebbe stampare:

hello
world

Mentre chiamando cat file_uniquely_named.txt > file_uniquely_named.txtnella shell corrente:

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

Stampa una stringa vuota.

Non l'ho testato su file di grandi dimensioni (probabilmente oltre 2 o 4 GB).

Ho preso in prestito questa risposta da Hart Simha e kos .

C'è anche ed(in 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

Puoi farlo usando la sostituzione del processo .

È un po 'un trucco anche se bash apre tutti i tubi in modo asincrono e dobbiamo aggirare questo sleepproblema usando così YMMV.

Nel tuo esempio:

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

• >(sleep 1 && cat > file_name) crea un file temporaneo che riceve l'output da grep
• sleep 1 ritardi di un secondo per dare a grep il tempo di analizzare il file di input
• infine cat > file_namescrive l'output

Puoi usare slurp con POSIX Awk:

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

Esempio

Questo è assolutamente possibile, devi solo assicurarti che nel momento in cui scrivi l'output, lo stai scrivendo su un file diverso. Questo può essere fatto rimuovendo il file dopo aver aperto un descrittore di file su di esso, ma prima di scriverlo:

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

Oppure riga per riga, per capirlo meglio:

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

È ancora una cosa rischiosa da fare, perché se COMMAND non funziona correttamente, perderai il contenuto del file. Ciò può essere mitigato ripristinando il file se COMMAND restituisce un codice di uscita diverso da zero:

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

Possiamo anche definire una funzione di shell per renderlo più facile da usare:

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

Esempio :

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

Inoltre, nota che questo manterrà una copia completa del file originale (fino alla chiusura del terzo descrittore di file). Se stai usando Linux e il file su cui stai elaborando è troppo grande per stare due volte sul disco, puoi controllare questo script che reindirizzerà il file al comando specificato blocco per blocco mentre annulli l'allocazione del già elaborato blocchi. Come sempre, leggi le avvertenze nella pagina di utilizzo.

Prova questo

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

cat testfile
AAA
BBB
CCC

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

Quanto segue farà la stessa cosa che spongefa, senza richiedere moreutils:

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

La --random-source=/dev/zeroparte si sforza di shuffare le sue cose senza fare alcun mescolamento, quindi bufferizzerà il tuo input senza alterarlo.

Tuttavia, è vero che l'utilizzo di un file temporaneo è il migliore, per motivi di prestazioni. Quindi, ecco una funzione che ho scritto che lo farà per te in modo generalizzato:

# 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"
}

Di solito uso il programma tee per fare questo:

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

Crea e rimuove un file temporaneo da solo.