En este capítulo se estudian los operadores relacionales, los operadores lógicos, la estructura condicional if (si) y se las emplea en la resolución de problemas que implican la toma de decisiones, además, se complementa el estudio de las funciones introduciendo los parámetros por defecto y los parámetros nombrados.
Operadores relacionales
Los operadores relacionales son empleados en la escritura de condiciones en programación. Una condición es toda sentencia de la cual se puede determinar su veracidad (true) o falsedad (false).
Los operadores relacionales comparan dos valores (escritos a ambos lados del operador) y devuelven siempre un valor booleano (true o false). Javascript cuenta con los siguientes operadores relacionales:
Operadores Relacionales
Operador
Descripción
==
Igual a
===
Igual y del mismo tipo que
!=
Diferente de
!==
Diferente o de otro tipo que
>
Mayor a
<
Menor a
>=
Mayor o igual a
<=
Menor o igual a
Por defecto, JavaScript, realiza las conversiones de tipos que sean necesarias, antes de comparar los valores.
Por ejemplo, se pueden comparar cadenas con números:
"50.34">5.554
30.45<"3.43"
12>="15"
"23"<=64
En estas comparaciones, JavaScript, convierte primero las cadenas en números y luego compara los valores convertidos. No obstante, no es una buena práctica de programación el mezclar diferentes tipos de datos, por lo que se aconseja no hacerlo.
La diferencia entre los operadores == y != y los operadores === y !==, radica en que los últimos no realizan ningun tipo de conversión, lo que es más seguro desde el punto de vista de programación y la razón por la cual se recomienda su uso.
Por ejemplo, en las siguientes comparaciones, se obtienen resultados distintos con los dos tipos de operadores:
"23" == 23
"23" === 23
"68.5" != 68.5
"68.5" !== 68.5
Operadores lógicos
Los operadores lógicos comparan valores booleanos (o expresiones que pueden ser convertidas o interpretadas como booleanos). Conjuntamente los operadores relacionales, permiten escribir expresiones lógicas complejas.
Javascript cuenta con los siguientes operadores lógicos:
Operadores Lógicos
Operador
Descripción
!
Negación
&&
Y lógico
||
O lógico
El operador de negación: !, cambia el valor o expresión booleana a la que precede, de verdadero a falso y viceversa. El operador "Y": &&, devuelve verdadero sólo si los dos valores que compara son verdaderos, en cualquier otro caso devuelve falso. El operador "O" lógico: ||, devuelve falso sólo si los dos valores que compara son falsos, en cualquier otro caso devuelve verdadero.
JavaScript interpreta como valores falsos: el cero (0), el texto vacío (""), el valor nulo (null) y el valor undefined e interperta como verdaderos cualquier cadena no vacía y cualquier valor no nulo o definido.
Por ejemplo, las siguientes instrucciones devuelven la negación de algunos de estos valores:
!""
!"cadena"
!undefined
!null
!54.23
Evaluación en corto circuito
En Javascript, al igual que en la mayoría de los lenguajes de programación, los operadores lógicos || e && se evalúan en cortocircuito, esto es, si con el primer valor se puede determinar (sin lugar a dudas) el resultado de la expresión, entonces el resultado es devuelto directamente, sin tomar en cuenta el segundo valor.
En el caso del operador &&, se sabe que el resultado es falso si el primer valor es falso (porque falso && cualquier otro valor es siempre falso). En el caso del operador ||, se sabe que el resultado es verdadero si el primer valor es verdadero (porque verdadero || cualquier otro valor es siempre verdadero). Tal como se puede comprobar en los siguientes ejemplos, donde, aunque los segundos valores son en realidad erróneos (son variables y/o funciones inexistentes) no generan ningún error, porque, al poder determinarse la veracidad o falsedad de las expresiones con el primer término, los segundos términos nunca son evaluados:
false && cos(3.2)
false && miVariable
true || tangente(6.43)
true || otraVariable
En JavaScript, el resultado de un operador lógico no siempre es un valor booleano (true/false) sino el valor con el cual se determina la veracidad o falsedad de la expresión.
Así, el operador "Y" (&&) devuelve el primer término, si el mismo equivale a falso y el segundo en caso contrario, mientras que el operador "O" (||) devuelve el primer término si es equivalente a verdadero y el segundo en caso contrario. Tal como se puede ver en los siguientes ejemplos:
"" && 3 > 2
undefined && true
null && "Hola"
Math.sin(0) && Math.cos(5.32)
Math.cos(0) || true
"Javascript" || false
"Aceptado" || "Rechazado"
Math.sqrt(25) || Math.cbrt(27)
Y las siguientes devuelven el segundo valor, pues con el primero no es posible determinar la veracidad o falsedad de la expresión:
true && "Resultado"
"Primero" && "Segundo"
1 && Math.sin(5.3)
false || "Resultado"
undefined || "Valor por defecto"
"" || "Rechazado"
"Aceptado" && "Rechazado"
0 || 2**5
45<23 || Math.sqrt(2)
Ejemplos
Número par
Como primer ejemplo, se elaborará una función que, haciendo uso de una expresión lógica, determine si un número es (true) o no (false) par:
Como se sabe, un número es divisible entre otro si el residuo de su división es cero y un número (n) es par si es divisible entre 2, es decir si se cumple que: n%2===0. Como el resultado de toda expresión relacional es siempre un valor booleano (true o false), el problema se resuelve simplemente devolviendo el resultado de esta expresión:
var esPar = n => n%2 === 0;
Llamando a la función con los números 124, 311 y 0, se obtiene:
esPar(124)
esPar(311)
esPar(0)
Qué son resultados correctos.
Número entero
Un número es entero si no tiene parte fraccionaria y un número no tiene parte fraccionaria si el residuo de su división entre 1 es cero, entonces para determinar si un número (n) es (true) o no (false) un entero, simplemente se verifica si es divisible entre 1: n%1===0:
var esEntero = function(n) { return n%1 === 0; };
LLamando al método desde los números 124, 911, 124.34, -457 y -93.672, se obtiene:
esEntero(124)
esEntero(911)
esEntero(124.24)
esEntero(-457)
esEntero(-93.672)
Que son los resultados correctos.
Número natural
Un número (n) es natural si es entero y positivo. La mayoría de las definiciones incluyen el número 0 en este conjunto, siendo esa la definición que se adopta en la asignatura.
Al igual que en los otros casos, el problema es directamente el resultado de una expresión lógica, donde se determina si el número es divisible entre 1 (si es entero) y si es positivo (mayor o igual a cero): n%1===0 && n>=0:
function esNatural(n) { return n%1 === 0 && n >= 0; };
Haciendo correr el programa con 27, 0, -45, 23.45 y -92.14, se obtiene:
esNatural(27)
esNatural(0)
esNatural(-45)
esNatural(23.45)
esNatural(-92.14)
Que son resultados correctos.
Parámetros
Los parámetros empleados hasta el momento, en todas las funciones elaboradas, son parámetros por valor. Como su nombre sugiere, estos parámetros sólo guardan el valor que se les manda, sin importar que dicho valor sea literal, esté guardado en una variable o sea el resultado de una función o expresión.
Por ejemplo, dada la función:
var sum2 = (x, y) => x+y;
Si es llamada, guardando previamente los valores a sumar en las variables "a" y "b":
var a = 7, b = 8; sum2(a, b)
La función sum2, no guarda las variables "a" y "b" en las variables "x" y "y", sino únicamente sus valores (los números 7 y 8).
Las variables originales permanecen inalteradas porque, como se dijo, la función no recibe las variables, sino únicamente sus valores. Como se puede comprobar en la siguiente función, que recibe dos números en los parámetros "c" y "d", estos parámetros son modificados dentro de la función, pero, como se puede ver, las variables externas permanecen inalteradas.
var c = 5, d = 7; print(c, d); function fun1(c, d) { c = c*3; d = d*4; return c+d; } print(fun1(c, d)); print(c, d)
Los parámetros pueden ser también parámetros por defecto, que son parámetros a los que se les asignan valores iniciales. De esa manera, si la función es llamada con un menor número de datos, los parámetros que no reciben un dato, toman su valor inicial (su valor por defecto).
Por ejemplo, la siguiente función calcula la suma de hasta 3 números, pero todos los parámetros tienen valores por defecto iguales a 0:
var suma = (a=0, b=0, c=0) => a+b+c;
Si no se manda uno o más de los 3 valores que requiere la función, los parámetros que no reciben un valor toman su valor por defecto (0). En este caso cero es un valor conveniente, porque al ser el valor neutro de la suma no altera el resultado y si, por ejemplo, no se manda el valor de "c", devuelve el resultado de "a+b", porque al ser "c" cero, no altera el resultado.
Así, a continuación, en la primera llamada que se hace a la función (con 3 valores) "a" es igual a 1, "b" es igual a 2 y "c" es igual a 3; en la segunda llamada (con 2 valores) "a" es igual a 1, "b" igual a 2 y "c" es igual a 0 (el valor por defecto); en la tercera llamada (con un valor) "a" es igual a 1, mientras que "b" y "c" son iguales a 0 (el valor por defecto) y en la última llamada (sin valores) "a", "b" y "c" son iguales a 0 (el por defecto):
suma(1, 2, 3)
suma(1, 2)
suma(1)
suma()
Como se puede ver, en todos los casos la función devuelve el resultado correcto y cuando no se manda ningún valor, devuelve 0.
Normalmente, los parámetros por defecto están al final de la lista de parámetros, sin embargo, en JavaScript los parámetros por defecto pueden estar en cualquier posición (no siempre al final), no obstante, para que un parámetro, que no está al final de la lista, emplee su valor por defecto, se le debe mandar el valor undefined. Por ejemplo, para que el segundo parámetro de suma emplee su valor por defecto, se le manda:
suma(12, undefined, 45)
En este caso "a" toma el valor 12, "b" toma el valor 0 (el valor por defecto) y "c" toma el valor 45.
Aunque estrictamente hablando, las funciones en JavaScript no admiten parámetros nombrados, pueden ser emulados recurriendo a los objetos literales, de acuerdo a la siguiente sintaxis:
({par1[=val1], par2[=val2], ..., parn[=valn]}={})
Donde, par1, par2, etc., son los nombres de los parámetros. Como se puede ver, los parámetros nombrados también pueden tener valores iniciales por defecto. Los parámetros nombrados se caracterizan porque, como su nombre sugiere, los datos deben ser mandados incluyendo el nombre del parámetro y porque esos nombres pueden ser mandados en cualquier orden (a diferencia de los parámetros por valor y por defecto, que deben ser mandados en el orden en que fueron declarados).
La igualdad y las llaves vacías escritas al final de la lista de parámetros nombrados: ={}, sólo son necesarias para aquellos casos en los que la función es llamada si ningún dato. Si se tiene la seguridad de que la función será llamada siempre, con algún dato, aunque ese dato sea un objeto vacío ({}), entonces la igualdad y las llaves pueden ser omitidas.
Los parámetros nombrados son particularmente útiles cuando la función consta de 3 o más parámetros, porque entonces es más fácil recordar el nombre de los parámetros, que la posición en la que fueron declarados.
Así la función suma, implementada con parámetros nombrados, es:
var suma_1 = ({a=0, b=0, c=0}={}) => a+b+c;
La cual puede ser llamada escribiendo los parámetros en desorden:
suma_1({c:3, b:2, a:1})
suma_1({b:2, a:1})
suma_1({c:3})
suma_1()
Si, al crear la función, no se escribe la igualdad al final de la lista de parámetros:
var suma_2 = ({a=0, b=0, c=0}) => a+b+c;
La función devuelve los mismos resultados que en el caso anterior, excepto cuando no se manda ningún dato a la función:
suma_2({c:3, b:2, a:1})
suma_2({b:2, a:1})
suma_2({c:3})
suma_2()
Para calcular la distancia (d) que alcanza un proyectil disparado con una velocidad inicial \(v_0\) (en m/s), con un ángulo de disparo θ (en grados), con la ecuación del movimiento parabólico:
\[
d = \dfrac{v^2_0 \sin(2\theta)}{2g}
\]
Se pueden emplear parámetros nombrados. En este caso es conveniente declarar como parámetro nombrado, con un valor por defecto, la aceleración de la gravedad (g): 9.80665 (m/s2), porque casi siempre se emplea ese valor (la gravedad estándar en la tierra) en los cálculos:
En esta función, como se puede ver, primero se transforma el ángulo de grados a radianes (con toRad), porque, como se sabe, todas las funciones trigonométricas operan con ángulos en radianes.
Llamando a la función, para calcular la distancia que alcanza un proyectil disparado con una velocidad inicial de 150 m/s y un ángulo de 30 grados, se obtiene:
alcance({theta:30, v0:150})
Por lo tanto, el proyectil alcanza una distancia de 993.5 m.
Como se puede ver en este ejemplo, se han mandado los datos a la inversa de como fueron declarados (se ha mandado primero theta y luego v0), lo que constituye, como se dijo, la principal ventaja de los parámetros nombrados: pueden ser mandados en cualquier orden.
Si se requiere un resultado más preciso, se manda además, la aceleración local de la gravedad, así, para Sucre, es aproximadamente: g=9.77721 m/s2):
alcance({g:9.77721, theta:30, v0:150})
Que es casi 3 metros mayor al resultado anterior y donde, una vez más, los datos han sido mandados en desorden.
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 Asi la condición se cumple (si es verdadera), caso contrario (else), si es falsa, ejecuta las instrucciones B. Luego el programa continua con las instrucciones restantes.
En JavaScript, la sintaxis de esta estructura, es:
if (condición) {
instrucciones A
} else {
instrucciones B
}
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:
if (condición)
instrucción_1;
else
instrucción_2;
El caso contrario (las instrucciones B) es opcional y la estructura puede tener únicamente el caso verdadero (las instrucciones A):
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 minimizar errores, se recomienda escribir siempre un punto y coma al final de cada instrucción (excepto cuando se escriben instrucciones sueltas en la calculadora, porque como se recordará, el punto y coma en la última instrucción, hace que el resultado no sea mostrado).
Ejemplos
Par, impar, cero
En este ejemplo se elabora una función que determina 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 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 sea igual a 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 0 y por lo tanto el algoritmo devolvería par, también para el número 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, en los diagramas, 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 exclusivo 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).
Es importante notar que el algoritmo tiene una condición implícita, pues específica que el número recibido debe ser entero. En algunos lenguajes ello simplemente implica elegir el tipo de dato a emplear, pero en los lenguajes no tipificados, como JavaScript, implica una condición donde se debe verificar que el número sea entero y donde, de no ser así, se lanza un error (con throw), como se muestra en el siguiente código:
var parImparCero = n => { if (n%1!==0) throw "El número debe ser entero"; if (n === 0) return "cero"; else if (n%2 === 0) return "par"; else return "impar"; };
El comprobar que los datos sean de los tipos correctos y/o estén entre los límites permitidos, se conoce como validación y es una práctica obligada en programación, pues evita errores al impedir valores o tipos de datos incorrectos.
El comando throw, empleado en el ejemplo, genera un error con el texto que se escribe después del mismo (en el ejemplo: "El número debe ser entero"), luego pasa el control del programa al primer bloque de tratamiento de errores (un bloque try-catch que será estudiado posteriormente) y si dicho bloque no existe (como en el ejemplo), throw termina la ejecución del módulo y pasa el control del programa al primer bloque try-catch externo, en este caso el bloque try-catch de la calculadora, el cual simplemente muestra el mensaje de error.
Como se dijo, la estructura try-catch será estudiada en capítulos posteriores, por el momento es suficiente saber que esta estructura atrapa los errores y que si un módulo no tiene esta estructura, el error es atrapado por el bloque try-catch de la calculadora, el cual muestra el mensaje de error lanzado.
parImparCero(0)
parImparCero(115)
parImparCero(244)
parImparCero(-115)
parImparCero(-110)
parImparCero(34.53)
El número debe ser entero
parImparCero(-7.3265e2)
El número debe ser entero
Alternativamente, para determinar si un número es entero, se puede emplear el método estático isInteger de la clase Number, el cual devuelve true si el número es entero y false en caso contrario.
El diagrama de flujo (la lógica), verificando primero si el número es impar y luego si es cero, es:
Siendo el código respectivo (validando en este caso, que el número sea entero, con el método estático isInteger), es:
function parImparCero(n) { if (!Number.isInteger(n)) throw "El número debe ser entero"; if (n%2 === 1) return "impar"; else if (n === 0) return "cero"; else return "par"; };
Con el cual, por supuesto, se obtienen los mismos resultados:
parImparCero(0)
parImparCero(115)
parImparCero(244)
parImparCero(-115)
parImparCero(-110)
parImparCero(34.53)
El número debe ser entero.
parImparCero(-7.3265e2)
El número debe ser entero.
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 y la función termina, sin realizar ninguna operación o procesamiento posterior, por lo tanto, en este tipo de problemas, no se requieren los casos contrarios (los else), porque si no se cumple un caso, el flujo del programa pasa de todas formas al caso contrario (sin requerir el else).
Sin embargo, se aclara que esto ocurre únicamente porque no se ejecuta ninguna instrucción después del bloque if-else. Si antes de salir del programa, sería necesario ejecutar alguna instrucción (cualquiera) sería necesario emplear los casos contrarios (los else).
Por lo tanto, para estos casos, el algoritmo puede ser programado de la siguiente forma:
var parImparCero_ = function(n) { if (!Number.isInteger(n)) throw "El número debe ser entero"; if (n%2 === 1) return "impar"; if (n === 0) return "cero"; return "par"; };
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, es:
var esBisiesto = function(a) { if (a%1!==0 || a<0) throw "¡El año debe ser entero positivo!"; if (a%100 === 0) return a%400 === 0; return a%4 === 0; };
La función devuelve siempre un valor booleano (un valor lógico): true o false, porque al ser el resultado de una expresión relacional, es un valor booleano.
Llamando al método con diferentes valores de prueba, se obtiene:
esBisiesto(1980)
esBisiesto(1982)
esBisiesto(1996)
esBisiesto(2000)
esBisiesto(2006)
esBisiesto(2012)
esBisiesto(2020)
esBisiesto(-2020)
¡El año debe ser entero positivo!
esBisiesto(2020.32)
¡El año debe ser entero positivo!
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:
Siendo el código respectivo (en forma de función flecha):
var esBisiesto_ = a => { if (a%1 !==0 || a<0) throw "¡El año debe ser entero positivo!"; if (a%100 === 0) a = a/100; return a%4 === 0; };
Que, por supuesto, devuelve los mismos resultados que con la lógica anterior:
esBisiesto_(1980)
esBisiesto_(1982)
esBisiesto_(1996)
esBisiesto_(2000)
esBisiesto_(2006)
esBisiesto_(2012)
esBisiesto_(2020)
esBisiesto_(-2020)
¡El año debe ser entero positivo!
esBisiesto_(2020.32)
¡El año debe ser entero positivo!
Mayor de 3 números
En este ejemplo se elabora una función que recibe tres números y devuelve el mayor ellos.
Como de costumbre, se pueden plantear varias alternativas de solución. Probablemente la más sencilla consiste en determinar si el primer número es el mayor, de no ser así, se comprueba si el segundo es el mayor y de no ser así el mayor (por defecto) es el tercero.
Por supuesto, el orden puede ser cambiado sin que en realidad cambie la lógica. El algoritmo, en forma de diagrama de flujo, es:
gojsGraph({divi, modelo: {"class":"go.GraphLinksModel","linkFromPortIdProperty":"fromPort","linkToPortIdProperty":"toPort","nodeDataArray":[{"category":"Conditional","text":"a>=b y a>=c","key":-4,"loc":"-144 -345.00000000000006"},{"category":"Start","text":"mayor","key":-1,"loc":"-144 -454"},{"category":"Input","text":"números: a, b, c","key":-3,"loc":"-143.99999999999994 -403"},{"category":"Start","text":"fin","key":-9,"loc":"-145 -147"},{"category":"Output","text":"a","key":-7,"loc":"-15.999999999999886 -221.99999999999983"},{"category":"Output","text":"c","key":-10,"loc":"-388.9999999999999 -221.99999999999983"},{"category":"Output","text":"b","key":-11,"loc":"-144.9999999999999 -221.99999999999983"},{"category":"Conditional","text":"b>=a y b>=c","key":-8,"loc":"-271 -282.00000000000006"}],"linkDataArray":[{"from":-1,"to":-3,"fromPort":"B","toPort":"T","points":[-144,-438.7333213806152,-144,-428.7333213806152,-144,-428,-143.99999999999994,-428,-143.99999999999994,-427.2666786193848,-143.99999999999994,-417.2666786193848]},{"from":-3,"to":-4,"fromPort":"B","toPort":"T","points":[-143.99999999999994,-388.7333213806152,-143.99999999999994,-378.7333213806152,-143.99999999999994,-376.8833393096924,-144,-376.8833393096924,-144,-375.0333572387696,-144,-365.0333572387696]},{"from":-4,"to":-7,"fromPort":"R","toPort":"T","visible":true,"points":[-64.41780090332031,-345.00000000000006,-54.41780090332031,-345.00000000000006,-15.999999999999886,-345.00000000000006,-15.999999999999886,-297.30556551615393,-15.999999999999886,-249.61113103230775,-15.999999999999886,-239.61113103230775],"text":"Si"},{"from":-4,"to":-8,"fromPort":"L","toPort":"T","visible":true,"points":[-223.5821990966797,-345.00000000000006,-233.5821990966797,-345.00000000000006,-271,-345.00000000000006,-271,-328.51667861938483,-271,-312.0333572387696,-271,-302.0333572387696],"text":"No"},{"from":-8,"to":-11,"fromPort":"R","toPort":"T","visible":true,"points":[-190.65548706054688,-282.00000000000006,-180.65548706054688,-282.00000000000006,-144.9999999999999,-282.00000000000006,-144.9999999999999,-265.80556551615393,-144.9999999999999,-249.61113103230775,-144.9999999999999,-239.61113103230775],"text":"Si"},{"from":-8,"to":-10,"fromPort":"L","toPort":"T","visible":true,"points":[-351.3445129394531,-282.00000000000006,-361.3445129394531,-282.00000000000006,-388.9999999999999,-282.00000000000006,-388.9999999999999,-265.80556551615393,-388.9999999999999,-249.61113103230775,-388.9999999999999,-239.61113103230775],"text":"No"},{"from":-11,"to":-9,"fromPort":"B","toPort":"T","points":[-144.9999999999999,-209.31998565673808,-144.9999999999999,-199.31998565673808,-144.9999999999999,-185.79333213806143,-145,-185.79333213806143,-145,-172.26667861938478,-145,-162.26667861938478]},{"from":-7,"to":-9,"fromPort":"B","toPort":"R","points":[-15.999999999999886,-209.31998565673808,-15.999999999999886,-199.31998565673808,-15.999999999999886,-147,-63.72024857964403,-147,-111.44047715928818,-147,-121.44047715928818,-147]},{"from":-10,"to":-9,"fromPort":"B","toPort":"L","points":[-388.9999999999999,-209.31998565673808,-388.9999999999999,-199.31998565673808,-388.9999999999999,-147,-283.77976142035584,-147,-178.5595228407118,-147,-168.5595228407118,-147]}]}})
El código respectivo, implementado en forma de una función estándar, es:
function mayor(a, b, c) { if (!Number.isFinite(a) || !Number.isFinite(b) || !Number.isFinite(c)) throw "Los datos deben ser de tipo numérico." if (a>=b && a>=c) return a; if (b>=a && b>=c) return b; return c; };
En este caso, aunque los números pueden ser enteros o reales, se valida que efectivamente sean números (no booleanos, cadenas o arreglos). Con ese fin, se recurre al método estático isFinite de la clase Number, el cual devuelve true si es un número válido y false en caso contrario.
Llamando a la función con algunos valores (arrays) de prueba, se obtiene:
mayor(1, 2, 3)
mayor(1, 3, 2)
mayor(3, 2, 1)
mayor(5, 4, 5)
mayor(4, 7, 4)
mayor(8, 8, 8)
Ecuación cuadrática
En este ejemplo se elabora una función que devuelve las dos soluciones de la ecuación cuadrática:
\[
a x^2 + b x + c= 0
\]
Programando la solución general:
\[
x_{1,2} = \dfrac{-b \pm \sqrt{b^2-4 a c}}{2 a}
\]
Las soluciones de la ecuación dependen del valor de la expresión que se encuentra dentro de la raíz cuadrada, denominado discriminante ("d = b2−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, siendo el caso por defecto positivo:
Al igual que en el ejemplo anterior, se valida que los tres datos sean efectivamente números (con isFinite):
var cuadratica = (a, b, c) => { const d = b**2-4*a*c; let r, i, r1, r2; if (d<0) { r = -b/(2*a); i = Math.sqrt(-d)/(2*a); r1 = Complex(r, i); r2 = Complex(r, -i); } else if (d===0) { r1 = -b/(2*a); r2 = r1; } else { r1 = (-b+Math.sqrt(d))/(2*a); r2 = (-b-Math.sqrt(d))/(2*a); } return [r1, r2]; };
Como se puede ver, para devolver los resultados complejos, se ha empleado la clase Complex, la cual crea un número complejo a partir de las partes real e imaginaria del número.
Llamando a la función con los coeficientes de algunas ecuaciones cuadráticas, se obtiene: