Comment puis-je utiliser goto en Javascript?

Absolument! Il existe un projet L'été de Goto qui permet l'utilisation de JavaScript à son plein potentiel et va révolutionner la façon dont vous pouvez écrire votre code.

Ce JavaScript prétraitement outil vous permet de créer une étiquette, puis goto à l'aide de cette syntaxe:

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

Par exemple, l'exemple de la question peut être écrit comme suit:

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

Notez que vous ne sont pas seulement limitée à la simple programmes comme un infini LATHER RINSE répétition du cycle—les possibilités offertes par les goto sont infinies et vous pouvez même faire une Hello, world! message à la console JavaScript 538 fois, comme ceci:

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

Vous pouvez lire plus sur comment goto est mis en œuvre, mais, fondamentalement, il fait un peu de JavaScript prétraitement qui tire profit du fait que vous pouvez simuler un goto avec un étiquetés while de la boucle. Donc, quand vous écrivez "Hello, world!" programme ci-dessus, il est traduit à quelque chose comme ceci:

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

Il y a certaines limites à ce processus de prétraitement, parce que tandis que les boucles ne peuvent pas s'étendent à travers de multiples fonctions ou des blocs. Ce n'est pas une grosse affaire, mais—je suis sûr que les avantages d'être en mesure de prendre avantage de goto en JavaScript sera absolument vous accabler.

Tout lien ci-dessus qui conduisent à goto.js la bibliothèque est TOUS MORTS, voici les liens nécessaires:

goto.js (non compressé) --- parseScripts.js (non compressé)

De Goto.js:

P. S. Pour ceux qui se poseraient la question (à ce jour, un total de zéro personnes), l'Été de Goto est un terme qui a été popularisé par Paul Irish, tout en discutant de ce script et PHP à la décision d'ajouter goto dans leur langue.

Et pour ceux qui ne reconnaissent pas immédiatement que cette chose entière est une blague, s'il vous plaît pardonnez-moi. <—(assurance).

En fait, je vois que ECMAScript (JavaScript) N'ont, en EFFET, une instruction goto. Cependant, le JavaScript goto a deux saveurs!

Les deux JavaScript saveurs de goto sont appelés marqué continuer et étiquetés pause. Il n'y a pas de mot-clé "goto" en JavaScript. Le goto est réalisée en JavaScript à l'aide de la pause et de continuer de mots clés.

Et c'est plus ou moins explicitement sur le site w3schools ici http://www.w3schools.com/js/js_switch.asp.

Je trouver de la documentation de la étiquetés continuer et étiquetés casser un peu maladroitement exprimé.

La différence entre la borne continuer et marqué de pause où ils peuvent être utilisés. L'étiquette de poursuivre ne peut être utilisé à l'intérieur d'une boucle while. Voir w3schools pour plus d'information.

===========

Une autre approche de travail est de disposer d'un géant de l'instruction while avec un géant de l'instruction switch à l'intérieur:

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. ...
    }

}

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;
}

Un for boucle? Répétez autant de fois que vous le souhaitez. Ou un while boucle, répéter jusqu'à ce qu'une condition est remplie. Il y a des structures de contrôle qui vous permettra de répéter le code. Je me souviens GOTO de Base... il fait si mauvais code! Langages de programmation modernes vous donner de meilleures options que vous pouvez réellement maintenir.

En général, je préfère ne pas utiliser GoTo pour les mauvaises raisons de lisibilité. Pour moi, c'est une mauvaise excuse pour une programmation simple itératif fonctions au lieu d'avoir à programmer des fonctions récursives, ou mieux encore (si des choses comme un Débordement de la Pile est à craindre), leur vraie itératif alternatives (qui peut parfois être complexe).

Quelque chose comme cela ferait:

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

Qu'à droite il y a une boucle infinie. L'expression ("true") à l'intérieur de la parenthèse de l'tandis que la clause est ce que le moteur Javascript vérifie - et si l'expression est vraie, il va garder la boucle en cours d'exécution. L'écriture de "vrai" ici renvoie toujours true, donc une boucle infinie.

Vous devriez lire quelques JS tutoriels comme ce un.

Ne sais pas si goto existe en JS, mais, de toute façon, il encourage les mauvais style de codage et doit être évitée.

Que vous pouvez faire:

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

Pour atteindre goto fonctionnalités tout en gardant la pile d'appel propre, je suis en utilisant cette méthode:

//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();
}

//...

Veuillez noter que ce code est lente car les appels de fonction sont ajoutés aux délais d'attente file d'attente, qui est évaluée à plus tard, dans le navigateur de mise à jour de boucle.

Veuillez également noter que vous pouvez passer des arguments (à l'aide de setTimeout(func, 0, arg1, args...) dans le navigateur plus récent que IE9, ou setTimeout(function(){func(arg1, args...)}, 0) dans les navigateurs plus anciens.

Autant que je sache, vous ne devriez jamais couru dans une affaire qui exige cette méthode, sauf si vous avez besoin de mettre en pause un non-parallelable boucle dans un environnement sans async/await soutien.

//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);
            }
        }