¿Hay un comando Unix para anteponer algunos datos de cadena a un archivo de texto?

Algo como:

prepend "to be prepended" text.txt

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

• -iescribe el cambio en su lugar y realiza una copia de seguridad si se proporciona alguna extensión. (En este caso .old)
• 1s;^;to be prepended;sustituye el comienzo de la primera línea por la cadena de reemplazo dada, utilizando ;como delimitador de comando.

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

Proceso de sustitución

Me sorprende que nadie haya mencionado esto.

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

lo cual es posiblemente más natural que la respuesta aceptada (imprimir algo y colocarlo en un comando de sustitución es lexicográficamente contra-intuitivo).

... y secuestrando lo que Ryan dijo anteriormente, con spongeusted no necesita un archivo temporal:

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

EDITAR: Parece que esto no funciona en Bourne Shell /bin/sh

Here String (solo zsh)

Usando una cadena aquí <<<, puede hacer:

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

Esta es una posibilidad:

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

Probablemente no pueda moverse fácilmente por un archivo intermedio.

Alternativas (pueden ser engorrosas con el escape de la carcasa):

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

Esto funcionará para formar la salida. El - significa entrada estándar, que se proporciona a través de la tubería desde el eco.

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

Para reescribir el archivo, se requiere un archivo temporal ya que no se puede volver a conectar al archivo de entrada.

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

Prefiero la respuesta de Adam

Podemos hacer que sea más fácil usar esponja . Ahora no necesitamos crear un archivo temporal y renombrarlo por

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

Si es aceptable reemplazar el archivo de entrada:

Nota:

• Hacerlo puede tener efectos secundarios inesperados, que pueden reemplazar un enlace simbólico con un archivo normal, terminar con diferentes permisos en el archivo y cambiar la fecha de creación (nacimiento) del archivo.

• sed -i, como en la respuesta del príncipe John Wesley , intenta al menos restaurar los permisos originales, pero también se aplican las otras limitaciones.

Aquí hay una alternativa simple que usa un archivo temporal (evita leer todo el archivo de entrada en la memoria como lo hace la solución de shime ):

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

^{Usar un comando de grupo ( { ...; ...; }) es un poco más eficiente que usar un subshell ( (...; ...)), como en la solución de 0xC0000022L .}

Las ventajas son:

• Es fácil controlar si el nuevo texto debe anteponerse directamente a la primera línea o si debe insertarse como nueva (s) línea (s) (simplemente agregue \nel printfargumento).

• A diferencia de la sedsolución, funciona si el archivo de entrada está vacío ( 0bytes).

La sedsolución se puede simplificar si la intención es anteponer una o más líneas enteras al contenido existente (suponiendo que el archivo de entrada no esté vacío):

sedLa ifunción de inserta líneas enteras:

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 portátil que también funciona 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

Tenga en cuenta que la nueva línea literal después de la \es obligatoria.

Si el archivo de entrada debe editarse en su lugar (conservando su inodo con todos sus atributos):

Usando la venerable edutilidad POSIX :

Nota:

• edinvariablemente lee el archivo de entrada como un todo en la memoria primero.

Para anteponer directamente a la primera línea (como con sed, esto no funcionará si el archivo de entrada está completamente vacío ( 0bytes)):

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

• -sedmensajes de estado suprimidos .
• Observe cómo se proporcionan los comandos edcomo un documento de varias líneas aquí ( <<EOF\n...\nEOF), es decir, a través de stdin ; de manera predeterminada, la expansión de cadenas se realiza en dichos documentos (las variables de shell se interpolan); cita el delimitador de apertura para suprimir eso (por ejemplo, <<'EOF').
• 1 convierte la primera línea en la línea actual
• La función srealiza una sustitución de cadena basada en expresiones regulares en la línea actual, como en sed; puede incluir nuevas líneas literales en el texto de sustitución, pero deben ser \-escapeadas.
• wvuelve a escribir el resultado en el archivo de entrada (para probar, reemplace wcon ,ppara imprimir solo el resultado, sin modificar el archivo de entrada).

Para anteponer una o más líneas enteras :

Al igual que con sed, la ifunción agrega invariablemente una nueva línea final al texto que se va a insertar.

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

• 0 ihace 0(el comienzo del archivo) la línea actual y comienza el modo de inserción ( i); tenga en cuenta que los números de línea están 1basados ​​en otra cosa .
• Las siguientes líneas son el texto a insertar antes de la línea actual, terminada .en su propia línea.

Probablemente no tenga nada incorporado, pero podría escribir el suyo con bastante facilidad, así:

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

Algo así al menos ...

En algunas circunstancias, el texto antepuesto puede estar disponible solo desde stdin. Entonces esta combinación funcionará.

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

Si desea omitir la teesalida, agregue > /dev/null.

Solución:

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

Tenga en cuenta que esto es seguro en todo tipo de entradas, porque no hay expansiones. Por ejemplo, si desea anteponer !@#$%^&*()ugly text\n\t\n, simplemente funcionará:

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

La última parte que queda por considerar es la eliminación de espacios en blanco al final del archivo durante la sustitución del comando "$(cat file.txt)". Todas las soluciones para esto son relativamente complejas. Si desea conservar las nuevas líneas al final del archivo.txt, consulte esto: https://stackoverflow.com/a/22607352/1091436

Otra forma de usar sed:

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

Si la línea a anteponer es multilínea:

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

Según lo probado en Bash (en Ubuntu), si comienza con un archivo de prueba a través de;

echo "Original Line" > test_file.txt

puedes ejecutar;

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

o, si la versión de bash es demasiado antigua para $ (), puede usar backticks;

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

y reciba los siguientes contenidos de "test_file.txt";

New Line
Original Line

Sin archivo intermediario, solo bash / echo.

Otra solución bastante sencilla es:

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

Si te gusta vi / vim, este puede ser más tu estilo.

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

Recomiendo definir una función y luego importarla y usarla cuando sea necesario.

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
}

Luego úsalo así:

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

El contenido de su archivo será:

This is second
This is first

Estoy a punto de utilizar este enfoque para implementar un actualizador de registro de cambios.