Überschreiben der letzten Zeile auf dem terminal

Mein bash-Skript sieht wie folgt aus:

echo "Description:"
while [ $finishInput -eq 0 ]; do
read tmp
desc="$desc"$'\n'"$tmp"
if [ -z "$tmp" ]; then
finishInput="1"
fi
done
echo -n "Maintainer:"
read maintainer

Liest er die desc var, bis eine leere Zeile übergeben wird. Danach will ich Lesen in andere Sachen.

Beim ausführen mein Aktuelles Skript sieht es wie folgt aus:

Description:
Line 1
Line 2

Maintainer:

Möchte ich überschreiben Sie die Letzte leere Zeile mit dem "Maintainer:".

Suchte ich nach einer Lösung, fand aber nur Vorschläge, die waren wie

echo -n "Old line"
echo -e "\r new line"

bleibt auf der Linie und überschreibt es. Dies ist nicht möglich in meinem Fall.

InformationsquelleAutor Zulakis | 2012-07-01

71

Verwenden Sie einfach "\e[1A".

In deinem Beispiel löschen Sie den text in der gleichen Zeile:
```
$ echo -n "Old line"; echo -e "\e[0K\r new line"
 new line
```
Wenn Sie möchten, kehren Sie zur vorherigen Zeile mit \e[1A:
```
$ echo "Old line"; echo -en "\e[1A"; echo -e "\e[0K\r new line"
 new line
```
Wenn du gehen willst N Zeilen nach oben, verwenden Sie \e[<N>A.
- Sie bleiben auf der gleichen Linie, die mit -n -. Dies ist nicht möglich in meinem Fall, wie oben geschrieben.
- Sorry, ich verpasste den Punkt. Ich habe gerade meine Feste Antwort.
- Besser in der \r vor der \e[0K, sonst wirst du wischen nach rechts und dann nach Links bewegen, möglicherweise verlassen junk, zwischen denen Sie waren und sind. Obwohl da soll es auch eine leere Zeile, weder unbedingt erforderlich sind.
- Danke, das hat funktioniert. Wo finden Sie solche Sonderzeichen?
- google einfach terminal ansi sequences. Eines der Ergebnisse: termsys.demon.co.uk/vtansi.htm
- Sehen man 5 terminfo und verwenden tput anstelle von hart codierten Sequenzen. tput cuu1 geht eine Zeile nach oben, tput cuu 4 geht bis 4 Zeilen, tput el löscht bis zum Ende der Zeile. Sie können speichern diese in den Variablen und den Aufwand zu verringern, der immer wieder ruft tput: ceol=$(tput el) und später echo "foo\r${ceol}A"
- Einfach Fragen, - gibt es Unterstützung für so etwas wie, dass aber in einem kompilierten Programm? d.h. ein C-Programm, zum Beispiel.
- wenn Sie sich immer noch Fragen: stackoverflow.com/a/3219471/2954547
- Der link, den Sie gepostet wird, ist unglaublich hilfreich. Jedoch, es nur erwähnt \e[K, \e[1K, und \e[2K. Ich gehe davon aus \e[0K ist das gleiche wie \e[K? Wenn dem so ist, warum nicht \e[2K statt \r\e[0K?
- Ihre Meinung über das oben wäre auch nett. Nur nicht sicher, ob es ein edge-case/Vorbehalte/weird-Macken, die würde man zuverlässiger als die anderen.
InformationsquelleAutor Igor Chubin
13

Fand ein großes guide zu escape-Sequenzen und erweitern wollte auf einige der Diskussionen hier.

Beim schreiben auf ein terminal, die Sie bewegen, eine unsichtbare cursor um, viel wie Sie tun, wenn Sie schreiben in einem text-editor. Bei der Verwendung von echo es wird automatisch beendet die Ausgabe mit einem neue-Zeile-Zeichen, das bewegt den cursor in die nächste Zeile.
```
$ echo "Hello" && echo " World"
Hello
 World
```
Können Sie -n um zu verhindern, dass die neue Zeile und wenn man das echo wieder nach, wird es hängen Sie an das Ende der Zeile
```
$ echo -n "Hello" && echo " World"
Hello World
```
Bleibt der cursor, wo es so war, auf seine eigene, können wir nicht verwenden -n überschreiben der vorherigen Zeile, die wir brauchen, bewegen Sie den cursor auf der linken Seite. Dazu müssen wir, um ihm eine escape-Sequenz, die lassen wir echo wissen, die wir verwenden werden mit -e und bewegen Sie dann den cursor, indem Sie eine Rückkehr Wagen \r setzt den cursor an den Anfang der Zeile.
```
$ echo -n "Hello" && echo -e "\rWorld"
World
```
Dass kann schauen, wie es funktionierte, aber sehen Sie, was passiert mit
```
$ echo -n "A longer sentance" && echo -e "\rShort sentance"
Short sentancence
```
Siehe den extra-Charaktere? Einfach schreiben über die Linie ändert nur das Zeichen, wo wir, schrieb Sie.

Um dies zu beheben, ist die akzeptierte Antwort oben wird das Escapezeichen verwendet \e[0K um alles zu löschen, nachdem der cursor, sobald der cursor bewegt Links. also \r an den Anfang \e[0K löschen, zu Ende.
```
$ echo -n "A longer sentance" && echo -e "\r\e[0KShort sentance"
Short sentance
```
Wichtig \e zu beginnen escape-Sequenzen arbeitet in zsh aber nicht in sh und nicht unbedingt in bash jedoch \033 funktioniert in allen von Ihnen. Wenn Sie wollen, dass Ihr script überall aus arbeiten, sollten Sie Präferenz \033
```
$ echo -n "A longer sentance" && echo -e "\r\033[0KShort sentance"
Short sentance
```
Aber escape-Zeichen können sogar noch mehr utility. Zum Beispiel \033[1A bewegt den cursor in die Vorherige Zeile, so brauchen wir nicht die -n auf dem bisherigen echo:
```
$ echo "A longer sentance" && echo -e "\r\033[1A\033[0KShort sentance"
Short sentance
```
\r bewegen an den Anfang \033[1A verschieben bis \033[0K löschen, um das Ende

Schließlich, das ist alles etwas chaotisch in meinem Buch, so können Sie diesen in einer Funktion:
```
overwrite() { echo -e "\r\033[1A\033[0K$@"; }
```
Mit $@ legt einfach alle Parameter der Funktion in den string
```
$ echo Longer sentance && overwrite Short sentence
Short sentence
```
Hoffe, das hilft Menschen, die wissen wollen ein bisschen mehr.

InformationsquelleAutor DanielM
12

Baute ich eine Funktion aus Dennis Williamsons Kommentar:
```
function clearLastLine() {
        tput cuu 1 && tput el
}
```
Dank Dennis Williamson
- Können Sie erklären, was diese tput tun?
- ist die Abkürzung für "cursor up # lines" und "el" -> "Clear to end of line", siehe: gnu.org - tput
InformationsquelleAutor Murmel
5

Wenn du echo ohne newline-Zeichen echo -n "Something" verwenden, können Sie \r mit Ihrem nächsten echo, um die 'cursor' an den Anfang der Zeile echo -e "\\rOverwrite something".
```
#!/bin/bash

CHECK_MARK="\033[0;32m\xE2\x9C\x94\033[0m"

echo -e "\n\e[4mDoing Things\e[0m"
echo -n "doing thing 1..."
sleep 1
echo -e "\\r${CHECK_MARK} thing 1 done"
```
Nur bewusst sein, dass, wenn der neue string kürzer ist, dass Sie Ihre alten string, der Schwanz von deinem alten string noch sichtbar sein werden. Hinweis: die done.. im gif oben.

InformationsquelleAutor Derek Soike
1
```
#!/bin/bash

echo "Description:"
while test -z $finishInput; do
 read -s tmp
 desc="$desc"$'\n'"$tmp"
 if [ -z "$tmp" ]; then
 finishInput=1
 else
    echo $tmp
 fi
 #echo "fi="$finishInput;
done
echo -n "Maintainer:"
read maintainer
```
Diese Lösung vermeidet die leere Zeile, aber die Eingabe wird nicht durchgeleitet, bevor Sie die Zeilen komplett sind.

Hinweis: Meine version von bash nicht akzeptieren, " [ $finishInput -eq 0 ]".
- Ich würde eher nicht so, da die Nutzer nicht sehen, Ihre Eingabe, bis Sie geben Sie einen Zeilenumbruch.
- Da sagen Sie "Hinweis", ich nehme an, Sie wissen, warum diese Zeile wurde nicht "akzeptiert". Im Falle, dass Sie oder jemand anderes vielleicht noch nicht kennen, es ist, weil die variable leer ist und ohne Anführungszeichen. Sollten Sie verwenden [ "$finishInput" -eq 0 ] oder besser: [[ $finishInput -eq 0 ]].
- [ "$finishInput" -eq 0 ] führt zu der Fehlermeldung "integer-Ausdruck erwartet" mit meinem bash. Meine bash version 4.2-2ubuntu2.
InformationsquelleAutor Michael Besteck
0

Wenn Sie möchten, führen Sie ein Skript in eine Schleife und nicht blow up Ihre scrollback, können Sie das folgende Muster verwenden:
```
while sleep 10s; do 
  echo -n $(script)
  echo -n -e "\e[0K\r"
done
```
Ersetzen Sie einfach die script Befehl mit Ihrem eigenen.

InformationsquelleAutor maxywb

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.