Come posso usare goto in Javascript?

Ho del codice che devo assolutamente implementare usando goto. Ad esempio, voglio scrivere un programma come questo:

start:
alert("RINSE");
alert("LATHER");
repeat: goto start

C'è un modo per farlo in Javascript?

Assolutamente! Esiste un progetto chiamato Summer of Goto che ti consente di utilizzare JavaScript al massimo delle sue potenzialità e rivoluzionerà il modo in cui puoi scrivere il tuo codice.

Questo strumento di preelaborazione JavaScript consente di creare un'etichetta e quindi di andare su di essa utilizzando questa sintassi:

[lbl] <label-name>
goto <label-name>

Ad esempio, l'esempio nella domanda può essere scritto come segue:

[lbl] start:
alert("LATHER");
alert("RINSE");
[lbl] repeat: goto start;

Nota che non sei limitato a semplici programmi banali come un LATHER RINSEciclo di ripetizione senza fine , le possibilità offerte gotosono infinite e puoi persino inviare un Hello, world!messaggio alla console JavaScript 538 volte, in questo modo:

var i = 0;
[lbl] start:
console.log("Hello, world!");
i++;
if(i < 538) goto start;

Puoi leggere di più su come viene implementato goto , ma sostanzialmente fa un po 'di preelaborazione JavaScript che sfrutta il fatto che puoi simulare un goto con un ciclo etichettatowhile . Quindi, quando scrivi "Ciao, mondo!" programma sopra, viene tradotto in qualcosa del genere:

var i = 0;
start: while(true) {
  console.log("Hello, world!");
  i++;
  if(i < 538) continue start;
  break;
}

Vi sono alcune limitazioni a questo processo di preelaborazione, poiché mentre i loop non possono estendersi su più funzioni o blocchi. Non è un grosso problema, però: sono sicuro che i vantaggi di poter trarre vantaggio da gotoJavaScript ti sopraffarranno.

Tutti i link sopra che portano alla libreria goto.js sono TUTTI MORTI, ecco i link necessari:

goto.js (non compresso) --- parseScripts.js (non compresso)

Da Goto.js :

PS Per chiunque si stia chiedendo (finora un totale di zero persone), Summer of Goto è un termine reso popolare da Paul Irish, mentre discute di questo copione e della decisione di PHP di aggiungere goto nella loro lingua.

E per coloro che non riconoscono immediatamente che tutta questa faccenda è uno scherzo, ti prego di perdonarmi. <- (assicurazione).

No. Non includevano quello in ECMAScript:

ECMAScript non ha alcuna dichiarazione goto.

In realtà, vedo che ECMAScript (JavaScript) INDEED ha un'istruzione goto. Tuttavia, il goto JavaScript ha due gusti!

I due tipi di JavaScript di goto sono chiamati etichettati continue ed etichettati break. Non esiste una parola chiave "goto" in JavaScript. Il goto viene realizzato in JavaScript utilizzando le parole chiave break e continue.

E questo è più o meno esplicitamente dichiarato sul sito Web w3schools qui http://www.w3schools.com/js/js_switch.asp .

Trovo che la documentazione dell'etichetta etichettata continui e sia etichettata in modo alquanto scomodo.

La differenza tra la continuazione etichettata e l'interruzione etichettata è dove possono essere utilizzati. L'etichetta continuata può essere utilizzata solo all'interno di un ciclo while. Vedi w3schools per qualche informazione in più.

===========

Un altro approccio che funzionerà è quello di avere una dichiarazione while gigante con una dichiarazione switch gigante all'interno:

while (true)
{
    switch (goto_variable)
    {
        case 1:
            // some code
            goto_variable = 2
            break;
        case 2:
            goto_variable = 5   // case in etc. below
            break;
        case 3:
            goto_variable = 1
            break;

         etc. ...
    }

}

Nel classico JavaScript è necessario utilizzare i cicli do-while per ottenere questo tipo di codice. Presumo che tu stia forse generando codice per qualcos'altro.

Il modo per farlo, come per il backtecode di bytecode su JavaScript, è avvolgere ogni target di etichetta in un do-while "etichettato".

LABEL1: do {
  x = x + 2;
  ...
  // JUMP TO THE END OF THE DO-WHILE - A FORWARDS GOTO
  if (x < 100) break LABEL1;
  // JUMP TO THE START OF THE DO WHILE - A BACKWARDS GOTO...
  if (x < 100) continue LABEL1;
} while(0);

Ogni ciclo do-while etichettato che usi in questo modo crea effettivamente i due punti etichetta per l'etichetta. Uno nella parte superiore e uno alla fine del ciclo. Salta indietro usa continua e salta avanti usa pausa.

// NORMAL CODE

MYLOOP:
  DoStuff();
  x = x + 1;
  if (x > 100) goto DONE_LOOP;
  GOTO MYLOOP;


// JAVASCRIPT STYLE
MYLOOP: do {
  DoStuff();
  x = x + 1;
  if (x > 100) break MYLOOP;
  continue MYLOOP;// Not necessary since you can just put do {} while (1) but it     illustrates
} while (0)

Sfortunatamente non c'è altro modo per farlo.

Codice di esempio normale:

while (x < 10 && Ok) {
  z = 0;
  while (z < 10) {
    if (!DoStuff()) {
      Ok = FALSE;
      break;
    }
    z++;
  }
  x++;
} 

Quindi supponiamo che il codice venga codificato in bytecode quindi ora è necessario inserire i bytecode in JavaScript per simulare il backend per qualche scopo.

Stile JavaScript:

LOOP1: do {
  if (x >= 10) break LOOP1;
  if (!Ok) break LOOP1;
  z = 0;
  LOOP2: do {
    if (z >= 10) break LOOP2;
    if (!DoStuff()) {
      Ok = FALSE;
      break LOOP2;
    }
    z++;
  } while (1);// Note While (1) I can just skip saying continue LOOP2!
  x++;
  continue LOOP1;// Again can skip this line and just say do {} while (1)
} while(0)

Quindi, usando questa tecnica, il lavoro va bene per scopi semplici. A parte quello non puoi fare molto altro.

Per il normale Javacript non dovresti mai usare goto, quindi dovresti probabilmente evitare questa tecnica qui a meno che tu non stia traducendo specificamente altro codice di stile per essere eseguito su JavaScript. Suppongo che sia così che ottengano l'avvio del kernel Linux in JavaScript, ad esempio.

NOTA! Questa è tutta una spiegazione ingenua. Per il corretto back-end J dei bytecode, considerare anche di esaminare i loop prima di emettere il codice. Molti semplici loop continui possono essere rilevati come tali e quindi è possibile utilizzare i loop anziché goto.

Questa è una vecchia domanda, ma dal momento che JavaScript è un obiettivo mobile - è possibile in ES6 l'implementazione che supporti le chiamate di coda appropriate. Nelle implementazioni con supporto per le chiamate di coda appropriate, è possibile disporre di un numero illimitato di chiamate di coda attive (ovvero le chiamate di coda non "aumentano lo stack").

A gotopuò essere pensato come una chiamata di coda senza parametri.

L'esempio:

start: alert("RINSE");
       alert("LATHER");
       goto start

può essere scritto come

 function start() { alert("RINSE");
                    alert("LATHER");
                    return start() }

Qui la chiamata a startè nella posizione di coda, quindi non ci saranno overflow dello stack.

Ecco un esempio più complesso:

 label1:   A
           B
           if C goto label3
           D
 label3:   E
           goto label1

Innanzitutto, abbiamo diviso la fonte in blocchi. Ogni etichetta indica l'inizio di un nuovo blocco.

 Block1
     label1:   A
               B
               if C goto label3
               D

  Block2    
     label3:   E
               goto label1

Dobbiamo legare insieme i blocchi usando goto. Nell'esempio il blocco E segue D, quindi aggiungiamo un goto label3dopo D.

 Block1
     label1:   A
               B
               if C goto label2
               D
               goto label2

  Block2    
     label2:   E
               goto label1

Ora ogni blocco diventa una funzione e ogni goto diventa una chiamata di coda.

 function label1() {
               A
               B
               if C then return( label2() )
               D
               return( label2() )
 }

 function label2() {
               E
               return( label1() )
 }

Per avviare il programma, utilizzare label1().

La riscrittura è puramente meccanica e può quindi essere eseguita con un sistema macro come sweet.js, se necessario.

const
    start = 0,
    more = 1,
    pass = 2,
    loop = 3,
    skip = 4,
    done = 5;

var label = start;


while (true){
    var goTo = null;
    switch (label){
        case start:
            console.log('start');
        case more:
            console.log('more');
        case pass:
            console.log('pass');
        case loop:
            console.log('loop');
            goTo = pass; break;
        case skip:
            console.log('skip');
        case done:
            console.log('done');

    }
    if (goTo == null) break;
    label = goTo;
}

Che ne dici di un forloop? Ripeti tutte le volte che vuoi. O un whileciclo, ripetere fino a quando non viene soddisfatta una condizione. Ci sono strutture di controllo che ti permetteranno di ripetere il codice. Ricordo GOTOin Basic ... ha fatto un codice così cattivo! I moderni linguaggi di programmazione ti offrono le migliori opzioni che puoi effettivamente mantenere.

C'è un modo per farlo, ma deve essere pianificato con cura. Prendiamo ad esempio il seguente programma QBASIC:

1 A = 1; B = 10;
10 print "A = ",A;
20 IF (A < B) THEN A = A + 1; GOTO 10
30 PRINT "That's the end."

Quindi crea il tuo JavaScript per inizializzare prima tutte le variabili, seguito da una chiamata di funzione iniziale per avviare il rotolamento della palla (eseguiamo questa chiamata di funzione iniziale alla fine) e imposta le funzioni per ogni set di linee in cui sai che verrà eseguito l'unica unità.

Seguilo con la chiamata di funzione iniziale ...

var a, b;
function fa(){
    a = 1;
    b = 10;
    fb();
}
function fb(){
    document.write("a = "+ a + "<br>");
    fc();
}
function fc(){
    if(a<b){
        a++;
        fb();
        return;
    }
    else
    {
    document.write("That's the end.<br>");
    }
}
fa();

Il risultato in questo caso è:

a = 1
a = 2
a = 3
a = 4
a = 5
a = 6
a = 7
a = 8
a = 9
a = 10
That's the end.

In generale, preferirei non utilizzare GoTo per una cattiva leggibilità. Per me, è una brutta scusa per programmare semplici funzioni iterative invece di dover programmare funzioni ricorsive, o anche meglio (se si temono cose come Stack Overflow), le loro vere alternative iterative (che a volte possono essere complesse).

Qualcosa del genere farebbe:

while(true) {
   alert("RINSE");
   alert("LATHER");
}

Proprio così c'è un ciclo infinito. L'espressione ("vero") all'interno delle parentesi della clausola while è ciò che il motore Javascript verificherà e, se l'espressione è vera, manterrà il ciclo in esecuzione. Scrivere "vero" qui viene sempre valutato come vero, quindi un ciclo infinito.

Certo, usando il switchcostrutto puoi simulare gotoin JavaScript. Sfortunatamente, la lingua non fornisce goto, ma questo è abbastanza buono come sostituto.

let counter = 10
function goto(newValue) {
  counter = newValue
}
while (true) {
  switch (counter) {
    case 10: alert("RINSE")
    case 20: alert("LATHER")
    case 30: goto(10); break
  }
}

Probabilmente si dovrebbe leggere alcuni tutorial JS come questo uno .

Non sono sicuro che gotoesista in JS, ma, in ogni caso, incoraggia uno stile di codifica errato e dovrebbe essere evitato.

Potresti fare:

while ( some_condition ){
    alert('RINSE');
    alert('LATHER');
}

Puoi semplicemente usare una funzione:

function hello() {
    alert("RINSE");
    alert("LATHER");
    hello();
}

Per ottenere funzionalità simili a goto mantenendo pulito lo stack di chiamate, sto usando questo metodo:

// in other languages:
// tag1:
// doSomething();
// tag2:
// doMoreThings();
// if (someCondition) goto tag1;
// if (otherCondition) goto tag2;

function tag1() {
    doSomething();
    setTimeout(tag2, 0); // optional, alternatively just tag2();
}

function tag2() {
    doMoreThings();
    if (someCondition) {
        setTimeout(tag1, 0); // those 2 lines
        return;              // imitate goto
    }
    if (otherCondition) {
        setTimeout(tag2, 0); // those 2 lines
        return;              // imitate goto
    }
    setTimeout(tag3, 0); // optional, alternatively just tag3();
}

// ...

Si noti che questo codice è lento poiché le chiamate di funzione vengono aggiunte alla coda dei timeout, che viene valutata in seguito, nel ciclo di aggiornamento del browser.

Si noti inoltre che è possibile passare argomenti (utilizzando setTimeout(func, 0, arg1, args...)nel browser più recente di IE9 o setTimeout(function(){func(arg1, args...)}, 0)nei browser meno recenti.

AFAIK, non dovresti mai imbatterti in un caso che richiede questo metodo a meno che non sia necessario mettere in pausa un ciclo non parallelabile in un ambiente senza supporto asincrono / attendi.

vai all'inizio e alla fine di tutte le chiusure dei genitori

var foo=false;
var loop1=true;
LABEL1: do {var LABEL1GOTO=false;
    console.log("here be 2 times");
    if (foo==false){
        foo=true;
        LABEL1GOTO=true;continue LABEL1;// goto up
    }else{
        break LABEL1; //goto down
    }
    console.log("newer go here");
} while(LABEL1GOTO);

// example of goto in javascript:

var i, j;
loop_1:
    for (i = 0; i < 3; i++) { //The first for statement is labeled "loop_1"
        loop_2:
            for (j = 0; j < 3; j++) { //The second for statement is labeled "loop_2"
                if (i === 1 && j === 1) {
                    continue loop_1;
                }
                console.log('i = ' + i + ', j = ' + j);
            }
        }

Un altro modo alternativo per ottenere lo stesso è usare le chiamate di coda. Ma non abbiamo nulla di simile in JavaScript. Quindi, generalmente, il goto viene realizzato in JS usando le due parole chiave seguenti. interrompi e continua , riferimento: Vai a Dichiarazione in JavaScript

Ecco un esempio:

var number = 0;
start_position: while(true) {
document.write("Anything you want to print");
number++;
if(number < 100) continue start_position;
break;
}