Esiste un comando Unix per anteporre alcuni dati di stringa a un file di testo?

Qualcosa di simile a:

prepend "to be prepended" text.txt

sed -i.old '1s;^;to be prepended;' inFile

• -iscrive la modifica in posizione ed esegue un backup se viene fornita un'estensione. (In questo caso, .old)
• 1s;^;to be prepended;sostituisce l'inizio della prima riga con la stringa di sostituzione data, utilizzando ;come delimitatore di comando.

printf '%s\n%s\n' "to be prepended" "$(cat text.txt)" >text.txt

Sostituzione del processo

Sono sorpreso che nessuno ne abbia parlato.

cat <(echo "before") text.txt > newfile.txt

che è probabilmente più naturale della risposta accettata (stampare qualcosa e collegarlo a un comando di sostituzione è lessicograficamente controintuitivo).

... e dirottando ciò che ha detto ryan sopra, con spongenon hai bisogno di un file temporaneo:

sudo apt-get install moreutils
<<(echo "to be prepended") < text.txt | sponge text.txt

EDIT: Sembra che questo non funzioni in Bourne Shell /bin/sh

Here String (solo zsh)

Usando una stringa qui - <<<, puoi fare:

<<< "to be prepended" < text.txt | sponge text.txt

Questa è una possibilità:

(echo "to be prepended"; cat text.txt) > newfile.txt

probabilmente non potrai aggirare facilmente un file intermedio.

Alternative (può essere complicato con la fuga dalla shell):

sed -i '0,/^/s//to be prepended/' text.txt

Questo funzionerà per formare l'output. - indica lo standard input, che viene fornito tramite la pipe da echo.

echo -e "to be prepended \n another line" | cat - text.txt

Per riscrivere il file è necessario un file temporaneo in quanto non può essere reindirizzato nel file di input.

echo "to be prepended" | cat - text.txt > text.txt.tmp
mv text.txt.tmp text.txt

Preferisco la risposta di Adam

Possiamo rendere più facile l'uso della spugna . Ora non è necessario creare un file temporaneo e rinominarlo con

echo -e "to be prepended \n another line" | cat - text.txt | sponge text.txt

Se è accettabile sostituire il file di input:

Nota:

• Ciò potrebbe avere effetti collaterali inaspettati, in particolare la potenziale sostituzione di un collegamento simbolico con un file normale, la conclusione con autorizzazioni diverse sul file e la modifica della data di creazione (nascita) del file.

• sed -i, come nella risposta del principe John Wesley , cerca di ripristinare almeno i permessi originali, ma si applicano anche le altre limitazioni.

Ecco una semplice alternativa che utilizza un file temporaneo (evita di leggere l'intero file di input in memoria come fa la soluzione di shime ):

{ printf 'to be prepended'; cat text.txt; } > tmp.txt && mv tmp.txt text.txt

^{L'utilizzo di un comando group ( { ...; ...; }) è leggermente più efficiente rispetto all'utilizzo di una subshell ( (...; ...)), come nella soluzione di 0xC0000022L .}

I vantaggi sono:

• E 'facile da controllare se il nuovo testo dovrebbe essere direttamente preposta alla prima linea o se debba essere inserito come nuova linea (s) (semplicemente accodamento \nal printfargomento).

• A differenza della sedsoluzione, funziona se il file di input è vuoto ( 0byte).

La sedsoluzione può essere semplificata se l'intento è di anteporre una o più righe intere al contenuto esistente (supponendo che il file di input non sia vuoto):

sedLa ifunzione di inserisce intere righe:

Con GNU sed :

# Prepends 'to be prepended' *followed by a newline*, i.e. inserts a new line.
# To prepend multiple lines, use '\n' as part of the text.
# -i.old creates a backup of the input file with extension '.old'
sed -i.old '1 i\to be prepended' inFile

Una variante portatile che funziona anche con macOS / BSD sed:

# Prepends 'to be prepended' *followed by a newline*
# To prepend multiple lines, escape the ends of intermediate
# lines with '\'
sed -i.old -e '1 i\
to be prepended' inFile

Nota che la nuova riga letterale dopo \è obbligatoria.

Se il file di input deve essere modificato in posizione (preservando il suo inode con tutti i suoi attributi):

Utilizzando la venerabile edutility POSIX :

Nota:

• edlegge invariabilmente prima il file di input nel suo complesso in memoria.

Per anteporre direttamente alla prima riga (come con sed, questo non funzionerà se il file di input è completamente vuoto ( 0byte)):

ed -s text.txt <<EOF
1 s/^/to be prepended/
w
EOF

• -sedmessaggi di stato soppressi .
• Nota come i comandi vengono forniti edcome here-document ( <<EOF\n...\nEOF) su più righe , cioè tramite stdin ; per impostazione predefinita, l'espansione delle stringhe viene eseguita in tali documenti (le variabili di shell sono interpolate); cita il delimitatore di apertura per sopprimerlo (ad esempio <<'EOF').
• 1 rende la prima riga la riga corrente
• la funzione sesegue una sostituzione di stringa basata su espressioni regolari sulla riga corrente, come in sed; puoi includere caratteri di ritorno a capo letterali nel testo sostitutivo, ma devono essere \preceduti da caratteri di escape.
• wriscrive il risultato nel file di input (per il test, sostituire wcon ,pper stampare solo il risultato, senza modificare il file di input).

Per anteporre una o più righe intere :

Come con sed, la ifunzione aggiunge invariabilmente una nuova riga finale al testo da inserire.

ed -s text.txt <<EOF
0 i
line 1
line 2
.
w
EOF

• 0 irende 0(l'inizio del file) la riga corrente e avvia la modalità di inserimento ( i); notare che i numeri di riga sono altrimenti 1basati su.
• Le righe seguenti sono il testo da inserire prima della riga corrente, terminata con .su una riga separata.

Probabilmente nulla di integrato, ma potresti scrivere il tuo abbastanza facilmente, in questo modo:

#!/bin/bash
echo -n "$1" > /tmp/tmpfile.$$
cat "$2" >> /tmp/tmpfile.$$
mv /tmp/tmpfile.$$ "$2"

Almeno qualcosa del genere ...

In alcune circostanze il testo anteposto può essere disponibile solo da stdin. Allora questa combinazione funzionerà.

echo "to be prepended" | cat - text.txt | tee text.txt

Se vuoi omettere l' teeoutput, aggiungi > /dev/null.

Soluzione:

printf '%s\n%s' 'text to prepend' "$(cat file.txt)" > file.txt

Nota che questo è sicuro su tutti i tipi di input, perché non ci sono espansioni. Ad esempio, se vuoi anteporre !@#$%^&*()ugly text\n\t\n, funzionerà semplicemente:

printf '%s\n%s' '!@#$%^&*()ugly text\n\t\n' "$(cat file.txt)" > file.txt

L'ultima parte da considerare è la rimozione degli spazi bianchi alla fine del file durante la sostituzione del comando "$(cat file.txt)". Tutte le soluzioni per questo sono relativamente complesse. Se desideri conservare le nuove righe alla fine di file.txt, consulta questo: https://stackoverflow.com/a/22607352/1091436

Un altro modo di utilizzare sed:

sed -i.old '1 {i to be prepended
}' inFile

Se la riga da anteporre è multilinea:

sed -i.old '1 {i\ 
to be prepended\
multiline
}' inFile

Come testato in Bash (in Ubuntu), se si inizia con un file di prova tramite;

echo "Original Line" > test_file.txt

puoi eseguire;

echo "$(echo "New Line"; cat test_file.txt)" > test_file.txt

oppure, se la versione di bash è troppo vecchia per $ (), puoi usare i backtick;

echo "`echo "New Line"; cat test_file.txt`" > test_file.txt

e ricevere il seguente contenuto di "test_file.txt";

New Line
Original Line

Nessun file intermedio, solo bash / echo.

Un'altra soluzione abbastanza semplice è:

    $ echo -e "string\n" $(cat file)

Se ti piace vi / vim, questo potrebbe essere più il tuo stile.

printf '0i\n%s\n.\nwq\n' prepend-text | ed file

# create a file with content..
echo foo > /tmp/foo
# prepend a line containing "jim" to the file
sed -i "1s/^/jim\n/" /tmp/foo
# verify the content of the file has the new line prepened to it
cat /tmp/foo

Consiglierei di definire una funzione e quindi di importarla e utilizzarla dove necessario.

prepend_to_file() { 
    file=$1
    text=$2

    if ! [[ -f $file ]] then
        touch $file
    fi

    echo "$text" | cat - $file > $file.new

    mv -f $file.new $file
}

Quindi usalo in questo modo:

prepend_to_file test.txt "This is first"
prepend_to_file test.txt "This is second"

Il contenuto del file sarà quindi:

This is second
This is first

Sto per utilizzare questo approccio per implementare un programma di aggiornamento del registro delle modifiche.