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, las instrucciones del bloque catch (las instrucciones 2) son ignoradas. Finalmente, sin importar si se ha producido o no un error, el programa salta al bloque finally y ejecuta 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 añadido directamente como un método de la clase Number, es:
Number.prototype.raizCuadrada = function(x1=1.1) { const n = this.valueOf(); if (n<0) throw new Error("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; };
En este caso, el método no puede ser getter, porque recibe un valor adicional: el valor inicial asumido (x1=1.1). Llamando al método con algunos valores de prueba, se obtiene:
(2).raizCuadrada()
(9.34).raizCuadrada()
(1).raizCuadrada()
(-7.45).raizCuadrada()
El mismo algoritmo implementado con la estructura do-while y el comando return, es:
Number.prototype.raizCuadrada = function(x1=1.1) { const n = this.valueOf(); if (n<0) throw new Error("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:
Number.prototype.raizCuadrada = function(x1=1.1) { const n = this.valueOf(); if (n<0) throw new Error("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) con el resultado calculado (x2), ese error es atrapado por catch en la variable e y devuelto como el resultado de la función. En JavaScript, el comando throw, como se puede ver en este ejemplo, no sólo puede lanzar (devolver) un objeto 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 respectivo, implementado como un método de la clase "Legendre", empleando las estructuras while y try-catch, es:
var Legendre = class {
constructor(número) {
this.num = número;
}
legendre(n=2) {
const x = this.num;
if (n%1!==0) throw new Error("El orden debe ser entero");
if (n<0) throw new Error("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:
(new Legendre(1.3)).legendre(2)
(new Legendre(1.5)).legendre(3)
(new Legendre(3.9)).legendre(7)
(new Legendre(2.1)).legendre(0)
(new Legendre(13.1)).legendre(1)
(new Legendre(6.1)).legendre(4.5)
(new Legendre(1.1)).legendre(-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 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, añadido como un método getter de la clase "Expo" (la cual extiende a la clase "Number") empleando la estructura do-while y el comando break, es:
var Expo = class extends Number{
get exponente() {
const y = this.valueOf();
if (y === 0) return 1;
const 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:
(new Expo(0)).exponente
(new Expo(2)).exponente
(new Expo(3.5)).exponente
(new Expo(4.7)).exponente
(new Expo(9.2)).exponente
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 trabajando con el residuo de su división entre 2*π, porque, con ese residuo, se obtiene el mismo resultado que con el ángulo original.
El diagrama de flujo que resuelve el problema, tomando en cuenta las anteriores consideraciones, es:
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 ciclo, el límite superior es la condición de finalización del ciclo, la diferencia entre dos valores consecutivos es el incremento del ciclo y la expresión de la productoria, es la instrucción a programar en el ciclo interno.
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:
El código respectivo, implementado como un método de la clase "DProd", es el siguiente:
var DProd = class {
constructor(número1, número2) {
this.n = número1;
this.m = número2;
}
get dobleProductoria() {
const {n, m} = this;
if (n === undefined) throw new Error("No ha definido el primer límite.");
if (m === undefined) throw new Error("No ha definido el segundo límite.");
if (n%1!==0 || m%1!==0) throw new Error("Los límites deben ser enteros");
if (n<0 || m<0) throw new Error("Los límites 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 y sean enteros y positivos. Llamando al método con algunos valores de prueba, se obtiene: