Como mostrar um relógio de corrida no terminal antes do prompt de comando

Eu prefiro usar o terminal e passar a maior parte do tempo usando-o. Estou procurando uma maneira de ver o tempo no terminal enquanto o uso em paralelo. O tempo mudaria automaticamente quando passasse. Seria incrível se fosse exibido à esquerda no meu prompt de comando.

Se este é o meu prompt de comando no terminal:

saurav@saurav-P4I45Gx-PE:~$

Então eu gostaria de ver o relógio (hora) como:

saurav@saurav-P4I45Gx-PE[06:27:01]:~$

ou

saurav@(06:27:01):~$

ou qualquer outro formato. onde 06:27:01é o tempo O que eu quero é apenas mostrar o tempo que muda quando os segundos passam.

Então, existe alguma maneira de conseguir isso?

Não tenho certeza se é tão simples conseguir isso usando o shell bash padrão (mas não estou dizendo que é impossível). Você provavelmente precisará de um comando / função capaz de atualizar o prompt de comando a cada segundo, sem interferir em qualquer coisa digitada no prompt.

O shell Z (zsh) possui um comando interno chamado zle, que, quando usado com o reset-promptargumento, força o prompt a ser expandido novamente e, em seguida, exibe novamente o buffer de edição.

Se você quiser experimentá-lo, use as seguintes etapas:

1. Instale o shell Z com este comando:

   sudo apt-get install zsh
   

2. Quando você executar zshpela primeira vez, escolha 0quando for solicitado.

3. Edite o ~/.zshrcarquivo e adicione as seguintes linhas:

   setopt PROMPT_SUBST
   PROMPT='%B%F{red}%n@%m%f%F{yellow}[%D{%L:%M:%S}]%f:%F{blue}${${(%):-%~}}%f$ %b'
   TMOUT=1
   
   TRAPALRM() {
       zle reset-prompt
   }
   

   Salve o arquivo e feche-o.

4. No seu terminal, quando você ainda estiver usando o zsh, execute source ~/.zshrcou simplesmente zshpara redefinir seu prompt. Agora seu prompt deve se parecer com:

   saurav@saurav-P4I45Gx-PE[1:25:21]:~$
   

   com algumas cores.

5. Se você gostar, corra chsh -s /bin/zshpara alterar seu shell atual para /bin/zsh(é necessário um novo login para que essa alteração tenha efeito).

6. Execute exitse você quiser sair do zsh shell.

Aqui está um screencast de 15 segundos do meu terminal:

Se você deseja exibir o tempo de execução no seu terminal, pode usar este comando. Ele exibirá o tempo no lado superior direito do seu terminal.

  while sleep 1;do tput sc;tput cup 0 $(($(tput cols)-11));echo -e "\e[31m`date +%r`\e[39m";tput rc;done &

Mas observe que a exibição do tempo usando este comando em algum momento pode se sobrepor ao texto presente no terminal. Portanto, use este comando com pouco cuidado.

Outra maneira pode estar usando o caractere de controle no PS1

[guru@guru-pc ~]$  PS1='\[\u@\h \T \w]\$'

[guru@guru-pc 11:06:16 ~]$

Mas neste método, seu tempo será atualizado somente após pressionar enter.

Se você deseja que o método acima seja permanente, adicione o comando acima (o que você gosta ou ambos) em seu ~.bashrcarquivo.

Se tudo o que você quer fazer é mostrar um relógio, basta usar date:

while :; do date +%r; sleep 1 ; done

Isso mostrará a hora a cada segundo até que você pare CtrlC. Se você deseja que ele esteja na mesma linha (o exemplo acima imprimirá uma nova linha a cada segundo), faça o seguinte:

while :; do printf '%s\r' "$(date +%r)"; sleep 1 ; done

Essa pergunta me incomoda há alguns dias e aqui está meu post editado com todo o material que aprendi. Especificamente, meu objetivo era conseguir mostrar o relógio próximo ao prompt no BASH. Assim como Radu Radeanu mencionado em sua resposta, a chave é encontrar uma função ou variável capaz de atualizar constantemente o prompt de comando ou redesenhar a tela, sem interferir na tela ou no que você digitar. Enquanto isso é possível com o loop while, como mostra G_P, o constante redesenho da tela com a função tput interfere com o texto que estiver na minha tela no momento em que ela é atualizada. Eu cheguei bem perto de conseguir o que o OP pediu, modificando um pouco o código que G_P postou, mas ainda acredito que a resposta de Radu é a mais próxima do que o OP deseja. Sem mais delongas, aqui estão algumas das coisas que eu

# 1, Minha solução preferida: Terminal Multiplexer

O multiplexador de terminal é um software que permite dividir a tela do terminal em duas ou mais telas. Em particular, quero chamar a atenção para o terminal Byobu. Esse emulador de terminal baseado em ncurses, permite mostrar tempo, porcentagem de CPU, memória e vários outros indicadores. Na captura de tela do meu terminal byobu, você pode ver a temperatura da CPU, porcentagem da bateria, qualidade da conexão com a Internet, frequência da CPU, RAM, data e hora do curso. Se você está principalmente preocupado em monitorar constantemente essas coisas enquanto está no terminal, Byobu é o caminho a percorrer. Na verdade, eu gostei tanto que o configurei para carregar automaticamente durante o login no tty. A única peculiaridade é que, em tty, você não pode mesclar as janelas separadas - alterne apenas as guias com as teclas F3 e F4.

Uma solução alternativa que envolve janelas de multiplexação é usando splitvt, que divide a tela em duas partes. Você pode executar um relógio do terminal, como tty-clockusar o comando watch com a data ou pode codificar um com um script. Mais sobre isso mais tarde. Na captura de tela, você pode ver uma parte da divisão com o prompt bash normal na parte superior, e na parte inferior, um script em execução, que atualiza constantemente constantemente a saída do datecomando com o clearcomando.

# 2, Enquanto Do loop e tput Esse é provavelmente o mais próximo do que a pessoa que fez a pergunta queria implementar com o bash.

O G_P postou uma ótima solução envolvendo os comandos while doe tput. No entanto, no código do G_P, havia duas coisas que eu não gostei. Um, o relógio estava à direita do prompt e dois - como o ciclo de suspensão é de 1 segundo (consulte o código original onde diz suspensão), a tela é redesenhada a cada segundo e isso atrapalha minha saída. O que fiz foi editar meu prompt do bash para ficar uma linha abaixo com o operador \ n e alterar o código do G_P para que o operador de tput posicionasse o relógio logo acima do prompt e atualizasse a cada 60 segundos; isso me permite ver horas e minutos (e não me importo exatamente com minutos), enquanto o loop do relógio não atrapalha minha tela. Primeiro, aqui está o meu prompt:

PS1='${debian_chroot:+($debian_chroot)}\n[*\u@Ubuntu*]\n $(date) :\w\$  ' 

E aqui está o código modificado do G_P: enter code here

 while sleep 60;do tput sc;tput cup 0 0;date +%R;tput rc;done &

Edição pequena : notei que esse código acima não acelera o relógio às vezes. Aqui está uma versão melhor: while true; do tput sc;tput cup 0 0;date +%R;tput rc; sleep 60; done & Este coloca o relógio na tela primeiro e depois informa ao bash para passar pelo ciclo de sono de 60 segundos

Observe que o copo tput 0 0 coloca o relógio no canto superior direito da tela, logo acima do meu prompt e o sono 60 muda o ciclo do sono para 60 segundos, porque dessa maneira eu posso monitorar apenas horas e minutos em vez de cada segundo. Dessa forma, qualquer texto que tenha na tela não será afetado, na maioria das vezes (apenas quando executar um comando no mesmo horário que o relógio é atualizado).

A linha PS1 já está no seu perfil .bashrc, então você só precisa ajustá-la um pouco. O loop while do deve ser adicionado em algum lugar do mesmo arquivo, de preferência no final com # comment que isso é algo que você adicionou inicialmente. E não se esqueça de sempre fazer backup de qualquer arquivo como esse para o caso de você fazer bubu e precisar voltar ao que era antes.

# 3, Script e outros

Esta parte é apenas para aqueles que querem ver o tempo. Para quem deseja monitorá-lo constantemente, os itens 1 e 2 são as opções preferidas.

Então, como já vimos, o loop while é bastante útil. Veja como você pode criar um relógio com os comandos while do loop, date e sleep.

Pressione return / enter, e você basicamente verá o comando output of date mostrado na tela limpa a cada segundo. Se você não quiser digitar tudo isso sempre, transforme tudo isso em script:

#!/bin/bash

while true
do
clear;date
sleep 1
done

Agora você pode executar esse script com splitvt em uma instância do bash, enquanto trabalha na outra.

Outra solução é o watch -n1 datecomando, que executará continuamente o comando date com período de 1 segundo.

Conclusão: aprendi algumas coisas enquanto tentava encontrar a resposta para essa pergunta, e espero que minhas descobertas tenham ajudado você de alguma forma, e espero poder contribuir com essa questão. O terminal IMHO do Byobu é a melhor solução, mas decida por si mesmo, faça algumas pesquisas e escolha a maneira que melhor lhe convier.

Algumas das coisas que encontrei ao pesquisar:

• Repita o comando no Unix
• Alguns exemplos de prompt do bash
• Prompt de relógio flutuante

Minha postagem original, a solução minimalista: edite seu arquivo ~ / .bashrc. Eu prefiro editá-lo com nano, então

nano ~/.bashrc

Aqui está a parte do meu próprio arquivo editado:

if [ "$color_prompt" = yes ]; then
    PS1='${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\$'    
else
   # PS1='${debian_chroot:+($debian_chroot)}[*\u@Ubuntu*]:\w\$ '
    PS1='${debian_chroot:+($debian_chroot)}[*\u@Ubuntu*]\t:\w\$ '
fi

Após a declaração else, a primeira linha é comentada com # (esse é o meu prompt antigo), agora a segunda linha é a que você deseja e, especificamente, o \toperador. Isso mostra o tempo de execução no formato de 24 horas. Para mais informações, confira isso . Também uma pequena nota: depois disso, estou usando o material, porque não estou usando o prompt colorido.

PS: Informe-me se devo adicionar alguma coisa à minha resposta ou editá-la de qualquer forma, mas, na maioria das vezes, acredito que essa é a resposta mais conclusiva que eu poderia ter, e pelo menos pessoalmente não adicionarei nada. novo nisso.

export PS1='\t$'

desde que eu prefiro apresentar tão pouco fundo informações possível sobre o i terminais geralmente personalizar cada sessão como #, $, etc. (se você quiser mudá-lo de forma permanente, a solução da minerz029 é perfeito)

Para modificá-lo para mostrar atual, eu poderia ir para

export PS1='\T$'

por hora no formato de 12 horas. Você pode visualizar a documentação do bash para outras opções.

Esse tempo será alterado apenas quando um novo prompt for executado

Você pode adicionar o seguinte ao seu .bashrc:

export PS1="\[\e]0;\u@\h: \w\a\]${debian_chroot:+($debian_chroot)}\u@\h:[\t]:\w\$ "

Qual produzirá:

USER@HOST:[12:59:59]:~$ _

Mais informações aqui: http://www.thegeekstuff.com/2008/09/bash-shell-ps1-10-examples-to-make-your-linux-prompt-like-angelina-jolie/#8

Procure por "8. Crie seu próprio prompt usando os códigos disponíveis para a variável PS1" na página acima.

Eu realmente gosto do recurso de relógio ncmpcpp , acionado pela 0tecla (veja a captura de tela). Para mais detalhes sobre o procedimento de instalação, consulte este post .

Influenciado por g_p e Serg , tentei criar função no bash. Funciona, mas não tenho certeza de que seja uma boa ideia verificar o comando ps a cada segundo para ver se o bash é um processo fg ou não

prompttime() {
  PSCOLGREEN="\[$(tput setaf 2)\]"
  PSCOLRESET="\[$(tput sgr0)\]"
  PS1="${PSCOLGREEN}\\$ ${PSCOLRESET}[--:--:-- \W] "
  [ "$PROMPTCURRTTY" ] || {
    PROMPTCURRTTYtemp=$(tty)
    PROMPTCURRTTY=${PROMPTCURRTTYtemp//\/dev\//}
    unset PROMPTCURRTTYtemp; }
  PROMPTSTATE="[S]s+"
  while :; do
    sleep 1
    [ "$(ps a | grep "${PROMPTCURRTTY}.*${PROMPTSTATE}.*$(basename $SHELL)")" ] &&
    { tput sc
      tput hpa 3
      echo -en "$(date +%T)"
      tput rc; }
    continue
  done&
}

Se você nunca precisar usá debian_chroot-lo, é um local útil para definir a hora em que o prompt de comando foi exibido usando:

export PROMPT_COMMAND='debian_chroot=$(date +%r)'

Digite isso no seu terminal e observe seu prompt de comando mudar com o tempo:

rick@alien:~$ export PROMPT_COMMAND='debian_chroot=$(date +%r)'

(09:14:59 PM)rick@alien:~$ 

Depois que o tempo é definido uma vez, para obter um relógio de corrida que atualiza a cada segundo uso:

while sleep 1;do tput sc;tput cup $(($(tput lines)-1)) 1;printf `date +%r`;tput rc;done &

Isso .gifmostra os comandos em ação: