Introducción al curso

1

¡Alto! Tenemos una nueva versión de este curso para ti

2

Bienvenidos al Curso de Fundamentos de JavaScript

3

Repositorio de este curso de fundamentos de JS

Primeros pasos en JavaScript

4

Variables

5

Variables: Strings

6

Variables: Números

7

Funciones

8

El alcance de las funciones

9

Objetos

10

Desestructurar objetos

11

Parámetros como referencia o como valor

12

Comparaciones en JavaScript

Estructuras de Control y Funciones

13

Condicionales

14

Funciones que retornan valores

15

Arrow functions

16

Estructuras repetitivas: for

17

Estructuras repetitivas: while

18

Estructuras repetitivas: do-while

19

Condicional múltiple: switch

Arrays

20

Introducción a arrays

21

Filtrar un array

22

Transformar un array

23

Reducir un array a un valor

Programación Orientada a Objetos en JavaScript

24

Cómo funcionan las clases en JavaScript

25

Modificando un prototipo

26

El contexto de las funciones: quién es this

27

La verdad oculta sobre las clases en JavaScript

28

Clases en JavaScript

Asincronismo

29

Funciones como parámetros

30

Cómo funciona el asincronismo en JavaScript

31

Cómo funciona el tiempo en JavaScript

32

¿Qué pasó con swapi.co?

33

Callbacks

34

Haciendo múltiples requests

35

Manejando el Orden y el Asincronismo en JavaScript

36

Manejo de errores con callbacks

37

Promesas

38

Promesas Encadenadas

39

Múltiples promesas en paralelo

40

Async-await: lo último en asincronismo

Juego de HTML

41

Comenzando el juego

42

Generando una secuencia de números

43

Iluminando la secuencia de colores

44

Obteniendo el input del usuario

45

Agregando la verificación del color elegido

46

Agregando los estados finales del juego

47

Conclusiones del curso

Complementos

48

Diferencias entre var, let y const

49

Memoización: ahorrando cómputo

50

¿Hace cuántos días naciste?

51

Funciones recursivas

52

Entiende los closures de JavaScript

53

Estructuras de datos inmutables

54

Cambiando de contexto al llamar a una función

55

¿Cuándo hace falta poner el punto y coma al final de la línea?

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Comparaciones en JavaScript

12/55
Recursos

Existen varias maneras de comparar variables u objetos dentro de javascript. En el primer ejemplo le asignamos a X un valor numérico y a Y un string. Para poder compararlos debemos agregar dos signos de igual (==). Esto los convierte al mismo tipo de valor y permite que se puedan comparar.

Cuando realizamos operaciones es recomendable usar tres símbolos de igual (===). Esto permite que JavasScript no iguale las variables que son de distinto tipo. Te recomendamos que uses el triple igual siempre que estés comparando variables.

Existen cinco tipos de datos que son primitivos:

  1. Boolean
  2. Null
  3. Undefined
  4. Number
  5. String

Aportes 314

Preguntas 16

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Resumen de la Clase:

Comparaciones en JavaScript

Existen varias maneras de comparar variables u objetos dentro de javascript.

Existen cinco tipos de datos que son primitivos y es necesario comprender al momento de hacer comparaciones:

• Boolean
• Null
• Undefined
• Number
• String
<h4>Variables</h4>

En el primer ejemplo le asignamos a ‘x’ un valor numérico y a ‘y’ un string.
Para poder compararlos debemos agregar dos signos de igual “==”. Esto los convierte al mismo tipo de valor y permite que se puedan comparar.


	var x = 4
	var y = '4'

	x == y    
	// true
	

Cuando realizamos operaciones es recomendable usar tres símbolos de igual (===). Esto permite que JavasScript no iguale las variables que son de distinto tipo.

					*Sacha recomienda usa siempre el triple igual, pero hay controversia...

	x === y  
	// false

<h4>Objetos</h4>

Al comparar objetos JS tiene en cuenta también el nombre del objeto, por lo tanto se remite a comparar el nombre de las variables a demás del valor de los atributos.
Con objetos literales desglosados (otroMas en este caso), pasa lo mismo y la comparación da false ya que lo que se genera es un nuevo objeto a partir del desglosado.


	var sacha = {
		nombre: 'Sacha'
	}
	var otro = {
		nombre: 'Sacha'
	}
	var otroMas = {
		...sacha
	}
	
	sacha == otro		
	// false
	
	sacha === otro 	
	// false

	sacha == otroMas	
	// false
	
	sacha === otroMas	
	// false

Si asignamos el valor del objeto a una variable y los comparamos, el doble y el triple igual darán como resultado ‘true’ ya que en este caso las dos variables estarían refiriendo al mismo espacio en la memoria RAM.


	var otroMasTodavia = sacha

	sacha == otroMasTodavia	
	// True
	
	sacha === otroMasTodavia	
	// True

Otra cosa a tener en cuenta es que si cambiamos el valor del atributo en la variable, automáticamente cambia el valor del objeto también, por el mismo motivo que los operadores dan ‘true’, ambos refieren al mismo espacio en la memoria RAM.


	otroMasTodavia.nombre = "Pepe"
	
	otroMasTodavia.nombre
	// "Pepe"
	
	sacha.nombre
	// "Pepe"

  • Dos cadenas son estrictamente iguales cuando la misma secuencia de caracteres, la misma longitud y los mismos caracteres en las operaciones corresponden.

  • Dos números son estrictamente iguales cuando son numéricamente iguales. NaN no es igual a nada, incluido NaN. Los ceros positivos y negativos son iguales entre si.

  • Dos operadores booleanos son estrictamente iguales si ambos son ‘TRUE’ o ambos son ‘FALSE’

  • Dos objetos distintos nunca son iguales para comparaciones estrictas o abstractas (===, ==).

  • Una expresión que compara objetos solo es verdadera si los operadores hacen referencia al mismo objeto.

  • Los tipos Null y Undefined son estrictamente iguales a ellos mismos y abstractamente iguales entre si.

Mi resumen de la clase:

let x = 3,
    y = '3'

console.log('Comparing variables:');
// Comparing the content
console.log(x == y)
// Comparing content and type
console.log(x === y)

let person = {
    name: 'Anthony'
}
// Creating a new object
let person2 = {
    name: 'Anthony'
}
// Pointing to the same object
let person3 = person

console.log('\nComparing objects:')
console.log(person === person2)
console.log(person === person3)

Js tiene distintas maneras de comparar con == compara si tienen el mismo valor sin importar el tipo (4 == “4” // true) y con === cuando comparamos si son idénticos los valores (4 === “4” //false ) CUANDO COMPARAMOS OBJETOS SE COMPARA REFERENTE A LA VARIABLE DEL OBJETO
![](

Para comparar en JavaScript utilizaremos dos situaciones diferentes:

  • La primera será declarar dos variables, una con valor numérico y la otra string pero con el mismo valor, así:
var x=10, y='10'

Si queremos usar el operador == nos devolverá TRUE porque con ese operador en una variable compara el contenido que tiene cada una de ellas.

Si usamos el operador === nos devolverá FALSE porque está comparando el contenido de las variables y el tipo de variable.

En objetos este tipo de comparaciones se comporta diferente en JavaScript

¿Porqué?

Porque al tener dos objetos con los mismos atributos ambos estan ocupado distintas posiciones de memoria

var elvis =
{
  nombre:'Elvis'
}

var otroNombre={
  nombre:'Elvis'
}

Para que nos pueda resultar verdadera la comparación debemos apuntar al mismo lugar de memoria ram que el otro objeto, es decir así:

var otroNombre=Sacha

Aquí al comparar con == y === Saldrá TRUE

== , compara el valor pero no su tipo
=== , evalúa el tipo del valor y luego su valor

Al comparar Objetos con diferentes atributos, este arrojara falso si utilizamos == ó === debido a que compara sus atributos

Al comparar Objetos con los mismo atributos, este arrojara false si utilizamos == ó === debido a que tiene diferentes nombres como Objetos

Para arrojar True los dos objetos deberán estar en el mismo espacio de la memoria ram, es decir que los dos tengan el mismo nombre y la mismas propiedades.

No viene al caso , pero entendí el concepto que dijo sobre “commitear a produccion” que lo vi en el curso de GIT, me emociona porque significa que estoy aprendiendo y que la ruta de aprendizaje va muy bien!

truthy and falsy, cosas raras del JavaScript

//falsy
console.log(Boolean(0))
console.log(Boolean(null))
console.log(Boolean(NaN)) //not a number
console.log(Boolean(undefined)) //not value yet
console.log(Boolean(false))
console.log(Boolean("")) //empty string

//truthly
console.log(Boolean(" ")) //string con algo
console.log(Boolean("a"))
console.log(Boolean(1)) //any number 
console.log(Boolean({})) //arrays, even if they are empty
console.log(Boolean(function(){})) //functions, even if they are empty

RESUMEN:


En esta clase vimos formas de comparar en JS, cabe aclarar que faltó ver:

  • Sin identidad/desigualdad estricta !==
  • Operadores de desigualdad !=
  • Operadores relacionales
  • Mayor que >, Mayor igual que >=
  • Menor que<, Menor igual que <=

Adjunto documentación de mucha utilidad para quienes deseen investigar un poco más.

Adjunto el código de esta clase con comentarios al respecto.

// Existen diferentes formas de comparar variable sy objetos en JS.

var x = 14, y = '14'

// Comparar dos variables ==
console.log(x==y) //Nos dará True. Toma los dos valores a comparar los lleva a un mismo tipo de dato.

// Si tienen el mismo valro y son el mismo tipo de variables
console.log(x===y)// Nos dará false.  Compara ambos valores.

//Siempre usar el triple igual para no caer en errores. No se commit ningún código que tenga doble igual.


//Comparación de objeos.atributos. Al compararlos con cualquier == === lo que hace es que js pregunta a la referencia. 
var nitrogeno ={
    enlace: 'covalente'
}

var selenio ={
    enlace:'covalente'
}

console.log(nitrogeno==selenio)// Ya que estos dos objetos no son iguales será false
console.log(nitrogeno.enlace==selenio.enlace)// Me arrojará true debido a que estos dos atributos si son iguales

// Cuando dos fragmentos de código aùntan a un mismo lugar en memoria ram. el cambio en una afectará el mismo sitio.


var selenio ={
   ...nitrogeno
}

//Me arroja false, porque arroja al mismo sitio en memoria.

OPERADORES DE COMPARACIÓN

  • Asignación de espacio en memoria(=) :
    x = 5 , y = ‘5’

  • Igualdad(==) : Convierte los operandos si no son del mismo tipo y luego los compara
    x == y // TRUE

  • Igualdad estricta(===) : devuelve verdadero si los operandos no son iguales y / o no son del mismo tipo
    x === y // FALSE

  • Desigualdad(!=) : Devuelve verdadero si los operandos no son iguales
    x != y // FALSE

  • Desigualdad estricta(!==) : Devuelve verdadero si los operandos NO son iguales y/o no del mismo tipo
    x !== y // TRUE


  • La comparación de objetos funciona con referencias de memoria
    x = { numero: 2}
    y = { numero:2 }
    esto siempre va a ser distinto a no ser que
    x= { numero: 2 }
    y = x

  • Tanbien es posible desglosar un objeto dentro de otro pero esto creará otro espacio en memoria para el nuevo objeto
    x = { numero: 2 }
    y = { …x }

Sacha al terminar el curso debió sentirse un objeto

No es lo mismo comparar objetos que con datos primitivos:

1- Los datos primitivos pueden ser identicos y a su vez apuntan a distintos espacios en memoria.

2- Los objetos pueden compartir espacio en memoria al pasar como referencia de otro objeto pero tambien pueden tener su proio espacio en memoria

3- AL comparar dos objetos que comparten un mismo espacio en memoria se obtiene "true" ya que comparten una misma referencia, pero si estos objetos no comparten el mismo espacio en memoria es decir que son objetos individuales se obtendra "false" sin importar que tengan los mismoa valores.

Notas:
Con valores primitivos:
= para asignar
== para comparar llevandolos a mismo tipo de dato (parseo)
=== para comparar valor y tipo de dato, respetando el tipo de dato original

Con objetos:
Tanto = como == compararan la dirección fisica del objeto (en memoria RAM) si y solo si se trata del mismo objeto dará true.

Al comparar objetos, Javascript mira si tienen la misma posición en memoria

Mi resumen


/* Clase de comparaciones */
var x = 4,
  y = "4";

/* Para comparar == */
console.log(x == y);
/* En este caso pasa el x a string para poder comparar */

/* Si ademas queremos comparar si son el mismo tipo y valor es con === */
console.log(x === y);

/* Por esto es tan importante utilizar el triple = */

/* ------------------------------------------------------------------------- */

/* En este caso dara FALSE, al ser objeto
compara la referencia de memoria de la variable*/

var gustavo = {
  nombre: "Gustavo"
};

var otro = {
  nombre: "Gustavo"
};

console.log(gustavo == otro);

/* Aun pasa con el triple = */
console.log(gustavo === otro);

/* ------------------------------------------------------------------------- */

/* Aca le hago apuntar al mismo lugar de memoria
Ahora dara True por la ref. a memoria */

var gustavo1 = {
  nombre: "Gustavo"
};

var otro1 = gustavo1;

console.log(gustavo1 == otro1);
console.log(gustavo1 === otro1);

/* ------------------------------------------------------------------------- */

/* Desglosamos a gustavo2 y le damos un obj literal a otro2
Dara a False, ya que crea otro 
objeto en un nuevo espacio de memoria */

var gustavo2 = {
  nombre: "Gustavo"
};

var otro2 = {
  ...gustavo2
};

console.log(gustavo2 == otro2);

/* ------------------------------------------------------------------------- */
/* Aca me va a cambiar el nombre del ojeto gustavo3
ya que apuntan al mismo lugar de memoria */
var gustavo3 = {
  nombre: "Gustavo"
};

var otro3 = gustavo3;

otro3.nombre = "Hernan"; /* Le cambio el nombre a otro3 */

console.log(gustavo3 == otro3);
console.log(gustavo3 === otro3);

/* ------------------------------------------------------------------------- */
/* Aca cambiara el nombre de otro4 pero no de gustavo4
son distinto lugar en memoria */
var gustavo4 = {
  nombre: "Gustavo"
};

var otro4 = {
  nombre: "Gustavo"
};

otro4.nombre = "Hernan"; /* Le cambio el nombre a otro4 */

console.log(gustavo4.nombre);
console.log(otro4.nombre);

Entendido, un poco confuso.

<code>
jesús
Object { nombre: "Jesús" }

otraPersona
Object { nombre: "Jesús" }

jesús.nombre == otraPersona.nombre
true
jesús.nombre === otraPersona.nombre
true

Cuando los atributos tienen el mismo valor sí dan true en la compración

== compara valores
=== compara valores y tipos

Algunos experimientos
undefined : Ni siquiera sabemos si es un objeto o un primitivo

undefined == undefined // true
undefined === undefined // true

null : Es un objeto pero vacío

null == null // true
null === null // true

NaN : Not-a-Number

NaN == NaN // false
NaN === NaN // false

Operadores de comparación
Se utilizan para comparar valores.

Tipos de operadores:
• Menor que: <
• Mayor que: >
• Menor que o igual a: <=
• Mayor que o igual a: >=
• Igual a: ===
• NO igual a: !==

Ejemplo
10<12
//Obtenemos como resultado “true”

=; asignar un valor.
==; comparar valores- al llevarlos al mismo tipo de dato.
===; igualdad entre valores.

No sabia que era tanta la importancia del triple igual, la implementare ahora en mi código!

APORTE DE RESUMEN DE LA CLASE

// RESUMEN DE LA CLASE: 'COMPARACIONES'
//
// - ( = ) ---> El signo igual sirve para asignar un valor a una variable
//
// - En esta clase se va a ver 2 formas de comparar 2 variables o 2 objetos a mas:variables o 2 objetos a mas:
//
// CASO 1: 'PARA VARIABLES'
// - ( == ) ---> Lo que hace esta forma de comparacion es llevar a los valores
//               de las dos variables a un mismo tipo de dato , ya sea 'string'
//               o 'numero' y luego si son iguales los valor nos botara (true) ,
//               en caso contrario , sera (false).
//
// - ( === ) ---> Lo que hace esta forma de comparacion es primero saber si ambos
//                valores de la variables estan en un mismo tipo de dato (string
//                o numero), caso contrario de inmediato nos botara (false). Si
//                esta correcto el primer proceso entonces se seguira a comparar
//                si los valores de las variables son los mismos.
//
//CASO 2: 'PARA OBJETOS'
// - ( == ) ---> Lo que se explico en la clase es que por mas que compares
//               los objetos y tengan la misma extructura y valores , siempre
//               sera falso porque ambas estan en diferentes posicion en memoria
//               RAM.
//
// - ( === ) ---> Se realiza el mismo proceso con el de las variables pero como
//                se ha dicho por mas que tengan todo igual va a estar ubicados
//                en diferentes posiciones en a memoria RAM.
//
// --------------> CUANDO ES FALSO
                   var fernando = {
                     nombre:'Fernando'
                   }

                   var otraPersona = {
                     nombre:'Fernando'
                   }
//                 Por mas que sean lo mismo los objetos en estan en diferentes
//                 posiciones en la memoria RAM
//
//                 OJO: Si cambias el valor a uno de los objetos, esto no afectara
//                      al otro.
//
// ---------------> CUANDO ES VERDADERO
                    var miguel = {
                      nombre: 'Miguel'
                    }

                    var segundaPersona = miguel
//                  Se dice que segundaPersona va a ser un objeto que apunta
//                  a la misma ubicacion en la memoria RAM del objeto miguel
//
//                  OJO: Si alteras algun valor de uno de los objetos , en este
//                  caso, si se alterara en el otro objeto debido a que ambos estan
//                  en la misma posicion de la memoria RAM.```

Programar en JavaScript es cambiar totalmente mi mentalidad, comenzando con los ===

los simbolos de asignacion y comparación ante una igualdad resultan ser muy diferentes en JavaScript == diferente de ===

😃

Qué sencillo es entender la Coerción con Sacha!

Los objetos se comportan como punteros ❕

Muy buena clase!!


x === y  ? c('Es verdadero') : c('Es falso')
// Devuleve. Es falso. Porque está comparando a profundidad, 'x' es un número y 'y' es un texto

Siempre que podamos utilicemos el triple igual (=), este hace que JS no iguale variables de distinto tipo. Por el contrario, el doble igual () igualara el tipo de valor de las variables, lo que no permite una correcta comparación.

Perfecta Explicación

mis apuntes:

//Comparaciones en JavaScript
var x = 4
var y = '4'
/*x==y -> true lleva los 2 valores a un mismo tipo de dato por ende es igual y verdadero
x===y -> false aqui compara los tipos una letra y un número lo cual 2 tipos de variable diferente, por eso el retorno de false*/
// en objetos
var persona = {
   nombre: 'Natanael'
}
var otrapersona = {
  nombre: 'Natanael'
}

/* al comparar objetos siempre dará false
persona == otrapersona -> false
persona === otrapersona -> false

a menos que referenciemos el primero asignadolo de la siguiente manera:
var otrapersona = persona
para luego comparar
persona === otrapesona -> true 

ya que es el mismo objeto referenciado tanto para == y === así apuntan a la misma dirección en memoria ram*/

Control + L = limpiar la consola

tengo un problema con el codigo, me aparece lo siguiente y no sé que debo hacer para corregirlo

var Sacha = {
nombre:‘Sacha’
}

var otraPersona = {
nombre:‘Sacha’
}

sacha
VM465:1 Uncaught ReferenceError: sacha is not defined
at <anonymous>:1:1
(anonymous) @ VM465:1
otraPersona
VM478:1 Uncaught ReferenceError: otraPersona is not defined
at <anonymous>:1:1
(anonymous) @ VM478:1

Woow… interesante!

Que significa el …? del video anterior

Se recomienda utilizar el triple =, para realizar una comparación mas precisa. Cuando se comparan objetos en JaveScript, se realiza una comparación en la referencia de memoria donde están las variables, no a los valores del objeto, esto es con una comparación con “ == ” y “ === ”.
Cuando dos objetos apuntan a la misma localidad de memoria y se modifica uno, las modificaciones afectan a los dos objetos.

Entonces se podria decir que lo que chequea la comparacion de objetos es el espacio asignado en memoria? -emoji pensativo-

Al crear objetos estos se reservan memoria y aunque sus valores parezcan ser iguales al estar en digamoslo así "en espacios de memoria diferentes" no pueden ser iguales. la única forma es que los objetos apunten al mismo espacio de memoria como cuando hacemos:
otraPersona=sasha
Por que asi, asignamos una especie de etiqueta al mismo espacio de memoria del objeto sasha, en lugar de reservar otro espacio.

No es gran cosa, pero por lo menos sabemos que estamos comparando y tengan en claro como se comparar una variable por valor o por referencia.

var x = '1' , y = 1
//variables primitivas, se compara por valor.
console.log(`x: ${x} ${typeof(x)}  y: ${y} ${typeof(y)}`)
console.log('x == y: ' + (x == y) )
console.log('x === y: ' + (x === y) )


var jose = {
    name : 'José'
}

var pepe = {
    name : 'Pepe'
}

//variables no primitivas: [Object, Array, function], se compara por referencia.
console.log(`jose: ${JSON.stringify(jose)} ${typeof(jose)}  y: ${JSON.stringify(pepe)} ${typeof(pepe)}`)
console.log('jose == pepe: ' + (jose == pepe) )
console.log('jose === pepe: ' + (jose === pepe) )

Sería bueno que colocaran ejemplos más reales, más cercanos a lo que nos podríamos ver enfrentados en producción, de esta forma, el curso se vuelve más interesante.

Una forma de saber cual es el tipo de dato de una variable u objeto es con el comando typeof().

De forma que en el último caso si ejecutamos typeof(sacha) el resultado arrojado será object.
Si probamos con typeof(sacha.nombre) obtendremos que se trata de un string.

el pequeño ejercicio, cualquier duda consulten

 function imprimirSiEsMayorDeEdad(persona){
        console.log(`${persona.edad} es:`)
        
        var {edad} = persona
        if (edad >= 18){
            console.log('es mayor')

        }
        else {
            console.log('es menor')
        }

    }
    imprimirSiEsMayorDeEdad(lucas)

Bien, aprendí a **copiar un objeto en otra variable ** sin asignar la misma referencia. Eso me dió un comportamiento no deseado cuando tomaba de un listado la información que quiero editar. Pues sin haberle dado guardar, ya estaba modificando la información de la lista, lo cual es incorrecto. Lo resolví en el momento con:
var copia = JSON.parse(JSON.stringify(objetoQueQuieroCopiar))
Ahora sé que puedo hacer:
var copia = {...objetoQueQuieroCopiar}

La clave al asignar un arreglo o un objeto a una variable en JS, se entiende que se crea un alias o una referencia a ese mismo objeto o arreglo

var x = 4, y = '4'

console.warn('Comparar tipos primitivos de JS')
// Estos son Number, String, Boolean, Undefined y Null

console.log('Números')
// comparar solo el valor           => true
console.log(x == y)
// comparar valor y tipo de dato    => false
console.log(x === y)


// Nota importante: En producción se recomienda encarecidamente comparar con el tripe igual === para asegurarnos que la data es identica por valor y por tipo


console.log('Booleanos')

var z = true, h = 'true'
// El primer caso es true, el segundo es false. Ya que una es de tipo booleano y el segundo es una cadena
console.log(z == h)
console.log(z === h)


console.log('Cadenas')

var nombre = 'Alejandro', alias = 'Alejandro'
// Ambas retornan true.. Cuando se comparan cadenas es mediante caseSensitive
console.log(nombre == alias)
console.log(nombre === alias)


/**
 * Comparar arreglos y objetos en JavaScript
 * Estos ya no son considerados como tipos primitivos del lenguaje, pues son consideradas como estructuras de datos complejas.
 * 
 * Su comparación no se hace por valor ni por tipo de dato,
 * Es mediante posición en memoria RAM (Referencia)
 */

console.warn('Comparar Arreglos y Objetos')
console.log('Arreglos')

var tecnologias = ['php', 'js', 'html', 'css']
var lenguajes = ['php', 'js', 'html', 'css']
// Ambos retornan   => false
// Si bien tienen el mismo contenido (valores) y son del mismo tipo. Cada variable de tipo arreglo se encuentra almacenada en distinta ubicación de memoria
console.log(tecnologias == lenguajes)
console.log(tecnologias === lenguajes)


console.log('Objetos')
var persona = {
    nombre: 'Paco'
}
var persona2 = {
    nombre: 'Paco'
}
var persona3 = {
    ...persona
}
// Ambos retornan   => false
// Si bien tienen el mismo contenido (valores) y son del mismo tipo. Son objeto distintos que se encuentran almacenados en distinta ubicación (referencia) de memoria
console.log(persona == persona2)
console.log(persona === persona2)
console.log(persona == persona3)
console.log(persona === persona3)




console.warn('Crear alias de objetos y arreglos')
// La asignación en objetos y arreglos en JS es por referencia y no por valor
var alias = persona
console.log('Persona', persona, 'Alias', alias)
// Ambos retornan       => true
// Al asignar a una variable un objeto, se crea un alias de ese objeto, es decir, la nueva variable apunta a la misma referencia de memoria del objeto asignado. En pocas palabras, se trata del mismo objeto
console.log(persona == alias)
console.log(persona === alias)

// Si el alias cambia, el objeto original tambien cambia y viceversa.
alias.nombre = 'Francisco'
console.log('Persona', persona, 'Alias', alias)
console.log(persona == alias)
console.log(persona === alias)



console.log('Arreglos')
// Crear un alias para el arreglo tecnologías
var tech = tecnologias
// Retornan true... Se trata del mismo arreglo (misma dirección de memoria)
console.log(tech == tecnologias)
console.log(tech === tecnologias)

tech.push('nodeJS')
// Se trata del mismo arreglo
console.log(tech, tecnologias)

//      clase 9  Comparaciones en JavaScript
/* Existen varias maneras de comparar variables u objetos dentro de javascript. 
En el primer ejemplo le asignamos a X un valor numérico y a Y un string. 
Para poder compararlos debemos agregar dos signos de igual (==). 
Esto los convierte al mismo tipo de valor y permite que se puedan comparar. */
var x=4, y='4'
// x == y esto nos devuelve TRUE. Esto lo que hace es comparar los valores igualando los datos a tipo string.Por ese motivo da True.

//Si queremos realizar una comparacion te tipos debemos utilizar el x === y
/* Cuando realizamos operaciones es recomendable usar tres símbolos de igual (===). Esto permite que JavasScript no iguale las variables que son de distinto tipo. 
Te recomendamos que uses el triple igual siempre que estés comparando variables. 

Existen cinco tipos de datos que son primitivos:

Boolean
Null
Undefined
Number
String
*/

var persona1 = {
    nombre:'jose'
}
var persona2 = { 
    nombre:'Elias'
}
/*persona1 == persona2 esto nos devuelve FALSE
Lo que sucede es que etsamos comparando objetos, cuando comparamos objeto lo que hace JS
es preguntar por la referencia de la variable  que estamos utilizando. Lo mismo sucede cuando 
utilzamos el === */
var otraPersona1 = persona1 
//Esta otra persona apunta a la misma referencia que persona1, por lo tanto en este caso si seran los mismos objetos en memoria ram.

El operador == lleva las dos variables a un mismo tipo de dato y los compara.
Con el operador === hace una comparación del tipo de dato y su valor.

1 == “1” --> true
1 === “1” --> false (son iguales pero uno es un número y el otro una cadena)
-1 == true --> true
1 == true --> true (tanto el -1 como el 1 se consideran equivalentes a un verdadero cuando se tratan como booleanos)
-1 === true --> false
1 === true --> false
1.0 == 1 --> true
1.0 === 1 --> true también ¡Ojo! JavaScript no distingue subtipos entre los números por lo que ambos son numéricos y por lo tanto del mismo tipo. "

<code>
Genial la explicación para entender objetos en memoria!

Los objetos en javascript tienen la misma logica de los apuntadores.

JavaScript lo que hace es llevar ambos valores a un mismo tipo de valor

Entonces para comparar dos variables y sabes si ambas son objetos se necesitaría utilizar la función typeof() o existe otra forma

typeof(objeto1) == typeof(objeto2)

Con los tres puntos … lo que se hace es desglosar los atributos del objeto

Es bueno saber eso, yo desconocía que se apuntaba a la misma dirección de memoria.

/* Apuntes de clase */
var valor1 = 1, valor2 = "1";
console.log(`La comparacion entre valor1 = ${valor1} y valor2 = ${valor2} es: ${valor1==valor2}`);
console.log(`La comparacion estricta entre valor1 = ${valor1} y valor2 = ${valor2} es: ${valor1===valor2}`);

var persona1 = {nombre: 'Arturo'}, persona2 = {nombre: 'Arturo'}
console.log(persona1==persona2) //El s¡resultado es false por que son objetos distintos aun cuando tengan los mismos datos
console.log(persona1===persona2)//El resultado sigues siendo false porque los objetos siguen siendo distintos
persona2 = persona1 //Reasignamos el valor de la variable, con el valor de la primera.
console.log(persona2==persona1)//El resultado es true ya que la variable persona2 hace referncia a los mismos datos de la variable persona1```

Es una buena practica el usar siempre el triple igual (===) para hacer comparaciones.

x y she

Esta clase fue un poco mas fácil de asimilar, considero que lo importante es tener claro los tipos de datos que existen. Vamos bien JavaScript. 💪🤓👨🏻‍💻

Jugando un poco, se me ocurrió una function capaz de decirme si dos valores eran del mismo tipo de dato y esto fue lo que hice:

function tipoValor (x, y) {
    let tipoX = typeof x
    let tipoY = typeof y
    let valor
    if (tipoX === tipoY) {
        valor = 'iguales'
    }   else {
        valor = 'diferentes'
    }

    let valorResult = valor


    console.log(`La variable x es de tipo ${tipoX} y la variable y es tipo ${tipoY}. Por lo tanto son ${valorResult}`)
}

tipoValor(x,y

Este fue el output: La variable x es de tipo number y la variable y es tipo string. Por lo tanto son diferentes

excelente clase!!!

Notas importantes de la clase:
El === es más confiable para comparar que el ==.
Algunos datos primitivos son:
Booleano: False/True
Null: Vacío
Undefined: Sin valos declarado
Number: Cualquier dígito
String: “Ejemplo”.

De cierta forma JS en vez de duplicar objetos, al asignar solo las referencias de memoria, hace un uso óptimo de la misma! Nice!

var x = 4, y = "4";/*El = asigna el doble = indica si son iguales
de manera general pero el triple = te compara tambien su caracteristica
como si es char o num*/

var diego =
{
  nombre: "Diego"
}
/*Cuando comparamos objetos se compara es la referencia
pero al comparar una carateristica del objeto ya queda como comparar
variables normales*/
var otraPersona =
{
  nombre: "Diego"
}

var otro = diego;
/*Si realizamos un cambio dentro del objeto otro tambien se va a cambiar
el de diego ya que en el fondo son el mismo objetoo osea comparten
las mismas caracteristicas y comparten el espacio en ram osea que cualquier cambio
en uno afecta el otro*/

console.log(diego == otraPersona);
/*Nos da falso porque en el fondo son objetos distintos es decir tienen
un espacio distinto en ram*/
console.log(diego ==  otro)
/*Aqui nos va a dar true ya que son el mismo objeto osea que estan guardados
en el mismo espacio de la ram */
//ambos funcionan en == y ===```

COMPARACIONES EN JAVASCRIPT

Existen diferentes maneras de comparar variables u objetos en Javascript .
Para la primera vamos a crear dos variables:
<
var x = 4, y = ‘4’

vamos a la consola y probamos el acceso a “X” y “Y”, luego de probadas las variables u que te muestres una en un valor numerico y la otra en un string, vas a tomar las dos y escribiras en la consola
x == y , se usa “==” para comparar dos variables, esto nos dará “true”, es decir compara las dos variables, tomándolas y llevandolas a un mismo tipo de dato y las compara, para ver si tienen el mismo, valor, como podemos observar al decir que el valor es verdadero, nos indica que “x” tiene el mismo valor que “y” que es un string.

Ahora si queremos preguntar si “x” y “y” tienen el mismo valor y son del mismo tipo de variable, debemos utilizar el triple igual (=) es decir “===” porque esto nos diferenciara si son del mismo tipo de variable, ahora si probamos en la consola;
x === y, nos dirá “false”, porque no son del mismo tipo de variable, tienen el mismo valor, pero “x” es un numero y “y” es un carácter a los ojos de Javascript. Siempre utilizaremos el triple igual para comparar o siempre que podamos, es el más indicado.

Este método solo sirve para comprar variables o valores primitivos como caracteres y/o números, mas no sirve con los objetos.

Tomamos como ejemplo;
<
var sacha = {
nombre: ‘Sacha’
}

var otraPersona = {
nombre: ‘Sacha’
}

Si comparamos en la consola;
Sacha == otraPersona
False

Nos dará una comparación negativa, por lo explicado anteriormente, esto solo sirve para valores primitivos, pero. Si hacemos esto;
<
var sacha = {
nombre: ‘Sacha’
}

var otraPersona = sacha

al hacer la comparación nos dira “true” esto debido aque estamos declarando la variable “otraPersona” con el valor de la variable “sacha” es decir se invoca la información el objeto anterior en este mismo por lo que al hacer la comparación dira que es verdaderamente igual, puesto que estamos comparando en si el mismo objeto y no dos distintos.

Ahora si desglosamos el objeto sacha dentro de “otraPersona” de manera que;
<
var sacha = {
nombre: ‘Sacha’
}

var otraPersona = {
…sacha

}

Nos seguirá dando “false” puesto que, a pesar de tener la misma información es casi lo mismo que en el primer ejemplo, es un objeto diferente, porque acá lo que estas haciendo es crear una copia directa del objeto “sacha”, lo que lo hace un objeto nuevo y volvemos al principio de que no puedes comparar dos objetos con esto, ya que esto solo sirve para comparar variables de valor primitivo.

Ahora si vamos y colocamos
<
var sacha = {
nombre: ‘Sacha’
}

var otraPersona = sacha

y vamos y escribimos en la consola “sacha” nos dira en la propiedad nombre que el nombre (válgase la redundancia) es sacha, y si escribimos “otraPersona” será lo mismo, pero que pasará si escribimos;
otraPersona.nombre = ‘pepe’
la respuesta es que cambiara, porque estamos colocando el objeto “sacha” dentro de la variable “otraPersona” con esto le estamos dando acceso al objeto de arriba por lo que al hacer una modificación a algun valor de otraPersona, realmente le estaremos haciendo un cambio directo a los valores del objeto “sacha”.

si le cmabias VAR por LET si te deja utilizarlo

let x = 4
let y = "4"

let sacha = {
    nombre: "sacha"

}

let otraPersona = {
    ...sacha
}```

= sirve para asignar
== sirve para comparar(llevando a ambos a un mismo tipo)
===compara(con los tipos originales)

Finalmente entiendo lo del ===

Existen cinco tipos de datos que son primitivos:

Boolean
Null
Undefined
Number
String

Son pequeñeces a las que nunca le presté atención, la verdad que estoy emocionado de saber tan poco y tener tanto por aprender! 😃

Con el operador == le pregunta a JS si los valores son iguales
Con el operador === le pregunta a JS si los valores son identicos

entiendo que es por el alcance de la funcion, ambas son funciones locales, no se si llamo sacha.nombre == otraPersona.nombre ya seria verdadero

interesante, me quedo claro hasta que repetí una vez mas lo que dijo el profe sobre que los objetos apuntan a un lugar en la memoria a diferencia de comparar variables que allí si comparan el tipo de dato y el valor

logro desbloqueado 😃

Simple 😃 Cuando comparas objetos en JS, lo que se compara es la misma referencia de memoria RAM. Para comparar Objetos, supongo que se debe hacer algún arreglo que compare cada atributo del objeto con otro. No estoy seguro de este último pero aquí dejo un resumen de la clase que me ha servido para despejar muchas dudas 😃

Excelente explicación!! Creo que jamás lo habría entendido sin el ejemplo de la ubicación en memoria RAM. Muy clara la diferencia 😄

Apuntes…

var x = 4;
var y = '4';

/** Se recomiendo utilizar siempre la comparación estricta **/
x == y // true, compara ambos como string
x === y // false, compara tipo y valor

var personaUno = {
    nombre: 'Juanito'
};

var personaDos = {
    nombre: 'Juanito'
};

/* En ambos casos se mostrará false, ya que ocupan diferentes lugares en memoria */
console.log(personaUno == personaDos); // false
console.log(personaUno === personaDos); // false

// Para que sea true se asigna de la siguiente manera, la cual no crea un nuevo objeto:
var personaDos = personaUno; // Así ambas personas son el mismo espacio en memoria
console.log(personaUno == personaDos); // true
console.log(personaUno === personaDos); // true

/* Al crear un nuevo objeto de esta forma, también nos mostrará false la comparación,
ya que el nuevo objeto es otro lugar en la memoria */
var personaDos = {
    ...personaUno
}
console.log(personaUno == personaDos); // false
console.log(personaUno === personaDos); // false

9. Comparaciones en JavaScript

Existen dos tipos de comparaciones en JavaScript:

  1. ==, esta es la comparación débil, compara el valor llevado a string, por lo cual con esta comparación 4 = “4”, sí, tan raro como suena, porque el valor en string es el mismo.
  2. ===, es la comparación fuerte, compara el valor y tipo de dato (typeof), entonces es la que más deberíamos usar.

Les comparto el código de la clase:

//9th Lesson: Comparations in JavaScript
var x = 4;
var y = '4';
//this is true, because == compares value, not data type
console.log(x == y);
//this is false, because === compares value AND data type
console.log(x === y);

var sacha = {
    nombre: 'Sacha'
};

var anotherPerson = {
    ...sacha
};
//if we compare objets, it compares the REFERENCE not the content
console.log(sacha==anotherPerson);

Se recomienda siempre hacer uso del triple igual (====) para realizar comparaciones.

muy importante como todo:v

Existen cinco tipos de datos que son primitivos:

Boolean:// false/true
Null:// nulo o "vacío"
Undefined:// Cuando una variable es declarada pero aún no tiene un valor asignado 
Number:// 383839
String:// "esto es una string"``````

Muy clara la clase. Me gusta que, manejen distintos ejemplos.

Excelente y muy bien profundizado!!

Súper genial está clase,la manera de como JS compara los objetos es fantástico y al mismo tiempo un tanto confusos si no se pone atención a lo explicado, hahahhaha.

var x = 4, y = "4";

var Sacha = {
    nombre: "Sacha",
};

var otraPersona = {
    nombre: "Sacha",
};

Excelente clase!

Hay que tener claro en que momento utilizar comparación ("") o comparación explícita("=")

Hay que tener claro en que momento utilizar comparación () o comparación explícita(=)

Comprueba los true y false en la consola de tu navegador

x == y
x === y

otraPersona == KarlxS
otraPersona === KarlxS
var x = 4, y = '4'

var KarlxS = {
    nombre: 'KarlxS'
}

var otraPersona = {
    ...KarlxS
}

// "==" --> compara el contenido
// "===" --> compara el contenido y el tipo

Genial!!

Si escribes variable.nombre == otravariable.nombre El resultado dará true

wooow excelente clase y las diferencias del == y ===

Genial

Lo del cambio de nombre me exploto la cabeza jajaja