Sim é possível, basta redirecionar a saída (AKA stdout) para um arquivo:

SomeCommand > SomeFile.txt  

Ou se você quiser anexar dados:

SomeCommand >> SomeFile.txt

Se você quiser stderrtambém use isso:

SomeCommand &> SomeFile.txt  

ou isto para anexar:

SomeCommand &>> SomeFile.txt  

se você quiser que ambos stderre a saída sejam exibidos no console e em um arquivo, use isto:

SomeCommand 2>&1 | tee SomeFile.txt

(Se você quiser apenas a saída, solte o 2acima)

Para gravar a saída de um comando em um arquivo, existem basicamente 10 maneiras comumente usadas.

Visão geral:

_{Observe que n.e.na coluna de sintaxe significa "não existente".
Existe um caminho, mas é muito complicado para caber na coluna. Você pode encontrar um link útil na seção Lista sobre isso.}

          || visible in terminal ||   visible in file   || existing
  Syntax  ||  StdOut  |  StdErr  ||  StdOut  |  StdErr  ||   file   
==========++==========+==========++==========+==========++===========
    >     ||    no    |   yes    ||   yes    |    no    || overwrite
    >>    ||    no    |   yes    ||   yes    |    no    ||  append
          ||          |          ||          |          ||
   2>     ||   yes    |    no    ||    no    |   yes    || overwrite
   2>>    ||   yes    |    no    ||    no    |   yes    ||  append
          ||          |          ||          |          ||
   &>     ||    no    |    no    ||   yes    |   yes    || overwrite
   &>>    ||    no    |    no    ||   yes    |   yes    ||  append
          ||          |          ||          |          ||
 | tee    ||   yes    |   yes    ||   yes    |    no    || overwrite
 | tee -a ||   yes    |   yes    ||   yes    |    no    ||  append
          ||          |          ||          |          ||
 n.e. (*) ||   yes    |   yes    ||    no    |   yes    || overwrite
 n.e. (*) ||   yes    |   yes    ||    no    |   yes    ||  append
          ||          |          ||          |          ||
|& tee    ||   yes    |   yes    ||   yes    |   yes    || overwrite
|& tee -a ||   yes    |   yes    ||   yes    |   yes    ||  append

Lista:

• command > output.txt

  O fluxo de saída padrão será redirecionado apenas para o arquivo, não será visível no terminal. Se o arquivo já existir, ele será substituído.

• command >> output.txt

  O fluxo de saída padrão será redirecionado apenas para o arquivo, não será visível no terminal. Se o arquivo já existir, os novos dados serão anexados ao final do arquivo.

• command 2> output.txt

  O fluxo de erro padrão será redirecionado apenas para o arquivo, não será visível no terminal. Se o arquivo já existir, ele será substituído.

• command 2>> output.txt

  O fluxo de erro padrão será redirecionado apenas para o arquivo, não será visível no terminal. Se o arquivo já existir, os novos dados serão anexados ao final do arquivo.

• command &> output.txt

  Tanto a saída padrão quanto o fluxo de erro padrão serão redirecionados apenas para o arquivo, nada será visível no terminal. Se o arquivo já existir, ele será substituído.

• command &>> output.txt

  Tanto a saída padrão quanto o fluxo de erro padrão serão redirecionados apenas para o arquivo, nada será visível no terminal. Se o arquivo já existir, os novos dados serão anexados ao final do arquivo.

• command | tee output.txt

  O fluxo de saída padrão será copiado para o arquivo, ele ainda estará visível no terminal. Se o arquivo já existir, ele será substituído.

• command | tee -a output.txt

  O fluxo de saída padrão será copiado para o arquivo, ele ainda estará visível no terminal. Se o arquivo já existir, os novos dados serão anexados ao final do arquivo.

• (*)

  O Bash não tem sintaxe abreviada que permite canalizar apenas StdErr para um segundo comando, que seria necessário aqui em combinação com teenovamente para completar a tabela. Se você realmente precisa de algo assim, veja "Como canalizar stderr e não stdout?" no Stack Overflow para algumas maneiras de como isso pode ser feito, por exemplo, trocando fluxos ou usando substituição de processo.

• command |& tee output.txt

  Tanto a saída padrão quanto os fluxos de erro padrão serão copiados para o arquivo enquanto ainda estiverem visíveis no terminal. Se o arquivo já existir, ele será substituído.

• command |& tee -a output.txt

  Tanto a saída padrão quanto os fluxos de erro padrão serão copiados para o arquivo enquanto ainda estiverem visíveis no terminal. Se o arquivo já existir, os novos dados serão anexados ao final do arquivo.

Você também pode usar teepara enviar a saída para um arquivo:

command | tee ~/outputfile.txt

Uma pequena modificação também pegará o stderr:

command 2>&1 | tee ~/outputfile.txt

ou um pouco mais curto e menos complicado:

command |& tee ~/outputfile.txt

teeé útil se você quiser capturar a saída do comando enquanto também a visualiza ao vivo .

Você pode redirecionar a saída do comando para um arquivo:

your_command >/path/to/file

Para anexar a saída do comando a um arquivo em vez de sobrescrevê-lo, use:

your_command >>/path/to/file

Uma melhoria a considerar -

Vários scripts injetarão códigos de cores na saída que você pode não querer sobrecarregar seu arquivo de log.

Para corrigir isso, você pode usar o programa sed para remover esses códigos. Exemplo:

command 2>&1 | sed -r 's/'$(echo -e "\033")'\[[0-9]{1,2}(;([0-9]{1,2})?)?[mK]//g' | tee ~/outputfile.txt

O scriptcomando

Há duas perguntas diferentes aqui. A primeira está no título:

Como faço para salvar a saída do terminal em um arquivo?

A segunda pergunta está no corpo:

Como faço para salvar a saída de um comando em um arquivo?

Todas as respostas postadas aqui abordam a segunda pergunta, mas nenhuma aborda a primeira pergunta que tem uma ótima resposta em Unix e Linux :

• Salve toda a saída do terminal em um arquivo

Esta resposta usa um comando pouco conhecido chamado scriptque salva toda a saída do seu shell em um arquivo de texto até que você digite exit. A saída do comando ainda aparece na tela, mas também aparece no arquivo de texto .

O processo é simples. Usar:

$ script ~/outputfile.txt
Script started, file is /home/rick/outputfile.txt
$ command1
$ command2
$ command3
$ exit
exit
Script done, file is /home/rick/outputfile.txt

Em seguida, observe a saída gravada dos comandos 1, 2 e 3 com:

cat ~/outputfile.txt

Isso é semelhante à resposta anterior de:

command |& tee ~/outputfile.txt

• Mas você não precisa usar |& tee ~/outputfile.txtdepois de cada commnd.
• O scriptcomando adicionou o benefício (ou desvantagem) de recarregar ~/.bashrcquando é iniciado.
• O scriptcomando mostra o prompt de comando ( $PS1) seguido pelos comandos que você digitou.
• O scriptcomando grava todos os detalhes em cores.

Enviar saída para a área de transferência

Muitas vezes queremos que a saída vá para a área de transferência para que possamos colá-la mais tarde. A partir desta resposta , você pode usar:

cat ~/.bashrc | xclip -selection clipboard

Agora você pode usar Ctrl+ Vem quase qualquer aplicativo para colar a saída do terminal em seu documento. Para colar a saída do terminal na área de transferência de volta ao seu terminal, use Ctrl+ Shift+ V.

some_command | tee command.loge some_command > command.logtem o problema de não salvar a saída do comando no command.logarquivo em tempo real.

Para evitar esse problema e salvar a saída do comando em tempo real, você pode anexar unbuffer, que vem com o expectpacote.

Exemplo:

sudo apt-get install expect
unbuffer some_command | tee command.log
unbuffer some_command > command.log

Assumindo log.pycontém:

import time
print('testing')
time.sleep(100) # sleeping for 100 seconds

você pode correr unbuffer python log.py | tee command.logouunbuffer python log.py > command.log

Mais informações: Como posso salvar uma saída de comando em um arquivo em tempo real?

Para crontrabalhos etc, você deseja evitar as extensões Bash. shOs operadores de redirecionamento POSIX equivalentes são

Bash          POSIX
------------  --------------
foo &> bar    foo >bar 2>&1
foo &>> bar   foo >>bar 2>&1
foo |& bar    foo 2>&1 | bar

Você notará que o recurso POSIX é, de certa forma, mais simples e direto. A &>sintaxe foi emprestada do cshque já deve convencê-lo de que é uma má ideia.

Se você deseja gerar a saída para o arquivo enquanto o comando está sendo executado:

script -c ./path/to/executable.bash -f log.txt

Use os recursos do emulador de terminal

Uma opção ainda não mencionada, que também pode salvar cores/cores, é usar um programa de console — como Konsole(o emulador de terminal padrão do KDE/Plasma) — para salvar a saída.

Konsole

Konsole has: 
File > Save output as... 

o atalho é Ctrl+ Shift+ S; ele permite que a saída seja salva como um arquivo de texto ou como HTML incluindo cores! Não tenho certeza exatamente quanto ele economizará, mas no meu teste incluiu apenas ~ 1000, toda a rolagem do terminal (você pode aumentar o buffer criando um novo perfil, Perfil > Novo ... e, em seguida, alterar a rolagem configurações para capturar mais; Konsole versão 4:21.08.1).

gnome-terminal

gnome-terminaltem "copiar saída como HTML" também, o que permite colar o HTML em um documento; ele preserva a cor, mas apenas copia o conteúdo da saída exibida atualmente na tela AFAICT.

genericamente

Você pode, é claro, fazer uma seleção direta de arrastar (manter pressionado o botão esquerdo do mouse enquanto arrasta) e depois copiar ( ctrl+ c, Editar > Copiar ou clicar com o botão direito do mouse e escolher copiar).

outros?

Sinta-se à vontade para modificar esta resposta para incluir outros aplicativos de terminal populares. Meu favorito, Yakuake, não parece ter esse recurso, nem a maioria dos terminais populares que analisei, incluindo terminal.app e Hyper.