Comment faire pour supprimer et remplacer la dernière ligne dans le terminal à l'aide de bash?

Je veux mettre en œuvre une barre de progression indiquant les secondes écoulées en bash. Pour cela, j'ai besoin d'effacer la dernière ligne affichée à l'écran (commande "effacer" efface tout l'écran, mais j'ai besoin d'effacer seulement la ligne de la barre de progression et la remplacer par la nouvelle information).

Résultat Final devrait ressembler à:

$ Elapsed time 5 seconds

Puis au bout de 10 secondes, je veux remplacer cette phrase (dans la même position à l'écran) par:

$ Elapsed time 15 seconds

InformationsquelleAutor Debugger | 2010-03-05

103

écho à un retour de chariot avec \r
```
seq 1 1000000 | while read i; do echo -en "\r$i"; done
```
de l'homme de l'écho:
```
-n     do not output the trailing newline
-e     enable interpretation of backslash escapes

\r     carriage return
```
- for i in {1..100000}; do echo -en "\r$i"; done pour éviter la seq appel 🙂
- C'est exactement ce à quoi j'ai besoin, merci !! Et l'utilisation de seq commande en effet de figer la termianl 🙂
- Lorsque vous utilisez des choses comme "for i in $(...)" ou "for i in {1..N}" de la production de tous les éléments avant de l'itération, c'est très inefficace pour les grandes entrées. Vous pouvez soit profiter de tuyaux: "seq 1 100000 | while read-je; ne ..." ou utilisez le bash de style c pour la boucle: "for ((i=0;;i++)); do ..."
- Merci Douglas et tokland - même si la séquence de production n'était pas directement partie de la question, j'ai changé de tokland plus efficace du tuyau
- Tout comme les bonnes vieilles machines à écrire.
- Mon imprimante matricielle est complètement gâcher mon papier. Il garde le brouillage des points sur le même morceau de papier qui n'est plus là, combien de temps cela prend-il de l'exécution du programme?
- comment faire la même chose avec php et stdout?
InformationsquelleAutor Ken
169

Le retour chariot en lui-même ne se déplace le curseur au début de la ligne. C'est OK si chaque nouvelle ligne de sortie est au moins aussi longue que la précédente, mais si la nouvelle ligne est plus courte, sur la ligne précédente ne sera pas complètement écrasé, par exemple:
```
$ echo -e "abcdefghijklmnopqrstuvwxyz\r0123456789"
0123456789klmnopqrstuvwxyz
```
Pour vider la ligne pour le nouveau texte, vous pouvez ajouter \033[K après la \r:
```
$ echo -e "abcdefghijklmnopqrstuvwxyz\r3[K0123456789"
0123456789
```
http://en.wikipedia.org/wiki/ANSI_escape_code
- Cela fonctionne vraiment bien dans mon environnement. Aucune connaissance de la compatibilité?
- En Bash, au moins, qui peut être réduit à \e[K au lieu de \033[K.
- Super réponse! Fonctionne parfaitement en utilisant le met en rubis. Maintenant partie de ma trousse à outils.
- +1 pour la compensation, le texte ainsi
- Pixel Développeur: Merci d'essayer de l'améliorer, mais votre montage est incorrect. Le retour doit arriver en premier pour déplacer le curseur au début de la ligne, puis la tuer efface tout, depuis que l'emplacement du curseur à la fin, laissant l'ensemble de la ligne de vide, ce qui est l'intention. Vous mettez ceux qui, au début de chaque nouvelle ligne, à l'instar de Ken réponse, de sorte qu'il est écrit sur une ligne vide.
- J'ai été en utilisant zshell qui pourrait avoir des comportements différents. Je vais vérifier mon hypothèse.
- Cela devrait sans aucun doute la réponse.
- Juste pour mémoire, on peut aussi faire \033[G je.o. \r avant \033[K bien évidemment \r est beaucoup plus simple. Aussi invisible-island.net/xterm/ctlseqs/ctlseqs.html donne plus de détails que Wikipédia et est de xterm développeur.
- C'est la réponse que je cherchais. De compensation de la ligne de compte pour imprévisibles ultérieure longueurs de ligne est le point clé.
InformationsquelleAutor Derek Veit
17

Derek Veit réponse fonctionne bien aussi longtemps que la longueur de la ligne ne dépasse jamais le terminal de largeur. Si ce n'est pas le cas, le code suivant va éviter indésirable de sortie:

avant la ligne est écrite pour la première fois, ne
```
tput sc
```
qui enregistre la position actuelle du curseur. Maintenant, chaque fois que vous souhaitez imprimer votre ligne, de
```
tput rc
tput ed
echo "your stuff here"
```
à retourner d'abord pour enregistrer la position du curseur, puis effacer l'écran à partir du curseur vers le bas, et enfin écrire la sortie.
- Un grand merci! +1
- Bizarre, ce n'est rien dans terminator. Savez-vous si il y a compatibilité des limites?
- Note pour Cygwin: Vous avez besoin d'installer le paquet "ncurses" utiliser "tput".
- Hm... Semble ne pas fonctionner si plus d'une ligne dans la sortie. Cela ne fonctionne pas: tput sc # save cursor echo '' > sessions.log.json while [ 1 ]; do curl 'http://localhost/jolokia/read/*:type=Manager,*/activeSessions,maxActiveSessions' >> sessions.log.json echo '' >> sessions.log.json cat sessions.log.json | jq '.' tput rc;tput el # rc = restore cursor, el = erase to end of line sleep 1 done
- Vous avez besoin d'utiliser tput ed plutôt que tput el. @Um de l'exemple utilisé ed (peut-être qu'il fixe après avoir commenté).
- Pour info, Voici la liste des tput commandes les Couleurs et le Mouvement du Curseur Avec tput
InformationsquelleAutor Um.
11

L' \033 méthode ne fonctionne pas pour moi. Le \r méthode fonctionne, mais il ne fait pas effacer quoi que ce soit, met juste le curseur au début de la ligne. Donc, si la nouvelle chaîne est plus courte que l'ancienne, vous pouvez voir les restes de texte à la fin de la ligne. En fin de compte tput était la meilleure façon d'aller. Il a d'autres utilisations outre le curseur stuff plus il est livré pré-installé sur la plupart des Linux & BSD distributions de sorte qu'il devrait être disponible pour la plupart les utilisateurs de bash.
```
#/bin/bash
tput sc # save cursor
printf "Something that I made up for this string"
sleep 1
tput rc;tput el # rc = restore cursor, el = erase to end of line
printf "Another message for testing"
sleep 1
tput rc;tput el
printf "Yet another one"
sleep 1
tput rc;tput el
```
Voici un petit script de compte à rebours pour jouer avec:
```
#!/bin/bash
timeout () {
    tput sc
    time=$1; while [ $time -ge 0 ]; do
        tput rc; tput el
        printf "$2" $time
        ((time--))
        sleep 1
    done
    tput rc; tput ed;
}

timeout 10 "Self-destructing in %s"
```
- Qui efface toute la ligne, en effet, problème, il scintille trop pour moi :'(
InformationsquelleAutor lee8oi
5

Dans le cas où les progrès de sortie est multi-ligne, ou le script aurait déjà imprimé le caractère de nouvelle ligne, vous pouvez sauter des lignes avec quelque chose comme:

printf "\033[5A"

qui fera le curseur pour sauter 5 lignes maximum. Puis vous pouvez remplacer ce que vous avez besoin.

Si cela ne fonctionne pas vous pouvez essayer de printf "\e[5A" ou echo -e "\033[5A", qui devrait avoir le même effet.

En fait, avec les séquences d'échappement vous pouvez contrôler presque tout l'écran.

InformationsquelleAutor Mr. Goferito
4

Utiliser le caractère de retour chariot:
```
echo -e "Foo\rBar" # Will print "Bar"
```
- Cette réponse est la façon la plus simple. Vous pouvez même obtenir le même effet en utilisant: printf "Foo\rBar"
InformationsquelleAutor Mikael S

Pouvez l'obtenir en plaçant retour chariot \r.

En une seule ligne de code avec printf

for i in {10..1}; do printf "Counting down: $i\r" && sleep 1; done

ou avec echo -ne

for i in {10..1}; do echo -ne "Counting down: $i\r" && sleep 1; done

InformationsquelleAutor Akif

-2

La façon la plus simple est d'utiliser le \r caractère je pense.

L'inconvénient est que vous ne pouvez pas avoir de lignes complètes, comme il n'efface la ligne courante.

Exemple Simple:
```
time=5
echo -n "Elapsed $time seconds"
sleep 10
time=15
echo -n "Elapsed $time seconds"

echo "\nDone"
```
- Hum, mais votre exemple n'est pas de supprimer et de remplacer la dernière ligne, qui est ce que l'OP a demandé.
InformationsquelleAutor Romuald Brunet

Vous devez vous connecter pour publier un commentaire.