¿Cómo funciona el operador ternario?
Hostia, pero si esto es de primero, carlangas.
Vamos a ver.
A ver, si tenemos aquí el número 9.
Una ternaria, básicamente, lo que vamos a decirle es,
primero, condición, ¿vale?
Condition.
Y le vamos a decir, cuando la condición sea true,
haz esto.
Cuando la condición sea false,
es false, haz esto, ¿vale?
Es true, haz esto.
Para que lo vean más bien, mejor lo puedes poner así, ¿vale?
Tienes la condición.
Si la condición es true, haces esto.
Si la condición es false, haces esto, ¿vale?
Entonces, en este caso, por ejemplo,
tenemos aquí una constante que es a,
pues decimos, si a es igual a 9,
entonces me devuelves pepito.
Y si no, me devuelves parmadef,
que he visto por ahí el nombre, ¿vale?
Y esto sería.
Lo importante es que veas que es una expresión
porque devuelve un valor, ¿vale?
Esta es la condición.
Esto es lo que devuelve si es true
y lo que devuelve si es false.
De esta forma, como a es igual a 9,
devuelve pepito.
Pero si dijésemos, a es igual a 13,
pues tendríamos parmadef.
Y lo que es más interesante todavía de las ternarias
es que no siempre tienes directamente
que devolver un valor así, de esta forma.
También podrías hacer, por ejemplo,
llamar a una función, ejecutar otro código.
Por ejemplo, podríamos decir,
si a es igual a 2, pues vamos a ejecutar aquí
más random, ¿vale?
Podríamos ejecutar un método que nos devuelva algo.
Y si no, vamos a decir que este ya está bien.
Entonces, ¿ves?
En este caso, como a es diferente a 2,
entra este.
Si le decimos que sea 9, pues ejecuta esto.
Y lo que es interesante es que esto
se va a ejecutar cada vez que se evalúe el código.
De forma que este más random que vemos aquí
va a ir cambiando.
O sea, si yo le digo 3 y le digo otra vez 9,
se volverá a ejecutar, ¿vale?
O sea, que cada vez que pase por este código
volverá a evaluar la ternaria
y este valor, pues, podrá ir cambiando.
Así que esto podrías llamar a una función,
podrías hacer mil millones de cosas.
Qué cosa horrible a las ternarias.
Qué poco de acuerdo estoy.
Las ternarias son de lo mejor.
De lo mejor del mundo.
Lo malo es utilizarlas mal.
Y entonces se vuelven horribles
cuando se utilizan mal.
Si se utilizan mal y a la gente se le va de las manos,
entonces, por ejemplo,
utilizando ternarias anidadas y cosas así.
Si se anidan, fatal.
O si se utilizan por encima de sus posibilidades.
Hay veces que un if tiene más sentido.
El abuso de las ternarias es asqueroso.
Estoy de acuerdo.
Todo lo que se abusa está mal.
Cuando se abusa de algo, ya huele.
Y en este caso, no es menos.
Y las ternarias son peligrosas
en el sentido de que se pueden abusar de ellas
y hacer cosas chungas.
Pero creo que si se utilizan correctamente
pueden tener bastante sentido, la verdad.
Me gustan las ternarias,
pero veo a muchos que intentan usarlas para todo.
Mira, sobre eso es que hay un...
Yo tengo un artículo.
Single line responsibility.
Que hablo de esto, ¿no?
Es esta.
Single line responsibility.
Que no tiene nada que ver con...
Ah, mira, estamos en directo en Twitch.
Qué bueno que sale esto.
Vale, pues está en inglés,
pero al final la idea es esta, ¿no?
Que, ¿veis?
O sea, al final no es un tema de las ternarias.
Es un tema de que hay gente
que se vuelve muy tarumba.
O sea, ¿ves?
Esto es una ternaria,
pero que no se entiende
porque está dentro de un objeto y tal.
No sé.
Creo que todas las cosas
que tengan su uso particular,
pues bueno, pues mejor.
Y es el hecho de que hay gente
que se cree que al hacerlo
en una sola línea,
pues vas a creer más listo.
Y no tiene nada que ver.
No tiene nada que ver.
Explica, porfa, en Ria,
que lo de true y tal,
verdadero, bla, bla.
A ver, hidratación y te lo explico.
¿Cómo se llama esa especie de ternaria
con ampersand ampersand?
A ver, el ampersand ampersand
no es una ternaria.
Os la explico, os la explico.
Se llama logical operator
y hay diferentes, ¿no?
Os lo comento.
Ese es bastante interesante
y también es peligroso,
pero está chulo.
A ver, logical operators,
expresiones, logical and.
Porque tenemos el logical and,
el or también, por supuesto.
Tenemos el nullish,
que es el de los dos interrogantes.
El tema del logical and.
A ver, logical and.
El logical and,
imaginemos que tenemos aquí la A,
que es 3,
y tenemos la B,
que es,
vamos a ponerle 0,
vamos a ponerle false,
vamos a ponerle false,
y tenemos la B,
que es 3, ¿vale?
Entonces, si digo A y B,
¿qué es lo que nos va a salir aquí?
Nos va a salir false.
¿Por qué?
Porque lo que estamos haciendo aquí,
al final esto es el operador lógico and.
Y el operador lógico es de and,
es el de la conjunción.
De forma,
que este operador lo que hace es,
que será,
va a ser,
va a evaluar de izquierda a derecha,
y va a decir,
si el de la izquierda es true,
sigo evaluando hacia la derecha, ¿no?
Y entonces evalúo el de la derecha,
y devuelvo el de la derecha.
Pero en este caso,
es,
si es false,
que es el de la izquierda,
lo que voy a hacer es devolver directamente
el de la izquierda,
y no voy a seguir evaluando, ¿vale?
En este caso,
he dicho A y B,
tienen que ser,
operando que sean con el and,
lo que esperas que sean true,
si no es true,
lo que hace es no pasar hacia la derecha,
y se queda en la izquierda.
Como A es false,
lo que hace es devolver es false, ¿vale?
Pero si A fuese true,
lo que vamos a ver es que devuelve 3.
¿Por qué?
Porque va de izquierda a derecha,
en la A dice,
A es truci,
dice,
sí,
es truci,
porque es true.
Perfecto.
Pues ahora sigo evaluando,
y lo que evalúa es el B,
y el B que es 3,
¿vale?
Pues devuelvo el 3.
Si B fuese false,
por ejemplo,
pues como podéis ver,
devolvería false.
O sea,
ya va a devolver cualquier cosa
que tenga el segundo.
Es así.
Si tienes 0,
igual,
lo mismo.
Una cosa que hay que tener cuidado
con el logical operator,
que es en este caso,
es el hecho de los false y los truci.
En este caso,
el A,
he dicho que es true,
y por lo tanto lo evalúa correctamente,
dice,
ah,
vale,
pues como es true,
sigo evaluando hacia la derecha,
y el segundo es B,
pues pongo el 3.
Pero también podrías poner aquí
un string vacío,
o un string vacío,
no,
un string con un espacio,
y esto también es truci.
Entonces,
lo que evalúa aquí
son valores,
es como si hiciese esto,
¿vale?
Son valores que puedan ser truci.
Y truci,
pues puede ser cualquier string
que no sea un string vacío totalmente,
como este,
o el 0 no es truci,
por ejemplo,
cualquier número que no sea 0,
por ejemplo,
el null,
que no sea null,
te estoy diciendo mal,
los falsi,
¿no?
Null,
undefined,
0,
false,
el string vacío,
estos son falsi,
¿vale?
Por ejemplo,
pues los que no sean falsi,
pues sean truci,
lo que hay que tener cuidado con esos,
porque si no,
tú puedes poner,
por ejemplo,
este,
un string que ponga false,
y esto se lo va a comer con patata,
¿vale?
Así que no es una ternaria,
pero sí que es un operador,
es el operador,
el logical operator,
el del and,
el del lógica,
la conjunción lógica.
Al final esto es,
matemática boleana,
lógica boleana,
y aparte de este,
también tienes este,
y también tienes este,
¿vale?
Tienes tres.
Este sería el del and,
este sería el del or,
y este sería el nullish,
¿vale?
Entonces,
como podemos ver,
vamos a poner aquí ahora el false,
y vamos a ver la diferencia.
Como podemos ver,
en el and,
necesitas que el de la izquierda sea true,
para evaluar el de la derecha,
pero en el siguiente,
en el or,
al final,
con que,
aunque el de la izquierda sea false,
lo que vas a hacer,
es siempre evaluar el siguiente,
porque al ser un or,
necesitas que sea uno u otro,
¿vale?
Uno de los dos,
no hace falta que sean los dos true,
por lo tanto,
al evaluar de izquierda a derecha,
cuando vea que es false,
dirá,
ah,
pues voy a intentar el de la derecha,
pero,
también hay que tener en cuenta que si es true,
pasará todo lo contrario,
al encontrar el primer true,
dirá,
ah,
pues este true,
como tiene que ser uno u otro,
y el primero que he encontrado es true,
pues lo que voy a devolver es el primer valor,
y en este caso,
devolve true,
¿vale?
Pues eso sería un poco la explicación de la...
Uy,
perdón,
que he abierto eso,
y quería abrir esto.
Esa sería la historia.
También,
en objetos es false,
en objetos es false,
pues al final,
bolean,
el que estos,
el objeto vacío no es false,
el array vacío no es false,
el problema está en compararlos a veces,
porque cuando empiezas a compararlos,
sí que te puede salir un false por ahí en medio,
por ejemplo.
El operador es muy sucio de usar
si los objetos que vienen no se hacen bien,
change my mind.
Pues puede ser.
El or,
yo suelo usar para initial values en formularios.
Pues mira,
para initial values en formularios,
a veces no tiene sentido,
tiene sentido,
tiene sentido,
pero son peligrosos,
porque al final,
el none es false,
el none sí que es false,
muy bien,
el none es false,
sí,
ese es el que uno se me había olvidado.
El or es un poco peligroso.
Imaginemos,
mira,
¿por qué es peligroso?
Dice,
yo lo utilizo para los valores iniciales de un formulario.
Te voy a explicar por qué puede ser peligroso.
¿Cuándo se utilizaría el nullish?
No lo he incertado.
Pues también te voy a explicar esto,
de frame rate.
Y vais a ver por qué es peligroso,
¿vale?
Imaginad que dice los initial values,
¿no?
Initial values
y tenemos un cero,
¿vale?
Entonces,
initial values
o initial
initial
counter,
¿vale?
Pongamos que tenemos un contador
y tenemos que el número por...
No entiendo por qué devuelvo un bolean a un objeto.
Bueno,
porque yo he puesto bolean
y he puesto el objeto,
¿no?
Y si lo transformo a un objeto,
pues al final te lo pone a true.
Hay que entender que el tipado de JavaScript es dinámico
y te permite justamente transformar de uno a otro.
Ahí está.
Bueno,
entonces,
imaginaos que tenemos una variable que es initial counter
y lo ponemos a cero.
Pero claro,
cero,
cero,
es falso.
Imaginaos que vosotros decís initial counter,
vamos a poner que sea initial counter,
o si no,
vamos a poner que sea 25.
Pues resulta que ahora initial counter es 25.
¿Es esto realmente lo que queríamos?
Pues seguramente no.
Seguramente no.
¿Por qué?
Porque el problema,
que lo que está pasando por aquí,
es que quería cero,
es un valor que podría ser tan válido como cualquier otro,
y en cambio lo que estamos haciendo aquí
es que nos hemos cargado el valor inicial,
que era cero,
por culpa de ser falsi.
Y ha sido por culpa del logical operator este,
que ha entendido que initial counter,
al ser falsi,
pues ha dicho,
ah,
pues como es falsi,
le pongo el valor por defecto de 25.
En este caso,
aquí tenéis un ejemplo de por qué sería bueno no utilizar el or,
sino que tendría más sentido utilizar el nullish.
Ahora,
lo que estamos diciendo,
initial counter es undefined o null,
porque si lo es,
ponme como valor por defecto 25.
Y ahora podemos ver que me mantiene siempre el cero.
Eso sería la forma.
Otra forma que tenéis que saber es que,
aparte de poder utilizarlo como un logical operator,
también lo podéis utilizar directamente como un logical assignment operator.
Y podéis ponerlo aquí,
directamente.
Entonces,
de esta forma lo simplificáis así.
De hecho,
no solo lo simplifica,
sino que es un poquito más óptimo.
Tampoco hagáis micro optimizaciones y os volváis locos con esto,
que os conozco.
Pero,
no es exactamente lo mismo esto,
que esto.
Y os voy a explicar por qué.
Aunque es muy sutil la diferencia,
puede ser interesante,
especialmente si aquí,
en lugar de un valor,
tenéis,
por ejemplo,
get value from database.
Pongamos que tenéis un método que tiene que ejecutar algo que es bastante costoso.
Esto no es igual.
Estas dos líneas no son exactamente iguales.
No son exactamente iguales porque esta de aquí,
va a evaluar esta expresión,
que ya que hemos dicho lo de las expresiones,
esta expresión la va a evaluar sí o sí,
independientemente del valor que tenga initial counter.
¿Vale?
Así que esto lo va a evaluar.
Va a entrar JavaScript aquí y va a evaluar esta parte de la derecha.
Pero en cambio aquí la línea 6 no la va a evaluar a no ser que realmente lo necesite.
O sea,
si mira que initial counter sea falsi,
entonces sí que evaluará la parte de la derecha.
Como os digo,
en este caso sería una micro,
micro,
micro optimización,
pero imaginais que sería así,
que tengamos algo así.
Get from database.
¿Vale?
Y que eso sea súper costoso.
Súper costoso.
Claro.
Bueno,
en este caso es que esto tampoco lo va a evaluar porque aquí está haciendo un short circuit.
Pero el tema es que esto entraría aquí y miraría siempre initial counter,
revisaría el valor para ver si realmente tiene el valor initial counter.
Esto en realidad haría más o menos lo mismo.
Sería una micro optimización,
pero la diferencia es que esta parte de aquí la va a evaluar siempre.
y esta parte de aquí no la va a evaluar a no ser que esto pase.
Al final puede ser una tontería,
pero que lo tengáis en cuenta.
Aparte de esto,
también lo podéis hacer con el or.
Esto también funciona.
Y tiene bastante sentido.
Queda bastante limpio.
O sea,
si entendéis la sintaxis,
yo creo que queda bastante limpia esta.
Y para poner valores por defecto en cosas de formularios y tal,
pues queda bastante bien porque al final pones aquí hola,
lo que sea,
false,
y quedan bien,
quedan bien,
mucho mejor que las que teníamos antes.
Así no reasigna el mismo valor initial counter.
Claro,
esta no la reasigna a no ser que lo necesite.
A no ser que lo necesite.
Por lectura preferiría hacerlo con una ternaria.
Peligroso,
polémico,
polémico,
polémico la verdad.
Yo no utilizaría una ternaria en este caso.
Si dominas y sabes lo que estás haciendo,
es que tiene más sentido esto.
Una ternaria,
aparte que te podría dar problemas,
parece una tontería que estás hablando de un micro nanosegundo.
Estamos hablando de nada.
Tonterías.
O sea,
microsegundos.
Estamos hablando de nino macrosegundos.
Por eso os digo que al final es una microautomización
en la que yo nunca pondría sobre la mesa
de,
no,
es que así va más rápido.
No,
eso no lo pondría nunca en la mesa.
Entonces,
sobre la ternaria,
yo la verdad es que no estoy muy de acuerdo
porque queda muy,
o sea,
es que es así,
¿no?
O sea,
¿no te parece?
Initial counter igual initial counter,
entonces initial counter 2.25,
¿no?
Me parece un poco exagerado,
¿no?
Pero qué más,
dice,
no te deja ver el resultado,
pero qué más da,
si no tenéis que ver el resultado.
Da igual,
si os tenéis que fiar de lo que os estoy comentando.
El nullish es una ternaria simplificada.
No es una ternaria simplificada,
es un operador que ya está.
Nunca usé el,
también estaría mal.
¿El qué?
También estaría mal.
Es que yo,
a mí este no me gusta mucho.
La verdad es que para este caso
tengo claro que utilizaría este.
Este me parece que es el más claro en este caso.
En este caso.
A mí sí que me gusta.
Sí,
claro,
la ternaria además,
obviamente,
esto lo que miraría es un falsi.
O sea,
esto sería,
esta sería más parecida a esta,
que estaría mal,
claro.
Sería parecida a esta que habíamos hecho,
que está mal.
Una cosa que podríais hacer aquí
es initial counter,
podríais hacer,
si es diferente a null,
y además hacerlo con dos,
es que esto es una mierda también.
Hacerlo así,
pero también es bastante compleja,
¿no?
No me gusta.
Hay gente que utiliza el,
hay gente que dice que utiliza esto
para los falsi.
A mí no me gusta este,
me gusta más utilizar boleano.
O sea,
más que evaluar el falsi,
lo que están haciendo es transformarlo a un boleano.
Si lo quieres transformar a un boleano,
es más fácil esto.
O se lee mejor que esto.
Y al final,
he visto cosas muy raras como poner tres y cosas así,
¿eh?
Prefiero un if.
Sí,
no,
si por complicar,
a ver,
es difícil que me digáis que preferís un if.
O sea,
no tiene sentido que me digáis que preferís un if a esto.
O sea,
lo que me estáis diciendo,
básicamente,
es que preferís esto.
Y no me lo creo.
O sea,
no me lo creo.
No me lo creo que prefiráis esto.
Que no me lo creo.
No me lo creo.
No me creo que prefiráis la parte de abajo.
No me lo creo.
Sí,
un switch.
Que os vayáis al peo,
un switch.
¿Y qué más?
¿Y qué más queréis?
¿Y qué más?
Queda más declarativo.
¿Cómo que más declarativo?
Todo lo contrario.
¿Cómo que más declarativo?
Queda más imperativo.
Esto es imperativo,
este código.
Esto estás diciendo,
si este código es tal,
el if lo sé leer,
lo de arriba no.
Pero eso es un problema de conocimientos,
no un problema de la sintaxis.
De hecho,
esto,
ahora que lo sabes,
es imposible que me digas que no lo sabes leer.
Imposible.
Llama una app y pasa ese en null,
ya te digo.
Sí,
mejor en binario.
¿Y qué más?
Me habéis cabreado.
Me voy.
Me voy.
Ya está.
Me voy.
Ya está.
Me voy.
Así uno no puede trabajar.
Bueno,
ahora en serio.
Me voy,
me voy.
Me voy a comer,
amigos.
Muchas gracias.
Mejor instalar un paquete.
Sí,
cancelo la miduconf.
Se acabó.
No hay miduconf.
Hasta aquí hemos llegado.
No podía asar.
O sea que,
chao.
Vamos a regalar una sub,
pero solo por rabia,
no por nada.
Si no.