Métodos condicionales 2

En este capítulo continúa el estudio de los métodos condicionales, empleando la estructura if, el operador condicional ? y la estructura switch (así como su equivalente if-else-if).

La estructura if (si)

If es la estructura selectiva por excelencia, su lógica, en forma de diagrama de flujo, es:

Es decir que if ejecuta las instrucciones A si la condición se cumple (si es verdadera), caso contrario si es falsa (else), ejecuta las instrucciones B. Luego el programa continua con las instrucciones restantes.

En JavaScript, la sintaxis de esta estructura, es la misma que en C/C++:

Si en lugar de dos o más instrucciones sólo existe una, las llaves no son necesarias, sin embargo, el emplearlas no constituye un error:

El caso contrario (las instrucciones B) es opcional y la estructura puede tener únicamente el caso verdadero (las instrucciones A):

En cuyo caso, la sintaxis, es:

O si sólo existe una instrucción:

Como se dijo, en JavaScript, si una instrucción termina con un salto de línea, el punto y coma al final de la misma no es imprescindible, sin embargo, para adquirir buenas costumbres y reducir errores, en la asignatura se debe escribir siempre un punto y coma al final de cada instrucción.

Sin embargo, cuando la instrucción está en la última línea de la calculadora JavaScript, sólo se debe escribir el punto y coma cuando no se quiere mostrar el resultado de esa instrucción.

Ejemplos

Par, impar, cero

En este ejemplo se elabora un método que permite determinar si un número entero es par, impar o cero, devolviendo el texto "par", si es par; "impar", si es impar y "cero", si es cero.

Como casi siempre ocurre en programación, el problema puede ser resuelto de diferentes formas, así, se puede verificar primero si el número es cero y de ser así el resultado es "cero". Sino (caso contrario) se puede verificar si es par y de ser así el resultado es "par", caso contrario el resultado es "impar", porque si el número entero no es cero ni par (por lógica) sólo puede ser impar (el caso por defecto).

Como ya se vio previamente, para determinar si un número entero es par, simplemente se verifica si el residuo de su división entre 2 es 0.

Igualmente, se puede verificar primero si el número es impar y luego si es cero, siendo el caso por defecto par.

Sin embargo, no se puede verificar primero si el número es par, porque el residuo de 0 entre 2 es también 0 (al igual que ocurre con un número par). En consecuencia, si se verificaría primero si el número es par, el algoritmo devolvería (erróneamente) "par" cuando el número es 0.

El algoritmo, en forma de diagrama de flujo, donde se verifica primero si el número es cero y luego si es par, es:

Como se puede ver en este ejemplo, las expresiones relacionales se escriben empleando los operadores relacionales estándar de JavaScript, pero, para la igualdad y la diferencia se emplean los operadores == y !=, NO === y !==, porque esos operadores son exclusivos de JavaScript, no obstante, al momento de programar, se aconseja emplear estos operadores, porque al ser más estrictos, son más seguros (menos propensos a ocasionar errores inesperados).

Para codificar el algoritmo en un método de una clase, se puede emplear una de las 3 opciones estudiadas en el anterior capítulo. Así creando una nueva clase independiente (la clase "Número") el código es:

Donde, por claridad y para ajustarse más estrictamente al algoritmo, se lee el valor del número (this.num en la constante local "n".

Para satisfacer la condición implícita del algoritmo (el número "n" debe ser entero), se pregunta si el número no es entero (n%1!==0) y de ser así se lanza (con throw) un error (de la clases Error) con el mensaje: "El número debe ser entero.". Al proceso de verificar que la información (los datos) sean del tipo correcto y que sus valores estén dentro del conjunto de valores permitidos, se denomina validación. En los lenguajes tipificados, como C/C++, los tipos de datos son validados por el compilador (antes de ejecutar el programa) pues se conocen los tipos de datos que se deben recibir. En los lenguajes no tipificados (como JavaScript) los tipos de datos deben ser validados en el código, al momento de ejecutar el programa.

El comando throw, empleado en este capítulo, lanza un error y detiene la ejecución del programa, entonces el control del programa pasa al primer bloque try-catch que encierra a throw. Si dicho bloque no existe (como en este ejemplo) el error es atrapado por el primer bloque try-catch externo. Cuando se trabaja en la calculadora, si no existe ningún bloque try-catch, el error es atrapado por el bloque try-catch de la calculadora, el cual simplemente muestra el mensaje de error.

La estructura try-catch será estudiada en capítulos posteriores, por el momento es suficiente saber que atrapa los errores y que la calculadora tiene un bloque try-catch, que atrapa los errores que no hubieran sido atrapados en el código, mostrando el mensaje del error en la calculadora.

Si bien no se han programado los métodos valueOf y toString, porque no se emplean en este caso, en una aplicación real deben ser programados para que el objeto pueda responder correctamente en operaciones donde se requiera su valor y/o su representación en forma de texto.

Para probar el método con algunos valores de prueba, se puede crear un objeto y llamar al método desde ese objeto (como se ha hecho en el anterior capítulo). Pero, si solo se quiere probar un método, es más práctico crear el objeto y llamar directamente (sin guardar el objeto en una variable). Así, para probar el método con los números: 115, 244, -115, -110 y 34.53, se escribe:

El diagrama de flujo (la lógica) donde se verifica primero si el número es impar y luego si es cero, es:

El código del método, implementado en una clase heredada de la clase "Number", es:

Al igual que en el ejemplo previo, para ajustarse mejor al algoritmo y facilitar la codificación, se lee el valor del número (this.valueOf()) en la constante "n".

Llamando al método para los mismos valores que en la solución anterior, se obtienen los mismos resultados:

Analizando con más detenimiento la lógica, se puede ver que, en todos los casos, una vez que se cumple una de las condiciones (cualquiera) el resultado es devuelto directamente, sin realizar ninguna operación o procesamiento posterior, por lo tanto, en realidad no se requieren los casos contrarios (los else), porque de todas formas (sin else) si la condición no es verdadera, el programa pasa a la siguiente instrucción.

Sin embargo, se aclara que esto ocurre únicamente porque no se realiza ninguna otra acción después del bloque if-else, si se realizaría alguna acción después del bloque (cualquiera) sería necesario emplear los casos contrarios (los else).

Entonces, sin else, el código es:

Llamando al método (directamente desde los números, porque son objetos la clase Number), se obtiene los mismos resultados:

Año bisiesto

En este ejemplo se resuelve el problema de determinar si un año (un número entero positivo) es (true) o no (false) bisiesto.

Un año es bisiesto si es divisible entre 4, excepto cuando termina en dos ceros, en cuyo caso, se verifica si el número, sin los dos ceros, es divisible entre 4, o, lo que es lo mismo, se verifica si el número es divisible entre 400. Así, si el año es 1900, se verifica si 19 es divisible entre 4 (19%4==0) o (lo que es lo mismo) si 1900 es divisible entre 400 (1900%400 = 19%4 == 0).

Como casi siempre ocurre en programación, existe más de una forma de resolver el mismo problema. Así, se puede verificar primero si el año es divisible entre 100 y de ser así se verifica si el año es divisible entre 400, caso contrario, se verifica si es divisible entre 4, como se muestra en el siguiente diagrama de flujo:

Al igual que en el ejemplo previo, aunque no está de forma explícita en el algoritmo, en el código se debe validar que el año sea un número entero positivo, porque no existen años ni reales ni negativos. El código respectivo, implementado en la clase "Número", heredada de la clase "Number", es::

Llamando al método con algunos valores de prueba, se obtiene:

Otra posible solución consiste en quitar los dos ceros del año cuando es divisible entre 100, luego, simplemente se verifica si el año (que ya no tiene los dos ceros) es divisible entre 4. Tal como se muestra en el siguiente diagrama de flujo:

El código del algoritmo, implementado en un método getter añadido directamente a la clase Number, es:

Observe que la variable "a" ha sido declarada con let (no const) porque su valor puede cambiar (cuando es divisible entre 100).

Llamando al método con los mismos valores que en el caso anterior, se obtiene:

Mayor de 3 números

En este ejemplo se elabora un método que recibe tres números y devuelve el mayor de ellos.

Como de costumbre, se pueden plantear varias alternativas de solución. Una de ellas consiste en determinar si el primer número es el mayor, de no ser así, se comprueba si es el segundo y de no ser así (por defecto) se sabe que el mayor es el tercero.

Por supuesto, el orden puede ser cambiado sin que (en este caso) cambie la lógica. El algoritmo, en forma de diagrama de flujo, es:

El algoritmo codificado como un método de la clase independiente "Mayor", es:

En este caso se implementan también los métodos valueOf y toString, para que devuelvan (respectivamente) el mayor valor en forma de número (Number) y el mayor valor en forma de texto (String).

La asignación: [this.a, this.b, this.c] = [a, b, c];, hace que se asignen (en una sola instrucción) los valores de las variables "a", "b" y "c", a las propiedades "a", "b" y "c" del objeto this. Este tipo de asignación, donde uno o más valores de un array se asignan a una o más variables o a una o más propiedades de otro objeto (o viceversa), se conoce como desestructuración y es una forma frecuentemente empleada en la práctica para realizar asignaciones múltiples en una sola instrucción. De hecho, los parámetros nombrados (estudiados en capítulos anteriores) corresponden a este tipo de asignación.

Igualmente la asignación: const {a, b, c} = this; es una desestructuración, donde las propiedades "a", "b" y "c" del objeto this, son asignados a las constantes locales "a", "b" y "c". En este caso, como this es un objeto, sus propiedades se desestructuran recibiéndolas en otro objeto ({a, b, c}). En realidad, cuando se escribe esta expresión, internamente JavaScript la transforma en: const {a: a, b: b, c: c} = this;, de manera que el valor de la propiedad "a:" (del objeto this) se almacena en la variable "a", el de la propiedad "b:" en la variable "b" y el de la propiedad "c:" en la variable "c". Si en su lugar se habría escrito: const {a: d, b: e, c: f} = this;, el valor de la propiedad "a:" se almacenaría en la variable "d", el de la propiedad "b:" en "e" y el de la propiedad "c:" en "f".

Probando el método con algunos valores de prueba, se obtiene:

Si se emplea un objeto de este tipo en una expresión que requiere un valor de tipo cadena (string) y en otra que requiere un valor de tipo numérico, JavaScript llama automáticamente al método toString (para obtener el string que representa al objeto) en el primer caso y a valueOf (para obtener el número que representa al objeto) en el segundo, tal como se muestra a continuación:

Ecuación cuadrática

En este ejemplo se elabora un método que devuelve las dos soluciones de la ecuación cuadrática:

Soluciones que se obtienen con la ecuación:

Las soluciones de la ecuación dependen del valor de la expresión que se encuentra dentro de la raíz cuadrada, denominada discriminante ("d = b²−4ac"). Si el discriminante es positivo, las dos soluciones son reales y distintas (porque la raíz es mayor a cero), si es cero, las soluciones son iguales (porque la raíz es cero) y si es negativo, las soluciones son complejas: un par conjugado (porque la raíz es negativa: imaginaria).

Entonces, para resolver el problema se calcula el valor del discriminante, luego se puede determinar si el discriminantes es positivo, negativo o cero, en cualquier orden. Así en la siguiente solución, se determina primero si el discriminante es negativo y luego si es cero, el caso restante (el caso por defecto) es positivo (porque si el discriminante no es negativo ni cero, necesariamente es positivo):

El algoritmo, programado como un método independiente de la clase "Cuadrática", es:

Como la ecuación tiene dos resultados (r1 y r2), se emplea un array para devolver los dos resultados ([r1, r2]), se puede emplear, igualmente, un objeto literal ({r1, r2}).

Se ha sobreescrito también el método toString, para que cuando se requiera una cadena (un string) JavaScript llame automáticamente a este método. En este caso el método toString devuelve la solución de la ecuación cuadrática, pero como esa solución es un array, llama al método aString que devuelve el array en forma de cadena.

En esta clase no se ha sobreescrito el método valueOf, porque los operadores y funciones matemáticas de JavaScript no operan sobre arrays.

Llamando al método con algunos valores de prueba, se obtiene:

Y cuando un objeto de esta clase forma parte de una expresión, se obtiene:

El operador: ?

El operador ? es equivalente a la estructura if-else, tiene la misma lógica que dicha estructura, pero, al ser un operador, se emplea en sentencias de asignación y al interior de expresiones, su sintaxis es:

condición ? instrucción caso verdadero : instrucción caso falso;

A diferencia de la estructura if-else, el caso contrario (el caso sino) es obligatorio (no opcional), porque al ser un operador, se requiere su resultado para completar las operaciones de las cuales forma parte.

Los casos de este operador pueden tener más de una instrucción, pero, de ser así, esas instrucciones deben estar encerradas entre paréntesis y separadas con comas (no entre llaves y separadas con puntos y comas):

condición ? (instr. 1, ..., instr. n) : (instr. 1, ..., instr. n);

Si bien el operador ?, puede ser empleado en los mismos casos que la estructura if, se emplea, sobre todo, en los casos donde la lógica es sencilla, porque en casos más complejos, el código se torna difícil de comprender.

Por ejemplo, el algoritmo que determina si un número es cero, par o impar:

Codificado con el operador ?, como un método getter, añadido a la clase Number, es:

Como se puede ver, el código es más corto que el equivalente con if, sin embargo, es menos claro. Note además que, al ser un operador, se emplea como parte de la expresión de retorno (no de forma independiente, como ocurre con la estructura if).

Llamando a la función con algunos valores de prueba, se obtienen los resultados correctos:

Igualmente, el algoritmo que determina si un año es o no bisiesto:

Codificado con el operador ?, como un método de la clase extendida Número, es:

La expresión entre paréntesis, en la instrucción de retorno: (a%100===0 ? a/100 : a), pregunta si el número es divisible entre 100 (si tiene dos ceros) y de ser así, devuelve el resultado de dividir el año entre 100 (a/100) caso contrario simplemente devuelve el año (a), en consecuencia, la expresión entre paréntesis devuelve el año sin los dos ceros, por lo tanto sólo queda verificar si ese resultado es divisible entre 4 (%4===0).

Probando el método con algunos valores de prueba, se obtiene:

De forma similar, la lógica que determina el mayor de 3 números:

Codificado con el operador ?, como un método getter de la clase independiente Mayor, es:

Llamando al método con algunos valores de prueba, se obtiene:

Note que, en este ejemplo, se ha validado con la función isFinite, que los valores recibidos sean realmente números (no booleanos, cadenas, etc.).

Finalmente, el algoritmo que resuelve la ecuación de segundo grado:

Codificada con el operador ?, como un método getter dinámico de la clase Cuadrática, es:

Aún cuando la expresión condicional se ha organizado en varias líneas, con el propósito de que el código sea más fácil de entender, sigue siendo más difícil de entender que su equivalente con if-else. Es por ello que se recomienda emplear el operador ? únicamente en expresiones condicionales sencillas.

Llamando al método con los coeficientes de las siguientes ecuaciones:

Se obtiene:

La estructura "switch"

Si la lógica que resuelve el problema corresponde al siguiente algoritmo:

O, empleando un conector (A):

Por claridad (para evitar cruce de líneas), en la asignatura se empleará la segunda forma.

En consecuencia, cuando se debe ejecutar una u otra instrucción en función al valor de una variable, se debe emplear la estructura switch, cuya sintaxis es:

Donde el comando break, termina la ejecución de la estructura switch y pasa el flujo del programa a la instrucción/estructura que está después de switch. Si se omite break el programa no sale de la estructura, sino que pasa a ejecutar las instrucciones del siguiente caso. Casi siempre, el no escribir el comando break es un error, pero en ocasiones se omite a propósito cuando, por ejemplo, se deben ejecutar las mismas instrucciones para dos o más casos consecutivos.

Si las condiciones son consecutivas, pero no son condiciones de igualdad y/o no se compara con la misma variable:

Se codifica empleando la estructura if- else estándar, de acuerdo al siguiente formato:

Número a día

En este ejemplo, se programa un método que convierte un número comprendido entre 1 y 7, en el día de la semana correspondiente, siendo el primer día de la semana (el día 1) el "domingo".

El diagrama de flujo que resuelve el problema, es:

El código respectivo, programado como un método getter de la clase heredada "Número", que hereda de la clase "Number", es:

Llamando al método con algunos valores de prueba, se obtiene:

Sin embargo, de acuerdo a la lógica (de acuerdo al diagrama de flujo) una vez que se cumple uno de los casos (cualquiera) el resultado es devuelto directamente. Por lo tanto, en realidad no se requiere la variable auxiliar "r", ni el comando break, sino que se puede emplear directamente el comando return, tal como se muestra en el método getter, añadido a la clase "Número":

Que, por supuesto, devuelve los mismos resultados:

Si bien esta forma es la que se emplearía en un caso práctico, en este capítulo, para adquirir la costumbre de escribir correctamente la estructura switch, los problemas de este tipo se resolverán empleando la primera forma (empleando break).

Días del mes

En este ejemplo, se programa un método que recibe el nombre de un mes "m" y (opcionalmente) el año "a" y devuelve el número de días que tiene el mes recibido.

El año es necesario sólo para el mes de febrero, porque si es bisiesto, el mes tiene 29 días en lugar de 28. En los otros casos simplemente se devuelve el número de días correspondientes al mes: 31 para enero, marzo, mayo, julio, agosto, octubre y diciembre y 30 para abril, junio, septiembre o noviembre).

El diagram de flujo que resuelve el problema, es:

En este caso, el dato que recibe el método es de tipo string, por lo tanto, se puede resolver el problema añadiendo el método a la clase "String", extendiendo la clase "String" o en una clase independiente con una propiedad (privada) de tipo string. En este ejemplo se ha optado por la segunda opción, entonces el problema se resuelve en la clase "Texto", que extiende a la clase "String". Además, dado que es necesario saber si el año (a) es bisiesto, se añade el método getter "esBisiesto" a la clase "Number":

En este caso, el método "díasDelMes" no puede ser un método getter, porque recibe un parámetro: el año. En el método, antes de comparar el nombre del mes, se convierte el texto a minúsculas y se guarda en la constante "m". Se lleva a cabo esta conversión para que, sin importar como haya sido escrito el mes, dentro del método esté siempre en minúsculas y por lo tanto pueda ser comparado con los meses escritos en minúsculas. Si no se lleva a cabo esta conversión y por ejemplo, el mes se escribe como "NOVIEMBRE", el método lanzaría el error "Nombre de mes inválido". Alternativamente se puede emplear el método toUpperCase, que convierte el texto a mayúsculas, en ese caso, los meses a comparar tendrían que ser escritos en mayúsculas.

Llamando al método desde objetos de tipo "Días", con algunos meses, se obtiene:

En la penúltima instrucción, el método devuelve 28 días para el mes de febrero, mientras en la última devuelve 29. Sucede así, porque en el primer caso, como no se ha mandado el año, el método utiliza el año por defecto: 2022, que no es bisiesto, mientras que en el último caso, como se le manda el año: 2020, utiliza ese año y como es bisiesto, devuelve 29 días.

Note que los casos "enero", "marzo", "mayo", "julio", "agosto" y "octubre" no tienen ninguna instrucción (están en blanco), por lo tanto, cuando se cumple cualquiera de esos casos, el programa continúa con las instrucciones de los siguientes casos (que en este ejemplo están en blanco) hasta que encuentra el comando break (o return o throw). Es decir que, una vez que se cumple un caso, la estructura switch no verifica ningún caso más, sino que ejecuta directamente todas las instrucciones de todos los casos posteriores, hasta que encuentra el comando break, return o throw).

Para comprender mejor el anterior comportamiento, se ha añadido a la clase "Texto", el método "díasDelMes2", que devuelve un string (una cadena) con todos los casos que son ejecutados cuando se cumple una condición:

Al igual que en el ejemplo previo, el método es un método estándar (no un método getter), porque recibe un parámetro (el año: a) y como se sabe, un método getter no puede recibir ningún dato (sólo debe trabajar con él o las propiedades del objeto). Al ser un método estándar, puede ser añadido directamente a la propiedad prototype de la clase "Días" (como se ha hecho en capítulos previos).

Creando un objeto con el mes "diciembre" y llamando al método, se obtiene:

Donde sólo se ejecuta la instrucción de ese caso, porque ese caso termina con el comando break. Pero, si se llama al método con el mes de "julio":

Se ejecutan las instrucciones de los casos: julio, agosto, octubre y diciembre, porque, como se dijo, una vez que se cumple un caso, switch, ejecuta las instrucciones de todos los casos subsiguientes hasta que encuentra el comando break (que está en el caso "diciembre"). Si ahora se llama al método con el mes de "enero":

Se ejecutan todas las instrucciones desde el caso "enero" hasta el caso "diciembre" (que es donde se encuentra el comando break). Igualmente, si se llama al método con el mes de "abril":

Se ejecutan las instrucciones de todos los casos desde "abril" hasta "noviembre" (que es donde se encuentra el comando break).