tablas - ¿Cómo puedo usar goto en Javascript?

obtener datos de una tabla html javascript

Question

Tengo un código que debo implementar usando goto . Por ejemplo, quiero escribir un programa como este:

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

¿Hay alguna manera de hacer eso en Javascript?

Answer 1

¡Absolutamente! Hay un proyecto llamado Summer of Goto que le permite usar JavaScript en todo su potencial y revolucionará la forma en que puede escribir su código.

Esta herramienta de preprocesamiento de JavaScript le permite crear una etiqueta y luego ir a ella usando esta sintaxis:

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

Por ejemplo, el ejemplo en la pregunta se puede escribir de la siguiente manera:

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

Tenga en cuenta que no solo se limita a programas sencillos y triviales como un ciclo de repetición de RINSE LATHER sin fin: las posibilidades que ofrece goto son infinitas e incluso puede crear un Hello, world! mensaje a la consola de JavaScript 538 veces, como este:

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

Puede leer más acerca de cómo se implementa goto , pero básicamente, realiza un preprocesamiento de JavaScript que aprovecha el hecho de que puede simular un goto con un ciclo While etiquetado . Entonces, cuando escribas "¡Hola, mundo!" programa anterior, se traduce a algo como esto:

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

Existen algunas limitaciones en este proceso de preprocesamiento, ya que los bucles while no pueden extenderse a través de múltiples funciones o bloques. Sin embargo, eso no es gran cosa. Estoy seguro de que los beneficios de poder aprovechar goto en JavaScript te abrumarán.

Todo el enlace anterior que conduce a la biblioteca goto.js está TODO MUERTO, aquí hay enlaces necesarios:

goto.js (sin comprimir) --- parseScripts.js (sin comprimir)

Answer 2

¿Qué tal un bucle for ? Repite tantas veces como quieras. O un ciclo while, repite hasta que se cumpla una condición. Hay estructuras de control que te permitirán repetir el código. Recuerdo GOTO en Basic ... ¡hizo un código tan malo! Los lenguajes de programación modernos le brindan mejores opciones que realmente puede mantener.

Answer 3

Claro, usando la construcción del switch puedes simular goto en JavaScript. Desafortunadamente, el lenguaje no proporciona goto , pero este es un reemplazo suficientemente bueno.

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

Answer 4

En el JavaScript clásico necesitas usar los bucles do-while para lograr este tipo de código. Supongo que quizás estés generando código para otra cosa.

La forma de hacerlo, como el código de bytes back-end de JavaScript, es ajustar cada objetivo de etiqueta en un "do-while" etiquetado.

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

Cada bucle do-while etiquetado que se usa así crea realmente los dos puntos de etiqueta para una etiqueta. Uno en la parte superior y uno al final del ciclo. Los usos de salto continúan y los saltos hacia adelante utilizan el descanso.

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

Desafortunadamente no hay otra manera de hacerlo.

Código de ejemplo normal:

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

Entonces, digamos que el código se codifica en bytecodes, por lo que ahora debe poner los códigos de bytes en JavaScript para simular su back-end para algún propósito.

Estilo de 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)

Entonces, usar esta técnica funciona bien para propósitos simples. Aparte de eso, no hay mucho más que puedas hacer.

Para Javacript normal no debería necesitar usar goto alguna vez, por lo que probablemente debería evitar esta técnica aquí a menos que esté traduciendo específicamente otro código de estilo para ejecutar en JavaScript. Supongo que así es como consiguen que el kernel de Linux arranque en JavaScript, por ejemplo.

¡NOTA! Esto es una explicación ingenua. Para una adecuada J-back-end de bytecodes, también considere examinar los bucles antes de dar salida al código. Muchos bucles de tiempo simples pueden detectarse como tales y luego puede usar bucles en lugar de goto.

Answer 5

En general, preferiría no utilizar GoTo para una mala legibilidad. Para mí, es una mala excusa para programar funciones iterativas simples en lugar de tener que programar funciones recursivas, o incluso mejor (si se teme a un desbordamiento de pila), sus verdaderas alternativas iterativas (que a veces pueden ser complejas).

Algo como esto haría:

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

Eso justo allí es un bucle infinito. La expresión ("verdadero") dentro de la parantheses de la cláusula while es lo que verificará el motor de Javascript, y si la expresión es verdadera, mantendrá el ciclo en funcionamiento. Escribir "verdadero" aquí siempre se evalúa como verdadero, por lo tanto, un ciclo infinito.

Answer 6

En realidad, veo que ECMAScript (JavaScript) HACE INDEED tiene una declaración goto. Sin embargo, ¡el JavaScript goto tiene dos sabores!

Los dos sabores de JavaScript de goto se llaman etiquetados Continuar y Rotulado. No hay una palabra clave "goto" en JavaScript. El goto se realiza en JavaScript utilizando las palabras clave break y continue.

Y esto se afirma más o menos explícitamente en el sitio web w3schools aquí http://www.w3schools.com/js/js_switch.asp .

Encuentro que la documentación de la etiqueta continúa y la rotulación etiquetada es algo torpemente expresada.

La diferencia entre el rotulo etiquetado continuar y etiquetado es donde se pueden usar. La etiqueta continuar solo puede usarse dentro de un ciclo while. Ver w3schools para más información.

===========

Otro enfoque que funcionará es tener una declaración gigante al mismo tiempo con una declaración de cambio gigante dentro:

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

Answer 7

Esta es una vieja pregunta, pero dado que JavaScript es un objetivo en movimiento, es posible en ES6 en la implementación que sea compatible con las llamadas de cola adecuadas. En implementaciones con soporte para llamadas de cola adecuadas, puede tener un número ilimitado de llamadas de cola activas (es decir, las llamadas de cola no "aumentan la pila").

Un goto se puede considerar como una llamada final sin parámetros.

El ejemplo:

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

Se puede escribir como

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

Aquí la llamada para start está en posición de cola, por lo que no habrá desbordamientos de pila.

Aquí hay un ejemplo más complejo:

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

Primero, dividimos la fuente en bloques. Cada etiqueta indica el comienzo de un nuevo bloque.

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

Necesitamos unir los bloques usando gotos. En el ejemplo, el bloque E sigue a D, por lo que agregamos una goto label3 después de D.

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

Ahora cada bloque se convierte en una función y cada giro se convierte en una llamada final.

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

Para iniciar el programa, use label1() .

La reescritura es puramente mecánica y, por lo tanto, se puede hacer con un macro sistema como sweet.js si es necesario.

Answer 8

Hay una forma de hacerlo, pero debe planificarse cuidadosamente. Tomemos como ejemplo el siguiente programa 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."

Luego, cree su JavaScript para inicializar todas las variables primero, luego realice una llamada de función inicial para comenzar a rodar la bola (ejecutamos esta llamada de función inicial al final) y configure las funciones para cada conjunto de líneas que usted sepa que se ejecutarán en la unidad.

Siga esto con la llamada de función inicial ...

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

El resultado en esta instancia es:

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

Answer 9

Ir al principio y al final de todos los cierres de padres

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

Answer 10

No. No incluyeron eso en ECMAScript:

ECMAScript no tiene una declaración goto.

Answer 11

Para lograr una funcionalidad tipo Goto mientras se mantiene limpia la pila de llamadas, estoy usando este método:

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

Tenga en cuenta que este código es lento ya que las llamadas a función se agregan a la cola de espera, que se evalúa más tarde, en el ciclo de actualización del navegador.

Tenga en cuenta también que puede pasar argumentos (utilizando setTimeout(func, 0, arg1, args...) en el navegador más nuevo que IE9, o setTimeout(function(){func(arg1, args...)}, 0) en navegadores más antiguos.

AFAIK, nunca deberías toparte con un caso que requiera este método a menos que necesites pausar un bucle no paralelo en un entorno sin soporte async / await.

Answer 12

Probablemente deberías leer algunos tutoriales de JS como este.

No estoy seguro si existe goto en JS, pero, de cualquier forma, fomenta el mal estilo de codificación y debe evitarse.

Podrías hacerlo:

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

Answer 13

Puedes usar una función simple:

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

Answer 14

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