Existe um comando Unix para acrescentar alguns dados de string a um arquivo de texto?

Algo como:

prepend "to be prepended" text.txt

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

• -igrava a alteração no local e faz um backup se alguma extensão for fornecida. (Nesse caso, .old)
• 1s;^;to be prepended;substitui o início da primeira linha pela sequência de substituição fornecida, usando ;como um delimitador de comando.

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

Substituição de Processo

Estou surpreso que ninguém tenha mencionado isso.

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

o que é indiscutivelmente mais natural do que a resposta aceita (imprimir algo e encaminhá-lo para um comando de substituição é lexicograficamente contra-intuitivo).

... e seqüestrar o que ryan disse acima, com spongevocê não precisa de um arquivo temporário:

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

EDIT: Parece que isso não funciona no Bourne Shell /bin/sh

Aqui String (apenas zsh)

Usando uma string here - <<<, você pode:

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

Esta é uma possibilidade:

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

você provavelmente não conseguirá facilmente contornar um arquivo intermediário.

Alternativas (pode ser complicado com o escape da concha):

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

Isso funcionará para formar a saída. O - significa entrada padrão, que é fornecida através do tubo a partir de eco.

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

Para reescrever o arquivo, é necessário um arquivo temporário, pois não é possível canalizar novamente para o arquivo de entrada.

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

Prefira a resposta de Adam

Podemos facilitar o uso da esponja . Agora não precisamos criar um arquivo temporário e renomeá-lo por

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

Se for aceitável substituir o arquivo de entrada:

Nota:

• Isso pode ter efeitos colaterais inesperados, principalmente o potencial de substituir um link simbólico por um arquivo normal, terminar com permissões diferentes no arquivo e alterar a data de criação (nascimento) do arquivo.

• sed -i, como na resposta do príncipe John Wesley , tenta pelo menos restaurar as permissões originais, mas as outras limitações também se aplicam.

Aqui está uma alternativa simples que usa um arquivo temporário (evita a leitura de todo o arquivo de entrada na memória da maneira que a solução do shime faz):

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

^{Usar um comando de grupo ( { ...; ...; }) é um pouco mais eficiente do que usar um subshell ( (...; ...)), como na solução de 0xC0000022L .}

As vantagens são:

• É fácil controlar se o novo texto deve ser anexado diretamente à primeira linha ou se deve ser inserido como nova (s) linha (s) (basta anexar \nao printfargumento).

• Diferentemente da sedsolução, ele funciona se o arquivo de entrada estiver vazio ( 0bytes).

A sedsolução pode ser simplificada se a intenção for anexar uma ou mais linhas inteiras ao conteúdo existente (assumindo que o arquivo de entrada não esteja vazio):

sedA ifunção de insere linhas inteiras:

Com o 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

Uma variante portátil que também funciona com o 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

Observe que a nova linha literal após o \é necessária.

Se o arquivo de entrada precisar ser editado no local (preservando seu inode com todos os seus atributos):

Usando o venerável edutilitário POSIX :

Nota:

• edinvariavelmente lê primeiro o arquivo de entrada como um todo na memória.

Para anexar diretamente à primeira linha (como em sed, isso não funcionará se o arquivo de entrada estiver completamente vazio ( 0bytes)):

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

• -sedmensagens de status suprimidas .
• Observe como os comandos são fornecidos edcomo um documento aqui com várias linhas ( <<EOF\n...\nEOF), ou seja, via stdin ; por padrão, a expansão de strings é executada nesses documentos (variáveis ​​de shell são interpoladas); cite o delimitador de abertura para suprimir isso (por exemplo, <<'EOF').
• 1 torna a primeira linha a linha atual
• A função sexecuta uma substituição de seqüência de caracteres baseada em regex na linha atual, como em sed; você pode incluir novas linhas literais no texto de substituição, mas elas devem ser \escapadas.
• wgrava o resultado de volta no arquivo de entrada (para teste, substitua wpor ,ppara imprimir apenas o resultado, sem modificar o arquivo de entrada).

Para acrescentar uma ou mais linhas inteiras :

Assim como seda ifunção, invariavelmente, adiciona uma nova linha final ao texto a ser inserido.

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

• 0 itorna 0(o início do arquivo) a linha atual e inicia o modo de inserção ( i); observe que os números de linha são 1baseados em outras coisas .
• As linhas a seguir são o texto a ser inserido antes da linha atual, terminado com .em sua própria linha.

Provavelmente nada embutido, mas você poderia escrever o seu com bastante facilidade, assim:

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

Algo assim pelo menos ...

Em algumas circunstâncias, o texto anexado pode estar disponível apenas no stdin. Então essa combinação deve funcionar.

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

Se você deseja omitir a teesaída, acrescente > /dev/null.

Solução:

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

Observe que isso é seguro em todos os tipos de entradas, porque não há expansões. Por exemplo, se você deseja anexar !@#$%^&*()ugly text\n\t\n, funcionará apenas:

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

A última parte que resta para consideração é a remoção de espaço em branco no final do arquivo durante a substituição de comandos "$(cat file.txt)". Todas as soluções para isso são relativamente complexas. Se você deseja preservar as novas linhas no final do arquivo.txt, consulte: https://stackoverflow.com/a/22607352/1091436

Outra maneira de usar sed:

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

Se a linha a ser anexada for multilinha:

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

Conforme testado no Bash (no Ubuntu), se iniciar com um arquivo de teste via;

echo "Original Line" > test_file.txt

você pode executar;

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

ou, se a versão do bash for muito antiga para $ (), você poderá usar backticks;

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

e receba o seguinte conteúdo de "test_file.txt";

New Line
Original Line

Nenhum arquivo intermediário, apenas bash / eco.

Outra solução bastante direta é:

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

Se você gosta do vi / vim, este pode ser o seu 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

Eu recomendo definir uma função e, em seguida, importar e usá-la quando necessário.

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
}

Em seguida, use-o assim:

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

O conteúdo do seu arquivo será:

This is second
This is first

Estou prestes a usar essa abordagem para implementar um atualizador de log de alterações.