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 develven resultados booleanos o que pueden ser interpretados como valores 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 booleano o el resultado de una expresión que devuelve un valor booleano (o un valor que puede ser interpretado como un valor booleano) 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 (sin evaluar) 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).
Así, en los siguientes ejemplos, todas las expresiones devuelven un resultado booleano (no un error), a pesar de que (en todos los casos) los segundos términos son erróneos: son variables y funciones inexistentes:
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 la 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 a la función 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. Con estos parámetros, si no se mandan datos para uno o más de los parámetros, la función emplea los valores por defecto asignados.
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 la función no recibe uno o más de los 3 valores que requiere, emplea los valores por defecto (0). En este caso cero es un valor adecuado, porque al ser el valor neutro de la suma no altera el resultado. Así, si la función no recibe "c", devuelve el resultado de sumar "a" y "b", porque al ser "c" 0, no afecta al resultado: a+b+0=a+b.
En los siguientes ejemplos, en la primera llamada que se mandan los tres valores (a=1, b=2 y c=3). En la segunda se mandan dos valores (a=1, b=2), por lo tanto "c" es 0. En la tercera llamada se manda un valor (a=1) por lo tanto "b" y "c" son 0 y en la última llamada no se manda ningún valor, por lo tanto "a", "b" y "c" son 0:
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, inclusive cuando no se manda ningún valor.
Normalmente, los parámetros por defecto están al final de la lista, 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 emplee su valor por defecto, se debe mandar (en esa posición) undefined. Por ejemplo, para que el segundo parámetro de suma emplee su valor por defecto, se escribe:
suma(12, undefined, 45)
En este ejemplo "a" es 12, "b" es 0 y "c" es 45.
Aunque las funciones en JavaScript no admiten propiamente 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. Como los datos se mandan conjuntamente el nombre del parámetro, 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: ={}, sólo son necesarias para aquellos casos en los que la función puede ser llamada si enviar ningún dato. Si se tiene la certeza de que la función recibirá, siempre, por lo menos un dato (inclusive si ese dato es 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.
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 no se emplea ={}:
var suma_2 = ({a=0, b=0, c=0}) => a+b+c;
La función devuelve los mismos resultados, excepto en la última llamada (donde no se manda ningún dato, ni siquiera un objeto vacío):
suma_2({c:3, b:2, a:1})
suma_2({b:2, a:1})
suma_2({c:3})
suma_2()
Por eso, se recomienda igualar (siempre) la lista de parámetros nombrados al objeto vacío: ={}.
En el siguiente ejemplo, empleando parámetros nombrados, se programa la función que permite 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}
\]
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 las funciones trigonométricas trabajan con ángulos en radianes, no en grados.
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 debe mandar también la aceleración local de la gravedad. Así un valor más adecuado para Sucre, es: g=9.77721 m/s2):
alcance({g:9.77721, theta:30, v0:150})
Que es casi 3 metros más que el resultado obtenido con la aceleración estándar.
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 pero el escribirlas no es 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 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 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 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, 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).
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 con la cadena: "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:
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 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.
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 a la función 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 a la función 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: