Con frecuencia, la lógica que resuelve el problema no se ajusta al flujo estándar de las estructuras iterativas. Por esa razón, la mayoría de los lenguajes (incluido JavaScript), cuentan con comandos que permiten alterar el flujo normal de las estructuras de control.
Dos de estos modificadores son: break y continue. El comando break, interrumpe inmediatamente la ejecución del ciclo y sale de la estructura iterativa. Continue, igualmente, interrumpe inmediatamente la ejecución del ciclo actual, pero no sale de la estructura iterativa, sino que pasa a ejecutar el siguiente ciclo de la estructura.
Aunque no son modificadores propiamente, los comandos return y throw, interrumpen igualmente la ejecución de cualquier estructura, por lo que pueden ser empleados para interrumpir, inmediatamente, la ejecución de cualquier ciclo o estructura (como se ha visto, por ejemplo, en la estructura switch).
El comando return, no sólo interrumpe la ejecución de la instrucción, sino también el de la función y devuelve el resultado de la misma.
De manera similar, el comando throw, no sólo interrumpe la ejecución de la instrucción, sino que además lanza un error, el cual puede ser atrapado (con catch) en la misma función o fuera de ella.
La modificación más frecuente corresponde a la siguiente lógica:
Es decir que las "instrucciones a" y las instrucciones "b" se repiten mientras la condición es falsa (No), pero la condición de finalización no está ni al principio (while) ni al final (do-while), sino al medio de las instrucciones.
Para implementar esta modificación, se crea un ciclo infinito y en su interior se escribe la condición de finalización, donde se emplea uno de los modificadores: break, return o throw, para salir del ciclo. Un ciclo infinito se crea simplemente escribiendo true en su condición (de esa manera la condición es siempre verdadera y en consecuencia, el ciclo se repite siempre):
while(true) {
instrucciones a
if (condición) [break|return|throw]
instrucciones b
}
do {
instrucciones a
if (condición) [break|return|throw]
instrucciones b
} while(true);
La estructura for cuenta con una sintaxis abreviada para crear un ciclo infinito:
for(;;) {
instrucciones a
if (condición) [break|return|throw]
instrucciones b
}
Tratamiento de errores
Hasta ahora, los errores lanzados en las funciones, han sido atrapados y mostrados por la calculadora JavaScript. En la práctica, esos errores deben ser atrapados en el método (o función) que los genera o, más frecuentemente, en el método o función que llama al método que lanza el error.
Los errores lanzados con throw son atrapado con catch, empleando la estructura try-catch-finally, que tiene la siguiente sintaxis:
Donde instrucciones 1 son las instrucciones que resuelven el problema (las instrucciones que se escriben normalmente para resolver el problema); catch inicia el bloque donde se atrapa el error, siendo "e" el nombre de la variable temporal que guarda el error generado, instrucciones 2 son las instrucciones que se ejecutan cuando se atrapa el error y donde se puede emplear la variable temporal "e"; finally inicia el bloque de instrucciones (instrucciones 3) que se ejecutan siempre, sin importar si se ha lanzado o no un error.
La forma en que opera esta estructura es la siguiente: Si ocurre un error al ejecutar las instrucciones 1 o se ha lanzado un error en esas instrucciones (con throw), la ejecución se detiene y el programa salta al bloque catch, donde el error es atrapado y guardado en la variable "e", entonces se ejecutan las instrucciones 2. Si no se produce ningún error al ejecutar las instrucciones 1, el bloque catch (las instrucciones 2) es ignorado. Finalmente, sin importar si se ha producido o no un error, el programa salta al bloque finally y se ejecutan las instrucciones 3.
En esta estructura sólo es imprescindible uno de los bloques: o catch o finally, así es válida la forma:
Se recalca que si existe el bloque finally, las instrucciones de ese bloque se ejecutan siempre, sin importar si se produce o no un error en el bloque try, mientras que las instrucciones del bloque catch sólo se ejecutan si se produce (o lanza) un error en el bloque try.
Ejemplos
Raíz cuadrada
En este ejemplo, se vuelve a resolver el problema de calcular la raíz cuadrada de un número real positivo, empleando la ecuación iterativa:
Donde, como se puede ver, se asume (como es natural) un valor inicial para "x1" (no para "x2").
Al ser un ciclo infinito, el algoritmo puede ser implementado con cualquiera de las estructuras iterativas, así con la estructura while y el comando break, el código es:
function raizCuadrada(n, x1=1.1) { if (n<0) throw "El número debe ser positivo"; if (n===0 || n===1) return n; let x2; while (true) { x2 = (x1+n/x1)/2; if (Math.abs(x1/x2-1)<1e-10) break; x1 = x2; } return x2; };
Con el cual se obtienen los resultados esperados:
raizCuadrada(2)
raizCuadrada(9.34)
raizCuadrada(1)
raizCuadrada(-7.45)
El código, con la estructura do-while y el comando return, es:
var raizCuadrada = function(n, x1=1.1) { if (n<0) throw "El número debe ser positivo"; if (n===0 || n===1) return n; let x2; do { x2 = (x1+n/x1)/2; if (Math.abs(x1/x2-1)<1e-10) return x2; x1 = x2; } while (true); };
Y con la estructura for y la estructura try-catch, es:
var raizCuadrada = (n, x1=1.1) => { if (n<0) throw "El número debe ser positivo"; try { if (n===0 || n===1) return n; let x2; for (;;) { x2 = (x1+n/x1)/2; if (Math.abs(x1/x2-1)<1e-10) throw x2; x1 = x2; } } catch(e) { return e; } };
En este último ejemplo, para romper el ciclo, se lanza un error (throw), en este caso, el error lanzado es el resultado calculado (x2), ese error (el resultado calculado) es atrapado por catch en la variable e y devuelto como el resultado de la función (lo que es correcto, porque "e" es el resultado calculado: el valor de "x2"). En JavaScript, el comando throw, como se puede ver en este ejemplo, no sólo puede lanzar (devolver) un mensaje error (como se ha hecho en los anteriores capítulos), sino cualquier valor JavaScript válido, así, en este ejemplo, lanza (devuelve) un número (el valor de la raíz cuadrada).
En una aplicación real, la estructura try-catch-finally, no se emplea para romper un ciclo y devolver un resultado, sino para capturar errores y ejecutar código en respuesta a esos errores, sin embargo, estos ejercicios ayudan a comprender como opera esta estructura y a utilizarla posteriormente en el tratamiento de errores.
Legendre enésimo de un número
En este ejemplo, se vuelve a resolver el problema de calcular el Legendre enésimo "n" de un número "x". La ecuación de definición del Legendre es:
En este caso, como es natural, antes de realizar el cambio de variables, se verifica si dicho cambio será necesario, es decir si es necesario una nueva iteración:
El código, empleando las estructuras while y try-catch, es:
function legendre(x, n) { if (n%1!==0) throw "El orden debe ser entero"; if (n<0) throw "El orden debe ser positivo"; try { if (n===0) return 1; if (n===1) return x; let le2, le0=1, le1=x, i=2; while (true) { le2 = (2-1/i)*x*le1-(1-1/i)*le0; if (i===n) throw le2; le0 = le1; le1 = le2; i++; } } catch(e) { return e; } };
Con el cual se obtienen los resultados esperados:
legendre(1.3, 2)
legendre(1.5, 3)
legendre(3.9, 7)
legendre(2.1, 0)
legendre(13.1, 1)
legendre(6.1, 4.5)
legendre(1.1, -3)
Exponente de un número
En este ejemplo, se elabora un método que calcula el exponente de un número "x", aplicando, iterativamente, la siguiente serie de Taylor:
Para resolver este tipo de problemas, se emplea un ciclo iterativo, donde, en cada iteración, se calcula y añade un nuevo término a la serie, hasta que, con el último valor añadido, la serie devuelve el mismo valor (o casi el mismo valor) que en la iteración anterior.
La principal dificultad, para programar una serie de Taylor, radica en deducir la regla para calcular el nuevo término de la serie.
Para ello se deben estudiar las operaciones que permiten calcular un nuevo término en base al anterior. Por ejemplo, para calcular el cuarto término, en base al tercero, se llevan a cabo las siguientes operaciones:
De donde se deduce que, para calcular un nuevo término, se debe multiplicar el término anterior por \(\dfrac{x}{i}\), siendo "i" un contador igual al número del término que está siendo calculado.
Una vez identificada la regla (prácticamente en todas las series) el algoritmo es el mismo: a) Asignar los valores iniciales a las variables; b) Repetir el ciclo, calculando y añadiendo un nuevo término a la serie, hasta que el último y penúltimo valores son iguales o casi iguales; c) Devolver el resultado calculado (llevando a cabo los cálculos adicionales que fueran necesarios).
El diagrama de flujo que resuelve el problema, es:
Donde, en el ciclo, se trabaja con el valor absoluto del número (x=|y|), porque con valores negativos, la serie pasa de tener sólo sumas a tener sumas y restas y cuando se restan números muy grandes (como ocurre en las series), los errores de redondeo son muy grandes, dando lugar a resultados erróneos, por lo que, siempre que sea posible, se deben evitar las restas. De no ser posible, se debe tratar de evitar trabajar con número muy grandes o muy pequeños.
En este caso específico, se puede trabajar con el valores positivos (con el valor absoluto del número) porque, para las potencias se cumple que:
\[ \text{e}^{-x} = \dfrac{1}{\text{e}^x} \]
Se recalca que esta relación (que es una propiedad matemática) es válida únicamente para las potencias, no puede ser aplicada a otros casos (como funciones trigonométricas, por ejemplo).
El código respectivo, empleando la estructura do-while y el comando break, es:
var exponente = y => { if (y === 0) return 1; x = Math.abs(y); let s2, ter = 1, s1 = ter, i = 1; do { ter *= x/i; s2 = s1+ter; if (Math.abs(s1/s2-1)<1e-14) break; s1 = s2; i++; } while (true); return y < 0 ? 1/s2 : s2; };
Llamando a la función, con los valores de prueba, se obtienen los resultados correctos:
exponente(0)
exponente(2)
exponente(3.5)
exponente(4.7)
exponente(-9.2)
Seno de un ángulo en radianes
En este ejemplo se calcula el seno de un ángulo en radianes, empleando la serie de Taylor:
Como en el ejemplo anterior, primero se deduce la regla que permite calcular un nuevo término en base al anterior, analizando las operaciones necesarias para calcular un nuevo término en base al anterior. Por ejemplo, para calcular el tercer término, a partir del segundo, las operaciones son:
De donde se deduce que para calcular un nuevo término, se debe multiplicar el anterior por:
\[ \left(-\dfrac{x^2}{i \cdot j}\right) \]
Donde "i" y "j" son dos contadores que comienzan en 2 y 3 respectivamente y que incrementan de 2 en 2, en cada repetición del ciclo.
En este caso la serie en sí tiene restas, por lo que no es posible evitarlas, entonces, para reducir los errores de redondeo, se debe evitar trabajar con números muy grandes. Dado que las funciones trigonométricas son cíclicas, un ángulo mayor o igual a 360 grados, puede ser reducido a su equivalente entre 0 y 360 grados (entre 0 y 2*π), simplemente calculando el residuo de su división entre 2*π, entonces, con ese residuo, se obtiene el resultado correcto.
El diagrama de flujo que resuelve el problema, tomando en cuenta las anteriores consideraciones, es:
El código respectivo, implementado con la estructura for y el comando break, es:
function seno(a) { let x = Math.abs(a)*180/Math.PI; while (x > 270) x -= 360; x *= Math.PI/180; if (x == 0) return 0; const xx=-x*x; let s2, ter = x, s1 = ter, i = 2, j = 3; for(;;) { ter *= xx/(i*j); s2 = s1+ter; if (Math.abs(s1/s2-1)<1e-14) break; s1 = s2; i += 2; j += 2; } return a < 0 ? -s2 : s2; };
Llamando a las funciones con los valores de prueba, se obtiene:
seno(0)
seno(2.45)
seno(3.22)
seno(56.8)
seno(-83.1)
seno(127.4)
Doble productoria
En este ejemplo se programa un método para calcular el resultado de la siguiente productoria:
La solución de problemas que implican productorias o sumatorias con límites definidos, como en este ejemplo, puede ser implementada directamente con la estructura for (sin necesidad inclusive de un algoritmo): el contador de la productoria es el contador del ciclo, el límite inferior es el valor inicial del contador, el límite superior es el valor final del contador (la condición de finalización del ciclo), la diferencia entre dos valores consecutivos es el incremento del ciclo y la expresión dentro de la productoria (en este ejemplo la raíz cúbica), es la instrucción a programar dentro del ciclo.
Adicionalmente, si se trata de una productoria, el acumulador tiene que iniciar en 1 (el número neutro de la multiplicación), mientras que si es una sumatoria, el acumulador tiene que iniciar en 0 (el número neutro de la suma).
Así, en este ejemplo, al ser dos productorias, se requieren dos ciclos for anidados, con dos acumuladores: "p1" para el ciclo externo y "p2" para el interno. El contador del ciclo externo es "x" y va desde 1 hasta "n", con un incremento de uno en uno, mientras que el contador del ciclo interno es "y" y va desde 1 hasta "m", con un incremento de dos en dos.
El diagram de flujo que resuelve este problema, es:
var dobleProductoria = function(n, m) { if (n === undefined) throw "No ha definido el primer límite."; if (m === undefined) throw "No ha definido el segundo límite."; if (n%1!==0 || m%1!==0) throw "Los números deben ser enteros"; if (n<0 || m<0) throw "Los números deben ser positivos"; let p1 = 1; for (let x = 1; x<=n; x++) { let p2 = 1; for (let y = 1; y<=m; y+=2) p2 *= Math.cbrt(x+y); p1 *= p2; } return p1; };
Como se puede ver, se valida que los límites de las productorias hayan sido establecidos (que no sean valores indefinidos), sean enteros y positivos. Llamando al método con algunos valores de prueba, se obtiene: