Operadores: Asignación, Comparación y Aritméticos.

Bien, después de esta clase ya puedo agregar un meme que explica más sobre operadores 🤓

Operador de asignacion

Operadores de comparacion

Operadores aritmeticos

tambien se les conoce como operadores binarios. por que toman dos valores y generan un resultado.

Operadores logicos

//Operadores binarios:
3 + 2 //Suma
50 - 10 // Resta
10 * 20 //Multiplicación
20 / 2 //División

"Diego " + "De Granda" //concatenación de strings

//Operadores unitarios:
!false //negación de la negación = true

//Operadores de asignación:
var a = 1; //Asignamos un valor a la variable

//Operadores para comparar:
3 == "3"; //Compara los valores y devuelve "true" en este caso

3 === "3"; //Compara y valida los tipos y valores. Devuelve "falso" en este caso

5 < 3 //Compara y valida si el 5 es menor a 3
5 > 3 //Compara y valida si el 5 es mayor a 3
5 <= 6 //Compara y valida si el 5 es menor o igual al 6
5 >= 6 //Compara y valida si el 5 es mayor o igual al 6

a && b //Valida si ambas variables son verdaderas para que se cumpla la condición
a || b //Aquí se cumple la condición si alguna de las dos variables es verdadera

var edad = 40
edad++ //Incrementa el valor en 1

edad += 2 //Incrementa el valor por 2

// OPERADORES

// ARITMETICOS

+ // Suma a + b,  afirmación unitaria +a : Positivo, concatenación "a" + "la" : "ala"
- // Resta a - b, negación unitaria -a : Negativo
* // Producto a * b
/ // Divisor a / b
% // Residuo a % b
** // Potencia a ** b, a elevado a b
++ // Incremento (suma uno) a++ : a = a + 1
-- // Decremento (resta uno) a-- : a = a - 1

// ASIGNACIÓN

= // Asignación a = b
+= // Asignación de adición  a += b : a = a + b
-= // Asignación de sustracción  a -= b : a = a - b
*= // Asignación de multiplicación  a *= b : a = a * b
/= // Asignación de división  a /= b : a = a / b
%= // Asignación de residuo  a %= b : a = a % b
**= // Asignación de potencia  a **= b : a = a ** b
<<= // Asignación de desplazamiento a la izquierda  a <<= b : a = a << b
>>= // Asignación de desplazamiento a la derecha  a >>= b : a = a >> b
>>>= // Asignación sin signo de desplazamiento a la derecha  a >>>= b : a = a >>> b
&= // Asignación AND  a &= b : a = a & b
^= // Asignación XOR  a ^= b : a = a ^ b
|= // Asignación OR  a |= b : a = a | b

// COMPARACIÓN

== // Igualdad a == b, a tiene el mismo valor que b
!= // Distinto a != b, a tiene un valor diferente a b
=== // Identidad a === b igual valor igual tipo de dato
!== // Sin Identidad a !== b igual valor o igual tipo de dato
> // Mayor que a > b
>= // Mayor o igual que a >= b
< // Menor que a < b
<= // Menor o igual que a <= b

// LOGICOS

&& // AND, Y, a && b : a y b
|| // OR, O, a || b : a o b
! // NOT, Negación, a = true : !a = false

// LOGICOS A NIVEL DE BITS

<< // Desplazamiento a la izquierda  a << b
>> // Desplazamiento a la derecha  a >> b
>>> // Desplazamiento a la derecha sin signo  a >>> b
& // AND  a & b
^ // XOR  a ^ b
| // OR  a | b
~ // NOT  a | b```

Hola, aquí les dejo una tabla con los operadores de Comparación y Asignación. 😃

Imágen extraída de aprendeaprogramar.com

Imagen extraída de google imagenes.

Exitos, compañeros!

Perfecta clase, solo hizo falta un operador binario o aritmético, llamado módulo que es escrito con el símbolo de porcentaje (%). Este operador nos devuelve el resto o el sobrante de la división aritmética.

Ejemplo:
6 % 2; // Devuelve 0, porque es una división perfecta. 8 % 3; // Devuelve 2, porque no es una división exacta, 2 * 3 = 6, y el restante es 2

¡Hola a todos! les comparto mis notas, espero les sean de utilidad 😄

Todo el mundo deja de lado a la disyunción exclusiva :c

El operador ^ (acento circunflejo) sirve para la operación de disyunción exclusiva entre dos booleanos. Esta operación, también conocida como XOR, es básicamente: o es A, o es B, pero no pueden ser A y B a la vez

Tabla de verdad de a ^ b:

![](

aqui les dejo los operadores

Es importante utilizar el operador de triple igualdad en los condicionales

//OPERADORES
//Operadores Binarios:
3 + 2;
50 - 10;
10 * 20;
20 / 2;
//Tambien sirve para concatenar String:
"Diego " + "De Granda";
//Operador de negación:
!true; //devolverá false
!false; //devolverá true
//Operador de asignación:
var a = 3;
//operador de comparación:
3 == "3"; // va comparar el valor mas no el tipo
3 === "3"; // compara que el valor y el tipo sean iguales
5 > 3; //5 es mayor que 3 es true
5 < 3; // 5 es menor que 3 es false
5 >= 6; // 5 es mayor o igual 6 es false
5 <= 6; // 5 es menor o igual que 6 es true
5 <> 6; //5 no es igual que 6

a && b; // va validar que a y b son verdad se cumple esa condición
a || b; // va validar que solo a o b sea verdad para que se cumpla esa condición
//operadores de incremento:
var edad = 40;
edad++; //el valor de edad se va incrementar en uno.
edad += 2; // el valor de edad va incrementar en dos.

**== Vs === Por qué no todo es igual **

• Operador doble Igual (==): compara 2 valores PERO lo hace sin chequear el tipo de las variables

• Operador triple Igual (===): chequea el contenido de la variable y además, chequea que las dos variables sean del mismo tipo.

la mejor velocidad para reproducir estos videos es de 1.75x … el contenido esta muy bien explicado… pero la velocidad normal es demasiado lenta.

OPERADORES

- ARITMETICOS/BINARIOS:    + (suma) , -  (resta), * (multiplicación) , / (división)
                            Binarios porque es entre dos valores
                            
- UNITY:        ! (negación)
                Un solo operador con un solo valor
- ASIGNACION:   = (igual)

- COMPARACIÓN   == (comparar)  NOTA: puede comparar entre diferentes tipos, como numeros y strings (el valor perse)
                === (comparar) Compara que los tipos y los valores sean iguales
                < (menor que)
                > (mayor que)
                <= (mejor o igual)
                >= (mayor o igual)
- LOGICOS       && (and)
                || (or)

                ++ Incrementar en 1 un valor
                +=2 Incrementar un valor en 2

OPERADORES

==> ARITMÉTICOS

+ // Suma a + b,  afirmación unitaria +a : Positivo, concatenación "a" + "la" : "ala"
- "// Resta a - b, negación unitaria -a : Negativo
* // Producto a * b
/ // Divisor a / b
%// Residuo a % b
** // Potencia a ** b, a elevado a b
++ // Incremento (suma uno) a++ : a = a + 1
-- // Decremento (resta uno) a-- : a = a - 1

==> ASIGNACIÓN

= // Asignación a = b
+= // Asignación de adición  a += b : a = a + b
-= // Asignación de sustracción  a -= b : a = a - b
*= // Asignación de multiplicación  a *= b : a = a * b
/= // Asignación de división  a /= b : a = a / b
%= // Asignación de residuo  a %= b : a = a % b
**= // Asignación de potencia  a **= b : a = a ** b
<<= // Asignación de desplazamiento a la izquierda  a <<= b : a = a << b
>>= // Asignación de desplazamiento a la derecha  a >>= b : a = a >> b
>>>= // Asignación sin signo de desplazamiento a la derecha  a >>>= b : a = a >>> b
&= // Asignación AND  a &= b : a = a & b
^= // Asignación XOR  a ^= b : a = a ^ b
|= // Asignación OR  a |= b : a = a | b

==> COMPARACIÓN

== // Igualdad a == b, a tiene el mismo valor que b
!= // Distinto a != b, a tiene un valor diferente a b
=== // Identidad a === b igual valor igual tipo de dato
!== // Sin Identidad a !== b igual valor o igual tipo de dato
> // Mayor que a > b
>= // Mayor o igual que a >= b
< // Menor que a < b
<= // Menor o igual que a <= b

==> LÓGICOS

&& // AND, Y, a && b : a y b
|| // OR, O, a || b : a o b
! // NOT, Negación, a = true : !a = false

==> LÓGICOS A NIVEL DE BITS

<< // Desplazamiento a la izquierda  a << b
>> // Desplazamiento a la derecha  a >> b
>>> // Desplazamiento a la derecha sin signo  a >>> b
& // AND  a & b
^ // XOR  a ^ b
| // OR  a | b
~ // NOT  a | b

_Link a documentación de Mozilla: _

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators

Lo del triple igual === es bárbaro

En ésta clase se vieron los operadores de Negación Lógica (NOT o !) Conjunción (AND o &&) y Disyunción (OR o ||)
Acá abajo te dejo la tabla de valores (En qué casos da Verdadero y cuales dan Falso)

Existen 3 típos de operadores: Aritméticos, Lógicos y Relacionales:

Aritméticos: +, *, -, /
Lógicos: &&, ||, !
Relacionales: =, ==, ===, +=, -=, *=, /=

Orden de prioridad, prelación y precedencia de los operadores:

En los ultimos ejemplos de Diego:

• edad++ es igual a edad + 1;
• edad += 2 es igual a usar edad = edad + 2;
  Es más fácil trabajar así solo hay que practicar!

🐱‍💻 Tendremos operadores de asignación, comparación y aritméticos para usarlos en el lenguaje de programación.

//operadores binarios, son los que generan operaciones normales
3 + 2
3 * 3
3 - 1
20 / 2
2 ** 5
10 % 3
"Adrian" + "Garcia"
!false
true
3 == "3" //true
3 === "3" //true in type
5 > 3
5 >= 3
5 < 3
5 <= 3
a && b //and
a || b //or

1++ //2
2-- //1

Aca un link a una cheatsheet de JS que me parecio fenomenal !

https://javascript.pythoncheatsheet.org/#export

En js el ! es como la carta del uno

//Operadores de operacion o operadores binarios
3 + 2
50 - 10
10 * 20
20 / 2
"Ramon " + "Ruiz"

//Operadores unitarios
!false

//Operadores de asignacion
var a = 1;

//Operadores de comparacion
3 == "3"//true
3 === "3"//false
5 < 3
5 > 3
5 <= 6 
5 >= 6

//Operadores Logicos
a && b
a || b

//Operadores de incremento
var edad = 40
edad++
edad += 2```

Operadores de Operación

• • : este tambien sirve para concatenar texto

• /

  3 + 2
  50 - 10
  10 * 20
  20 / 20
  "Bryan" + “Calero” //concatenar

Unity Operator

• ! : Sirve para negar

  !false //no devuelve que es true ya que lo estaria negando

Operadores de Asignación y comparación

• = : Asigna valor

• == : hace una comparación no estricta (no importa tipos de variables)

• === : Hace una comparación estricta (Importas los tipos de variables)

  var a = 1; //asigna uno a la variable x
  3 == “3”; //TRUE compara dos variables y no toma en cuenta el tipo de variable
  3 === “3”;//FALSE Compara dos variable y toma en cuenta el tipo de variable

Codigo desafio juego - piedra, papel o tijera

/*=============================================
    Juego - Piedra, Tijera o Papel
=============================================*/

// Esatructura de datos
const opciones = ["piedra", "tijera", "papel"];

function jugadorMaquina() {
  // Retorna un valor aleatorio entre 0 y 3
  var indice = Math.floor(Math.random() * 3);
  document.getElementById(
    "maquina"
  ).innerHTML = `<strong>Máquina:</strong> ${opciones[indice]}`;
  return opciones[indice];
}

/*=============================================
=  Obtiene seleccion del Jugador del HTML     =
=============================================*/
function getRadioButtonSelectedValue() {
  var elementos = document.getElementsByName("opcionesjugador");
  for (i = 0; i < elementos.length; i++) {
    if (elementos[i].checked) {
      var seleccionJugador = elementos[i].value;
      var seleccionMaquina = jugadorMaquina();
      /*=============================================
      =            Jugador = Maquina                =
      =============================================*/
      if (seleccionJugador === seleccionMaquina) {
        mostrarResultado("EMPATE");
      /*=============================================
      =   Combinaciones de Piedra, Papel y Tijera   =
      =============================================*/
      } else {
        seleccionJugador === "piedra" && seleccionMaquina === "papel"
          ? mostrarResultado("PERDISTE")
          : null;
        seleccionJugador === "piedra" && seleccionMaquina === "tijera"
          ? mostrarResultado("GANASTE")
          : null;
        seleccionJugador === "papel" && seleccionMaquina === "piedra"
          ? mostrarResultado("GANASTE")
          : null;
        seleccionJugador === "papel" && seleccionMaquina === "tijera"
          ? mostrarResultado("PERDISTE")
          : null;
        seleccionJugador === "tijera" && seleccionMaquina === "piedra"
          ? mostrarResultado("PERDISTE")
          : null;
        seleccionJugador === "tijera" && seleccionMaquina === "papel"
          ? mostrarResultado("GANASTE")
          : null;
      }
    }
  }
}

// Muestra el resultado en HTML
function mostrarResultado(resultado) {
  return (document.getElementById(
    "resultado"
  ).innerHTML = `<strong>¡${resultado}!</strong>`);
}

//operadores binarios, son los que generan operaciones normales
3 + 2
3 * 3
3 - 1
20 / 2
2 ** 5
10 % 3
"Andres" + “Viviana”
!false
true
3 == “3” //true
3 === “3” //true in type
5 > 3
5 >= 3
5 < 3
5 <= 3
a && b //and
a || b //or

• **Operadores de comparación **https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Operadores/Comparison_Operators

• Operadores aritméticos
  https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Operadores/Aritméticos

• Operadores de asignación
  https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Operadores/Assignment_Operators

¿En los operadores no entraría también el “MOD” (%)?

Falto el operador %, es el que devuelve el residuo de una división

== // Es igual
=== // Es identico

Considero que faltó el operador ternario.

var a = 5;
var b = 3;
c = a > b ? "Es mayor" : "Es menor";

Si la condición después del símbolo de igual (=) se cumple entonces se c tendrá el valor de “Es mayor”, de lo contrario c tomará el valor de “Es menor”.

😃

//Operadores binarios:
3 + 2 //Suma
50 - 10 // Resta
10 * 20 //Multiplicación
20 / 2 //División

"Diego " + “De Granda” //concatenación de strings

//Operadores unitarios:
!false //negación de la negación = true

//Operadores de asignación:
var a = 1; //Asignamos un valor a la variable

//Operadores para comparar:
3 == “3”; //Compara los valores y devuelve “true” en este caso

3 === “3”; //Compara y valida los tipos y valores. Devuelve “falso” en este caso

5 < 3 //Compara y valida si el 5 es menor a 3
5 > 3 //Compara y valida si el 5 es mayor a 3
5 <= 6 //Compara y valida si el 5 es menor o igual al 6
5 >= 6 //Compara y valida si el 5 es mayor o igual al 6

a && b //Valida si ambas variables son verdaderas para que se cumpla la condición
a || b //Aquí se cumple la condición si alguna de las dos variables es verdadera

var edad = 40
edad++ //Incrementa el valor en 1

edad += 2 //Incrementa el valor por 2

Existe un término ‘fancy’ en programación llamado overloading, que se refiere a que un operador (en este caso) cuenta con más de un comportamiento dependiendo de los tipos de valores usados en la operacion.
Un ejemplo de esto sería el operador +.

3 + 4 // Output: 7 (En este caso sería una simple suma aritmética)
'Hola ' + 'compañeros' // Output: Hola compañeros (En este caso sería una string concatenation)

Algo más a tener en cuenta, es que los operadores como +=, -=, etc., son operadores que se pueden usar únicamente con variables. Como por ejemplo, la variable edad que utilizó el profesor en esta clase.
Un saludo.

Operadores de Comparación
= (Es igual a) Igual a

(Mayor que) Mayor que
< (Menor que) Menor que
= (Mayor o igual a) Mayor o igual que
<= (Menor o igual a) Menor o igual que
<> (No es igual a) No es igual a
!= (No es igual a) No es igual a
!< (No menor que) No es menor que
!> (no mayor que) No es mayor que

Operadores de Asignación en JavaScript
https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Operadores/Assignment_Operators

otra forma de suma sencilla para entender de donde sale edad++ incremento
edad = edad + 1;
edad++,
son lo mismo

El tema de que se cumpla uno y/o la otra se aprendé con las Tablas de Verdad en matemáticas discretas, dejo la tabla:

(&& = Y ; || = O ; ! = Negación)

// Operadores asignacion, comparacion y  aritmeticos


//operadores binarios o matematicos

3 + 2 //regresa suma
50 -10 //regresa resta
10 * 20// regresa multiplicacion
20 / 2 // regresa division


//concatenacion

"Diego"+"De Granda"

//negacion

!false // con el caracter ! estamos indicando que lo que esta a su lado es false
       //por lo tanto se volveria verdadero lo que significa ahora ese valor


//operadores de asignacion (con el = aignamos valores)

var a = 1;


// comparacion de valores

//==

3=="3"; //true


3 === "3" //false

/*diferencias entre  == vs ===

== solo compara que los valores sean iguales sin importar su tipo

=== es estricto y compara todos los puntos para verificar que sean 100% iguales


*/


5 < 3 //false

5 > 3 // true


5 <= 6 // true

5 >= 6 // false 

a && b /* validar si dos condiciones son verdaderas 
        solo sera true si todas la condiciones son verdad de lo contrario
        siempre sera false*/

a || b /* validar si alguna de las condiciones es verdad, si almenos una es true
          pasaria el condicional porque seria verdad, pero si nada es verdad sera false    */


var edad = 40

//valores de incremento

edad++ // aunmenta 1

edad += 2 // edad = edad + 2;

Operadores en JavaScript

Los operadores de asignación son los siguientes: (Estos simplemente asignan un valor)

• =
• +=
• -=
• /=
• *=

Los operadores de comparación devuelven un boolean. Estos comparan dos valores y tenemos la doble igualdad y la triple igualdad:

• == //La doble igualdad compara valores.

• === //La triple igualdad compara el valor mas tipo de dato.
  Recomendación: Evitar usar la doble igualdad para comparaciones porque puede dar problemas.

• != //Negación, compara la diferencia pero al igual que antes, solo compara valor.

• !== //Evalua la diferencia tanto de valor y tipo de dato. Por eso se recomienda más.
  Y los demás operadores son:

• <

• =

• <=

Los operadores unarios son aquellos operadores que no requieren dos datos. Solo les basta uno.

• typeof
• !    // negación

Los operadores aritméticos

• /
• %
• ++ //Incremento
• – //Decremento

Nota: Cuando estos dos últimos operadores van después de la variable:
por ejem: numbers++ o numbers-- se le llama post incremento y post decremento, quiere decir que el valor va a cambiar para la próxima vez que llame a dicha variable.

Entonces si queremos hacer el cambio al momento de llamar la variable, le damos un pre incremento o pre decremento, así:
++numbers o --numbers.

Una imagen que nos muestra el orden de prioridad de los operadores
.
.

Les comparto las comparaciones que debemos evitar como buenas practicas.

Qué util, no sabía la diferencia entre == y ===.

Los que se encuentran por aqui [email protected] no se rindan y sigan cumpliendo sus sueños, muchas personas desearian estar en nuestro lugar

te quiero profe Diego, sos el que mejor explica y el que mas emocion me hace dar por la programacion!!!

Operador aritmético
Permiten realizar operaciones aritméticas en los números.

• + // Suma a + b, afirmación unitaria +a : Positivo, concatenación “a” + “la” : “ala”
• // Resta a - b, negación unitaria -a : Negativo
• // Producto a * b
• / // Divisor a / b
• % // Residuo a % b
• ** // Potencia a ** b, a elevado a b
• ++ // Incremento (suma uno) a++ : a = a + 1
• // Decremento (resta uno) a-- : a = a – 1

Operador de comparación
Nos permiten realizar comparaciones con nuestros tipos de datos

• == // Igualdad a == b, a tiene el mismo valor que b
• != // Distinto a != b, a tiene un valor diferente a b
• === // Identidad a === b igual valor igual tipo de dato
• !== // Sin Identidad a !== b igual valor o igual tipo de dato
• // Mayor que a > b
• >= // Mayor o igual que a >= b
• < // Menor que a < b
• <= // Menor o igual que a <= b

Operadores lógicos
Permiten realizar operaciones lógicas o booleanas.

• && // AND, Y, a && b : a y b
• || // OR, O, a || b : a o b
• ! // NOT, Negación, a = true : !a = false

Operador bit a bit
Nos permite trabajar los valores nivel de bit de informacion.

• << // Desplazamiento a la izquierda a << b
• >> // Desplazamiento a la derecha a >> b
• >>> // Desplazamiento a la derecha sin signo a >>> b
• & // AND a & b
• ^ // XOR a ^ b
• | // OR a | b
• ~ // NOT a | b```

Operador de asignación
Nos permite guardar valores en nuestras variables

• = // Asignación a = b
• += // Asignación de adición a += b : a = a + b
• -= // Asignación de sustracción a -= b : a = a - b
• *= // Asignación de multiplicación a *= b : a = a * b
• /= // Asignación de división a /= b : a = a / b
• %= // Asignación de residuo a %= b : a = a % b
• **= // Asignación de potencia a **= b : a = a ** b
• <<= // Asignación de desplazamiento a la izquierda a <<= b : a = a << b
• >>= // Asignación de desplazamiento a la derecha a >>= b : a = a >> b
• >>>= // Asignación sin signo de desplazamiento a la derecha a >>>= b : a = a >>> b
• &= // Asignación AND a &= b : a = a & b
• ^= // Asignación XOR a ^= b : a = a ^ b
• |= // Asignación OR a |= b : a = a | b

He Aprendido algo nuevo, los 3 iguales sirven para comparar tipos de datos, es muy interesante.

Hola compañeros, estuve consultando, y encontré algo llamado operadores unarios que, en efecto, vienen a ser los operadores binarios (+ y -) aplicados a un único operando.

Ambos ejecutan una conversión numérica, de la siguiente forma:

-“1” // -1
+“1” // 1
+false // 0
-true // -1

Es decir, el + funciona como el método de coerción Number() pero mas corto, y el - de la misma forma pero haciendo negativo el resultado.

Otro dato del comportamiento de +, es que al operar con + si uno de los operandos es una cadena, el otro en convertido a una cadena también. Ejemplo:

‘1’ + 1 // ‘11’ => El uno de tipo number se convirtió en string y se concateno.
2 + 2 + ‘1’ => Ambos dos fueron sumados como number pero al llegar al string, su resultado (4) es convertido en string y concatenado.
‘1’ + 2 + 2 => Despues del string los dos operandos son convertidos a string y concatenados.

Me pareció interesante compartirlo 😉

No quiero ofender al profesor de este curso pero el profesor de la escuela de Python explica muchisimo mejor los operadores y sus usos, ya que python y JS son practicamente lo mismo.

Mi pequeño aporte, si no saben como poner || es el botón ala izquierda del 1.

Y una explicación

|| = es true si se cumple esto o esto ej.( 5=6 || 5=7)=false
&& = es true si se cumple esto y esto ej.( 6=6 && 6>5 )=true

Miniproyecto hasta la actual clase. Con las mayorías de los temas vistos.

var num1 = 10;
var num2 = 20;
var num3 = 3;
var str3 = "3";
var str1, str2;

function suma(num1, num2) {
  return num1 + num2;
}

function resta(num1, num2) {
  return num1 - num2;
}

function mult(num1, num2) {
  return num1 * num2;
}

function div(num1, num2) {
  return num1 / num2;
}

function mod(num1, num2) {
  return num1 % num2;
}

function conc(str1, str2) {
  console.log(str1 + str2);
}

//Operadores aritmeticos
function OutOperadoresAritmeticos() {
  console.log(
    "Operadores Aritmeticos " + suma(num1, num2),
    resta(num1, num2),
    mult(num1, num2),
    div(num1, num2),
    mod(num1, num2)
  );
}

function Comparacion(num3, str3) {
  if (num3 == str3) {
    return true;
  } else {
    return false;
  }
}

function ComparacionExacta(num3, str3) {
  if (num3 === str3) {
    return true;
  } else {
    return false;
  }
}

function ComparacionMenorQue(num3, str3) {
  if (num3 < num1) {
    return true;
  } else {
    return false;
  }
}

function ComparacionMayorQue(num3, num1) {
  if (num3 > num1) {
    return true;
  } else {
    return false;
  }
}

function ComparacionMayorOIgual(num3, num1) {
  if (num3 >= num1) {
    return true;
  } else {
    return false;
  }
}

function ComparacionMenorOIgual(num3, num1) {
  if (num3 <= num1) {
    return true;
  } else {
    return false;
  }
}

function imprimirComparaciones() {
  console.log(
    "Comparaciones: " + Comparacion(num3, str3),
    ComparacionExacta(num3, str3),
    ComparacionMayorQue(num3, num1),
    ComparacionMayorOIgual(num3, num1),
    ComparacionMenorQue(num3, num1),
    ComparacionMenorOIgual(num3, num1)
  );
}

imprimirComparaciones();
OutOperadoresAritmeticos();

Mi resumen de operadores

Tabla de comparación:

Ver más en ¿Por qué “0” == [] es false?

Excelente

Este meme es bueno jajajaja

'b' + 'a' + +'a' + 'a'

'baNaNa'

Es importante diferenciar entre ++x y x++. Si verifican en consola lo siguiente:

var x = 20
x++
20

La consola devolverá 20, pero si se vuelve a imprimir la variable x el valor será 21. En cambio si se pone como sufijo, la consola devolverá inmediatamente 21

var x = 20
++x
21

Esto pasa por que si se usa ++ como operador prefijo (++x), devuelve el valor de su operando después de agregar uno; si se usa como operador sufijo (x++), devuelve el valor de su operando antes de agregar uno. Esto es muy útil entenderlo para ciclos lógicos como for

* → Operarador de multiplicación

Ejemplo: 2 * 2

/ → Operador de división

Ejemplo: 4 / 4

+ → Operador de suma

Ejemplo: 2 + 2

Tambien se puede usar con cadenas de texto, esto se llama ‘concatenación’, por ejemplo:

"Santiago " + "Bastidas"

- → Operador de resta

Ejemplo: 4 - 4

! → Operador de negación

Ejemplo: !true daría resultado false y viceversa

= → Operador de asignación

**Ejemplo: var a**= 4

== → Operador de comparación

Ejemplo: 3 == "3" da como resultado "true"

=== → Operador de comparación estricto por tipo

Ejemplo: 3 === "3" ****da como resultado "false" porque este operador compara tanto el tipo de dato sea igual en los dos valores. Otro ejemplo en el que saldría un valor verdadero sería: 3 === 2 + 1

< Menor que

Ejemplo: 3 < 5 da como resultado "true" y 5 < 3 da como resultado "false"

> Mayor que

Ejemplo: 5 > 3 da como resultado "true" y 3 > 5 da como resultado "false"

≤ Menor o igual que

Ejemplo: 3 <= 5 da como resultado "true" y 5 <= 3 da como resultado "false". También se pude validar lo siguiente, 5 <= 5 y el resultado sería "true"

≥ Mayor o igual que

Ejemplo: 3 >= 5 da como resultado "false" y 5 >= 3 da como resultado "true". También se pude validar lo siguiente, 5 <= 5 y el resultado sería "true"

a && b Operador “Y” valida que los dos valores u operaciones sean verdaderos, si uno es verdadero y el otro no, el resultado será falso.

Ejemplo: 1 < 2 && 4 < 8 el resultado va a ser "true"

a || b Operador “O” valida que uno de los dos valores u operaciones sean verdaderos, si uno es verdadero y el otro no, el resultado sera verdadero, solo si ninguno es verdadero el resultado es falso

Ejemplo: 1 < 2 || 3 < 1 El resultado va a ser "true" debido a que 1 si es menor que 2 aunque en la otra comparación sea "false" porque 3 no es menor que 1.

Son operadores que incrementan el valor de una variable.

++ ó =+

Ejemplo: var edad = 18 , edad++ , edad =+ 2 Estos operadores ayudan a incrementar el valor de la varible, en el primer caso se incrementa el valor en 1 unidad, en el segundo caso se puede asignar el valor que se quiere incrementar.

// Operadores Aritmeticos | Operadores Binarios 
+  (suma)
-   (resta)
*  (multiplicacion)
/   (division)
% (resto de una division)
----------------------------------------------------------------------
// Operadores Relacionales 
> (Mayor que)
< (Menor que)
>= (Mayor Igual)
<= (Menor Igual)
==  (Igualdad)
=== (Estrictamente igual)
! =    (Distinto o Igual)
! == (Desigualdad estricta)
--------------------------------------------------------------------------
// Operadores Logicos 

AND: (&& : (Y) )  // Se deben cumplir las dos condiciones
OR : ( ||  :  (O) //  Se debe cumplir una de las dos condiciones
NOT ( ! ) Devuelve false si su único operando se puede convertir a true; de lo contrario, devuelve true.

Ej:   
var n1 = !true; // !t devuelve false
//Valor incrementar (++)  
var edad = 40;
edad ++;
41
// Incrementar 2
edad + = 2;  // Es  igual a escribir
edad + edad = 2;

// Decremento ( - - )
var edad = 41;
edad --;
40

Genial

Les comparto la precedencia de operadores para que conozcan cómo se determina el orden en el cual los operadores son evaluados.

https://developer.mozilla.org/es/docs/Web/JavaScript/Guide/Expressions_and_Operators

Tambien el decremento con – o -=

Vamos muy bien con el curso!, excelentes explicaciones, y muy ordenadas las notas en Github.

Al usar === sí importa el tipo de dato ej: 3 === "3" false

comparar un numero con un string con == no importa el tipo de dato, sino el valor ej: 3 == "3" true

Les recomiendo el enlace de la documentacion Mozilla, hay cosas curiosas como esto

var a5 = ‘Cat’ && ‘Dog’; // t && t returns Dog

Tambien los operadores '? ’ y ‘,’

¿Alguien sabe como sacar el simbolo de “o”? Las dos lineas verticales.

Buena introducción pero sin duda recomiendo revisar el enlace a la documentación para ver todos los operadores y que aquí no se han llegado a mencionar.

se viene el operador Nullish coalescing , ya está en Stage 4 !!!

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator

OPERADORES!:

• • • / suma, resta, multiplicacion y division (operadores binarios, entre dos variables).
      ! Es una negacion (!true) , significaria que es falso
      = asignacion
      == comparacion del valor 3 == “3” seria true
      === comparacion estricta 3 === “3” seria falso

< signo menor o mayor <= menor o igual y viceversa.
a && b ( si la condicion a Y la condicion b … )
a || b (si la condicion a O la condicion b … )
+= sumar 2 veces el mismo valor
% devuelve el residuo de la division como bien dice el compañero de abajo.

aqui les dejo mas ejemplos de operadores

No entendí muy bien los operadores “&&” y “||”, alguien podría pasarme una lectura adicional con ejemplos, creo que fue tocado muy superficial este tema.

% permite conocer el residuo de una division

estupendo

Apenas vengo a entender el === 🤯

Les comparto mis apuntes:

ARTIMÉTICOS
Permiten realizar operaciones entre datos de tipo numérico.

Suma:
3 + 2
Pero también sirve para concatenar cadenas de texto (string).
"Hola " + “mundo”

Multiplicación:
5 * 10

Resta:
20 - 15

División:
9 / 3

BOOLEANOS
Permiten realizar operaciones entre datos booleanos.

AND (&&): El resultado es verdadero únicamente cuando los dos operadores son verdadero, de lo contrario el resultado es falso.

Ej:
true && true
// Resultado: true

OR (||): El resultado es verdadero cuando cualquiera de los dos operadores es verdadero o si ambos son verdadero, por el contrario si ambos son falsos, el resultado es falso.

Ej:
true || false
// Resultado: true

NOT (!) NEGACIÓN: Invierte el valor del operador, si es verdadero pasa a ser falso y si es falso pasa a ser verdadero.

Ej:
!true
// Resultado: falso

!false
// Resultado: true

ASIGNACIÓN
Permite asignar un valor o dato a una variable.

Ej:
x = 3

COMPARACIÓN
Permite comparar dos valores (datos) o variables, devolviendo un valor verdadero (true) si cumple la comparación o un valor falso (false) si no.

Igual: compara los valores haciendo conversión de tipos
3 == “3”
// Resultado: true

Estrictamente igual: compara valores y tipos
3 === “3”
// Resultado: false

Menor que
5 < 3
// Resultado: false

Menor que
5 > 3
// Resultado: true

Menor o igual que
5 <= 5
// Resultado: true

Mayor o igual que
5 >= 6
// Resultado: false

INCREMENTO O DECREMENTO
Permite incrementar o decrementar valores numéricos.

Siendo x = 2
x++ es igual a decir x+=1
// Resultado: 3

Siendo x = 2
x-- es igual a decir x-=1
// Resultado: 1

Siendo x = 2
x+=2
// Resultado: 4

Siendo x = 2
x-=3
// Resultado: -1

5>3 | 5<3 | 5<=3 COMPARACIÓN
3+2 SUMA
3-2 RESTA
3*2 MULTIPLICACIÓN
3/2 DIVISIÓN
3%2 RESTANTE
!Negación
=== Igualación estricta
==Igualación(No tan estricto)
a && b SI ALGUNA DE LAS DOS NO ES VERDADERA NO SE CUMPLE LA CONDICIÓN
a || b BUSCA EL PRIMER VERDADERO
var i = 30
i++ Incrementa el numero por uno
i+= 2 Incrementa el numero por dos

No entendí porque el operador =+ en el ejemplo “edad += 2” hizo que el valor 40 pasara a 43.

El operador (+=) no necesariamente solo aumentara 2, puede aumentar el valor que quieras, obiamente mayor a 1, te lo explico mejor en el ejemplo!

var edad = 10; 
edad++; //Edad ahora valdra 11

//Pero si usamos el operador +=
edad += 2; //edad valdra  13 (Porque anteriormente le asignamos 1 arriba mas 2 = 13)

//Pero le podemos asignar un valor mayor a 2
edad += 100; //Ahora nuestra variable valdra 113

//Puedes aignarle cualquier valor mayor a "1" al operador (+=)

Hola, buena explicación.
Podrias establecer ejemplos de aplicación de Asignación de desplazamiento, derecha e Izquierda:
del modo: x >>>= y ;

Operadores: Asignación, Comparación y Aritméticos.

Operadores de asignación

Un operador de asignación asigna un valor a su operando izquierdo basándose en el valor de su operando derecho. El operador de asignación simple es igual (=), que asigna el valor de su operando derecho a su operando izquierdo. Es decir, x = y asigna el valor de y a x.

Operadores de comparación

Un operador de comparación compara sus operando y devuelve un valor lógico en función de si la comparación es verdadera (true) o falsa (false).

Operadores aritméticos

Un operador aritmético toma valores numéricos (ya sean literales o variables) como sus operandos y devuelve un solo valor numérico.

Los operadores aritméticos estándar son suma (+), resta (-), multiplicación (*) y división (/).

Es importante tener esos puntos básicos bien claros

https://hetpro-store.com/TUTORIALES/compuertas-logicas/

Recomiendo leer un poco sobre compuertas logicas y/o tablas de verdad para comprender mejor este tema!

Muy buena clase.

Ejemplos
Caso 1:

• Compara su contenido sin tomar en cuenta el tipo de dato.

Caso 2:

• Compara su contenido y el tipo de dato.

Caso 3:

• Compara su contenido y el tipo de dato
  (Por eso es igual 5 es igual a 5).

Caso 4:

• Compara nadamas el contenido.

Operadores: Asignación, Comparación y Aritméticos.

3+2
5
50-10
40
10*20
200
20/2
10
"Diego " + "De Granda"
'Diego De Granda'
!false
true
var a=1;
undefined
3 =="3"
true
3==="3"
false
5<3
false
5>3
true
5<=6
true
5>=6
false
a && b
'20'
a || b
1
var edad=40;
undefined
edad ++;
40
edad += 2;
43

// Operadores:
// Asignación:
const asignacion = {
    asignacion: "=",
    adicion: "+=", 
    sustracción: "-=",
    multiplicacion: "*=",
    division: "/=",
    residuo: "%=",
    potencia: "**=",
    and: "&=",
    or: "|=",
}

// Comparación:
const comparacion = {
    igualA: "==",
    noIgualA: "!=",
    igualEstricto: "===",
    noIgualEstricto: "!==",
    mayorQue: ">",
    mayorOIgualQue: ">="
    menorQue: "<",
    menorOIgualQue: "<="
}

// Aritméticos:
const aritmeticos = {
    suma: "+",
    resta: "-",
    multiplicacion: "*",
    division: "/",
    residuo: "%",
    potencia: "**",
    incremento: "++", tener en cuenta si es --a y a--
    decremento: "--" tener en cuenta si es --a y a--
}

// Lógicos:
const logicos = {
    and: "&&",
    or: "||"
    not: "!",
}

Aparte del “+=” para aumentar el valor de una variable podemos usar “-=” para restar, “/=” para dividir “*=” para multiplicar e incluso “%=” para sacar y asignar directamente el modulo.

//operadores binareos o matematicos
1+2
3-4
5*6
7/8
"jeisson "+"Felipe"//tambiensirve con srings

!false //unity operator o operadores unitarios (el signo "!" niega la operacion )

var a = 1//operador de asignacion
a == 1   //operador de conparacion igual
1 === "1"//operacion de comparacion igual estricta
5 >  3   //operacion de comparacion mayor que
5 >= 3   //operacion de comparacion mayor o igual
5 <  3   //operacion de comparacion menor que
5 <= 3   //operacion de comparacion menor o igual

a && b //operacion de validacion si a y b son verdad
a || b //operacion de validacion si a o b es verdad

var edad = 40
edad ++  //operador de sumar un numero
edad +=2 //operador de sumar la cantidad que quiera

Buena clase

para hacer:

& teclado: SHIFT + 6 se llama AMPERSAND

| | teclado sólo la tecla Al lado del 1, arrbia del tab, bajo el escape.

Llevo un buen rato y no la dejo de mirar

Buen curso

Falto el operador ‘diferente’ para saber si dos valores son diferentes:

"a" != "b" //true
"a" != "a" //false
1 != "1" //false
1 !== "1" //true