In: eine Zeichenfolge ohne Zeilenumbrüche *
Ermöglicht dem Benutzer das Bearbeiten und Übermitteln der Zeile
Out: die geänderte Zeichenfolge (optional mit einem nachgestellten Zeilenumbruch)

Der Zeileneditor muss dem Benutzer mindestens Folgendes erlauben:

1. Bewegen Sie einen sichtbaren Cursor nach links und rechts

2. Zeichen an der Cursorposition einfügen und / oder überschreiben

3. Zeichen an der Cursorposition entfernen

4. Senden Sie die neue Zeichenfolge, dh beenden Sie die Bearbeitung, damit die geänderte Zeichenfolge zurückgegeben / gedruckt / angezeigt / gespeichert wird ... (ohne weiteren Text)

Geschätzt, aber nicht erforderlich:

• Erklärung Ihres Codes.

• Link zu einer Online-Test-Site, die Ihr Programm / Ihre Funktion demonstrieren kann

• ein animiertes Bild, das die Verwendung demonstriert (TIO erlaubt beispielsweise keine Interaktivität)

Hinweis:

• Tastenkombinationen sind nur Vorschläge

• GUI oder visuelles Styling ist nicht erforderlich

Beispiele

Im Folgenden wird der Cursor mit dargestellt _.

In: Just some text
Benutzer darf bearbeiten:
 Just some text_  Benutzer drückt ←neunmal (linke Pfeiltaste)
 Just ̲some text  Benutzer drückt Delviermal
 Just ̲ text  Benutzer drückt  Benutzer drückt aus:any
 Just any_text Enter
Just any text

In: Remove me
Benutzer darf bearbeiten:
 Remove me_  Benutzer drückt Backspaceneunmal
 _  Benutzer drückt aus: (leere Zeichenfolge)Enter
 

* Um triviale Editorlösungen zu vermeiden, muss dies entweder über eine andere Eingabemethode als die Bearbeitungsbefehle erfolgen oder durch einen Zeilenumbruch oder ähnliches von diesen getrennt sein.

APL (Dyalog) , 5 Bytes

⍞←⍞⋄⍞

Dies ist eine Tradition, also benutze sie

∇a
⍞←⍞⋄⍞
∇

Rufen Sie es dann mit auf a, und geben Sie anschließend die Startzeichenfolge ein. Anschließend können Sie die Zeichenfolge bearbeiten.

JavaScript (ES6), 15 bis 14 Byte

Ich verstehe nicht, warum das so viele positive Stimmen bekommt!

s=>prompt(s,s)

Ein Byte dank Adáms Vorschlag, dass ich die ursprüngliche Eingabe in der anzeige , gespeichert prompt.

Versuch es

f=
s=>prompt(s,s)
console.log(f("Edit this ..."))

Bash 4.x, 25 Zeichen

read -ei "$*" t
echo "$t"

Probelauf:

bash-4.3$ bash interactive.sh hello world
hello golfing world
hello golfing world

(Zeile 2 oben war die interaktive Bearbeitung, Zeile 3 die Ausgabe des resultierenden Texts.)

Bash + Vi / Vim, 14 Bytes

echo $1>a;vi a

vizu aliased ist vimauf macOS, weiß ich nicht über anderen OSes.

HTML + JavaScript (ES6), 77 66 64 Byte

HTML

<input id=t

JavaScript

onkeyup=e=>e.which-13||alert(t.value);f=a=>t.value=a;

10 Bytes dank Jörg Hülsermann und 2 Bytes dank Luke.

onkeyup=e=>e.which-13||alert(t.value);f=a=>t.value=a;

f("Remove Me");

<input id=t>

Python 2 , 275 200 Bytes

Kein Gewinner, aber hier ist es:

from msvcrt import*
s=list(input())[::-1]
c=i=0
def p(a):print''.join(a)[::-1]
while'\r'!=c:p(s[:i]+['<']+s[i:]);c=getch();x=c!='\b';exec["s[i:i+1-x]=c*x","i=(i-1+2*(c<'\\t'))%-~len(s)"][x*' '>c]
p(s)

Erläuterung:

Dies funktioniert durch Umkehren der Eingabe (mit [::-1]) und Ausschließen und Einfügen von Zeichen in diese umgekehrte Eingabe, sodass sich der Cursor nicht bewegen muss. Kehrt es beim Drucken erneut um.

Verwendung:

[Tab] -Taste zum Bewegen nach rechts
[Strg + C] zum Bewegen nach links
[Backspace] zum Löschen von
[Return] zum Beenden der Bearbeitung
Jede andere Taste wird in den Text eingefügt

Beispiel:

Am Beispiel von OP

In: Just some text
 Just some text>
 Just some> text  Benutzer drückt Ctrl+Cfünfmal
 Just > text  Benutzer drückt Backspaceviermal
 Just any> text  Benutzer drückt  Benutzer drückt Out:any
 Just any> text Enter
Just any text

Inline Editor Version:

Wenn der Text inline bearbeitet werden soll, fügen Sie ,'\r',am Ende der printAnweisung Folgendes hinzu :

def p(a):print''.join(a)[::-1],'\r',

C + NCURSES, 573 Bytes

#include <curses.h>
i;j;k;s;c;p;int main(a,b)char**b;{char*q;char t[999];if(a&&(q=b[1]))while(*q)t[s++]=*q++;i=s;initscr();noecho();keypad(stdscr,1);do{for(j=0;j<i;j++)addch(t[j]);addch('|');for(j=i;t[j];j++)addch(t[j]);c=getch();switch(c){case KEY_LEFT:if(i)i--;break;case KEY_RIGHT:if(i<s)i++;break;case 8:case 127:case KEY_BACKSPACE:if(i){for(k=i-1;k<s;k++)t[k]=t[k+1];i--;s--;}break;case KEY_DC:if(i<s){for(k=i;k<s;k++)t[k]=t[k+1];s--;}break;default:if(c>31&c<127){for(k=s;k>i;k--)t[k]=t[k-1];t[i]=c;i++;s++;}}clear();}while(c!=10);printw(t);getch();endwin();return 0;}

Prüfung

• Kompilieren und mit Eingabe ausführen Just some text.

• Drücken Sie neunmal die Nach-links-Taste.

• Drücken Sie die Entf-Taste viermal.

• Drücken Sie adann ndann y.

• Drücken Sie Enterzum Beenden.

Detailliert

#include <curses.h>

int main(int argc, char ** argv)
{
    char*q = 0;
    char t[999] = {0};
    int j = 0, k = 0;
    int i = 0; // cursor before first char
    int s = 0; // current size
    int c = 0; // current input
    int p = 0;

    // copy first command-line argument
    if(argc>0 && (q=argv[1]))while(*q)t[s++]=*q++; i=s;

    initscr(); // initiate NCURSES
    noecho(); // input does not echo on entry
    keypad(stdscr,TRUE); // handle all input

    do
    {
        // print current content with cursor
        for(j=0;j<i;j++) addch(t[j]);
        addch('|'); for(j=i;t[j];j++) addch(t[j]);

//      printw("\n\n> key %d pressed",c); // debug

        c = getch(); // read next char

        switch(c)
        {
            case KEY_LEFT: // left arrow; cursor left
            if(i > 0) i--;
            break;

            case KEY_RIGHT: // right arrow; cursor right
            if(i < s) i++;
            break;

            case 8: // backspace; remove previous char
            case 127:
            case KEY_BACKSPACE:
            if(i > 0)
            {
                for(k=i-1; k<s; k++) t[k]=t[k+1];
                i--;s--;
            }
            break;

            case KEY_DC: // delete; remove next char
            if(i < s)
            {
                for(k=i; k<s; k++) t[k]=t[k+1];
                s--;
            }
            break;

            default: // none of the above

            if(c > 31 && c < 127) // printable char
            {
                for(k=s; k>i; k--) t[k]=t[k-1];
                t[i] = c;i++;s++;
            }
        }

        clear(); // clear screen
        if(c == 10) break;
    }
    while(c);

    addch('\n');
    printw(t); // print final result
    getch(); // wait for any input
    endwin();
    return 0;
}

VBScript, 23 bis 40 Bytes

MsgBox InputBox("",,Wscript.Arguments(0))

C #, 53 Bytes

s=>{SendKeys.SendWait(s);return Console.ReadLine();};

Wo sist eine Zeichenfolge zu ändern und die Ausgabe ist der neue Wert.

SendKeys.SendWait : Sendet die angegebenen Schlüssel an die aktive Anwendung und wartet darauf, dass die Nachrichten verarbeitet werden.

oder 74 Byte, wenn wir uns nicht in einem Windows Forms-Kontext befinden:

s=>{System.Windows.Forms.SendKeys.SendWait(s);return Console.ReadLine();};

Ruby, 9 19 22 84 Bytes

->s{r=Readline;r.pre_input_hook=->{r.insert_text s;r.redisplay};r.readline}

Dadurch wird ein Readline-Pre-Input-Hook erstellt, der den Text einfügt und dann erneut anzeigt. Danach wird irb durcheinander gebracht, also stelle sicher, dass dies von einer Datei ausgeführt wird. Wird als Lambda ausgeführt, wird die Eingabezeichenfolge als Argument verwendet und die Ausgabezeichenfolge zurückgegeben.

puts Readline.readline

Hierbei wird die Readline-Bibliothek zum Bearbeiten von Zeilen verwendet. Meine vorherige Antwort erlaubte nur Leerzeichen.

puts gets

Das ist wirklich, wirklich selbsterklärend.

Edit: Ich wurde um eine Erklärung gebeten. Dies ist äquivalent zu puts(gets). getsgibt einen String mit einem Zeileneditor ein. putsgibt es aus.

PHP + HTML, 26 Bytes

<input value=<?=$_GET[0]?>

Der Browser fügt das schließende Tag automatisch hinzu

$ _GET Verwenden einer URL wie http://example.com?0=inputals Eingabe Erstellt in einem HTML<input value=input

Und dies ist die Ausgabe für die Zeichenfolge-Eingabe

<input value=input

Tcl, 17

puts [gets stdin]

Online-Dolmetscher saugen nur, um es zu demonstrieren, dann zeige ich einige Bilder von einer Windows-Befehlsshell:

Testfall 1

Testfall 2

AHK , 32 Bytes

InputBox,s,,,,,,,,,,%1%
Send,%s%

InputBoxspeichert alles, was als Variable eingegeben wurde, sund gibt eine Startaufforderung für die Variable aus, bei 1der es sich um den ersten übergebenen Parameter handelt.
Sendsendet Tastatureingaben an das aktuelle Fenster. In diesem Fall ist es der Inhalt von s.
MsgBoxwar eine Option, aber zum Golfen Sendist 2 Bytes kürzer.

Excel VBA-Direktfenster-Befehl - 22 Byte

[a1]=inputbox(0,,[a1])

ZX Spectrum BASIC, 7 Bytes

Trivial, der Vollständigkeit halber enthalten ( INPUTund jeweils PRINTein Byte-Token).

INPUT a$: PRINT a$

SmileBASIC, 138 Bytes

DEF E S@L
WAIT
B=BUTTON(1)C=C-(B==4&&C)+(B>7&&C<LEN(S))I$=INKEY$()IF"\u0008"<I$THEN B=I$<"\u000E"S=SUBST$(S,C,B,I$*!B)?S?" "*C;1IF"\u0008"!=I$GOTO@L
END

Erzeugt eine Funktion E mit 1 Argument und 0 Ausgängen. (Ausgabe wird in der Konsole angezeigt)

Die maskierten Zeichen sollten die eigentlichen Symbole sein, aber sie würden hier nicht angezeigt.

Kontrollen:

Normal keys: Insert a character before the cursor.
Enter: Delete the character at the cursor.
Backspace: Submit.
D-pad left: Move cursor left.
All buttons except up, down, and left on the d-pad: Move cursor right.

Das Einfügen / Löschen von Zeichen ist rückwärts, daher ist die Verwendung sehr ärgerlich (sollte aber dennoch die Anforderungen erfüllen).

Just some text
1             
'(press right 5 times)
Just some text
     1
'(press enter 4 times)
Just  text
     1
'(press a)
Just a text
     1
'(press right)
Just a text
      1
'(...)
Just any text
       1
'(press backspace)

Windows-Befehlsinterpreter, 16 Byte

set/pa=
echo %a%

Das ist sehr trivial; der befehlsinterpreter ist quasi ein "zeileneditor".

Commodore BASIC (C64Mini, C64 / 128, VIC-20 usw.) 179 tokenisierte BASIC-Bytes

Dies sollte im Geschäftsmodus eingegeben werden (Groß- / Kleinschreibung)

 0a$="Just some text":?"{SHIFT+CLR/HOME}"a$"_":fOi=0to1step0:getk$:on-(k$<>"")goS2:goS1:nE
 1?"{CTRL+N}{CLR/HOME}"a$"_  ";:return
 2ifasc(k$)<>20thena$=a$+k$:on-(asc(k$)=13)goS4:return
 3if-(len(a$))thena$=leF(a$,len(a$)-1):goS4:return
 4?"{ARROW LEFT}{ARROW LEFT}{ARROW LEFT}  ":return

Ermöglicht grundlegende Textbearbeitung + Löschen + Neue Zeile. Die maximale Größe a$aller Zeichenfolgen in Commodore BASIC beträgt 255 Zeichen. Wenn Sie also mehr Zeichen eingeben, stürzt das Programm ab. Ich werde einen Weg finden, um> 255 Zeichen zu machen, wenn das nötig ist.