Upload via hfc (batch)

Uploaded using hfc tool

.gitattributes

@@ -186,3 +186,13 @@ subir/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]JavaScript
 subir/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]JavaScript/01-Introducción[[:space:]]a[[:space:]]JavaScript/05-Tipos[[:space:]]de[[:space:]]Datos[[:space:]]en[[:space:]]JavaScript[[:space:]]Primitivos[[:space:]]y[[:space:]]Complejos.mp4 filter=lfs diff=lfs merge=lfs -text
 subir/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]JavaScript/01-Introducción[[:space:]]a[[:space:]]JavaScript/06-Manipulación[[:space:]]de[[:space:]]Strings[[:space:]]en[[:space:]]JavaScript[[:space:]]Escritura[[:space:]]Concatenación[[:space:]]y[[:space:]]Substrings.mp4 filter=lfs diff=lfs merge=lfs -text
 subir/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]JavaScript/01-Introducción[[:space:]]a[[:space:]]JavaScript/07-Números[[:space:]]y[[:space:]]Operaciones[[:space:]]Matemáticas[[:space:]]en[[:space:]]JavaScript.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]JavaScript/01-Introducción[[:space:]]a[[:space:]]JavaScript/08-Conversión[[:space:]]de[[:space:]]Tipos[[:space:]]en[[:space:]]JavaScript[[:space:]]Implícita[[:space:]]y[[:space:]]Explícita.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]JavaScript/01-Introducción[[:space:]]a[[:space:]]JavaScript/09-Conversión[[:space:]]de[[:space:]]Tipos[[:space:]]en[[:space:]]JavaScript[[:space:]]Explícita[[:space:]]e[[:space:]]Implícita.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]JavaScript/02-Estructuras[[:space:]]de[[:space:]]Control[[:space:]]y[[:space:]]Lógica/01-Operadores[[:space:]]de[[:space:]]Comparación[[:space:]]en[[:space:]]JavaScript[[:space:]]Igualdad[[:space:]]y[[:space:]]Desigualdad.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]JavaScript/02-Estructuras[[:space:]]de[[:space:]]Control[[:space:]]y[[:space:]]Lógica/02-Operadores[[:space:]]Lógicos[[:space:]]en[[:space:]]Programación[[:space:]]AND[[:space:]]OR[[:space:]]y[[:space:]]NOT.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]JavaScript/02-Estructuras[[:space:]]de[[:space:]]Control[[:space:]]y[[:space:]]Lógica/03-Estructuras[[:space:]]Condicionales[[:space:]]Uso[[:space:]]de[[:space:]]IF[[:space:]]ELSE[[:space:]]y[[:space:]]ELSE[[:space:]]IF[[:space:]]en[[:space:]]JavaScript.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]JavaScript/02-Estructuras[[:space:]]de[[:space:]]Control[[:space:]]y[[:space:]]Lógica/04-Juego[[:space:]]de[[:space:]]Adivinanza[[:space:]]Programación[[:space:]]con[[:space:]]Estructuras[[:space:]]Condicionales.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]JavaScript/02-Estructuras[[:space:]]de[[:space:]]Control[[:space:]]y[[:space:]]Lógica/05-Estructura[[:space:]]y[[:space:]]uso[[:space:]]del[[:space:]]condicional[[:space:]]Switch[[:space:]]en[[:space:]]programación.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]JavaScript/02-Estructuras[[:space:]]de[[:space:]]Control[[:space:]]y[[:space:]]Lógica/06-Ciclo[[:space:]]For[[:space:]]Iteración[[:space:]]de[[:space:]]Listas[[:space:]]y[[:space:]]Uso[[:space:]]de[[:space:]]Consolelog[[:space:]]en[[:space:]]JavaScript.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]JavaScript/02-Estructuras[[:space:]]de[[:space:]]Control[[:space:]]y[[:space:]]Lógica/07-Iteración[[:space:]]con[[:space:]]forof[[:space:]]en[[:space:]]JavaScript[[:space:]]para[[:space:]]arrays[[:space:]]y[[:space:]]strings.mp4 filter=lfs diff=lfs merge=lfs -text
+subir/Curso[[:space:]]de[[:space:]]Fundamentos[[:space:]]de[[:space:]]JavaScript/02-Estructuras[[:space:]]de[[:space:]]Control[[:space:]]y[[:space:]]Lógica/08-Iteración[[:space:]]sobre[[:space:]]Objetos[[:space:]]con[[:space:]]forIn[[:space:]]en[[:space:]]JavaScript.mp4 filter=lfs diff=lfs merge=lfs -text

subir/Curso de Fundamentos de JavaScript/01-Introducción a JavaScript/07-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/basico-js

subir/Curso de Fundamentos de JavaScript/01-Introducción a JavaScript/07-Números y Operaciones Matemáticas en JavaScript.vtt

@@ -0,0 +1,677 @@
+WEBVTT
+
+00:00.000 --> 00:03.600
+En esta clase vamos a hablar sobre el tipo
+de dato primitivo
+
+00:03.600 --> 00:04.600
+number.
+
+00:04.600 --> 00:07.800
+Para ello es importante que sepamos tres
+cosas
+
+00:07.800 --> 00:11.800
+o tres tipos de números que podemos
+escribir en JavaScript.
+
+00:11.800 --> 00:15.000
+La primera son los enteros y los decimales.
+
+00:15.000 --> 00:17.800
+Entonces voy a escribir por aquí un
+comentario.
+
+00:17.800 --> 00:20.000
+Vamos a colocar
+slash.
+
+00:20.000 --> 00:25.000
+Vamos a colocar tipo entero y decimal.
+
+00:25.000 --> 00:28.600
+Tanto el entero como el decimal en
+JavaScript
+
+00:28.600 --> 00:30.800
+se escriben, por supuesto, diferente,
+
+00:30.800 --> 00:35.200
+pero por debajo su tipo de dato sigue
+siendo para ambos number.
+
+00:35.200 --> 00:36.600
+Entonces,
+veámoslo.
+
+00:36.600 --> 00:40.600
+Por ejemplo, vamos a colocar entero igual
+a cualquier número
+
+00:40.600 --> 00:44.400
+y en decimal vamos a escribir un número
+decimal
+
+00:44.400 --> 00:47.000
+como por ejemplo
+3.14.
+
+00:47.000 --> 00:50.200
+Si nosotros escribimos
+console.log
+
+00:50.200 --> 00:55.200
+y escribimos el type of para saber el tipo
+de dato de entero
+
+00:55.200 --> 00:59.800
+y también escribimos type of para saber el
+tipo de dato de decimal
+
+00:59.800 --> 01:03.800
+y guardamos, vamos aquí a nuestra
+consola
+
+01:03.800 --> 01:07.200
+y ahí nos va a arrojar que ambos son de
+tipo number.
+
+01:07.200 --> 01:11.600
+Es decir, que en JavaScript no tenemos
+ningún tipo de distinción
+
+01:11.600 --> 01:15.400
+a nivel de tipo de dato para los números
+enteros y decimales.
+
+01:15.400 --> 01:18.000
+Ambos los conocemos como
+números.
+
+01:18.000 --> 01:22.200
+Ahora, otra cosa importante es la notación
+científica.
+
+01:22.200 --> 01:25.200
+Esta notación científica en JavaScript,
+
+01:25.200 --> 01:27.600
+voy a escribir aquí
+científica,
+
+01:27.600 --> 01:29.800
+la vamos a conocer también como
+numbers
+
+01:29.800 --> 01:31.800
+y se escribe de la siguiente manera.
+
+01:31.800 --> 01:33.800
+Vamos a colocar
+científico
+
+01:33.800 --> 01:39.200
+y aquí lo que hacemos es decir 5e para
+expresar esa potencia
+
+01:39.200 --> 01:41.600
+y luego colocamos, por ejemplo,
+3.
+
+01:41.600 --> 01:43.600
+Entonces, así escribimos los
+números
+
+01:43.600 --> 01:46.000
+que son de notación
+científica.
+
+01:46.000 --> 01:50.000
+Y luego estarían, por supuesto, los
+números que son infinitos.
+
+01:50.000 --> 01:53.200
+Vamos a colocar acá
+3.infinitos
+
+01:53.200 --> 01:55.800
+y los que no son un
+número,
+
+01:55.800 --> 01:58.800
+que también lo conocemos en inglés como
+not a number,
+
+01:58.800 --> 02:02.800
+que se escribe, por supuesto, n-a-n por
+las siglas en inglés.
+
+02:02.800 --> 02:04.800
+¿Cómo serían
+ambos?
+
+02:04.800 --> 02:08.600
+Sería infinito,
+infinito,
+
+02:08.600 --> 02:12.200
+y tal cual, escribimos infinity en inglés.
+
+02:12.200 --> 02:16.000
+Y así podríamos expresar un número
+infinito en JavaScript
+
+02:16.000 --> 02:19.200
+y también el número, o el no número,
+
+02:19.200 --> 02:22.200
+entonces sería no es un
+número,
+
+02:22.200 --> 02:26.000
+número lo escribimos tal cual, n-a-n,
+
+02:26.000 --> 02:28.000
+que significa not a
+number.
+
+02:28.000 --> 02:31.200
+Y listo, por esta parte ya tendríamos
+cubiertas
+
+02:31.200 --> 02:35.400
+los tipos de números que podemos
+encontrarnos en JavaScript.
+
+02:35.400 --> 02:39.600
+Por otro lado, tenemos lo que son las
+operaciones aritméticas.
+
+02:39.600 --> 02:42.400
+Voy a subir esto un poco para tener más
+espacio
+
+02:42.400 --> 02:47.400
+y aquí vamos a colocar operaciones
+aritméticas.
+
+02:47.400 --> 02:49.800
+Aquí nos vamos a encontrar con dos grupos.
+
+02:49.800 --> 02:52.600
+El primer grupo son precisamente la suma,
+
+02:52.600 --> 02:54.800
+la resta, la multiplicación y la división.
+
+02:54.800 --> 02:58.000
+Así que escribámoslo, suma,
+resta,
+
+02:58.000 --> 03:02.000
+multiplicación y
+división.
+
+03:02.000 --> 03:06.400
+Listo, ¿cómo escribiríamos cada una de
+estas operaciones en JavaScript?
+
+03:06.400 --> 03:10.600
+Entonces, la suma sería tal cual, tomar un
+número
+
+03:10.600 --> 03:15.000
+y colocarle el operador más con otro número.
+
+03:15.000 --> 03:17.600
+Seguido tenemos lo que es la
+resta
+
+03:17.600 --> 03:20.800
+y esto lo conocemos también con un número,
+
+03:20.800 --> 03:24.000
+el signo menos y luego otro
+número.
+
+03:24.000 --> 03:26.600
+Seguido tenemos lo que es la multiplicación,
+
+03:26.600 --> 03:29.400
+voy a copiarme esto que ya escribí por aquí,
+
+03:29.400 --> 03:35.000
+voy a cambiarle aquí estos signos para que
+no nos saque error.
+
+03:35.000 --> 03:38.000
+Y seguido lo que vamos a hacer es colocar
+dos números,
+
+03:38.000 --> 03:41.400
+pero para multiplicarlos sería con un
+asterisco.
+
+03:41.400 --> 03:46.200
+Y la división sería, vamos a tomar esto
+que ya escribí por acá,
+
+03:46.200 --> 03:49.000
+le cambio la O, y ahora, ¿cómo
+sería?
+
+03:49.000 --> 03:51.800
+Simplemente tomamos un número cualquiera,
+
+03:51.800 --> 03:56.000
+le colocamos una barrita y el número por
+el cual queremos
+
+03:56.000 --> 03:58.600
+dividir el primer número que colocamos.
+
+03:58.600 --> 04:01.400
+Estas serían las primeras operaciones
+aritméticas
+
+04:01.400 --> 04:03.600
+que nos podemos encontrar en JavaScript.
+
+04:03.600 --> 04:08.400
+Otro grupo también es el módulo y la
+exponencia así.
+
+04:08.400 --> 04:13.400
+Entonces sería módulo y exponencia así.
+
+04:13.400 --> 04:15.800
+¿Cómo hacemos
+esto?
+
+04:15.800 --> 04:19.400
+Para esta parte lo que hacemos es escribir
+una variable
+
+04:19.400 --> 04:23.600
+que se llame módulo y este módulo lo
+podemos conocer
+
+04:23.600 --> 04:26.200
+con el signo de
+porcentaje.
+
+04:26.200 --> 04:28.400
+Esto nos va a indicar ese
+módulo,
+
+04:28.400 --> 04:31.200
+pero nos sirve muchísimo en esos casos en
+los que queremos
+
+04:31.200 --> 04:33.800
+saber si un número es múltiplo de otro número.
+
+04:33.800 --> 04:37.000
+Entonces este va a ser perfecto para ese
+tipo de casos.
+
+04:37.000 --> 04:39.200
+Y por otro lado, tenemos exponenciación.
+
+04:39.200 --> 04:42.200
+Voy a quitarle esta L que se me fue por
+ahí
+
+04:42.200 --> 04:45.000
+y vamos a corregir aquí, vamos a quitar
+tildes
+
+04:45.000 --> 04:46.600
+para que no nos saque
+error.
+
+04:46.600 --> 04:50.200
+Y esta exponenciación o potencia la
+conocemos justamente
+
+04:50.200 --> 04:53.800
+con un número y es como si fuera
+multiplicación,
+
+04:53.800 --> 04:57.400
+pero sumándole otro asterisco, o sea,
+serían dos.
+
+04:57.400 --> 05:01.400
+Y en este caso ya tendríamos lo de módulo
+y potencia.
+
+05:01.400 --> 05:05.200
+Por otro lado, es importante saber que
+JavaScript
+
+05:05.200 --> 05:10.000
+tiene ciertos dilemitas a la hora de la
+precisión.
+
+05:10.000 --> 05:12.000
+Entonces vamos a
+revisarlo.
+
+05:12.000 --> 05:15.200
+Entonces voy a colocar por ejemplo acá
+precisión.
+
+05:15.200 --> 05:17.200
+Precisión.
+
+05:17.200 --> 05:19.400
+¿Cuáles son esos problemitas? Mirémoslo.
+
+05:19.400 --> 05:24.000
+Por ejemplo, si colocamos resultado de
+alguna operación,
+
+05:24.000 --> 05:31.600
+en este caso yo quiero que se sume el 0.
+1 con el 0.2,
+
+05:31.600 --> 05:34.400
+ahí lo que esperaríamos sería
+0.3,
+
+05:34.400 --> 05:37.600
+pero revisemos qué es lo que hace JavaScript.
+
+05:37.600 --> 05:40.400
+JavaScript lo que hace en este
+caso
+
+05:40.400 --> 05:44.200
+es justamente colocar un número súper,
+súper largo.
+
+05:44.200 --> 05:48.000
+Entonces aquí es donde tenemos esos
+dilemas de precisión.
+
+05:48.000 --> 05:50.400
+Pero con JavaScript podemos también
+solucionar
+
+05:50.400 --> 05:52.800
+ese tipo de casos y en dado
+caso
+
+05:52.800 --> 05:55.800
+de que solamente necesitemos un decimal,
+
+05:55.800 --> 05:57.600
+lo podemos hacer de la siguiente forma.
+
+05:57.600 --> 06:02.000
+Podemos colocar por ejemplo console.
+log de ese resultado
+
+06:02.000 --> 06:05.600
+y
+utilizamos.toFixed
+
+06:05.600 --> 06:08.400
+y luego le decimos qué tantos valores
+queremos
+
+06:08.400 --> 06:10.000
+después del
+punto.
+
+06:10.000 --> 06:13.800
+En este caso podríamos decirle que
+solamente necesitamos 1.
+
+06:13.800 --> 06:16.000
+Entonces volvemos a correr nuestro
+programa
+
+06:16.000 --> 06:20.000
+y aquí ya nos sale que evidentemente 0.
+1 más 0.2
+
+06:20.000 --> 06:22.800
+es solamente
+0.3.
+
+06:22.800 --> 06:24.600
+Con este tema de la
+precisión
+
+06:24.600 --> 06:27.400
+también es importante tener en
+cuenta
+
+06:27.400 --> 06:30.000
+que si nosotros queremos comparar números,
+
+06:30.000 --> 06:34.400
+es decir, ese resultado con el número como
+tal 0.3,
+
+06:34.400 --> 06:36.400
+tendríamos un
+error.
+
+06:36.400 --> 06:40.800
+Por ejemplo, si yo le digo console.log,
+
+06:40.800 --> 06:47.400
+yo quiero saber si ese resultado es igual,
+igual, igual a 0.3.
+
+06:47.400 --> 06:50.200
+Voy a explicarte esto antes de
+continuar
+
+06:50.200 --> 06:51.800
+y es que esto lo que está
+haciendo
+
+06:51.800 --> 06:55.800
+es que nos comprueba si este resultado,
+
+06:55.800 --> 06:59.200
+es decir, el valor
+0.33300...
+
+06:59.200 --> 07:04.000
+Bueno, todo esto es igual a 0.3 a nivel de
+número
+
+07:04.000 --> 07:06.000
+y también a nivel de
+tipo,
+
+07:06.000 --> 07:09.000
+es decir, que si este
+tipo,
+
+07:09.000 --> 07:13.000
+es decir, tipo número, es igual a este
+tipo de dato,
+
+07:13.000 --> 07:14.200
+que también es
+número.
+
+07:14.200 --> 07:16.600
+Entonces él va a empezar a validar tanto
+el valor
+
+07:16.600 --> 07:20.200
+como el tipo, por eso colocamos estos tres
+igual.
+
+07:20.200 --> 07:24.000
+Entonces en este caso si nosotros hacemos
+esa operación,
+
+07:24.000 --> 07:26.000
+él nos va a decir que es
+falso.
+
+07:26.000 --> 07:28.000
+Entonces con este tipo de
+temas
+
+07:28.000 --> 07:31.200
+hay que tener muchísimo cuidado
+precisamente por esa razón,
+
+07:31.200 --> 07:33.600
+porque JavaScript no es tan
+preciso
+
+07:33.600 --> 07:36.600
+a la hora de hacer este tipo de cálculos.
+
+07:36.600 --> 07:39.600
+Por otro lado, tenemos otras
+operaciones
+
+07:39.600 --> 07:42.000
+que las podemos realizar con
+Mat.
+
+07:42.000 --> 07:45.000
+¿Cómo las vamos a
+hacer?
+
+07:45.000 --> 07:49.600
+Vamos a escribir por acá operaciones
+avanzadas
+
+07:49.600 --> 07:51.600
+y lo que hacemos es lo
+siguiente.
+
+07:51.600 --> 07:55.000
+Si nosotros quisiéramos saber la raíz
+cuadrada de un número,
+
+07:55.000 --> 07:56.800
+lo haríamos de la siguiente
+forma.
+
+07:56.800 --> 08:02.400
+Vamos a colocar const, decimos raíz cuadrada,
+
+08:02.400 --> 08:07.800
+y aquí le colocamos
+math.sqrt
+
+08:07.800 --> 08:10.400
+y dentro le colocamos el
+número
+
+08:10.400 --> 08:13.400
+por el cual nosotros queremos saber esa
+raíz cuadrada.
+
+08:13.400 --> 08:17.000
+Ahora, si nosotros quisiéramos saber el
+valor absoluto
+
+08:17.000 --> 08:19.800
+de un número negativo o de cualquier número,
+
+08:19.800 --> 08:23.400
+lo que hacemos es decir valor
+absoluto
+
+08:23.400 --> 08:26.200
+y aquí le decimos math
+nuevamente
+
+08:26.200 --> 08:29.400
+y en este caso le escribimos
+abs
+
+08:29.400 --> 08:31.600
+y dentro colocamos el
+número
+
+08:31.600 --> 08:34.400
+por el cual queremos saber ese valor absoluto.
+
+08:34.400 --> 08:37.000
+Y por último, si nosotros quisiéramos
+saber
+
+08:37.000 --> 08:40.400
+un número random o que él nos arroje
+cualquier número,
+
+08:40.400 --> 08:44.400
+lo que podemos hacer es decirle
+aleatorio
+
+08:44.400 --> 08:47.600
+igual a
+math.random
+
+08:47.600 --> 08:51.400
+y él ya con eso nos saca un número aleatorio.
+
+08:51.400 --> 08:54.200
+Entonces, revisemos esto que acabamos de
+hacer.
+
+08:54.200 --> 08:57.400
+Vamos a colocar 3
+console.log,
+
+08:57.400 --> 09:01.200
+ups, vamos a colocar copiar, pegar, pegar.
+
+09:01.200 --> 09:04.200
+Voy a borrar esas líneas que se crearon
+por allá abajo,
+
+09:04.200 --> 09:06.200
+copio este valor por
+acá,
+
+09:06.200 --> 09:09.800
+también copio este en el console.log,
+
+09:09.800 --> 09:11.400
+guardamos y
+listo.
+
+09:11.400 --> 09:15.400
+Entonces, acá vemos que la raíz cuadrada
+de 16 es 4,
+
+09:15.400 --> 09:17.800
+que el valor absoluto de menos 7 es
+7
+
+09:17.800 --> 09:20.400
+y me arrojó un número random
+aquí.
+
+09:20.400 --> 09:24.200
+Entonces, ya con esto tendríamos toda la
+parte de números,
+
+09:24.200 --> 09:26.000
+diferentes
+notaciones,
+
+09:26.000 --> 09:27.200
+tanto las
+operaciones
+
+09:27.200 --> 09:51.200
+y también tendríamos algunas operaciones
+avanzadas.
+

subir/Curso de Fundamentos de JavaScript/01-Introducción a JavaScript/07-clase-number_acc7d1d1-5270-488c-88fc-349f8c28432c.js

@@ -0,0 +1,37 @@
+// 1. Tipo entero y decimal
+const entero = 42
+const decimal = 3.14
+console.log(typeof entero, typeof decimal)
+
+// 2. Notación científica
+const cientifico = 5e3
+
+// 3. Infinitos y NaN
+const infinito = Infinity
+const noEsUnNumero = NaN
+
+// Operaciones aritméticas
+
+// 1. Suma, Resta, Mutiplicación y División
+const suma = 3 + 4
+const resta = 4 - 4
+const mutiplicacion = 4 * 7
+const division = 16 / 2
+
+// 2. Módulo y Exponenciación
+const modulo = 15 % 8
+const exponenciacion = 2 ** 3
+
+// Precisión
+const resultado = 0.1 + 0.2
+console.log(resultado)
+console.log(resultado.toFixed(1))
+console.log(resultado === 0.3)
+
+// Operaciones Avanzadas
+const raizCuadrada = Math.sqrt(16)
+const valorAbsoluto = Math.abs(-7)
+const aleatorio = Math.random()
+console.log(raizCuadrada)
+console.log(valorAbsoluto)
+console.log(aleatorio)

subir/Curso de Fundamentos de JavaScript/01-Introducción a JavaScript/08-Conversión de Tipos en JavaScript Implícita y Explícita.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:63ba91178eef23a3a1032d09d5ac176f04f431d15dd50a3b96a07d7eed5dfced
+size 112265141

subir/Curso de Fundamentos de JavaScript/01-Introducción a JavaScript/08-Conversión de Tipos en JavaScript Implícita y Explícita.vtt

@@ -0,0 +1,384 @@
+WEBVTT
+
+00:00.000 --> 00:04.140
+En esta clase vamos a hablar sobre
+typecasting y cohesion,
+
+00:04.140 --> 00:08.300
+o también conocido como conversión de
+tipos en JavaScript.
+
+00:08.300 --> 00:11.800
+Este término en particular es muy
+conocido
+
+00:11.800 --> 00:14.000
+y es muy característico en JavaScript,
+
+00:14.000 --> 00:16.800
+así que es súper fundamental y hace parte,
+por supuesto,
+
+00:16.800 --> 00:19.100
+de este lenguaje tan
+maravilloso.
+
+00:19.100 --> 00:22.500
+Entonces, resulta que en los lenguajes de
+programación,
+
+00:22.500 --> 00:25.500
+normalmente, como escribimos nosotros el
+código,
+
+00:25.500 --> 00:27.400
+el computador o nuestro
+programa,
+
+00:27.400 --> 00:30.300
+pues no lo puede entender solamente cómo
+lo escribimos,
+
+00:30.300 --> 00:31.800
+lo entendemos
+nosotros.
+
+00:31.800 --> 00:35.400
+Para eso, normalmente, existen lo que son
+compiladores
+
+00:35.400 --> 00:38.600
+o intérpretes que lo que hacen es traducir
+ese código
+
+00:38.600 --> 00:41.100
+que nosotros escribimos como seres
+humanos
+
+00:41.100 --> 00:44.900
+a un código que el computador pueda entender.
+
+00:44.900 --> 00:48.400
+Entonces, para ello, se dividen los
+diferentes grupos
+
+00:48.400 --> 00:49.900
+de lenguajes de
+programación.
+
+00:49.900 --> 00:52.700
+Existen tantos lenguajes
+compilados
+
+00:52.700 --> 00:57.200
+como lo son, por ejemplo, C, C++, Rast, Go,
+Swift,
+
+00:57.200 --> 00:59.500
+y también tenemos códigos
+interpretados
+
+00:59.500 --> 01:04.300
+como lo son, por ejemplo, JavaScript, Python,
+Ruby, PHP,
+
+01:04.300 --> 01:07.200
+y todos estos son importantes de tener en
+cuenta
+
+01:07.200 --> 01:10.400
+precisamente porque cuando tenemos
+lenguajes
+
+01:10.400 --> 01:12.100
+que son
+compilados,
+
+01:12.100 --> 01:13.900
+todo este código es
+traducido
+
+01:13.900 --> 01:17.300
+antes de la ejecución de nuestro programa.
+
+01:17.300 --> 01:21.000
+Y lo que son los interpretados son
+justamente aquellos
+
+01:21.000 --> 01:25.100
+que se van traduciendo a medida que se va
+ejecutando el código.
+
+01:25.100 --> 01:28.100
+Supongamos que estamos en una
+cocina
+
+01:28.100 --> 01:30.100
+y que queremos hacernos un sándwich,
+
+01:30.100 --> 01:33.500
+pero para poder hacerlo, queremos revisar
+una receta,
+
+01:33.500 --> 01:36.300
+pero esa receta está en
+francés
+
+01:36.300 --> 01:38.400
+y resulta que no sabemos
+francés.
+
+01:38.400 --> 01:40.400
+Y ahí tenemos varias
+opciones.
+
+01:40.400 --> 01:44.300
+La primera es que ya esté la receta traducida,
+
+01:44.300 --> 01:47.300
+que en este caso sería un compilador,
+
+01:47.300 --> 01:50.300
+que es precisamente quien nos traduzca
+nuestra receta
+
+01:50.300 --> 01:52.400
+para después nosotros poderla
+leer
+
+01:52.400 --> 01:54.500
+y poder crear nuestro
+sándwich.
+
+01:54.500 --> 01:56.500
+O existe otra
+posibilidad
+
+01:56.500 --> 01:59.300
+y es que tengamos algún amigo o amiga
+francesa
+
+01:59.300 --> 02:02.100
+y nos vaya diciendo a medida que vayamos
+haciendo
+
+02:02.100 --> 02:04.700
+las instrucciones que debemos ir haciendo.
+
+02:04.700 --> 02:08.800
+Esa es la definición también de lo que son
+los interpretados.
+
+02:08.800 --> 02:11.300
+Entonces, podemos hacer alusión
+precisamente
+
+02:11.300 --> 02:13.800
+a cosas que pasan antes de ejecución,
+
+02:13.800 --> 02:15.000
+como los
+compilados,
+
+02:15.000 --> 02:18.000
+o que suceden a medida que se va
+ejecutando el programa,
+
+02:18.000 --> 02:19.600
+como los
+interpretados,
+
+02:19.600 --> 02:21.900
+y ahí es donde entra
+JavaScript.
+
+02:21.900 --> 02:25.300
+Resulta que ambos grupos también tienen
+otras características
+
+02:25.300 --> 02:28.100
+que son precisamente el chequeo de tipos.
+
+02:28.100 --> 02:29.900
+Resulta que en los
+compilados
+
+02:29.900 --> 02:32.300
+sucede el chequeo estático de
+tipos
+
+02:32.300 --> 02:34.500
+y en los interpretados, al contrario,
+
+02:34.500 --> 02:37.700
+sucede el chequeo dinámico de tipos.
+
+02:37.700 --> 02:39.200
+¿Esto qué quiere
+decir?
+
+02:39.200 --> 02:43.400
+Que JavaScript no se da cuenta de qué
+tipos de datos tenemos
+
+02:43.400 --> 02:47.400
+hasta que él va revisando como nuestro
+programa.
+
+02:47.400 --> 02:49.600
+Ahí también hablamos de que
+JavaScript
+
+02:49.600 --> 02:51.900
+tiene un tipado que es
+débil,
+
+02:51.900 --> 02:55.300
+precisamente porque nosotros podemos
+escribir código como.
+
+02:55.300 --> 02:59.200
+Una variable, le podemos asignar un valor
+numérico, por ejemplo,
+
+02:59.200 --> 03:02.400
+y después volverle a asignar un valor string.
+
+03:02.400 --> 03:04.600
+Eso lo permite
+JavaScript.
+
+03:04.600 --> 03:08.300
+Y gracias a eso podríamos ver cosas como
+estas.
+
+03:08.300 --> 03:10.700
+En este código estamos viendo lo siguiente.
+
+03:10.700 --> 03:12.400
+Tenemos unas
+variables,
+
+03:12.400 --> 03:15.500
+pero más abajo, justamente donde dice título,
+
+03:15.500 --> 03:18.800
+estamos abriendo el string con una comilla
+simple,
+
+03:18.800 --> 03:20.600
+pero no lo estamos
+errando.
+
+03:20.600 --> 03:23.000
+Ahí justamente nos sale un
+error,
+
+03:23.000 --> 03:26.000
+pero JavaScript lo que hace es ir
+corriendo nuestro código
+
+03:26.000 --> 03:29.400
+y cuando llega a ese punto, ¡pum!, sale el
+error.
+
+03:29.400 --> 03:32.100
+Entonces eso es muy importante tenerlo en
+cuenta
+
+03:32.100 --> 03:34.700
+porque en casos como
+estos,
+
+03:34.700 --> 03:37.900
+que es donde vemos const número igual a dos,
+
+03:37.900 --> 03:40.100
+const booleano igual a
+true,
+
+03:40.100 --> 03:41.900
+si los queremos
+sumar,
+
+03:41.900 --> 03:45.900
+JavaScript dice como que, bueno, ¿y ahora
+qué hago?
+
+03:45.900 --> 03:49.000
+Vamos a solucionar aquí como se pueda.
+
+03:49.000 --> 03:52.000
+Y lo que hace es convertir los
+tipos
+
+03:52.000 --> 03:53.800
+a conveniencia de
+JavaScript,
+
+03:53.800 --> 03:56.200
+y en este caso nos sale
+tres.
+
+03:56.200 --> 03:59.800
+A pesar de que estamos sumando un número
+con un booleano,
+
+03:59.800 --> 04:02.200
+él hace su conversión en tiempo de
+ejecución
+
+04:02.200 --> 04:03.800
+y nos sale un
+número.
+
+04:03.800 --> 04:06.800
+Eso es lo que vamos a revisar precisamente
+en esta clase,
+
+04:06.800 --> 04:08.700
+la conversión de
+tipos.
+
+04:08.700 --> 04:12.000
+Resulta que existen también dos tipos de
+conversión.
+
+04:12.000 --> 04:13.500
+Una que es
+implícita,
+
+04:13.500 --> 04:16.500
+es decir, que el mismo JavaScript lo hace
+solito,
+
+04:16.500 --> 04:18.300
+así como en el ejemplo
+anterior,
+
+04:18.300 --> 04:21.600
+o también puede existir la conversión
+explícita,
+
+04:21.600 --> 04:24.200
+que es justamente que nosotros como
+programadores
+
+04:24.200 --> 04:27.600
+podemos tomar un valor, ejemplo, un booleano,
+
+04:27.600 --> 04:31.400
+y convertirlo a string, number o lo que sea.
+
+04:31.400 --> 04:33.700
+Esa sería la conversión
+explícita.
+
+04:33.700 --> 04:35.800
+Ahora vamos a revisarles
+justamente
+
+04:35.800 --> 04:43.800
+en nuestro editor de
+código.
+

subir/Curso de Fundamentos de JavaScript/01-Introducción a JavaScript/09-Conversión de Tipos en JavaScript Explícita e Implícita.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1937a5016bbd3dcfbd4d37936b93e95c9f61508e8619a04f2e602b344a0635b
+size 93220895

subir/Curso de Fundamentos de JavaScript/01-Introducción a JavaScript/09-Conversión de Tipos en JavaScript Explícita e Implícita.vtt

@@ -0,0 +1,853 @@
+WEBVTT
+
+1
+00:00:00.099 --> 00:00:02.680
+Vamos a comenzar hablando sobre el typecasting,
+
+2
+00:00:03.260 --> 00:00:04.860
+pero de la forma explícita,
+
+3
+00:00:05.339 --> 00:00:10.059
+es decir, de la conversión de tipos explícita. Vamos a colocarlo por aquí.
+
+4
+00:00:10.679 --> 00:00:11.179
+Explicit
+
+5
+00:00:12.200 --> 00:00:12.700
+typecasting.
+
+6
+00:00:13.780 --> 00:00:20.619
+Ya sabemos que esto es conversión de tipos de forma explícita. ¿Qué es lo que vamos a hacer? Voy a escribir un
+
+7
+00:00:21.160 --> 00:00:27.980
+string número, es decir, voy a colocar acá un string, pero por dentro le voy a poner, por ejemplo, un 42.
+
+8
+00:00:28.680 --> 00:00:30.860
+Y lo que voy a hacer ahora es convertirlo
+
+9
+00:00:31.220 --> 00:00:31.960
+a entero.
+
+10
+00:00:32.360 --> 00:00:34.739
+¿Cómo voy a hacer? Entonces voy a decirle const
+
+11
+00:00:35.060 --> 00:00:35.560
+integer
+
+12
+00:00:36.300 --> 00:00:38.180
+y aquí lo que hago es decirle
+
+13
+00:00:38.720 --> 00:00:39.220
+parse
+
+14
+00:00:39.800 --> 00:00:41.960
+int, que aquí nos sale justamente,
+
+15
+00:00:42.720 --> 00:00:43.620
+y le mandamos
+
+16
+00:00:44.040 --> 00:00:45.500
+este valor string.
+
+17
+00:00:45.860 --> 00:00:48.040
+Entonces vamos a colocar un console.log
+
+18
+00:00:49.220 --> 00:00:54.000
+y dentro vamos a colocar el íntegre. Vamos a colocarle también un typeof
+
+19
+00:00:54.320 --> 00:00:57.040
+para revisar qué salió ahí. Typeof,
+
+20
+00:00:57.360 --> 00:00:59.120
+vamos a correr nuestro programa
+
+21
+00:01:00.160 --> 00:01:03.540
+Y aquí revisamos que tenemos un íntegre que es 42
+
+22
+00:01:04.060 --> 00:01:09.300
+y encima también nos convirtió el tipo de dato de string a número.
+
+23
+00:01:09.820 --> 00:01:11.479
+También podemos tener
+
+24
+00:01:12.320 --> 00:01:14.240
+para conversión a flotante.
+
+25
+00:01:14.740 --> 00:01:17.100
+¿Cómo sería esto? Sería const
+
+26
+00:01:18.160 --> 00:01:18.660
+string
+
+27
+00:01:19.140 --> 00:01:19.640
+decimal
+
+28
+00:01:20.900 --> 00:01:21.400
+decimal
+
+29
+00:01:22.260 --> 00:01:25.320
+y vamos a colocar, voy a colocar aquí string
+
+30
+00:01:25.640 --> 00:01:26.140
+decimal
+
+31
+00:01:26.760 --> 00:01:28.060
+y decimos 3.14.
+
+32
+00:01:29.760 --> 00:01:33.740
+Ahora vamos a decir const float como un número flotante
+
+33
+00:01:34.500 --> 00:01:35.360
+y le decimos
+
+34
+00:01:35.660 --> 00:01:36.160
+parse
+
+35
+00:01:36.500 --> 00:01:37.960
+float en este caso
+
+36
+00:01:38.260 --> 00:01:43.120
+y le mandamos justo este valor. Vamos a colocar estos mismos console.log
+
+37
+00:01:43.580 --> 00:01:44.540
+por aquí abajo
+
+38
+00:01:45.180 --> 00:01:54.000
+Y aquí en este caso le decimos float y el type of the float. Vamos a ver qué nos sale. Y en este caso nos sale que es 3.14
+
+39
+00:01:55.040 --> 00:01:55.840
+en número.
+
+40
+00:01:56.400 --> 00:02:02.860
+Y adicional nos dice que el tipo de dato es número. Recordemos que en JavaScript, a pesar de que sea un número decimal
+
+41
+00:02:03.380 --> 00:02:09.280
+o un número entero, ambos son conocidos con el tipo de dato number sin ningún tipo de distinción.
+
+42
+00:02:09.919 --> 00:02:12.940
+Por otro lado, si queremos convertir a binario,
+
+43
+00:02:13.500 --> 00:02:17.560
+voy a subir esto un poco, Podemos colocar lo siguiente. Const
+
+44
+00:02:17.900 --> 00:02:18.400
+binary
+
+45
+00:02:18.900 --> 00:02:21.940
+igual a, y aquí decimos 10, 10.
+
+46
+00:02:22.440 --> 00:02:24.360
+Y luego decimos const,
+
+47
+00:02:24.740 --> 00:02:25.240
+decimal,
+
+48
+00:02:26.220 --> 00:02:32.120
+decimal, va a ser igual a quién? A parse, otra vez int, como lo hicimos al principio.
+
+49
+00:02:32.420 --> 00:02:35.880
+Y en este caso lo que hacemos es mandarle nuestro binario
+
+50
+00:02:36.400 --> 00:02:44.980
+y luego le decimos la base del binario. En este caso queremos que sea 2 y aquí lo que hace es convertir de binario a decimal.
+
+51
+00:02:45.620 --> 00:02:48.200
+En este caso volvemos a colocar los console.log
+
+52
+00:02:49.400 --> 00:02:53.760
+y le colocamos nuestro decimal. Entonces, cambiamos float por decimal,
+
+53
+00:02:54.060 --> 00:02:54.560
+guardamos,
+
+54
+00:02:55.240 --> 00:02:56.760
+corremos nuestro código
+
+55
+00:02:57.200 --> 00:03:00.420
+y aquí ya sale que el valor del console.log,
+
+56
+00:03:00.740 --> 00:03:02.120
+el primero, es 10.
+
+57
+00:03:02.800 --> 00:03:05.920
+Nos convirtió precisamente este número a binario
+
+58
+00:03:06.300 --> 00:03:14.280
+y también nos sale que también nos convirtió el tipo de data. Entonces, esta es una de las mejores formas que podemos hacer para convertir
+
+59
+00:03:14.600 --> 00:03:16.740
+tipos justamente de la forma
+
+60
+00:03:17.060 --> 00:03:18.900
+explícita a nivel numérico.
+
+61
+00:03:19.500 --> 00:03:24.140
+Ahora revisemos uno de los casos más interesantes que tiene JavaScript, que es justamente
+
+62
+00:03:24.860 --> 00:03:27.580
+este type casting pero de forma implícita.
+
+63
+00:03:28.060 --> 00:03:33.660
+Entonces voy a traerme este texto por acá, voy a subir y voy a colocar acá en vez de explicit
+
+64
+00:03:34.120 --> 00:03:34.620
+implicit.
+
+65
+00:03:35.460 --> 00:03:47.620
+¿Qué es lo que va a suceder y qué es lo que hace JavaScript? Vamos a revisar. En este caso, voy a colocar const. Vamos a escribir una suma y esa suma puede ser, por ejemplo, de un string que es 5
+
+66
+00:03:48.020 --> 00:03:48.520
+más
+
+67
+00:03:48.840 --> 00:03:49.340
+3.
+
+68
+00:03:49.860 --> 00:03:55.100
+¿Cuál sería el resultado de esa operación? Por favor, veme contando en los comentarios
+
+69
+00:03:55.440 --> 00:03:57.440
+mientras yo voy escribiendo este console.log.
+
+70
+00:03:58.440 --> 00:04:02.140
+Voy a guardar acá y corremos nuevamente nuestro código.
+
+71
+00:04:02.500 --> 00:04:05.140
+En este caso, como puedes ver, nos sale 53.
+
+72
+00:04:06.620 --> 00:04:08.460
+Lo que hace es una conversión
+
+73
+00:04:10.160 --> 00:04:14.280
+de este número a string y lo que hace es concatenar.
+
+74
+00:04:15.080 --> 00:04:20.560
+¿Por qué? Porque este signo más también nos sirve no solamente para sumar, sino para concatenar
+
+75
+00:04:20.920 --> 00:04:26.020
+strings. Entonces lo que dice JavaScript es como, ah, este es un string y este es un número.
+
+76
+00:04:26.460 --> 00:04:31.020
+Nay, cambiémoslo de una vez a string y coloquemos el string concatenado.
+
+77
+00:04:31.620 --> 00:04:46.800
+Entonces acá no nos serviría justamente para hacer sumas. ¿Por qué? ¿Por qué? Ya sabemos que JavaScript por debajo hace de las suyas. Es muy interesante que revisemos esto no solamente con strings y números, sino también con booleanos. Revisemos cómo sería con un boolean.
+
+78
+00:04:48.320 --> 00:04:49.900
+Si colocamos, por ejemplo,
+
+79
+00:04:50.220 --> 00:04:50.720
+const
+
+80
+00:04:51.560 --> 00:04:52.060
+zoomWithBoolean
+
+81
+00:04:54.140 --> 00:04:55.700
+y decimos, por ejemplo,
+
+82
+00:04:56.260 --> 00:04:57.840
+nuevamente un string
+
+83
+00:04:58.620 --> 00:05:00.360
+3 más true,
+
+84
+00:05:00.820 --> 00:05:03.880
+en este caso, ¿qué crees que va a suceder? Console.log,
+
+85
+00:05:05.140 --> 00:05:07.420
+vamos a colocarle zoom with boolean,
+
+86
+00:05:07.860 --> 00:05:08.360
+guardamos
+
+87
+00:05:09.000 --> 00:05:10.520
+y corremos el código.
+
+88
+00:05:11.020 --> 00:05:12.960
+Aquí ya vemos que también
+
+89
+00:05:13.360 --> 00:05:15.240
+JavaScript hizo de las suyas.
+
+90
+00:05:15.560 --> 00:05:22.320
+Resulta que vio el string y dijo, ay no pues los otros también los quiero en string. Entonces tomó el true,
+
+91
+00:05:22.660 --> 00:05:25.460
+lo convirtió a string e hizo que la concatenación.
+
+92
+00:05:26.420 --> 00:05:30.700
+Resulta que hay un truquito muy interesante para saber en qué casos
+
+93
+00:05:31.060 --> 00:05:32.240
+JavaScript concatena
+
+94
+00:05:32.540 --> 00:05:34.180
+o en qué casos JavaScript
+
+95
+00:05:34.500 --> 00:05:35.000
+suma.
+
+96
+00:05:35.460 --> 00:05:38.900
+Porque si nos fijamos, si hacemos este ejemplo,
+
+97
+00:05:39.300 --> 00:05:40.740
+vamos a decir zoom
+
+98
+00:05:41.360 --> 00:05:41.860
+with
+
+99
+00:05:42.780 --> 00:05:44.720
+number. Vamos a colocarle así.
+
+100
+00:05:45.040 --> 00:05:47.900
+En este caso si hacemos por ejemplo dos más
+
+101
+00:05:48.260 --> 00:05:48.760
+true,
+
+102
+00:05:49.240 --> 00:05:50.400
+¿qué crees que va a suceder?
+
+103
+00:05:50.860 --> 00:05:52.360
+Vamos a colocarle console.log,
+
+104
+00:05:53.960 --> 00:05:55.200
+zoom with number.
+
+105
+00:05:55.940 --> 00:05:57.540
+Vamos a guardar, corremos
+
+106
+00:05:58.120 --> 00:06:06.740
+y aquí nos sale tres. Aquí si JavaScript dijo, OK, dos más true, voy a convertir true en un número y voy a sumarlos.
+
+107
+00:06:07.200 --> 00:06:08.860
+Entonces ya no está concatenando,
+
+108
+00:06:09.160 --> 00:06:10.380
+sino que está sumando.
+
+109
+00:06:10.720 --> 00:06:12.900
+Ahí es donde viene el truquito, porque
+
+110
+00:06:13.380 --> 00:06:16.620
+JavaScript como hace de las suyas, pues nosotros tenemos que entender
+
+111
+00:06:16.920 --> 00:06:18.420
+qué es lo que hace precisamente.
+
+112
+00:06:19.240 --> 00:06:21.300
+Para ello vamos a realizar lo siguiente.
+
+113
+00:06:21.920 --> 00:06:22.920
+Vamos a colocar
+
+114
+00:06:23.480 --> 00:06:23.980
+unas
+
+115
+00:06:24.440 --> 00:06:24.940
+variables,
+
+116
+00:06:25.600 --> 00:06:27.400
+voy a colocar por acá.
+
+117
+00:06:28.020 --> 00:06:28.520
+Const
+
+118
+00:06:29.220 --> 00:06:30.260
+string value
+
+119
+00:06:30.600 --> 00:06:34.460
+y vamos a colocarle un string, en este caso que sea 10.
+
+120
+00:06:35.020 --> 00:06:37.100
+Vamos a colocarle un number
+
+121
+00:06:37.800 --> 00:06:38.300
+value.
+
+122
+00:06:39.020 --> 00:06:41.440
+Y este number value va a ser 10.
+
+123
+00:06:41.980 --> 00:06:43.900
+Y vamos a colocarle un boolean,
+
+124
+00:06:44.340 --> 00:06:44.840
+obviamente
+
+125
+00:06:45.440 --> 00:06:45.940
+const
+
+126
+00:06:46.520 --> 00:06:47.020
+boolean,
+
+127
+00:06:48.160 --> 00:06:48.660
+boolean
+
+128
+00:06:49.240 --> 00:06:49.740
+value,
+
+129
+00:06:50.500 --> 00:06:57.380
+igual a, en este caso puede ser, por ejemplo, true. ¿Qué es lo que vamos a hacer? Vamos a colocar console.log
+
+130
+00:06:58.060 --> 00:06:59.280
+y vamos a sumar
+
+131
+00:06:59.600 --> 00:07:01.580
+todas ellas. Vamos a revisar
+
+132
+00:07:02.140 --> 00:07:14.740
+qué es lo que hace precisamente al sumar string con número y string con boolean. Luego, número con string, número con booleano y luego booleano con string y booleano con number. A ver qué es lo que sucede. Entonces,
+
+133
+00:07:15.120 --> 00:07:15.620
+console.log,
+
+134
+00:07:16.500 --> 00:07:23.660
+¿de quién? Vamos a empezar con string value y voy a hacer lo siguiente. Voy a colocarle aquí un más
+
+135
+00:07:24.000 --> 00:07:26.180
+y voy a copiarme esto dos veces.
+
+136
+00:07:26.600 --> 00:07:27.440
+Voy a colocarle
+
+137
+00:07:27.860 --> 00:07:28.360
+inicialmente
+
+138
+00:07:28.800 --> 00:07:31.560
+string con string. A ver qué sucede.
+
+139
+00:07:31.980 --> 00:07:36.880
+Luego string con number y luego string con boolean.
+
+140
+00:07:37.780 --> 00:07:40.540
+Seguido de esto hacemos lo mismo console.log,
+
+141
+00:07:41.680 --> 00:07:44.240
+pero en este caso vamos a empezar con number.
+
+142
+00:07:44.660 --> 00:07:46.260
+Vamos a decir string
+
+143
+00:07:46.720 --> 00:07:54.440
+number más string, que ya por aquí arribita lo teníamos, pero vamos a colocarlo de todas formas para seguir como el hilo conductor.
+
+144
+00:07:55.760 --> 00:07:58.320
+Luego sería number con number,
+
+145
+00:07:58.780 --> 00:08:02.320
+y luego sería number con un boolean.
+
+146
+00:08:02.780 --> 00:08:04.400
+Y ya nos queda por último
+
+147
+00:08:04.780 --> 00:08:05.280
+console.log
+
+148
+00:08:06.160 --> 00:08:14.180
+de quién, de el booleano. Vamos a empezar con él más quién. Vamos a, voy a copiarme esto otra vez dos veces
+
+149
+00:08:14.600 --> 00:08:16.600
+y empezamos con un string,
+
+150
+00:08:17.100 --> 00:08:19.080
+luego con quién con un número,
+
+151
+00:08:20.220 --> 00:08:21.140
+aquí lo pegamos
+
+152
+00:08:21.520 --> 00:08:23.400
+y luego con un boolean.
+
+153
+00:08:24.320 --> 00:08:26.020
+Ok, aquí ya tenemos
+
+154
+00:08:26.560 --> 00:08:30.860
+todo para poder entender que es lo que hace precisamente JavaScript. Revisemos.
+
+155
+00:08:31.540 --> 00:08:35.340
+String se está mezclando con quién? Con strings, number y boolean.
+
+156
+00:08:35.700 --> 00:08:39.360
+Luego el number se está mezclando con string, number y booleano.
+
+157
+00:08:39.760 --> 00:08:44.280
+Y también los booleanos los estamos juntando con quién? Con string, number y boolean.
+
+158
+00:08:45.060 --> 00:08:45.560
+Excelente.
+
+159
+00:08:46.220 --> 00:08:49.900
+¿Qué crees que va a suceder acá? Vamos a correr nuestro código
+
+160
+00:08:50.620 --> 00:08:53.120
+y aquí voy a correr esto un poquito.
+
+161
+00:08:53.780 --> 00:08:57.840
+Bueno, el problema es que no vamos a saber dónde comienza. Voy a colocarle un console.log
+
+162
+00:08:58.620 --> 00:09:00.860
+y le voy a colocar una rayita
+
+163
+00:09:01.180 --> 00:09:04.660
+para que sepamos en dónde es que comienza. Voy a correrlo de
+
+164
+00:09:05.020 --> 00:09:11.260
+nuevo. OK, vamos a buscar la rayita. Muy bien. Entonces, string con string, lo que hace es concatenar.
+
+165
+00:09:12.280 --> 00:09:13.580
+String con number,
+
+166
+00:09:14.420 --> 00:09:15.560
+¿qué hace? Concatenar.
+
+167
+00:09:16.460 --> 00:09:19.620
+String con boolean, lo que hace también es concatenar.
+
+168
+00:09:20.480 --> 00:09:27.760
+Cuando es con número, veamos acá que serían estos tres. Lo que hace es string en número con string, concatena,
+
+169
+00:09:28.200 --> 00:09:29.720
+que sería este 10 10.
+
+170
+00:09:30.060 --> 00:09:33.060
+Luego number con number, lo que hace es sumar,
+
+171
+00:09:33.580 --> 00:09:37.200
+luego number con boolean, también lo que hace es sumar.
+
+172
+00:09:37.900 --> 00:09:38.400
+Seguido,
+
+173
+00:09:38.820 --> 00:09:40.780
+ya tenemos boolean con
+
+174
+00:09:41.380 --> 00:09:43.560
+string, lo que hace es concatenar,
+
+175
+00:09:44.440 --> 00:09:47.120
+y luego boolean con number, suma.
+
+176
+00:09:47.480 --> 00:09:50.660
+Boolean con boolean, lo que hace es sumar.
+
+177
+00:09:51.400 --> 00:09:53.300
+Por favor, cuéntame en los comentarios
+
+178
+00:09:54.360 --> 00:09:59.040
+cuál es la clave acá, qué es lo que hace, cuándo con catena y cuándo sumo.
+
+179
+00:10:00.180 --> 00:10:03.400
+La técnica básicamente es encontrar los strings.
+
+180
+00:10:03.780 --> 00:10:06.900
+Si hay un string, JavaScript lo que hace es concatenar.
+
+181
+00:10:07.380 --> 00:10:09.160
+Entonces te voy a poner por acá un mensajito,
+
+182
+00:10:09.640 --> 00:10:10.140
+concatenar.
+
+183
+00:10:12.000 --> 00:10:13.560
+Y cuando es
+
+184
+00:10:14.420 --> 00:10:23.640
+sin strings, lo que él hace es sumar y ya. Ese es básicamente el truquito. Entonces, en este caso sería este con catena, este también,
+
+185
+00:10:24.220 --> 00:10:25.000
+este también,
+
+186
+00:10:25.940 --> 00:10:27.000
+este suma.
+
+187
+00:10:27.380 --> 00:10:29.540
+Entonces, vamos a colocarlo por acá.
+
+188
+00:10:29.920 --> 00:10:30.900
+Este también
+
+189
+00:10:31.360 --> 00:10:31.860
+suma.
+
+190
+00:10:32.400 --> 00:10:38.060
+Por aquí este. A medida que no vea un string, si ya hay un string, ya, inmediatamente sabemos que concaten.
+
+191
+00:10:38.560 --> 00:10:41.440
+En este caso es suma y este también
+
+192
+00:10:42.440 --> 00:10:42.940
+suma.
+
+193
+00:10:44.220 --> 00:10:46.620
+¿Qué tal? ¿Cómo te parece JavaScript?
+
+194
+00:10:47.860 --> 00:10:51.600
+Bueno, este tipo de cositas hay que tenerlos en cuenta precisamente porque
+
+195
+00:10:52.100 --> 00:10:54.360
+JavaScript es de débil tipado.
+
+196
+00:10:54.920 --> 00:11:08.760
+Y bueno, también hace de las suyas y es importante conocerlo a la hora de que estemos también trabajando en nuestro código. Cuéntame, por favor, si esto ya lo conocía, si es nuevo, cómo te parece este concepto también de typecasting que es bastante interesante en JavaScript.
+
+197
+00:11:09.340 --> 00:11:15.580
+Por aquí tengo preparado un quiz para ti, así que por favor alista tu respuesta en los comentarios.
+
+198
+00:11:16.260 --> 00:11:18.700
+Tenemos el siguiente ejercicio. Const
+
+199
+00:11:19.140 --> 00:11:21.360
+número igual a un
+
+200
+00:11:21.780 --> 00:11:23.320
+valor que es 596.
+
+201
+00:11:24.400 --> 00:11:29.220
+Y luego dice const, número convertido igual a parseInt
+
+202
+00:11:29.720 --> 00:11:31.400
+y dentro esta número.
+
+203
+00:11:31.820 --> 00:11:35.920
+¿Cuál es la idea de este quiz? Saber cuál es el resultado de estos dos console.log.
+
+204
+00:11:36.500 --> 00:11:42.540
+Del primero tenemos el typeof de número y del segundo tenemos el typeof de número convertido.
+
+205
+00:11:43.480 --> 00:11:44.200
+Las respuestas
+
+206
+00:11:45.060 --> 00:11:49.440
+correctas para este ejercicio, ¿cuáles son? A, string y número,
+
+207
+00:11:49.900 --> 00:11:52.660
+B, string, string, o C,
+
+208
+00:11:52.960 --> 00:11:54.360
+number y string.
+
+209
+00:12:00.180 --> 00:12:02.140
+La respuesta correcta es
+
+210
+00:12:02.480 --> 00:12:04.680
+A, string y number.
+
+211
+00:12:05.100 --> 00:12:10.040
+Recordemos que el primer valor al estar entre comillas simple es un string,
+
+212
+00:12:10.520 --> 00:12:13.680
+pero que el segundo le estamos haciendo una conversión
+
+213
+00:12:14.280 --> 00:12:19.960
+explícita Y ya lo estamos convirtiendo, por supuesto, a Number. Cuéntame cómo te fue en los comentarios.

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/01-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/basico-js

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/01-Operadores de Comparación en JavaScript Igualdad y Desigualdad.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd028665c8b31de1437b65e26145e8c4a6d4cff10e08936c13d7e8edab3f1bc9
+size 31296513

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/01-Operadores de Comparación en JavaScript Igualdad y Desigualdad.vtt

@@ -0,0 +1,476 @@
+WEBVTT
+
+00:00.000 --> 00:01.560
+Vamos a empezar a hablar de lo que se
+llama
+
+00:01.560 --> 00:03.440
+ejecución
+condicional.
+
+00:03.440 --> 00:06.140
+Pero para poder entrar a detalles con
+ejecución condicional,
+
+00:06.140 --> 00:08.940
+tenemos que hablar de operadores de
+comparación.
+
+00:08.940 --> 00:12.000
+Y los operadores de comparación es lo que
+nos van a ayudar
+
+00:12.000 --> 00:14.180
+a generar una
+condición.
+
+00:14.180 --> 00:17.900
+Empezamos con un operador que son dos iguales.
+
+00:17.900 --> 00:21.860
+Estos dos iguales, en vez de asignarle
+valor a una variable,
+
+00:21.860 --> 00:26.740
+nos van a ayudar a comparar si algo es
+igual a otra cosa.
+
+00:26.740 --> 00:28.980
+Si eso es verdad, vamos a poder hacer algo.
+
+00:28.980 --> 00:31.700
+Si no es verdad, vamos a poder hacer otra
+cosa.
+
+00:31.700 --> 00:34.140
+Y de ahí empiezan las
+condiciones.
+
+00:34.140 --> 00:37.420
+Hay un segundo operador que son tres iguales.
+
+00:37.420 --> 00:40.060
+Y para mí, este es importante porque este
+nos va a ayudar
+
+00:40.060 --> 00:42.300
+a evitar muchos
+errores.
+
+00:42.300 --> 00:45.380
+Este valor o este operador lo que va a
+hacer es,
+
+00:45.380 --> 00:51.260
+si algo es igual a algo, pero va a generar
+una verificación
+
+00:51.260 --> 00:52.240
+en dos
+temas.
+
+00:52.240 --> 00:55.340
+Lo primero es que la igualdad sea en el valor,
+
+00:55.340 --> 00:58.020
+pero de igual forma en el tipo de dato.
+
+00:58.020 --> 01:01.180
+Si el valor es el mismo y el tipo de dato
+es el mismo,
+
+01:01.180 --> 01:02.740
+entonces nos va a dar un
+true.
+
+01:02.740 --> 01:04.140
+Si no, nos va a dar un
+false.
+
+01:04.140 --> 01:07.500
+Y con eso podemos nosotros hacer algo para
+poder continuar con
+
+01:07.500 --> 01:08.620
+nuestro
+código.
+
+01:08.620 --> 01:11.380
+Recomiendo que siempre que estemos
+hablando de operadores
+
+01:11.380 --> 01:14.820
+de comparación, utilicemos este de tres
+porque nos va a ayudar
+
+01:14.820 --> 01:16.780
+a evitar muchos
+errores.
+
+01:16.780 --> 01:22.660
+De ahí pasamos a un operador que es si
+este objeto o si este
+
+01:22.660 --> 01:25.540
+valor es diferente de este otro valor.
+
+01:25.540 --> 01:28.140
+Que de igual forma esto es como genera una
+negación.
+
+01:28.140 --> 01:30.700
+Pero si esto es diferente, nos va a dar un
+true.
+
+01:30.700 --> 01:32.700
+Si esto es igual, nos va a dar un false.
+
+01:32.700 --> 01:35.060
+Y entonces con eso podemos tomar decisiones.
+
+01:35.060 --> 01:39.020
+De igual forma, existe el diferente de,
+
+01:39.020 --> 01:43.500
+que es diferente de, pero vamos a utilizar
+dos símbolos de
+
+01:43.500 --> 01:46.860
+igual para al igual que este, nosotros lo
+que estamos
+
+01:46.860 --> 01:51.140
+diciendo es este valor es diferente a este
+valor,
+
+01:51.140 --> 01:55.700
+porque entonces es diferente en el valor y
+en el tipo de dato.
+
+01:55.700 --> 01:57.460
+De igual forma, si utilizamos
+este,
+
+01:57.460 --> 01:59.740
+vamos nosotros a evitar muchos errores,
+
+01:59.740 --> 02:02.060
+ya que estemos buscando una negación.
+
+02:02.060 --> 02:03.460
+Eso es muy
+importante.
+
+02:03.460 --> 02:06.460
+Existe otro operador que es
+mayor.
+
+02:06.460 --> 02:09.940
+Cuando nosotros queremos evaluar si un
+valor es mayor a otro
+
+02:09.940 --> 02:13.380
+valor, podemos hacer algo, entonces
+utilizamos este
+
+02:13.380 --> 02:14.380
+operador.
+
+02:14.380 --> 02:16.860
+Hay otro que es si es
+menor.
+
+02:16.860 --> 02:20.060
+Cuando un valor es menor de este a este,
+
+02:20.060 --> 02:22.420
+entonces nos va a regresar un true y con
+esto podemos
+
+02:22.420 --> 02:22.940
+avanzar.
+
+02:22.940 --> 02:25.860
+Si no es menor, nos va a regresar un false.
+
+02:25.860 --> 02:28.860
+Y de igual forma, tenemos si es mayor o igual,
+
+02:28.860 --> 02:30.420
+que también es
+importante.
+
+02:30.420 --> 02:33.460
+Si este valor es mayor o igual a este otro
+valor,
+
+02:33.460 --> 02:34.460
+podemos
+avanzar.
+
+02:34.460 --> 02:36.940
+Si no, entonces podemos hacer otra cosa.
+
+02:36.940 --> 02:40.740
+Pero de igual forma, tenemos si es menor o
+igual a este valor.
+
+02:40.740 --> 02:43.420
+Si valor A es menor o igual a valor B,
+
+02:43.420 --> 02:45.540
+entonces nos regresa un true, avanzamos.
+
+02:45.540 --> 02:49.100
+Si no, nos regresa un false y hacemos algo
+más.
+
+02:49.100 --> 02:51.620
+Vamos a pasar a hablar de ejemplos para
+que estos
+
+02:51.620 --> 02:53.700
+operadores te queden mucho más claro.
+
+02:53.700 --> 02:55.460
+Entonces, para empezar con los ejemplos,
+
+02:55.460 --> 02:59.060
+vamos a construir una constante que va a
+ser A y esta constante
+
+02:59.060 --> 03:01.740
+va a ser igual a
+10.
+
+03:01.740 --> 03:05.660
+Regresamos a generar otra constante que va
+a ser B y esta
+
+03:05.660 --> 03:09.180
+constante va a ser igual a
+20.
+
+03:09.180 --> 03:12.920
+Vamos a construir una tercer constante que
+va a ser C y esta
+
+03:12.920 --> 03:17.300
+constante en string va a ser igual a 10.
+
+03:17.300 --> 03:18.980
+Y ahorita vamos a ver por
+qué.
+
+03:18.980 --> 03:24.460
+Lo primero es un empezamos con la
+validación de si A es igual
+
+03:24.460 --> 03:26.160
+a
+B.
+
+03:26.160 --> 03:28.820
+Ahorita vamos a llevar este código a
+nuestro navegador
+
+03:28.820 --> 03:31.740
+para poder utilizar la consola del
+navegador y ejecutar
+
+03:31.740 --> 03:32.700
+JavaScript.
+
+03:32.700 --> 03:35.380
+Ya que tenemos nuestra consola del
+navegador abierta,
+
+03:35.380 --> 03:37.800
+lo que vamos a hacer es vamos a copiar
+este código que ya
+
+03:37.800 --> 03:41.100
+hicimos, lo vamos a pegar acá, para que la
+consola del
+
+03:41.100 --> 03:43.820
+navegador lo que nos ayuda es a poder
+validar JavaScript,
+
+03:43.820 --> 03:45.860
+porque el navegador lo que entiende es
+JavaScript.
+
+03:45.860 --> 03:48.340
+Si le damos Enter, de inicio tenemos un false.
+
+03:48.340 --> 03:48.820
+¿Por
+qué?
+
+03:48.820 --> 03:51.220
+Porque lo que estamos haciendo es le
+estamos preguntando al
+
+03:51.220 --> 03:55.260
+navegador, oye, la variable A es igual a
+la variable B y aquí
+
+03:55.260 --> 03:57.020
+podemos ver prácticamente que no es igual.
+
+03:57.020 --> 03:59.700
+La variable A es un 10, la variable B es
+un 20.
+
+03:59.700 --> 04:03.780
+Ahora, si yo pongo, por ejemplo, la
+variable A es igual,
+
+04:03.780 --> 04:07.900
+igual, igual a la variable C, ¿qué creen
+que va a salir?
+
+04:07.900 --> 04:10.140
+Si pongo C, me sale que es un false.
+
+04:10.140 --> 04:11.100
+¿Por
+qué?
+
+04:11.100 --> 04:14.180
+Como estábamos hablando, la variable A es
+igual a 10,
+
+04:14.180 --> 04:15.980
+la variable C es igual a
+10.
+
+04:15.980 --> 04:19.380
+Ahí se cumple la primera comparación.
+
+04:19.380 --> 04:21.580
+Pero recordemos que cuando utilizamos el 3,
+
+04:21.580 --> 04:23.020
+se hacen dos
+validaciones.
+
+04:23.020 --> 04:27.860
+La primera es el valor, que el valor es igual,
+
+04:27.860 --> 04:29.740
+pero luego es el tipo de
+valor.
+
+04:29.740 --> 04:34.420
+Aquí vemos que si bien A es igual a 10 y C
+es igual a 10,
+
+04:34.420 --> 04:38.780
+el tipo de valores A es un número y C es
+un string.
+
+04:38.780 --> 04:41.900
+Entonces, ahí no se cumple esta
+comparación y me regresa un
+
+04:41.900 --> 04:42.820
+false.
+
+04:42.820 --> 04:48.100
+Si ponemos, por ejemplo, A es diferente a B,
+
+04:48.100 --> 04:51.780
+me regresa un true, porque sabemos que 10
+es diferente a
+
+04:51.780 --> 04:52.700
+20.
+
+04:52.700 --> 04:59.380
+Si yo pongo, por ejemplo, un A es
+diferente a C,
+
+04:59.380 --> 05:02.140
+me regresa un true, porque de igual forma,
+
+05:02.140 --> 05:04.820
+cuando utilizamos 2, le estamos diciendo,
+
+05:04.820 --> 05:09.940
+es diferente en el dígito, en el valor y
+en el tipo de valor.
+
+05:09.940 --> 05:13.500
+Es diferente, por ejemplo, en este es un 10,
+sí,
+
+05:13.500 --> 05:16.420
+esto es igual, pero este es un número y
+este es un string.
+
+05:16.420 --> 05:19.300
+Entonces, ahí se cumple esa comparación y
+me regresa que es
+
+05:19.300 --> 05:20.220
+un
+true.
+
+05:20.220 --> 05:28.180
+Podemos ir, por ejemplo, con A es mayor,
+A es mayor a B,
+
+05:28.180 --> 05:31.580
+y me regresa un false, porque
+evidentemente 10 no es mayor
+
+05:31.580 --> 05:32.460
+que
+20.
+
+05:32.460 --> 05:35.300
+Y con eso nos podemos ir con los ejemplos.
+
+05:35.300 --> 05:41.540
+A es menor, por ejemplo, A es menor o igual a,
+
+05:41.540 --> 05:44.340
+vamos a ponerle B, sí, es
+verdad,
+
+05:44.340 --> 05:49.140
+A es menor a 20, porque A es 10 y B es 20.
+
+05:49.140 --> 05:56.100
+O podemos ir incluso con A es mayor que C
+y me regresa un
+
+05:56.100 --> 05:56.620
+false.
+
+05:56.620 --> 05:57.120
+¿Por
+qué?
+
+05:57.120 --> 06:00.340
+Pues porque 10 no es mayor que
+10.
+
+06:00.340 --> 06:02.420
+Entonces, estos son algunos ejemplos que
+nos ayudan a
+
+06:02.420 --> 06:06.340
+utilizar las comparaciones, estos
+operadores de comparación
+
+06:06.340 --> 06:09.140
+que nos van a ayudar a tomar ciertas
+decisiones para cuando
+
+06:09.140 --> 06:32.700
+entremos prácticamente a ejecuciones
+condicionales.
+

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/01-index_46d19b83-ac83-452d-858c-5e612b45b72f.js

@@ -0,0 +1,21 @@
+/*
+
+Operadores de comparación
+
+*/
+
+== 
+=== 
+!= 
+!== 
+>
+< 
+>= 
+<= 
+
+const a = 10; 
+const b = 20; 
+const c = "10"
+
+a == b; 
+

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/02-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/basico-js

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/02-Operadores Lógicos en Programación AND OR y NOT.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d19fe009c55fb0f04f5e475e237677010007bd0b333cbd49ebbcf7af111204bb
+size 22991528

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/02-Operadores Lógicos en Programación AND OR y NOT.vtt

@@ -0,0 +1,343 @@
+WEBVTT
+
+00:00.000 --> 00:02.000
+Vamos a hablar ahora de operadores lógicos.
+
+00:02.000 --> 00:03.800
+Estos son tres operadores
+básicos,
+
+00:03.800 --> 00:05.500
+pero son operadores que nos van a ayudar
+mucho.
+
+00:05.500 --> 00:09.000
+¿Por qué? Porque no siempre es si un valor
+es igual a otro valor.
+
+00:09.000 --> 00:13.400
+En ocasiones necesitamos saber si un valor
+y otro valor son iguales,
+
+00:13.400 --> 00:14.700
+entonces algo puede
+pasar.
+
+00:14.700 --> 00:19.400
+Y cuando queremos validar eso, empezamos
+con un y, por ejemplo.
+
+00:19.400 --> 00:23.200
+Si este valor y este valor hacen esto,
+o son esto,
+
+00:23.200 --> 00:25.000
+entonces pasa
+esto.
+
+00:25.000 --> 00:27.100
+El siguiente ahora es lo
+opuesto.
+
+00:27.100 --> 00:32.300
+Si este valor o este valor, entonces vamos
+a ponerlo con el operador o,
+
+00:32.300 --> 00:34.500
+que son este
+valor.
+
+00:34.500 --> 00:38.400
+Entonces aquí es un si valor A o valor B
+se cumplen,
+
+00:38.400 --> 00:40.900
+entonces podemos continuar con esta parte.
+
+00:40.900 --> 00:43.800
+Y el tercer valor es un valor de negación.
+
+00:43.800 --> 00:47.300
+Es no, que se le conoce como el valor de no.
+
+00:47.300 --> 00:50.800
+Si este valor no es esto, que hay algunos
+ejemplos,
+
+00:50.800 --> 00:56.100
+si este valor y o este valor o este valor
+no es este valor,
+
+00:56.100 --> 00:58.100
+entonces puede pasar esta
+parte.
+
+00:58.100 --> 00:59.300
+Esto es
+importante.
+
+00:59.300 --> 01:00.900
+Vamos con los
+ejemplos.
+
+01:00.900 --> 01:04.000
+Aquí, para poder continuar, vamos a
+generar tres constantes,
+
+01:04.000 --> 01:07.700
+que sería la constante A, que va a ser
+igual a 10,
+
+01:07.700 --> 01:12.300
+la constante B, que va a ser igual a 20.
+
+01:14.700 --> 01:18.000
+Aquí, solo por buena práctica, punto y
+coma al final.
+
+01:18.000 --> 01:21.500
+Y la constante C, que va a ser un string,
+
+01:21.500 --> 01:26.300
+pero va a ser un string que va a ser 10.
+
+01:26.300 --> 01:29.600
+Y esta va a ser nuestra constante C.
+
+01:29.600 --> 01:32.200
+Entonces, de igual forma, vamos a llevar
+este código
+
+01:32.200 --> 01:35.400
+directamente a nuestra consola de navegador.
+
+01:35.400 --> 01:36.800
+Vamos a iniciarlo
+aquí.
+
+01:36.800 --> 01:40.200
+Y ya que estamos acá, entonces empezamos
+con
+
+01:40.200 --> 01:45.700
+si A, por ejemplo, es igual a
+B
+
+01:45.700 --> 01:55.500
+y A es igual, igual, igual a
+C,
+
+01:55.500 --> 01:56.900
+¿qué creen que nos va a regresar
+aquí?
+
+01:56.900 --> 01:59.500
+Aquí nos tiene que regresar un false o un
+true.
+
+01:59.500 --> 02:01.100
+¿Qué es lo que vamos a
+validar?
+
+02:01.100 --> 02:05.700
+Si A es igual a B y A es
+igual,
+
+02:05.700 --> 02:08.200
+pero recordemos que este igual es en
+valor
+
+02:08.200 --> 02:10.800
+y en el tipo de valor es igual a
+C,
+
+02:10.800 --> 02:12.500
+nos tiene que regresar un
+false.
+
+02:12.500 --> 02:14.900
+Si no, entonces nos tiene que regresar un,
+perdón,
+
+02:14.900 --> 02:16.300
+nos tiene que regresar aquí un
+true
+
+02:16.300 --> 02:19.300
+y si no se cumple esto, nos tiene que
+regresar un false.
+
+02:19.300 --> 02:21.400
+Si le damos enter, nos regresa
+evidentemente un false.
+
+02:21.400 --> 02:25.000
+¿Por qué? Porque sabemos que 10 no es
+igual a 20
+
+02:25.000 --> 02:27.600
+y sabemos que este A, a pesar de que es un 10,
+
+02:27.600 --> 02:29.200
+no es igual a este
+C,
+
+02:29.200 --> 02:32.600
+porque simplemente no son del mismo tipo
+de valor.
+
+02:32.600 --> 02:33.500
+Vamos a ver
+otro.
+
+02:33.500 --> 02:38.600
+Sería si A es diferente a
+B
+
+02:38.600 --> 02:48.000
+o, y con esto ponemos o A es igual a C,
+
+02:48.000 --> 02:50.400
+entonces nos regresa un
+true.
+
+02:50.400 --> 02:53.800
+¿Por qué? Porque sabemos que en esta
+condicional
+
+02:53.800 --> 02:56.400
+alguna de estas dos se tiene que cumplir,
+
+02:56.400 --> 02:59.000
+no las dos, solo alguna de estas dos.
+
+02:59.000 --> 03:02.000
+Sabemos que A sí es diferente a
+B,
+
+03:02.000 --> 03:06.100
+entonces aquí se está cumpliendo o A es
+igual a C.
+
+03:06.100 --> 03:07.600
+Sabemos que esto no es
+igual,
+
+03:07.600 --> 03:10.600
+entonces como esta se cumple, nos regresa
+un true.
+
+03:10.600 --> 03:13.000
+Ahora vamos a ver un último ejemplo.
+
+03:13.000 --> 03:16.200
+Este ejemplo es tricky y te va a quedar un
+ejercicio ahorita
+
+03:16.200 --> 03:19.100
+que es un, que me lo puedas explicar en
+comentarios.
+
+03:19.100 --> 03:23.200
+Lo primero es iniciamos con el
+not,
+
+03:23.200 --> 03:25.700
+lo metemos en
+paréntesis,
+
+03:25.700 --> 03:28.900
+entonces aquí vamos a poner una comparación.
+
+03:28.900 --> 03:33.900
+Si A es igual, igual, igual a
+C.
+
+03:33.900 --> 03:38.100
+Y como ya viste, si le doy entre me va a
+regresar un true.
+
+03:38.100 --> 03:39.400
+Explícame en
+comentarios
+
+03:39.400 --> 03:41.400
+por qué me está regresando un true aquí.
+
+03:46.800 --> 03:48.800
+Bien, entonces vamos a
+examinarla.
+
+03:48.800 --> 03:52.800
+Aquí tenemos prácticamente una doble
+validación en esta línea.
+
+03:52.800 --> 03:55.400
+Vamos a empezar por la validación de
+adentro de los paréntesis.
+
+03:55.400 --> 03:59.500
+Lo que estamos haciendo aquí es si A es igual,
+igual, igual a C.
+
+03:59.500 --> 04:01.800
+Nosotros ya sabemos que esto es un false.
+
+04:01.800 --> 04:05.400
+¿Por qué? Porque A en valor sí es igual,
+
+04:05.400 --> 04:07.400
+pero en el tipo de valor es diferente.
+
+04:07.400 --> 04:09.100
+Entonces aquí nos regresa un
+false.
+
+04:09.100 --> 04:11.000
+Pero lo que estamos buscando con la
+negación
+
+04:11.000 --> 04:12.900
+es convertir ese false en un
+true.
+
+04:12.900 --> 04:14.700
+Como aquí pasa un
+false,
+
+04:14.700 --> 04:17.700
+lo que hace la negación es un no, va a
+pasar así,
+
+04:17.700 --> 04:20.100
+entonces lo que hace es convierte ese
+false en un true
+
+04:20.100 --> 04:21.500
+y nos regresa un
+true.
+
+04:21.500 --> 04:23.800
+Eventualmente en tu carrera puede ser que
+te encuentres
+
+04:23.800 --> 04:25.900
+con validaciones muy similares a
+estas
+
+04:25.900 --> 04:27.800
+y en este momento te convendría
+saber
+
+04:27.800 --> 04:30.000
+cómo puedes convertir un false en un
+true
+
+04:30.000 --> 04:32.100
+si es el tipo de validación que estás
+buscando.
+
+04:32.100 --> 05:00.100
+Y lo harías de esta
+forma.
+

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/02-logica_f00b3100-7500-4fb8-b9b3-dea80a95bc8c.js

@@ -0,0 +1,14 @@
+/*
+
+Operadores Lógicos
+
+*/
+
+&& 
+|| 
+! 
+
+const a = 10;
+const b = 20;
+const c = "10"
+

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/03-Estructuras Condicionales Uso de IF ELSE y ELSE IF en JavaScript.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b0ead3fcaedb081404fc738e45b8aaaaf24746c7fa282a7ccff8f16d316a5c04
+size 43616348

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/03-Estructuras Condicionales Uso de IF ELSE y ELSE IF en JavaScript.vtt

@@ -0,0 +1,575 @@
+WEBVTT
+
+00:00.000 --> 00:02.620
+Vamos a comenzar con estructuras
+condicionales,
+
+00:02.620 --> 00:05.500
+o mejor conocidas como estructuras de control.
+
+00:05.500 --> 00:08.460
+Hay una de ellas que se llama IF, con la
+que vamos a iniciar.
+
+00:08.460 --> 00:11.560
+Si tú me dices como, Diego, yo ya sé cómo
+hacer constantes,
+
+00:11.560 --> 00:13.800
+ya sé cómo hacer variables, ya sé cómo
+hacer funciones,
+
+00:13.800 --> 00:15.560
+pero todo el código que yo
+tengo,
+
+00:15.560 --> 00:18.520
+quiero ver qué parte del código se puede
+ejecutar
+
+00:18.520 --> 00:20.660
+con relación a
+algo.
+
+00:20.660 --> 00:24.620
+Y con ese algo, es aquí donde ocupamos
+estas estructuras de control
+
+00:24.620 --> 00:27.960
+para poder hacer algunas validaciones que
+nos ayuden a ver
+
+00:27.960 --> 00:30.960
+qué parte de todo el código tiene que
+entrar en acción.
+
+00:30.960 --> 00:36.300
+La primera que vamos a ver es IF, así que
+vamos a hacer ya.
+
+00:36.300 --> 00:39.020
+Tenemos entonces las estructuras de control.
+
+00:39.020 --> 00:43.560
+La primera estructura de control que vamos
+a utilizar se llama IF,
+
+00:43.560 --> 00:47.460
+que es prácticamente sí, por ejemplo,
+¿no?
+
+00:47.460 --> 00:50.960
+Si pasa esto, entonces que se ejecute esto.
+
+00:50.960 --> 00:54.560
+Si no, entonces que se ejecute otra cosa.
+
+00:54.560 --> 00:59.560
+Y para esta estructura de control vamos a
+utilizar los operadores,
+
+00:59.560 --> 01:03.860
+que los operadores son ciertos símbolos
+que nos ayudan a generar esa condición.
+
+01:03.860 --> 01:06.660
+Entonces, la estructura de IF
+es,
+
+01:06.660 --> 01:10.000
+tenemos el sí, vamos a utilizar paréntesis,
+
+01:10.000 --> 01:12.460
+y en paréntesis aquí va a pasar alguna
+variable,
+
+01:12.460 --> 01:15.060
+por ejemplo, alguna
+let,
+
+01:15.060 --> 01:18.200
+que es la let que vamos nosotros a evaluar,
+
+01:18.200 --> 01:23.420
+con algún operador que nos pueda ayudar a
+generar esa validación
+
+01:23.420 --> 01:26.360
+y que sea igual a algo
+más.
+
+01:26.360 --> 01:30.100
+Entonces, con este algo más, si esta
+condición,
+
+01:30.100 --> 01:31.960
+porque esto es una condición, se cumple,
+
+01:31.960 --> 01:36.060
+entonces aquí viene cierto
+código
+
+01:36.060 --> 01:39.500
+que tiene que suceder si la condición se
+cumple.
+
+01:39.500 --> 01:42.420
+Podríamos dejarlo aquí, pero esto es muy
+sencillo.
+
+01:42.420 --> 01:47.560
+Si esta condición no se cumple, entonces
+utilizamos el else.
+
+01:47.560 --> 01:52.100
+Si no se cumple, entonces algo más tiene
+que pasar.
+
+01:52.100 --> 01:54.760
+Y es algo más, simplemente pasa con
+else
+
+01:54.760 --> 01:56.420
+y ponemos entonces
+brackets,
+
+01:56.420 --> 02:00.220
+y aquí ya nosotros podemos empezar a
+generar el código
+
+02:00.220 --> 02:02.100
+de la condición que no se
+cumplió.
+
+02:02.100 --> 02:04.020
+Esta sería la primera
+estructura.
+
+02:04.020 --> 02:05.700
+Tenemos el
+IF.
+
+02:05.700 --> 02:09.100
+Esto de aquí pasa, es verdad, es lo que
+estamos buscando,
+
+02:09.100 --> 02:10.660
+se ejecuta este
+código.
+
+02:10.660 --> 02:13.820
+Si no, entonces se ejecuta este código.
+
+02:13.820 --> 02:16.420
+Pero ahora, ¿qué pasa si yo estoy
+generando
+
+02:16.420 --> 02:18.660
+o estoy trabajando con alguna
+condición
+
+02:18.660 --> 02:22.100
+en donde es más compleja y no solo quiero
+que pase esto?
+
+02:22.100 --> 02:24.820
+Que puede ser esto o esto
+otro,
+
+02:24.820 --> 02:27.260
+y si no, entonces puede pasar
+esto.
+
+02:27.260 --> 02:30.820
+Entonces aquí está esta condición o esta
+estructura crece,
+
+02:30.820 --> 02:33.220
+entonces viene else
+if,
+
+02:33.220 --> 02:37.100
+que es un entonces si este otro pasa,
+
+02:37.100 --> 02:39.900
+aquí ponemos más
+código,
+
+02:39.900 --> 02:42.100
+este código se ejecuta, si esto
+no,
+
+02:42.100 --> 02:45.600
+entonces vamos a poner algunos corchetes,
+
+02:45.600 --> 02:47.100
+y dentro de los
+corchetes
+
+02:47.100 --> 02:49.960
+vamos a poner la estructura de fold que
+tiene que pasar
+
+02:49.960 --> 02:53.360
+en caso de que ninguna condición que yo
+quiera se vaya a cumplir.
+
+02:53.360 --> 02:57.660
+Y acá vamos a empezar a utilizar lo que
+son los operadores,
+
+02:57.660 --> 03:00.860
+que los operadores son prácticamente los
+símbolos
+
+03:00.860 --> 03:03.760
+que nos van a ayudar a validar lo que yo
+quiero
+
+03:03.760 --> 03:05.200
+en esta
+estructura.
+
+03:05.200 --> 03:06.460
+Vamos a pasar a un
+ejemplo
+
+03:06.460 --> 03:08.800
+para que entonces nos quede mucho más claro.
+
+03:08.800 --> 03:12.560
+Un ejemplo muy básico sería, vamos a
+empezar con un let,
+
+03:12.560 --> 03:18.000
+y entonces este let va a ser, por ejemplo,
+nombre,
+
+03:18.000 --> 03:21.220
+y aquí vamos a utilizar el operador de
+asignación,
+
+03:21.220 --> 03:24.500
+en donde el nombre va a ser
+Diego.
+
+03:24.500 --> 03:26.100
+Perfecto, tenemos
+esto,
+
+03:26.100 --> 03:30.360
+entonces ahora vamos a ver si el nombre es
+igual a Diego,
+
+03:30.360 --> 03:31.200
+tiene que pasar
+algo,
+
+03:31.200 --> 03:33.600
+si no, entonces simplemente no va a pasar
+nada.
+
+03:33.600 --> 03:38.200
+Entonces si, por ejemplo, nombre, que es
+la variable,
+
+03:38.200 --> 03:43.600
+es igual a
+Diego,
+
+03:43.600 --> 03:46.000
+si esta variable o esta condición se cumple,
+
+03:46.000 --> 03:51.300
+entonces aquí vamos a poner un console.
+log
+
+03:51.300 --> 03:57.000
+y tendría que poner tipo Hola Diego.
+
+03:57.000 --> 04:01.000
+Entonces vamos a terminar ahí y vamos a
+guardar.
+
+04:01.000 --> 04:02.700
+Vamos a ir a nuestro
+índex,
+
+04:02.700 --> 04:05.400
+y en nuestro índex yo voy a utilizar un
+servidor
+
+04:05.400 --> 04:08.600
+que viene en uno de los plugins de VS Code,
+
+04:08.600 --> 04:10.200
+está aquí, entonces vamos a
+poner,
+
+04:10.200 --> 04:14.800
+vamos a abrir prácticamente este servidor
+en nuestra consola.
+
+04:14.800 --> 04:16.700
+Aquí prácticamente ya no lo está abriendo,
+
+04:16.700 --> 04:18.000
+entonces vamos a abrir la pestaña acá,
+
+04:18.000 --> 04:19.600
+tenemos nuestro
+documento,
+
+04:19.600 --> 04:22.200
+y aquí podemos ver que hace referencia al
+documento
+
+04:22.200 --> 04:24.100
+que tenemos que es
+este.
+
+04:24.100 --> 04:26.800
+Entonces todo el código JavaScript que
+ejecutemos acá
+
+04:26.800 --> 04:28.400
+nos tiene que dar una
+respuesta.
+
+04:28.400 --> 04:32.000
+Si tenemos aquí, por ejemplo, nuestro,
+
+04:32.000 --> 04:37.000
+como inspector de elementos, vamos para allá,
+
+04:37.000 --> 04:40.900
+y aquí nos vamos directamente a nuestra
+consola,
+
+04:40.900 --> 04:43.900
+vamos a borrar como todos estos errores
+que nos salen,
+
+04:43.900 --> 04:45.500
+y guardamos una vez más
+acá.
+
+04:45.500 --> 04:48.600
+Entonces todo el código que nosotros
+estemos trabajando aquí
+
+04:48.600 --> 04:50.400
+de JavaScript, al momento de guardar,
+
+04:50.400 --> 04:52.600
+automáticamente nos va a dar una respuesta
+aquí,
+
+04:52.600 --> 04:54.900
+y como podemos ver, aquí ya nos sale un
+console.log
+
+04:54.900 --> 04:57.900
+que es Hola Diego, que viene en la línea
+4
+
+04:57.900 --> 05:00.500
+de nuestro índex, que es prácticamente esta.
+
+05:00.500 --> 05:02.800
+Entonces aquí ya podemos ver que, bueno,
+
+05:02.800 --> 05:04.300
+esta condición se
+cumplió.
+
+05:04.300 --> 05:04.900
+¿Por
+qué?
+
+05:04.900 --> 05:08.200
+Porque me está regresando prácticamente el
+console.log.
+
+05:08.200 --> 05:10.300
+Si yo le cambio, por ejemplo, aquí a,
+
+05:10.300 --> 05:14.400
+vamos a ponerle Nico, y lo
+guardo,
+
+05:14.400 --> 05:16.000
+no pasa absolutamente
+nada,
+
+05:16.000 --> 05:18.500
+porque esta condición no se está cumpliendo.
+
+05:18.500 --> 05:22.200
+Y es ahí donde nosotros podemos utilizar
+un else, por ejemplo.
+
+05:22.200 --> 05:23.900
+Entonces ponemos un else,
+¿OK?
+
+05:23.900 --> 05:27.700
+Si el nombre de la variable o el resultado
+de la variable
+
+05:27.700 --> 05:32.900
+nombre no es Diego, entonces saca algo más.
+
+05:32.900 --> 05:45.000
+.log es un, no vamos a poner, nombre no
+encontrado.
+
+05:45.000 --> 05:47.700
+Entonces si guardamos, prácticamente me
+sale el else.
+
+05:47.700 --> 05:51.200
+Recordemos que el else prácticamente va a
+ser esta
+
+05:51.200 --> 05:52.300
+condición
+default.
+
+05:52.300 --> 05:56.800
+Si nada se cumple, ¿cuál va a ser esa
+instrucción o ese código
+
+05:56.800 --> 05:58.600
+default que se tiene que
+ejecutar?
+
+05:58.600 --> 06:01.500
+Podría no ejecutarse nada, pero casi
+siempre es bueno tener
+
+06:01.500 --> 06:04.500
+una respuesta por
+default.
+
+06:04.500 --> 06:06.700
+Si las condiciones no se están cumpliendo,
+
+06:06.700 --> 06:08.100
+que no se ayuden a ver como,
+oye,
+
+06:08.100 --> 06:10.900
+nada de lo que me estás intentando validar
+es real,
+
+06:10.900 --> 06:12.300
+entonces te estoy regresando
+esto,
+
+06:12.300 --> 06:15.100
+que en este caso es un nombre no encontrado.
+
+06:15.100 --> 06:18.900
+El nombre que estoy intentando validar
+simplemente no existe.
+
+06:18.900 --> 06:22.400
+Pero si yo conozco, por ejemplo, a Nico y
+también a Diego,
+
+06:22.400 --> 06:25.100
+y me gustaría saludar a los dos, entonces
+aquí podemos nosotros
+
+06:25.100 --> 06:27.200
+poner un if,
+¿no?
+
+06:27.200 --> 06:32.700
+En donde este if, lo que va a ser
+prácticamente,
+
+06:32.700 --> 06:37.100
+vamos a sacar esto aquí, y va a ser hola,
+Nico.
+
+06:40.200 --> 06:43.000
+Aquí ponemos nuestro else, que recordemos
+que va a ser como
+
+06:43.000 --> 06:48.300
+el default en caso de que no se coloque el
+nombre de Nico.
+
+06:48.300 --> 06:53.300
+Entonces, si guardamos, aquí tengo un error.
+
+06:53.300 --> 06:56.600
+Entonces, aquí nos sale un error que nos
+dice que el error viene
+
+06:56.600 --> 06:59.400
+en la línea 5, que es prácticamente acá.
+
+06:59.400 --> 07:01.800
+Y claro, hay un error porque estoy
+diciendo que,
+
+07:01.800 --> 07:04.600
+perfecto, entonces si esta condición no se
+cumple,
+
+07:04.600 --> 07:06.100
+tendr��a que entrar esta
+condición,
+
+07:06.100 --> 07:08.400
+pero no le estoy poniendo cuál es la
+condición.
+
+07:08.400 --> 07:10.400
+Entonces, para poder hacer una segunda
+condición,
+
+07:10.400 --> 07:12.800
+abrimos lo que son paréntesis y ponemos.
+
+07:12.800 --> 07:16.400
+Entonces, si para hacer una segunda condición,
+
+07:16.400 --> 07:23.400
+entonces si nombre es igual, igual, igual a,
+por ejemplo,
+
+07:23.400 --> 07:25.900
+Nico, que es lo que tenemos
+aquí,
+
+07:25.900 --> 07:28.900
+y esta es una segunda condición, entonces
+si se cumple esta,
+
+07:28.900 --> 07:30.400
+tendría que entrar este
+console.
+
+07:30.400 --> 07:33.900
+Si guardamos, aquí ya me sale hola, Nico.
+
+07:33.900 --> 07:35.400
+Vamos a quitar esto de
+aquí.
+
+07:35.400 --> 07:37.400
+Entonces, es la forma en la que podemos
+empezar a hacer
+
+07:37.400 --> 07:40.400
+condiciones, y es la forma entonces en la
+que podemos
+
+07:40.400 --> 07:46.400
+empezar a ejecutar cierto código de
+acuerdo a esa condición.
+

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/03-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/basico-js

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/03-index_fe9ea1fe-4786-4cef-8d43-ddbe3a1d4f46.js

@@ -0,0 +1,9 @@
+let nombre = "Nico";
+
+if (nombre === "Diego") {
+  console.log("Hola Diego");
+} else if (nombre === "Nico") {
+  console.log("Hola Nico");
+} else {
+  console.log("Nombre no encontrado");
+}

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/04-Juego de Adivinanza Programación con Estructuras Condicionales.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5b4757d26440e757933d84d44cbea04068f31061189ec4cbbe3ef5d8cc4f8a10
+size 68039498

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/04-Juego de Adivinanza Programación con Estructuras Condicionales.vtt

@@ -0,0 +1,708 @@
+WEBVTT
+
+00:00.000 --> 00:01.660
+Vamos a empezar con un pequeño juego.
+
+00:01.660 --> 00:04.200
+Este juego va a ser adivinen el número
+secreto.
+
+00:04.200 --> 00:07.860
+Para este juego vamos a utilizar una
+ecuación condicional
+
+00:07.860 --> 00:10.660
+que dependiendo la respuesta podamos
+validar
+
+00:10.660 --> 00:12.700
+si se acerca o no al número
+secreto
+
+00:12.700 --> 00:15.760
+o si prácticamente estamos adivinando ese
+número secreto.
+
+00:15.760 --> 00:18.900
+Y para poder comenzar, vamos a iniciar con
+una constante
+
+00:18.900 --> 00:22.700
+que se va a llamar número
+secreto.
+
+00:22.700 --> 00:33.300
+Esa constante va a ser igual a un método
+que se llama Math.floor.
+
+00:33.300 --> 00:35.100
+Te voy a dejar en la descripción de la
+clase
+
+00:35.100 --> 00:36.900
+un poco más de información de
+Math.floor
+
+00:36.900 --> 00:38.500
+y otro método que se llama
+Math.random
+
+00:38.500 --> 00:40.100
+para que puedas entenderlos
+más.
+
+00:40.100 --> 00:42.500
+Pero lo que estos dos métodos nos van a
+ayudar a hacer
+
+00:42.500 --> 00:45.400
+es construir un número de forma aleatoria.
+
+00:45.400 --> 00:47.800
+Y nosotros le vamos a decir de qué rango a
+qué rango
+
+00:47.800 --> 00:50.900
+para que podamos delimitar el número que
+se va a construir.
+
+00:50.900 --> 00:52.700
+Entonces, adentro de este
+método
+
+00:52.700 --> 00:59.100
+vamos a utilizar otro que se llama Math.
+random.
+
+00:59.100 --> 01:01.700
+Y aquí le vamos a poner, prácticamente,
+
+01:01.700 --> 01:04.600
+que quiero que el rango de números que se
+va a generar
+
+01:04.600 --> 01:08.900
+sea de el 10 al
+1.
+
+01:08.900 --> 01:12.200
+Entonces, con esto, esta constante me va a
+construir
+
+01:12.200 --> 01:15.100
+un número en aleatorio del 1 al
+10
+
+01:15.100 --> 01:16.200
+con el cual vamos a estar
+jugando
+
+01:16.200 --> 01:18.100
+para poder delimitar el número
+secreto
+
+01:18.100 --> 01:20.400
+que tenemos que
+adivinar.
+
+01:20.400 --> 01:21.800
+Ya que tenemos
+eso,
+
+01:21.800 --> 01:24.600
+vamos ahora a construir la
+constante
+
+01:24.600 --> 01:26.700
+con la cual nosotros vamos a
+jugar,
+
+01:26.700 --> 01:31.000
+que se va a llamar número del jugador.
+
+01:31.000 --> 01:34.200
+Y este número del jugador va a ser igual a...
+
+01:34.200 --> 01:37.400
+Este va a ser igual a un
+parseInt
+
+01:37.400 --> 01:39.800
+y el parseInt, hasta
+adentro,
+
+01:39.800 --> 01:45.200
+vamos a tener un
+prompt
+
+01:45.200 --> 01:48.600
+que nos va a ayudar a preguntar,
+prácticamente, en el navegador
+
+01:48.600 --> 01:51.800
+para que nosotros podamos inyectar cierta
+información
+
+01:51.800 --> 01:54.200
+con la cual vamos a jugar y se va a extraer.
+
+01:54.200 --> 01:57.700
+Entonces, este prompt va a
+ser...
+
+01:57.700 --> 02:07.000
+Adivina el número secreto
+entre...
+
+02:07.000 --> 02:14.000
+Vamos a ponerle entre el 1 al
+10.
+
+02:14.000 --> 02:18.000
+Entonces, ya con esto, si nosotros salvamos,
+
+02:18.000 --> 02:19.400
+nos aparece lo que es el
+prompt.
+
+02:19.400 --> 02:21.400
+Entonces, aquí lo que nosotros podemos
+decir es
+
+02:21.400 --> 02:23.300
+vamos a jugar con
+4.
+
+02:23.300 --> 02:25.900
+Entonces, ahorita no tengo forma de saber
+qué es el 4,
+
+02:25.900 --> 02:31.700
+solo si mandamos llamar el número del jugador.
+
+02:31.700 --> 02:34.400
+Entonces, aquí me sale que estoy jugando
+con 4.
+
+02:34.400 --> 02:35.300
+Perfecto.
+
+02:35.300 --> 02:36.900
+Entonces, ahora lo que vamos a hacer es...
+
+02:36.900 --> 02:39.700
+Vamos a empezar con algunos
+mensajes
+
+02:39.700 --> 02:41.300
+en los cuales podemos
+ver
+
+02:41.300 --> 02:42.800
+que yo tengo una pequeña
+retroalimentación
+
+02:42.800 --> 02:45.000
+de cuál es el número con el que estoy
+jugando
+
+02:45.000 --> 02:48.100
+para poder entrar a una
+validación.
+
+02:48.100 --> 02:49.200
+Entonces, lo primero que vamos a
+hacer
+
+02:49.200 --> 02:59.100
+es un pequeño console
+log...
+
+02:59.100 --> 03:02.100
+En el cual lo que vamos a poner aquí es...
+
+03:02.100 --> 03:09.900
+Primero, vamos a irnos de esta forma.
+
+03:09.900 --> 03:16.900
+Este es el número con el que
+juega.
+
+03:16.900 --> 03:21.400
+Y acá vamos a poner el valor de nuestra
+variable,
+
+03:21.400 --> 03:27.400
+que va a ser número
+jugador.
+
+03:27.400 --> 03:28.400
+Perfecto.
+
+03:28.400 --> 03:30.100
+Entonces, si yo hago eso y aquí
+pongo
+
+03:30.100 --> 03:31.800
+vamos a jugar con el
+7,
+
+03:31.800 --> 03:34.100
+me tiene que regresar el número con el que
+estoy jugando.
+
+03:34.100 --> 03:34.500
+Perfecto.
+
+03:34.500 --> 03:36.500
+Entonces, esto es para que yo visualmente
+ahorita
+
+03:36.500 --> 03:38.800
+desde la consola pueda ver con qué número
+juegue
+
+03:38.800 --> 03:42.200
+y no tengo que estar mandando llamar la
+variable.
+
+03:42.200 --> 03:45.300
+Ahora vamos a empezar con nuestra
+estructura id.
+
+03:45.300 --> 03:48.300
+Si, por ejemplo, vamos a poner
+aquí
+
+03:48.300 --> 03:59.700
+número jugador es igual, igual, igual a
+número secreto,
+
+03:59.700 --> 04:03.600
+entonces aquí prácticamente ya estamos
+ganando.
+
+04:03.600 --> 04:08.300
+Entonces, vamos a poner
+console.log
+
+04:08.300 --> 04:13.000
+y el mensaje de
+tipo...
+
+04:13.000 --> 04:21.800
+Felicidades, adivinaste el número secreto.
+
+04:21.800 --> 04:28.000
+Perfecto.
+
+04:28.000 --> 04:31.400
+Entonces, vamos a hacer un pequeño ejemplo.
+
+04:31.400 --> 04:33.800
+Aquí tengo el 8,
+¿ok?
+
+04:33.800 --> 04:35.700
+De momento, vamos a ver
+acá,
+
+04:35.700 --> 04:37.500
+tengo un pequeño error en la línea 9,
+
+04:37.500 --> 04:38.500
+ahorita lo vamos a
+checar,
+
+04:38.500 --> 04:40.000
+voy a hacer aquí la
+variable.
+
+04:40.000 --> 04:44.600
+Pero lo que quiero hacer yo acá es número
+secreto.
+
+04:44.600 --> 04:48.400
+Quiero ver qué es lo que me regresa el
+número secreto.
+
+04:48.400 --> 04:50.300
+Entonces, el número secreto prácticamente
+es 2,
+
+04:50.300 --> 04:52.100
+evidentemente no va a entrar en la aplicación.
+
+04:52.100 --> 04:54.400
+Yo pongo el 8 y el número secreto es
+prácticamente 2.
+
+04:54.400 --> 04:57.200
+Ahora aquí,
+jugador.
+
+04:57.200 --> 04:58.000
+Ya
+está.
+
+04:58.000 --> 05:00.600
+Entonces, con eso, si el número es el mismo,
+
+05:00.600 --> 05:05.400
+el número es el mismo en el tipo de valor
+y en el valor,
+
+05:05.400 --> 05:07.000
+entonces esta condición se va a
+cumplir
+
+05:07.000 --> 05:09.000
+y me tiene que regresar el felicidades.
+
+05:09.000 --> 05:11.700
+Si aquí ponemos un
+6,
+
+05:11.700 --> 05:15.100
+perfecto, es con el número que estoy yendo.
+
+05:15.100 --> 05:18.700
+Y si ponemos el número
+secreto,
+
+05:18.700 --> 05:19.900
+el número secreto es un
+6.
+
+05:19.900 --> 05:21.600
+Entonces, aquí algo está
+pasando
+
+05:21.600 --> 05:24.800
+porque no se está generando nuestra
+validación.
+
+05:24.800 --> 05:28.400
+Entonces, primero aquí vamos
+a...
+
+05:28.400 --> 05:30.100
+Juegas,
+¿ok?
+
+05:30.100 --> 05:32.100
+Y vamos a hacer un intento
+más,
+
+05:32.100 --> 05:33.800
+vamos a ponerle
+5,
+
+05:33.800 --> 05:34.900
+verifico el
+5,
+
+05:34.900 --> 05:37.400
+y quiero ver si realmente el
+matrandom
+
+05:37.400 --> 05:40.700
+me está regresando un número random.
+
+05:40.700 --> 05:42.800
+Número secreto es
+10.
+
+05:42.800 --> 05:43.300
+Perfecto.
+
+05:43.300 --> 05:45.400
+Entonces, vemos que se está cambiando este
+número
+
+05:45.400 --> 05:47.200
+y vemos que no está imprimiendo eso.
+
+05:47.200 --> 05:49.000
+Entonces, si hubiéramos puesto
+10,
+
+05:49.000 --> 05:51.900
+esta validación se tiene que cumplir.
+
+05:51.900 --> 05:54.100
+Y aquí ya tendríamos
+prácticamente,
+
+05:54.100 --> 05:55.400
+o ya hubiéramos
+ganado.
+
+05:55.400 --> 05:58.000
+Pero como no estamos siempre adivinando el
+número,
+
+05:58.000 --> 06:01.700
+vamos a meter entonces la validación else if,
+
+06:01.700 --> 06:04.300
+en el cual vamos a
+ver,
+
+06:04.300 --> 06:08.900
+vamos a poner si el número del
+jugador
+
+06:08.900 --> 06:10.900
+es, por
+ejemplo,
+
+06:10.900 --> 06:14.700
+menor que al número
+secreto,
+
+06:14.700 --> 06:22.800
+entonces nos tendría que regresar como
+console.log.
+
+06:22.800 --> 06:26.500
+Aquí algún anuncio de, por
+ejemplo,
+
+06:26.500 --> 06:35.500
+el número es demasiado, demasiado bajo.
+
+06:35.500 --> 06:39.100
+O sí, puede ser el
+número,
+
+06:39.100 --> 06:42.900
+si el número, si nuestro número es menor
+al número secreto,
+
+06:42.900 --> 06:50.700
+es demasiado bajo y podemos darle intenta
+de nuevo.
+
+06:50.700 --> 06:52.000
+Entonces, aquí
+guardamos,
+
+06:52.000 --> 06:55.400
+podemos intentarlo una vez más,
+4.
+
+06:55.400 --> 06:57.300
+No nos está regresando alguna validación.
+
+06:57.300 --> 07:02.300
+Vamos a ver cuál fue entonces el número
+secreto.
+
+07:02.300 --> 07:07.400
+El número secreto es 4, no, el número
+secreto es 3.
+
+07:07.400 --> 07:10.100
+Entonces, evidentemente nuestro número es
+mayor a 3.
+
+07:10.100 --> 07:12.700
+Aquí podríamos hacer una validación más,
+
+07:12.700 --> 07:14.300
+según el ejercicio que tú lo puedas hacer.
+
+07:14.300 --> 07:17.000
+Nosotros podemos terminar con el else,
+
+07:17.000 --> 07:18.700
+que entonces el else es el
+default,
+
+07:18.700 --> 07:21.600
+que en el default es la suposición es
+demasiado alta.
+
+07:21.600 --> 07:25.800
+Yo podría poner, por ejemplo, aquí un else if,
+
+07:25.800 --> 07:28.800
+si el número es mayor al número secreto,
+
+07:28.800 --> 07:31.300
+entonces el número es demasiado alto,
+
+07:31.300 --> 07:32.300
+intenta de
+nuevo,
+
+07:32.300 --> 07:36.000
+pero esa puede ser mi validación por default.
+
+07:36.000 --> 07:40.600
+Si no es bajo, entonces puede ser alto
+hasta que le atines.
+
+07:40.600 --> 07:43.400
+Yo podría poner entonces aquí un else
+if
+
+07:43.400 --> 07:45.200
+para poder validar si es muy
+alto,
+
+07:45.200 --> 07:47.700
+y el default para poder validar si el
+número
+
+07:47.700 --> 07:51.100
+incluso es mucho mayor del rango del 1 al 10.
+
+07:51.100 --> 07:56.900
+Voy a utilizar este default para poder
+decidir cómo,
+
+07:56.900 --> 08:00.300
+console.log,
+
+08:00.300 --> 08:04.000
+en este
+caso,
+
+08:04.000 --> 08:07.400
+el número es muy
+alto.
+
+08:07.400 --> 08:09.700
+Intenta de
+nuevo.
+
+08:09.700 --> 08:10.900
+Intenta de
+nuevo.
+
+08:10.900 --> 08:13.900
+Entonces, si guardo, ya tengo
+prácticamente toda la lógica.
+
+08:13.900 --> 08:16.400
+Si yo pongo un
+7,
+
+08:16.400 --> 08:18.100
+entonces aquí me dice,
+perfecto,
+
+08:18.100 --> 08:20.000
+el número con el cual vas a guardar es 7,
+
+08:20.000 --> 08:22.500
+y entonces adivinaste,
+felicidades.
+
+08:22.500 --> 08:25.900
+Vamos a poner aquí para ver cuál es el
+número secreto.
+
+08:25.900 --> 08:28.200
+El número secreto vemos que, en efecto, es 7,
+
+08:28.200 --> 08:30.800
+entonces está entrando esta primera
+validación.
+
+08:30.800 --> 08:33.000
+Si hubiera sido un número con el que yo
+juego
+
+08:33.000 --> 08:35.300
+que es más bajo que el número secreto,
+
+08:35.300 --> 08:38.200
+me saldría la validación de, oye, tu
+número es muy bajo,
+
+08:38.200 --> 08:41.100
+o si hubiera sido muy alto, entraría
+directamente en else.
+
+08:41.100 --> 08:44.300
+Solo para probar, vamos a intentarlo de nuevo.
+
+08:44.300 --> 08:47.100
+Vamos a ponerle un 3, y
+perfecto.
+
+08:47.100 --> 08:48.600
+Entonces, el número es demasiado bajo,
+
+08:48.600 --> 08:50.500
+intentalo de nuevo, y una prueba
+más
+
+08:50.500 --> 08:54.600
+para ver si tenemos suerte en que salga
+una versión distinta.
+
+08:54.600 --> 08:58.200
+Vamos a ponerle un 8, y el número es
+demasiado bajo.
+
+08:58.200 --> 09:04.000
+Vamos a ver aquí, número secreto es 10.
+
+09:04.000 --> 09:07.200
+Entonces, sigue siendo menor, por eso está
+entrando este if,
+
+09:07.200 --> 09:08.600
+pero si hubiera sido
+mayor,
+
+09:08.600 --> 09:10.500
+me saldría entonces la otra validación.
+
+09:10.500 --> 09:13.500
+Este es, por ejemplo, un pequeño
+juego
+
+09:13.500 --> 09:16.600
+que nos ayuda a implementar una ejecución
+condicional
+
+09:16.600 --> 09:19.300
+en el cual dependiendo dos
+valores,
+
+09:19.300 --> 09:22.600
+la condición de dos valores, es el código
+que se va a ejecutar.
+
+09:22.600 --> 09:25.400
+En este caso, mis ejemplos son simplemente
+console.log,
+
+09:25.400 --> 09:27.000
+pero en tu caso, en algún
+futuro,
+
+09:27.000 --> 09:28.600
+pueden ser cosas mucho más
+complejas
+
+09:28.600 --> 09:31.100
+que dependiendo la validación de dos valores,
+
+09:31.100 --> 09:32.600
+tú ya puedes empezar a hacer
+código
+
+09:32.600 --> 09:33.900
+o funciones mucho más
+complejas
+
+09:33.900 --> 09:47.900
+que te van a ayudar a generar otro tipo de
+valor.
+

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/04-Lecturas recomendadas.txt

@@ -0,0 +1,3 @@
+https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Math/floor
+https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Math/random
+https://github.com/platzi/basico-js

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/04-juego_650efe0f-44b0-4f37-a8e6-b3215adc7ee0.js

@@ -0,0 +1,15 @@
+const numeroSecreto = Math.floor(Math.random() * 10 + 1);
+
+const numeroJugador = parseInt(
+  prompt("Adivina el número secreto entre el 1 al 10")
+);
+
+console.log(`Este es el número con el que juegas ${numeroJugador}`);
+
+if (numeroJugador === numeroSecreto) {
+  console.log("¡Felicidades, adivinaste el número secreto!");
+} else if (numeroJugador < numeroSecreto) {
+  console.log("El número es demasiado bajo, intenta de nuevo");
+} else {
+  console.log("El número es muy alto, intenta de nuevo");
+}

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/05-Estructura y uso del condicional Switch en programación.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:345b773867ccc79d9032f155949cd472afe7a1535fa43b14eac289251c791c1f
+size 90748094

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/05-Estructura y uso del condicional Switch en programación.vtt

@@ -0,0 +1,956 @@
+WEBVTT
+
+00:00.000 --> 00:03.000
+Vamos a comenzar a hablar de una nueva
+estructura de control
+
+00:03.000 --> 00:04.400
+que se llama
+Switch.
+
+00:04.400 --> 00:07.920
+Esta va a ser similar en la lógica de lo
+que es el if,
+
+00:07.920 --> 00:12.080
+else if e else, ya que de igual forma
+vamos a generar
+
+00:12.080 --> 00:15.280
+diferentes escenarios para poder generar
+una validación.
+
+00:15.280 --> 00:16.760
+Si la variación se va
+cumpliendo,
+
+00:16.760 --> 00:18.800
+va a entrar un código
+específico.
+
+00:18.800 --> 00:21.360
+Pero aquí va a haber una validación distinta.
+
+00:21.360 --> 00:25.960
+A diferencia de if o else if, nosotros
+validamos diferentes
+
+00:25.960 --> 00:26.440
+cosas.
+
+00:26.440 --> 00:30.520
+Podemos validar si dos variables son iguales,
+si dos variables
+
+00:30.520 --> 00:34.520
+son distintas, si dos variables son mayor,
+menor, igual a.
+
+00:34.520 --> 00:37.360
+A diferencia de todo esto, en Switch
+únicamente vamos
+
+00:37.360 --> 00:39.880
+a validar si se cumple, si es
+true.
+
+00:39.880 --> 00:42.720
+Si lo que está dentro de lo que queremos
+validar en Switch es
+
+00:42.720 --> 00:45.120
+verdad, entonces va a entrar un escenario.
+
+00:45.120 --> 00:49.160
+No vamos a tener un else if o un else per se.
+
+00:49.160 --> 00:51.480
+Simplemente vamos a tener diferentes
+escenarios.
+
+00:51.480 --> 00:54.680
+Y si una expresión, que es como se llama
+lo que vamos a validar,
+
+00:54.680 --> 00:56.760
+se cumple en cualquiera de los escenarios,
+
+00:56.760 --> 00:58.640
+va a entrar ese fragmento de código.
+
+00:58.640 --> 01:01.920
+Y si no, al final, va a existir un default
+que va a ser el
+
+01:01.920 --> 01:04.200
+código que se va a ejecutar en caso de que
+ninguno de los
+
+01:04.200 --> 01:06.560
+escenarios previos sea
+correcto.
+
+01:06.560 --> 01:08.800
+Así que vamos a entender cuál es esta
+estructura.
+
+01:08.800 --> 01:11.880
+Pasamos al
+código.
+
+01:11.880 --> 01:13.800
+Ya que estamos aquí con nuestro código,
+
+01:13.800 --> 01:17.320
+lo que vamos a hacer es la estructura base
+de Switch es
+
+01:17.320 --> 01:18.760
+así.
+
+01:18.760 --> 01:22.320
+Iniciamos con Switch, generamos el paréntesis.
+
+01:22.320 --> 01:27.080
+Adentro del paréntesis, existe lo que se
+le llama expresión.
+
+01:27.080 --> 01:31.200
+Que esto es prácticamente lo que vamos a
+validar.
+
+01:31.200 --> 01:33.440
+Esta es la condición que se va a evaluar.
+
+01:33.440 --> 01:36.720
+Si esto existe, entonces tenemos nuestros
+brackets,
+
+01:36.720 --> 01:39.960
+abrimos y comenzamos con algo que se llama
+case,
+
+01:39.960 --> 01:42.040
+que son como los casos a
+evaluar.
+
+01:42.040 --> 01:45.160
+En donde, en case, cada case va a tener un
+valor,
+
+01:45.160 --> 01:48.840
+por ejemplo, valor 1, que es el valor a
+evaluar.
+
+01:48.840 --> 01:51.280
+Si esta expresión es igual a este valor,
+
+01:51.280 --> 01:55.440
+entonces ponemos los dos puntos y en la
+parte de abajo ponemos
+
+01:55.440 --> 01:57.720
+el código a
+ejecutar.
+
+02:02.240 --> 02:05.160
+Pero como te comenté, hay diferentes casos.
+
+02:05.160 --> 02:07.520
+Si este código se ejecuta, se ejecuta bien,
+
+02:07.520 --> 02:10.440
+entonces nos interesa que suceda un break.
+
+02:10.440 --> 02:13.120
+Quiere decir que le vamos a decir a Switch,
+oye,
+
+02:13.120 --> 02:16.880
+ya no ejecutes nada o ya no metas a
+condición nada.
+
+02:16.880 --> 02:20.640
+Simplemente aquí rompe este ciclo y
+entonces ya ejecuta
+
+02:20.640 --> 02:22.840
+este código como el código
+final.
+
+02:22.840 --> 02:26.520
+En caso de que este caso que hayamos
+nosotros evaluado no
+
+02:26.520 --> 02:31.200
+sea, vamos a pasar a el caso
+2.
+
+02:31.200 --> 02:34.080
+Y aquí prácticamente la expresión se va a
+repetir.
+
+02:34.080 --> 02:37.200
+Nosotros vamos a estar haciendo una
+evaluación.
+
+02:37.200 --> 02:42.520
+Si la expresión aquí es true, ponemos el
+código que se va
+
+02:42.520 --> 02:43.440
+a
+ejecutar.
+
+02:43.440 --> 02:45.440
+Y en caso de que ese código sea real,
+
+02:45.440 --> 02:47.440
+entonces aquí generamos un
+break.
+
+02:47.440 --> 02:50.080
+Esto se puede repetir cuantas veces quieras,
+
+02:50.080 --> 02:52.960
+cuantos casos tú tengas que evaluar
+prácticamente.
+
+02:52.960 --> 02:57.440
+Se puede ir a 10, se puede ir a 8, se
+puede ir a 9,
+
+02:57.440 --> 03:01.120
+depende mucho, pero cada uno de los casos
+lo que va a ser la
+
+03:01.120 --> 03:02.880
+expresión, ¿es
+verdad?
+
+03:02.880 --> 03:03.400
+No.
+
+03:03.400 --> 03:04.080
+¿Perfecto?
+
+03:04.080 --> 03:04.680
+¿Es
+verdad?
+
+03:04.680 --> 03:05.200
+No.
+
+03:05.200 --> 03:05.760
+¿Perfecto?
+
+03:05.760 --> 03:06.320
+¿Es
+verdad?
+
+03:06.320 --> 03:06.840
+Sí.
+
+03:06.840 --> 03:07.440
+¿Es
+verdad?
+
+03:07.440 --> 03:07.960
+No.
+
+03:07.960 --> 03:08.480
+¿Es
+verdad?
+
+03:08.480 --> 03:08.960
+Sí.
+
+03:08.960 --> 03:09.480
+¿Es
+verdad?
+
+03:09.480 --> 03:09.960
+No.
+
+03:09.960 --> 03:10.480
+¿Es
+verdad?
+
+03:10.480 --> 03:10.960
+No.
+
+03:10.960 --> 03:11.480
+¿Es
+verdad?
+
+03:11.480 --> 03:11.960
+No.
+
+03:11.960 --> 03:12.480
+¿Es
+verdad?
+
+03:12.480 --> 03:12.960
+No.
+
+03:12.960 --> 03:13.460
+¿Es
+verdad?
+
+03:13.460 --> 03:14.280
+Sí.
+
+03:14.280 --> 03:17.760
+Ejecuta este código y se genera un break
+para que ya no entre
+
+03:17.760 --> 03:19.440
+a evaluar el siguiente
+caso.
+
+03:19.440 --> 03:22.720
+En caso de que ninguna de nuestros casos
+de arriba,
+
+03:22.720 --> 03:25.200
+ninguno de estos casos, sea
+verdad,
+
+03:25.200 --> 03:30.040
+entonces aquí tenemos un
+default,
+
+03:30.040 --> 03:37.480
+en el cual se convertiría como nuestro
+else en el if,
+
+03:37.480 --> 03:40.680
+en el cual el default es un oye, ninguno
+de estos casos fue
+
+03:40.680 --> 03:41.520
+verdad.
+
+03:41.520 --> 03:50.280
+Entonces aquí podemos ejecutar otro código
+que tengamos para
+
+03:50.280 --> 03:51.120
+un caso de
+default.
+
+03:51.120 --> 03:54.180
+Por ejemplo, si estamos evaluando si
+existen productos
+
+03:54.180 --> 03:58.320
+en la tienda para poder regresar a lo
+mejor el costo del producto
+
+03:58.320 --> 04:01.360
+o la descripción del producto, pero de
+repente ese producto no
+
+04:01.360 --> 04:04.360
+existe, va a entrar un default que es un
+lo siento,
+
+04:04.360 --> 04:07.520
+en este momento no tenemos ese producto
+que estás buscando o
+
+04:07.520 --> 04:10.160
+prácticamente no contamos con ese producto.
+
+04:10.160 --> 04:12.360
+Ese sería una respuesta default, pero
+tiene que generar
+
+04:12.360 --> 04:15.320
+prácticamente la validación de cada uno de
+los casos.
+
+04:15.320 --> 04:18.320
+Si el producto lo encuentra, entra a ese
+caso específico y
+
+04:18.320 --> 04:21.520
+ya genera un break para que no pase a las
+siguientes
+
+04:21.520 --> 04:22.320
+validaciones.
+
+04:22.320 --> 04:24.600
+Y entonces en ese momento, este código es
+el que se va a
+
+04:24.600 --> 04:27.400
+ejecutar para poder regresar
+algo.
+
+04:27.400 --> 04:29.480
+Vamos a pasar ahorita a un
+ejemplo,
+
+04:29.480 --> 04:31.640
+a un ejemplo de cómo utilizaríamos eso en
+la vida
+
+04:31.640 --> 04:32.400
+real.
+
+04:32.400 --> 04:36.880
+Así que voy a comentar todo esto para que
+no genere un conflicto
+
+04:36.880 --> 04:38.520
+con el código que vamos a
+hacer.
+
+04:38.520 --> 04:40.520
+Y ahorita te acabo de dar un ejemplo de,
+por ejemplo,
+
+04:40.520 --> 04:44.440
+vamos a buscar frutas o ciertos productos
+en una tienda en caso
+
+04:44.440 --> 04:47.960
+de que sea eso lo que estamos trabajando
+nosotros.
+
+04:47.960 --> 04:50.040
+Entonces vamos a generar una variable que
+se va a llamar
+
+04:50.040 --> 04:52.920
+let y se va a llamar, por ejemplo, la
+expresión.
+
+04:52.920 --> 04:53.420
+¿Por
+qué?
+
+04:53.420 --> 04:55.560
+Porque es lo que vamos a utilizar para
+validar.
+
+04:55.560 --> 04:58.480
+Esto puede ser cualquier nombre, puede ser
+el producto,
+
+04:58.480 --> 05:01.080
+simplemente para ser explícito en cómo
+funciona Switch,
+
+05:01.080 --> 05:02.760
+le voy a poner yo
+expresión.
+
+05:02.760 --> 05:06.840
+Y aquí vamos a regresar un string con,
+por ejemplo,
+
+05:06.840 --> 05:10.120
+papayas, porque estamos en un mercado y me
+interesa comprar
+
+05:10.120 --> 05:14.840
+frutas y ahorita estoy yo buscando si
+venden o no papayas.
+
+05:14.840 --> 05:19.480
+Entonces regreso en Switch, generamos
+nuestra estructura.
+
+05:19.480 --> 05:23.520
+Aquí ponemos que la expresión, esta es la
+expresión que va a
+
+05:23.520 --> 05:24.680
+entrar a
+validación.
+
+05:24.680 --> 05:27.420
+Entonces si esta expresión existe en
+cualquiera de los
+
+05:27.420 --> 05:30.080
+casos, que me regrese una información.
+
+05:30.080 --> 05:35.120
+Ya que tengo eso, abrimos aquí
+prácticamente nuestras llaves y
+
+05:35.120 --> 05:37.000
+empezamos con los
+casos.
+
+05:37.000 --> 05:41.240
+El caso 1 es
+naranjas.
+
+05:41.240 --> 05:42.680
+Están buscando
+naranjas.
+
+05:42.680 --> 05:48.380
+Si existen naranjas, entonces lo que
+quiero con sol.log es que
+
+05:48.380 --> 05:52.640
+me regrese, por ejemplo, el costo de las
+naranjas.
+
+05:52.640 --> 06:02.880
+Las naranjas cuestan, vamos a ponerle,
+
+06:02.880 --> 06:06.680
+20 pesos el
+kilo.
+
+06:06.680 --> 06:07.760
+Súper.
+
+06:07.760 --> 06:11.120
+Entonces si regresa eso, aquí generamos un
+break para que ya
+
+06:11.120 --> 06:13.320
+no entre las siguientes validaciones.
+
+06:13.320 --> 06:16.520
+Si no encuentra naranja, le vamos a pedir
+que entre a un
+
+06:16.520 --> 06:17.560
+siguiente
+caso.
+
+06:17.560 --> 06:19.320
+A hablar de un siguiente
+caso.
+
+06:19.320 --> 06:23.280
+En este caso va a ser
+manzanas.
+
+06:23.280 --> 06:24.200
+Manzanas.
+
+06:24.200 --> 06:25.560
+Perfecto.
+
+06:25.560 --> 06:26.880
+Entonces tenemos aquí
+manzanas.
+
+06:26.880 --> 06:31.040
+En caso de que encuentre las manzanas,
+
+06:31.040 --> 06:32.960
+quiero que me regrese lo
+mismo.
+
+06:32.960 --> 06:37.880
+Las manzanas cuestan, vamos a ponerle,
+
+06:37.880 --> 06:41.160
+43 pesos el
+kilo.
+
+06:41.160 --> 06:44.760
+43 pesos el
+kilo.
+
+06:44.760 --> 06:47.160
+Súper
+bien.
+
+06:47.160 --> 06:49.760
+Aquí es importante, por ejemplo, me está
+marcando aquí un error
+
+06:49.760 --> 06:50.560
+en
+console.
+
+06:50.560 --> 06:53.120
+Es porque hay que cerrar con los dos puntos.
+
+06:53.120 --> 06:53.960
+¿Para
+qué?
+
+06:53.960 --> 06:55.760
+Esta es la forma, esta es la
+cifra.
+
+06:55.760 --> 06:58.520
+Esta es la forma, esta es la sintaxis real
+de poder generar
+
+06:58.520 --> 06:59.200
+esta
+evaluación.
+
+06:59.200 --> 07:01.320
+Si manzanas existe, va a pasar a console.log.
+
+07:01.320 --> 07:05.320
+Si no le pongo los dos puntos, no estoy
+terminando la sintaxis
+
+07:05.320 --> 07:08.920
+correcta, que simplemente va a generar un
+error.
+
+07:08.920 --> 07:11.640
+Entonces ya aquí podemos poner el break.
+
+07:11.640 --> 07:13.800
+Y con el break pasamos a un siguiente caso.
+
+07:13.800 --> 07:16.680
+Vamos a poner, en nuestro caso 3, va a ser,
+
+07:16.680 --> 07:21.400
+quiero buscar o poner
+plátanos.
+
+07:21.400 --> 07:26.400
+Plátanos, dos puntos, y vamos a un console.
+log para que nos
+
+07:26.400 --> 07:29.000
+regrese los costos de los plátanos en caso
+de que los
+
+07:29.000 --> 07:30.280
+haya
+encontrado.
+
+07:30.280 --> 07:33.880
+Puse punto y coma, que está mal, es dos
+puntos.
+
+07:33.880 --> 07:45.160
+Entonces aquí el plátano está en 30 pesos
+el kilo.
+
+07:45.160 --> 07:46.040
+Súper.
+
+07:46.040 --> 07:49.800
+Ahora, lo que voy a hacer yo es voy a
+hacer un caso compartido.
+
+07:49.800 --> 07:53.560
+Voy a poner, por ejemplo, aquí faltó el break.
+
+07:53.560 --> 07:57.600
+Entonces vamos a poner aquí el break y
+pasamos a este caso
+
+07:57.600 --> 07:58.600
+compartido.
+
+07:58.600 --> 08:01.480
+¿Qué pasa si, por ejemplo, tengo dos
+productos que tengan el
+
+08:01.480 --> 08:02.200
+mismo
+costo?
+
+08:02.200 --> 08:05.120
+Pues no tendría que ponerlos en líneas
+separadas.
+
+08:05.120 --> 08:07.040
+Puedo generar
+esto.
+
+08:07.040 --> 08:09.800
+Mangos, lo dejo ahí, dos
+puntos.
+
+08:09.800 --> 08:15.040
+Y el siguiente caso, que sería papayas,
+
+08:15.040 --> 08:16.800
+que es justamente lo que yo estoy buscando.
+
+08:16.800 --> 08:17.600
+Dos
+puntos.
+
+08:17.600 --> 08:24.440
+Y ya aquí entonces le digo que me regrese
+el console.log con
+
+08:24.440 --> 08:34.040
+este caso, que sería los mangos y las
+papayas cuestan,
+
+08:34.040 --> 08:38.760
+vamos a ponerle, 25 pesos el
+kilo.
+
+08:38.760 --> 08:39.600
+Súper
+bien.
+
+08:39.600 --> 08:43.440
+Si eso ya nos da, entonces aquí me genera
+un break y ya con
+
+08:43.440 --> 08:44.800
+eso puedo
+avanzar.
+
+08:44.800 --> 08:46.520
+Creo que ya tengo suficientes productos.
+
+08:46.520 --> 08:50.000
+Entonces, en default lo que voy a hacer es
+un console.log para
+
+08:50.000 --> 08:52.240
+decir que no contamos con ese producto.
+
+08:52.240 --> 08:55.360
+Pero como yo no sé cuál es el producto que
+a lo mejor él o
+
+08:55.360 --> 08:57.920
+el usuario me están dando, lo que vamos a
+hacer es,
+
+08:57.920 --> 09:03.080
+vamos a hacerlo dinámico y vamos a decir
+como lo siento,
+
+09:03.080 --> 09:15.080
+no contamos con, aquí ponemos expresión.
+
+09:15.080 --> 09:18.000
+Y ya con eso, ya no tengo que poner un break,
+
+09:18.000 --> 09:20.840
+porque automáticamente default es como
+esta es la respuesta por
+
+09:20.840 --> 09:23.600
+default que va a haber cuando no
+encuentres un producto.
+
+09:23.600 --> 09:26.720
+Ya que estamos acá, ya que tenemos
+prácticamente todos
+
+09:26.720 --> 09:30.320
+nuestros casos listos, lo único que
+tenemos que hacer ahora es,
+
+09:30.320 --> 09:35.400
+a lo mejor podemos poner un console.
+log en el cual le
+
+09:35.400 --> 09:38.880
+pidamos que si encontró o no el producto,
+
+09:38.880 --> 09:45.040
+simplemente evaluar si hay algo más que
+desees.
+
+09:47.680 --> 09:49.800
+Y es
+pregunta.
+
+09:49.800 --> 09:51.280
+Y terminamos con punto y
+coma.
+
+09:51.280 --> 09:57.040
+Y aquí, como estamos en español, puedo
+ponerle, perfecto.
+
+09:57.040 --> 10:01.840
+Ya con eso, si pongo guardar,
+automáticamente aquí me tiene
+
+10:01.840 --> 10:03.840
+que regresar el console.log del caso,
+
+10:03.840 --> 10:05.960
+en caso de que se haya
+encontrado,
+
+10:05.960 --> 10:07.640
+que la avaliación fuera
+verdad.
+
+10:07.640 --> 10:09.320
+Y es el caso que nos tiene que regresar.
+
+10:09.320 --> 10:11.520
+Estamos poniendo que la expresión es igual
+a papaya.
+
+10:11.520 --> 10:13.800
+Entonces, me regresa, los mangos y las
+papayas cuestan
+
+10:13.800 --> 10:15.200
+$25 el
+kilo.
+
+10:15.200 --> 10:16.760
+Ese caso sí
+existe.
+
+10:16.760 --> 10:18.680
+Aquí estamos haciendo una validación doble.
+
+10:18.680 --> 10:21.680
+Si yo pongo aquí mangos, que de hecho no
+se escribió bien,
+
+10:21.680 --> 10:26.360
+pero si yo pongo aquí mangos, ahora en
+caso de que,
+
+10:26.360 --> 10:30.520
+por ejemplo, ya no esté buscando papayas,
+esté buscando uvas,
+
+10:30.520 --> 10:34.520
+que uvas no están en mis casos, si lo doy
+a guardar,
+
+10:34.520 --> 10:37.560
+me regresa, lo siento, no contamos con uvas.
+
+10:37.560 --> 10:39.040
+Hay algo más que
+desees.
+
+10:39.040 --> 10:40.960
+Entonces, esto es una
+computación,
+
+10:40.960 --> 10:42.640
+me obliga a buscar otra
+cosa.
+
+10:42.640 --> 10:45.440
+Y si lo que estoy buscando existe en los
+casos,
+
+10:45.440 --> 10:50.040
+entonces me va a regresar el texto o el
+código que ya entra
+
+10:50.040 --> 10:52.560
+directamente en ese caso para ejecutarse.
+
+10:52.560 --> 10:56.000
+Y es la forma como podemos evaluar de
+forma distinta
+
+10:56.000 --> 10:57.080
+ciertas
+opciones.
+
+10:57.080 --> 11:00.920
+Aquí es importante comentar, y esto te lo
+decía en un inicio,
+
+11:00.920 --> 11:05.240
+switch es diferente a if, porque nosotros,
+si te das cuenta,
+
+11:05.240 --> 11:09.160
+aquí no estamos utilizando ciertas
+expresiones de
+
+11:09.160 --> 11:15.400
+comparación para poder ver si lo que
+queremos evaluar existe.
+
+11:15.400 --> 11:19.480
+Aquí automáticamente switch lo que hace
+aquí es un,
+
+11:19.480 --> 11:23.360
+hace una, como un operador de comparación
+estricto,
+
+11:23.360 --> 11:28.360
+que es como si utilizáramos nosotros,
+el triple igual.
+
+11:28.360 --> 11:31.640
+En donde va a evaluar si el valor y el
+tipo de valor es
+
+11:31.640 --> 11:34.920
+igual a lo que nosotros tenemos aquí.
+
+11:34.920 --> 11:38.440
+Si el valor es igual, estrictamente igual
+en el tipo de
+
+11:38.440 --> 11:40.960
+valor y el valor, entonces se va a
+ejecutar eso.
+
+11:40.960 --> 11:43.640
+Ellos por debajo están utilizando este
+tipo de
+
+11:43.640 --> 11:44.720
+comparación.
+
+11:44.720 --> 11:48.160
+Aquí no podemos poner si esta expresión es
+igual o menor a,
+
+11:48.160 --> 11:48.720
+o bla, bla,
+bla.
+
+11:48.720 --> 11:51.240
+No podemos hacer ningún otro tipo de
+operador de
+
+11:51.240 --> 11:52.080
+comparación.
+
+11:52.080 --> 11:56.600
+Switch solo funciona con un comparador
+estricto,
+
+11:56.600 --> 11:59.240
+que sería si utilizáramos el triple igual.
+
+11:59.240 --> 12:01.760
+Y esto automáticamente lo hace switch aquí,
+
+12:01.760 --> 12:03.920
+para poder buscar los
+casos.
+
+12:03.920 --> 12:05.760
+Si el caso existe, nos regresa algo.
+
+12:05.760 --> 12:08.000
+En caso de que no, simplemente nos manda
+por default y ya
+
+12:08.000 --> 12:34.640
+podemos
+continuar.
+

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/05-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/basico-js

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/05-index_de4c8b16-5dec-44cd-9c4f-a920b62de0bf.js

@@ -0,0 +1,40 @@
+// switch(expresion) {
+//   case valor1:
+//     // código a ejecutar
+//     break;
+//   case valor2:
+//     // código a ejecutar
+//     break;
+//   case valor1:
+//     // código a ejecutar
+//     break;
+//   case valor2:
+//     // código a ejecutar
+//     break;
+//   default:
+//     // código
+// }
+
+let expr = "Uvas";
+
+switch (
+  expr // ===
+) {
+  case "Naranjas":
+    console.log("Las naranjas cuestan $20 el kilo");
+    break;
+  case "Manzanas":
+    console.log("Las manzanas cuestan $43 el kilo");
+    break;
+  case "Plátanos":
+    console.log("El plátano esta en $30 el kilo");
+    break;
+  case "Mangos":
+  case "Papayas":
+    console.log("Los mangos y las papayas cuestan $ 25 pesos el kilo");
+    break;
+  default:
+    console.log(`Lo siento, no contamos con ${expr}`);
+}
+
+console.log("¿Hay algo más que desees?");

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/06-Ciclo For Iteración de Listas y Uso de Consolelog en JavaScript.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:023add2d366e4d4bad0acc2332accfd47447ec8f220244e2974f3bb5c034a4f2
+size 46373774

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/06-Ciclo For Iteración de Listas y Uso de Consolelog en JavaScript.vtt

@@ -0,0 +1,688 @@
+WEBVTT
+
+00:00.000 --> 00:01.440
+Y para comenzar con
+loops,
+
+00:01.440 --> 00:03.800
+vamos a ver un método que se llama form,
+
+00:03.800 --> 00:05.280
+que nos va a ayudar a
+iterar.
+
+00:05.280 --> 00:08.120
+Cuando tenemos algún
+objeto
+
+00:08.120 --> 00:10.760
+que tenga ciertos elementos iterables,
+
+00:10.760 --> 00:13.160
+quiere decir que tenga ciertos
+objetos
+
+00:13.160 --> 00:15.320
+que nosotros podamos pasar uno por uno,
+
+00:15.320 --> 00:17.160
+a eso es lo que vamos a estar utilizando
+métodos
+
+00:17.160 --> 00:19.240
+que nos ayuden a hacer
+loops.
+
+00:19.240 --> 00:20.520
+El primero se llama
+form.
+
+00:20.520 --> 00:21.520
+Vamos a ver qué
+es.
+
+00:22.360 --> 00:24.800
+Cuando empezamos con método
+form,
+
+00:24.800 --> 00:27.040
+el método form lo que nos va a ayudar es a
+iterar
+
+00:27.040 --> 00:29.800
+por cada elemento que venga en una
+lista
+
+00:29.800 --> 00:30.960
+en nuestra
+consola.
+
+00:30.960 --> 00:31.800
+Es lo que vamos a hacer
+ahorita.
+
+00:31.800 --> 00:34.040
+Vamos a generar algo y vamos a iterar en
+cada elemento
+
+00:34.040 --> 00:36.520
+y vamos a ver la respuesta en la consola.
+
+00:36.520 --> 00:39.240
+La estructura del form es una estructura
+particular
+
+00:39.240 --> 00:41.160
+porque es muy similar a lo que teníamos con,
+
+00:41.160 --> 00:43.360
+por ejemplo, estamos hablando de if.
+
+00:43.360 --> 00:46.000
+Utilizamos la palabra reservada que es form,
+
+00:46.000 --> 00:47.480
+venimos con
+paréntesis,
+
+00:47.480 --> 00:51.880
+aquí adentro del paréntesis va a venir una
+variable,
+
+00:51.880 --> 00:53.640
+que es la variable que vamos a
+utilizar
+
+00:53.640 --> 00:55.240
+para hacer la
+iteración.
+
+00:55.240 --> 00:57.040
+Esta variable se va a estar jugando,
+
+00:57.040 --> 00:59.800
+entonces después viene como la
+condición
+
+01:00.920 --> 01:02.760
+que se tiene que
+ejecutar.
+
+01:02.760 --> 01:04.840
+Y después de la condición viene lo que se
+llama
+
+01:04.840 --> 01:05.760
+el
+incremento.
+
+01:06.800 --> 01:09.680
+Esta variable es la que va a estar
+incrementando
+
+01:09.680 --> 01:11.840
+cuando vayamos a la
+condición.
+
+01:11.840 --> 01:13.880
+Ahorita vamos a explicar un poco más a
+detalle.
+
+01:13.880 --> 01:14.960
+Ya que tenemos
+esto,
+
+01:14.960 --> 01:18.240
+que son tres pasos que vienen adentro de
+un form,
+
+01:18.240 --> 01:21.480
+abrimos nuestros
+corchetes.
+
+01:21.480 --> 01:27.480
+Adentro de los corchetes entonces va a
+venir el código
+
+01:27.480 --> 01:28.480
+que se va a
+ejecutar.
+
+01:30.760 --> 01:32.440
+Entonces veamos qué pasa
+aquí.
+
+01:32.440 --> 01:34.360
+Tenemos la palabra reservada
+for.
+
+01:34.360 --> 01:36.840
+Adentro de for vamos a iniciar una variable.
+
+01:36.840 --> 01:38.760
+Esta variable va a entrar
+a,
+
+01:38.760 --> 01:40.600
+aquí vamos a empezar a una condición.
+
+01:40.600 --> 01:43.800
+Esta condición tiene que venir de alguna
+otra
+
+01:43.800 --> 01:46.120
+variable externa que tengamos que
+iterar
+
+01:46.120 --> 01:48.080
+porque tiene ciertos elementos como un
+array
+
+01:48.080 --> 01:49.320
+o algo
+similar.
+
+01:49.320 --> 01:52.280
+Si esto, una vez que esta condición suceda,
+
+01:52.280 --> 01:54.200
+esta variable va a
+incrementar
+
+01:54.200 --> 01:55.880
+para que nosotros podamos
+iterar.
+
+01:55.880 --> 01:57.280
+Tiene que ejecutarse ese
+código
+
+01:57.280 --> 01:59.880
+y cuando regresemos a la segunda vuelta,
+
+01:59.880 --> 02:02.080
+esta variable ya no va a valer lo que
+valía antes,
+
+02:02.080 --> 02:03.960
+ahora va a valer
+más.
+
+02:03.960 --> 02:04.880
+Entra la
+condición,
+
+02:04.880 --> 02:07.520
+quiere decir que tiene que suceder
+algo
+
+02:07.520 --> 02:10.120
+y ahora esta variable vuelve a incrementar,
+
+02:10.120 --> 02:11.160
+se ejecuta el
+código
+
+02:11.160 --> 02:12.800
+y cuando regresemos a una tercera vuelta,
+
+02:12.800 --> 02:14.240
+esta variable ha
+incrementado,
+
+02:14.240 --> 02:16.080
+así que su valor ahora es
+distinto
+
+02:16.080 --> 02:18.600
+y seguimos esta iteración
+prácticamente
+
+02:18.600 --> 02:20.840
+hasta que esta condición se
+rompa.
+
+02:20.840 --> 02:21.680
+Quiere
+decir,
+
+02:21.680 --> 02:23.840
+y ahorita lo vamos a ver en un ejemplo
+mucho más práctico,
+
+02:23.840 --> 02:26.200
+pero que esta condición ya no sea verdad,
+
+02:26.200 --> 02:29.880
+ahí se rompe este ciclo, prácticamente
+este loop
+
+02:29.880 --> 02:32.400
+y ya el código se deja de
+ejecutar.
+
+02:32.400 --> 02:35.080
+Ahora, si pasamos a un ejemplo
+práctico
+
+02:35.080 --> 02:37.120
+de cómo llevaríamos esto a la realidad,
+
+02:37.120 --> 02:38.440
+lo llevaríamos
+así.
+
+02:38.440 --> 02:40.400
+Voy a borrar esto para que no genere
+problema
+
+02:40.400 --> 02:41.640
+o más bien lo voy a
+comentar
+
+02:41.640 --> 02:45.160
+para que se quede aquí como un ejemplo
+visual
+
+02:45.160 --> 02:47.760
+y venimos aquí a abrir o comenzar con un
+let
+
+02:47.760 --> 02:50.240
+y este let va a ser un
+array,
+
+02:50.240 --> 02:51.760
+va a ser una
+lista.
+
+02:51.760 --> 02:54.480
+Entonces aquí ponemos nuestros corchetes
+cuadrados
+
+02:54.480 --> 02:56.920
+y comenzamos a agregar elementos a nuestra
+lista.
+
+02:58.000 --> 03:00.080
+Voy a comenzar con
+eat,
+
+03:01.720 --> 03:03.680
+sleep, es un mántar que me
+gusta,
+
+03:05.400 --> 03:07.400
+close, tiene que ser siempre en
+strings
+
+03:09.360 --> 03:10.800
+y aquí,
+repeats.
+
+03:13.640 --> 03:16.200
+Ya que tenemos nuestra lista,
+guardamos
+
+03:16.200 --> 03:17.560
+y ahora vamos a
+iterar.
+
+03:17.560 --> 03:21.440
+La intención es, vamos a generar un for
+loop
+
+03:21.440 --> 03:23.960
+para poder imprimir en nuestra
+consola
+
+03:23.960 --> 03:26.280
+cada uno de estos
+elementos.
+
+03:26.280 --> 03:28.480
+Entonces empezamos con la estructura de for,
+
+03:28.480 --> 03:31.680
+abrimos nuestros
+paréntesis
+
+03:31.680 --> 03:34.040
+y en ellos vamos a iniciar la
+variable
+
+03:34.040 --> 03:36.440
+que tenemos aquí, tenemos que inicializar
+una variable.
+
+03:36.440 --> 03:38.920
+Empezamos con lets, vamos a ponerla,
+
+03:38.920 --> 03:41.840
+casi siempre vas a ver que la variable que
+se inicia
+
+03:41.840 --> 03:43.000
+es la variable
+i.
+
+03:44.160 --> 03:47.040
+Esto es por sintaxis, pero puede ser
+cualquier variable,
+
+03:47.040 --> 03:48.720
+tú le puedes poner cualquier nombre,
+
+03:48.720 --> 03:50.600
+pero por sintaxis y por simplicidad,
+
+03:50.600 --> 03:53.520
+una variable i es la que va a estar iterando.
+
+03:53.520 --> 03:56.000
+i es igual a
+cero.
+
+03:56.000 --> 03:58.160
+Ahorita vas a entender un poquito por qué.
+
+03:58.160 --> 04:02.760
+Entonces ahora, mientras i sea menor a,
+
+04:03.600 --> 04:05.920
+aquí vamos a utilizar la
+longitud,
+
+04:05.920 --> 04:07.840
+la longitud de nuestra
+lista.
+
+04:07.840 --> 04:09.200
+Aquí podemos ver que tenemos una
+lista
+
+04:09.200 --> 04:11.160
+que tiene cuatro
+elementos.
+
+04:11.160 --> 04:14.640
+Entonces mientras i sea menor a la
+longitud
+
+04:14.640 --> 04:17.720
+de los elementos adentro de nuestra lista,
+
+04:17.720 --> 04:20.080
+entonces punto,
+lents,
+
+04:21.360 --> 04:25.080
+entonces i se tiene que incrementar.
+
+04:25.080 --> 04:26.000
+i más
+uno.
+
+04:27.080 --> 04:30.040
+Abrimos nuestros corchetes y ya
+aquí
+
+04:30.040 --> 04:32.840
+lo que queremos que se ejecute es el punto
+log
+
+04:32.840 --> 04:36.200
+y en el punto log queremos que se ejecute
+la lista,
+
+04:37.440 --> 04:39.800
+corchetes cuadrados, con
+i.
+
+04:40.720 --> 04:42.960
+Entonces vamos a repasar este código.
+
+04:42.960 --> 04:45.520
+Tenemos aquí nuestra lista que tiene
+cuatro elementos.
+
+04:45.520 --> 04:47.680
+Si hablamos de la longitud de nuestra lista,
+
+04:47.680 --> 04:51.040
+vamos a ver que es una longitud de cuatro
+elementos
+
+04:51.040 --> 04:55.160
+porque son el número de elementos que
+tiene esa lista.
+
+04:55.160 --> 04:56.520
+Iniciamos con el
+for.
+
+04:56.520 --> 04:58.280
+Aquí inicializamos una
+variable
+
+04:58.280 --> 05:01.080
+que esta variable en este momento es igual
+a cero.
+
+05:01.080 --> 05:03.560
+Entonces mientras cero sea
+menor
+
+05:03.560 --> 05:06.440
+que la longitud de cuatro de nuestra lista,
+
+05:06.440 --> 05:08.680
+incrementa por
+uno.
+
+05:08.680 --> 05:11.040
+Entonces quiere decir que mientras esta
+condición
+
+05:11.040 --> 05:13.160
+se cumpla en cada
+ciclo,
+
+05:13.160 --> 05:14.640
+la i se va a
+incrementar,
+
+05:14.640 --> 05:16.320
+la variable i se va a
+incrementar.
+
+05:16.320 --> 05:18.160
+Entonces vamos a
+repasar.
+
+05:18.160 --> 05:19.760
+i es igual a
+cero.
+
+05:19.760 --> 05:24.080
+Cero es menor a cuatro o la longitud de
+nuestra lista, sí.
+
+05:24.080 --> 05:27.000
+Entonces cero en este momento vale uno,
+
+05:27.000 --> 05:28.240
+se incrementa por
+uno.
+
+05:28.240 --> 05:31.280
+Y nosotros lo que vamos a hacer es en el
+console log,
+
+05:31.280 --> 05:33.280
+como tenemos nuestra
+lista,
+
+05:33.280 --> 05:37.160
+vamos a imprimir nuestro elemento
+cero
+
+05:37.160 --> 05:39.520
+de la posición de la lista que va a ser it.
+
+05:39.520 --> 05:41.280
+Pasamos al siguiente
+ciclo.
+
+05:41.280 --> 05:44.160
+Ahora i ya no vale cero, i vale uno.
+
+05:44.160 --> 05:46.680
+Entonces uno es menor que cuatro, sí.
+
+05:46.680 --> 05:48.560
+Entonces uno
+incrementa,
+
+05:48.560 --> 05:50.560
+o más bien uno incrementa a
+dos
+
+05:50.560 --> 05:52.360
+porque tiene que incrementar por uno.
+
+05:52.360 --> 05:54.120
+Entonces aquí lo que va a hacer el console
+log,
+
+05:54.120 --> 05:58.720
+en lista vamos a imprimir la posición uno
+en nuestra lista
+
+05:58.720 --> 06:00.240
+que es
+sleep.
+
+06:00.240 --> 06:04.960
+Y vamos al siguiente ciclo y ahora let i
+ya no vale uno,
+
+06:04.960 --> 06:07.640
+ahora vale dos y así
+sucesivamente
+
+06:07.640 --> 06:10.600
+hasta que lleguemos al punto en el que i
+ya no sea menor
+
+06:10.600 --> 06:12.120
+que la longitud de nuestra
+lista
+
+06:12.120 --> 06:15.360
+y ahí se rompe este ciclo y ya no imprime
+nada.
+
+06:15.360 --> 06:17.120
+Si yo en este momento le doy
+enter,
+
+06:19.680 --> 06:20.520
+vamos a
+guardar.
+
+06:22.120 --> 06:24.920
+Sale it, sleep, done and
+repeat.
+
+06:24.920 --> 06:28.480
+Porque si llegamos aquí y ponemos por
+ejemplo list,
+
+06:28.480 --> 06:31.000
+entonces sale que list son cuatro
+elementos
+
+06:31.000 --> 06:33.240
+que es it, sleep, go, done,
+repeat.
+
+06:33.240 --> 06:36.760
+Y si ponemos por ejemplo list.length,
+que es longitud,
+
+06:36.760 --> 06:38.600
+nos sale que la longitud son cuatro.
+
+06:38.600 --> 06:41.320
+Entonces mientras i, esta
+variable,
+
+06:41.320 --> 06:43.880
+va pasando por el loop, cada uno de los
+ciclos
+
+06:43.880 --> 06:47.080
+va incrementando de cero a uno, de uno a dos,
+
+06:47.080 --> 06:49.480
+de dos a tres, de tres a
+cuatro,
+
+06:49.480 --> 06:53.120
+y entonces ahí como cuatro ya no es menor
+a cuatro,
+
+06:53.120 --> 06:55.240
+simplemente ya no genera ningún código,
+
+06:55.240 --> 06:58.600
+se rompe el ciclo porque ya no tenemos un
+quinto elemento,
+
+06:58.600 --> 07:02.160
+que sería un cuarto si empezamos de cero, uno,
+dos, tres.
+
+07:02.160 --> 07:04.240
+Ya no tenemos un cuarto elemento, se rompe
+el ciclo
+
+07:04.240 --> 07:08.000
+si nosotros imprimimos cada uno de los
+elementos de la lista.
+
+07:08.000 --> 07:10.120
+Esta es la forma en la cual nosotros
+iteramos
+
+07:10.120 --> 07:13.240
+elementos que existen en una lista con un for.
+
+07:13.240 --> 07:14.600
+For nos ayuda a generar
+eso,
+
+07:14.600 --> 07:17.520
+una interacción por cada uno de los elementos.
+
+07:17.520 --> 07:20.480
+Aquí estamos utilizando un console.log
+como muy básico,
+
+07:20.480 --> 07:23.200
+pero nosotros podemos utilizar
+esto
+
+07:23.200 --> 07:27.000
+para poder desempeñar algún código un poco
+más complejo
+
+07:27.000 --> 07:29.480
+en el cual vayamos a utilizar este
+valor
+
+07:29.480 --> 07:34.480
+para algo en
+específico.
+

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/06-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/basico-js

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/06-index_b6ce4075-8bc9-491e-8bb3-0971a24ddf2d.js

@@ -0,0 +1,9 @@
+// for (variable; condición; incremento) {
+//   código a ejecutar
+// }
+
+let list = ["eat", "sleep", "code", "repeat"];
+
+for (let i = 0; i < list.length; i++) {
+  console.log(list[i]);
+}

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/07-Iteración con forof en JavaScript para arrays y strings.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:50f3ce9037aff0a376981943867a5663223c698ee1b7ae28969a84b90fae5b21
+size 28428981

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/07-Iteración con forof en JavaScript para arrays y strings.vtt

@@ -0,0 +1,366 @@
+WEBVTT
+
+00:00.000 --> 00:03.500
+Vamos a ver un nuevo for o un nuevo método
+loop
+
+00:03.500 --> 00:05.340
+que nos va a ayudar para poder iterar.
+
+00:05.340 --> 00:07.780
+Este se llama
+for-off,
+
+00:07.780 --> 00:11.840
+que prácticamente el nombre creo que ya es
+extremadamente explícito.
+
+00:11.840 --> 00:15.500
+Es por cada elemento de cierta cosa.
+
+00:15.500 --> 00:18.040
+For, este elemento, off, esta
+cosa.
+
+00:18.040 --> 00:20.500
+Vamos a hacer cierto código y vamos a
+iterar
+
+00:20.500 --> 00:25.400
+hasta que se cumpla prácticamente el loop
+que estamos buscando.
+
+00:25.400 --> 00:27.840
+Vamos a ver cuál es la estructura de este
+método.
+
+00:27.840 --> 00:30.400
+Como te comenté, vamos a empezar aquí con
+un comentario
+
+00:30.400 --> 00:34.100
+para que podamos rayar sin que nos
+regresen errores.
+
+00:34.100 --> 00:37.000
+Vamos a estar viendo a lo que se llama
+for-off.
+
+00:37.000 --> 00:41.800
+Y for-off es una forma de iterar ciertos
+elementos de igual forma.
+
+00:41.800 --> 00:44.500
+Aquí es importante explicar que
+for-off
+
+00:44.500 --> 00:48.000
+lo vamos a estar utilizando en objetos
+iterables.
+
+00:48.000 --> 00:52.400
+Estos, los ejemplos son arrays o strings.
+
+00:52.400 --> 00:55.400
+¿Por qué? Porque estos dos son objetos
+iterables
+
+00:55.400 --> 00:59.800
+que terminan siendo una lista, una lista
+de algo.
+
+00:59.800 --> 01:01.000
+Esto es
+importante.
+
+01:01.000 --> 01:04.800
+Entonces, cada vez que queramos iterar
+sobre elementos de una lista,
+
+01:04.800 --> 01:06.800
+vamos a utilizar
+for-off.
+
+01:06.800 --> 01:08.800
+Y cuando me refiero a elementos de una
+lista
+
+01:08.800 --> 01:12.600
+o conocidos como objetos iterables, son
+arrays y strings.
+
+01:12.600 --> 01:14.900
+Entonces, la estructura base
+es,
+
+01:14.900 --> 01:17.000
+generamos nuestra palabra reservada for,
+
+01:17.000 --> 01:18.700
+abrimos nuestros
+paréntesis,
+
+01:18.700 --> 01:21.800
+ponemos aquí la
+variable,
+
+01:21.800 --> 01:26.100
+la variable, es de, que sería
+off,
+
+01:26.100 --> 01:27.800
+y el
+objeto.
+
+01:31.200 --> 01:33.700
+Y ya aquí abrimos nuestros corchetes,
+
+01:33.700 --> 01:36.600
+y en nuestros corchetes ponemos el código
+a ejecutar.
+
+01:37.900 --> 01:40.600
+Entonces, la iteración viene for la
+variable
+
+01:40.600 --> 01:45.600
+o el elemento de nuestra lista o objeto
+iterable,
+
+01:45.700 --> 01:47.700
+haz como ese
+loop,
+
+01:47.700 --> 01:50.600
+y si, o sea, si esto sigue siendo
+verdad
+
+01:50.600 --> 01:52.400
+o sigue estando dentro del
+loop,
+
+01:52.400 --> 01:55.800
+entonces, genera este código a ejecutar.
+
+01:55.800 --> 01:58.200
+Una vez que se rompa esta validación,
+
+01:58.200 --> 02:00.200
+entonces, aquí lo vamos a
+ver,
+
+02:00.200 --> 02:03.100
+como ya no existe ningún objeto adentro de
+esta lista,
+
+02:03.100 --> 02:04.300
+voy a generar un
+break,
+
+02:04.300 --> 02:06.400
+y ya no se va a ejecutar ningún tipo de
+código,
+
+02:06.400 --> 02:10.200
+y ya no se va a seguir iterando sobre este
+objeto iterable.
+
+02:10.200 --> 02:11.300
+Prácticamente se
+rompe,
+
+02:11.300 --> 02:15.200
+y ahí nosotros como que terminamos de iterar.
+
+02:15.200 --> 02:16.800
+Por ejemplo, en
+código,
+
+02:16.800 --> 02:19.400
+vamos a generar como una
+lista,
+
+02:19.400 --> 02:21.200
+va a ser entonces un
+let,
+
+02:21.200 --> 02:24.200
+que se va a llamar, por ejemplo, canasta.
+
+02:24.200 --> 02:25.700
+Y esta canasta va a
+tener,
+
+02:25.700 --> 02:29.600
+generamos una lista y va a tener frutas,
+manzana.
+
+02:30.700 --> 02:33.400
+Vamos a ponerle, por ejemplo,
+pera.
+
+02:33.400 --> 02:37.600
+Vamos a tener, por ejemplo, laranja.
+
+02:43.100 --> 02:47.300
+Y vamos a agregar, por ejemplo, uva.
+
+02:47.300 --> 02:48.800
+Aquí tenemos nuestra
+lista.
+
+02:48.800 --> 02:53.600
+Ahora, ya sabemos cuál es la estructura de
+nuestro for off.
+
+02:53.600 --> 02:56.200
+Entonces, de forma muy sencilla, empezamos
+con nuestro for.
+
+02:56.200 --> 02:59.100
+Aquí ponemos, vamos a iniciar con la variable.
+
+02:59.100 --> 03:01.800
+Y casi siempre yo, lo que suelo hacer es un,
+
+03:01.800 --> 03:04.600
+si tengo una lista de ciertos elementos,
+
+03:04.600 --> 03:06.700
+en este caso, son
+frutas,
+
+03:06.700 --> 03:09.700
+pues voy a hacer por cada
+fruta,
+
+03:09.700 --> 03:11.500
+el nombre de mi
+variable,
+
+03:11.500 --> 03:14.200
+de la
+canasta.
+
+03:14.200 --> 03:16.300
+Canasta.
+
+03:16.300 --> 03:18.700
+Entonces, genera el siguiente código.
+
+03:18.700 --> 03:20.200
+Y este código va a ser
+sencillo.
+
+03:20.200 --> 03:21.600
+Va a ser un ejemplo
+rápido,
+
+03:21.600 --> 03:25.000
+que es, quiero que me imprimas un console.
+log
+
+03:25.000 --> 03:28.500
+en el navegador, la
+fruta.
+
+03:28.500 --> 03:29.600
+Entonces, de forma muy
+rápida,
+
+03:29.600 --> 03:34.400
+es por cada fruta de la canasta, genera esto.
+
+03:34.400 --> 03:35.900
+Y esto es,
+imprímeme,
+
+03:35.900 --> 03:38.300
+prácticamente en la consola del navegador,
+
+03:38.300 --> 03:39.700
+cada una de las
+frutas.
+
+03:39.700 --> 03:43.000
+En el momento en el que ya no tengas
+frutas en la lista,
+
+03:43.000 --> 03:46.400
+deja de generar como esta iteración o este
+loop.
+
+03:46.400 --> 03:47.600
+Y es prácticamente lo que
+tenemos,
+
+03:47.600 --> 03:49.100
+manzana, pera, naranja y
+uvas,
+
+03:49.100 --> 03:51.300
+que es lo que tenemos
+aquí.
+
+03:51.300 --> 03:53.800
+Esto va a estar pasando por cada uno de
+los elementos.
+
+03:53.800 --> 03:55.300
+Y como te comentaba en un
+inicio,
+
+03:55.300 --> 03:58.800
+es importante recordar que
+esto,
+
+03:58.800 --> 04:01.400
+este método forOf solo va a
+funcionar
+
+04:01.400 --> 04:03.700
+cuando nosotros tenemos objetos iterables,
+
+04:03.700 --> 04:06.100
+que estos son arrays o
+strings.
+
+04:06.100 --> 04:08.200
+Cada objeto que genere una
+lista,
+
+04:08.200 --> 04:09.700
+al cual nosotros
+podamos,
+
+04:09.700 --> 04:11.300
+prácticamente si venimos
+aquí,
+
+04:11.300 --> 04:13.700
+y queremos una
+canasta,
+
+04:13.700 --> 04:15.700
+esto es una lista que tiene ciertos objetos,
+
+04:15.700 --> 04:18.300
+si a esta canasta le pongo un punto
+length
+
+04:18.300 --> 04:19.800
+y me regreso una
+longitud,
+
+04:19.800 --> 04:21.200
+esto es nuestra
+lista.
+
+04:21.200 --> 04:24.700
+Cada que tengamos una lista de objetos
+iterables,
+
+04:24.700 --> 04:43.700
+nosotros podemos utilizar un
+forOf.
+

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/07-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/basico-js

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/07-index_415ee999-5c83-4b2a-8c39-ea8b0790bcfa.js

@@ -0,0 +1,15 @@
+/*
+
+for of arrays, strings [algo]
+
+for (varible of objeto) {
+  código 
+}
+
+*/
+
+let canasta = ["manzana", "pera", "naranja", "uva"];
+
+for (fruta of canasta) {
+  console.log(fruta);
+}

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/08-Iteración sobre Objetos con forIn en JavaScript.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1e797bbfc1c1937a88cef7df279b69e1a20cb9d869c094319d1051acd89b9fc3
+size 55718947

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/08-Iteración sobre Objetos con forIn en JavaScript.vtt

@@ -0,0 +1,500 @@
+WEBVTT
+
+00:00.000 --> 00:03.040
+Vamos a iniciar ahora con un método de
+iteración que se llama forIn,
+
+00:03.040 --> 00:05.040
+que a diferencia de lo que es el forOff,
+
+00:05.040 --> 00:08.880
+forIn lo vamos a utilizar para poder
+iterar sobre objetos innumerables.
+
+00:08.880 --> 00:10.520
+Ejemplo,
+objetos.
+
+00:10.520 --> 00:13.000
+Y tú puedes preguntar, ¿qué son los objetos,
+Diego?
+
+00:13.000 --> 00:16.040
+Y los objetos es prácticamente una
+estructura de datos
+
+00:16.040 --> 00:18.280
+diferente a lo que sería un Array o un
+String
+
+00:18.280 --> 00:20.200
+para poder guardar
+información.
+
+00:20.200 --> 00:23.640
+Los objetos tienen algo importante que se
+llaman propiedades,
+
+00:23.640 --> 00:25.920
+que es la propiedad y tiene un valor.
+
+00:25.920 --> 00:29.440
+A diferencia de un Array, que simplemente
+generas una lista de valores,
+
+00:29.440 --> 00:32.080
+un objeto tiene que tener una propiedad y
+su valor.
+
+00:32.080 --> 00:34.160
+Es una estructura diferente de datos.
+
+00:34.160 --> 00:37.680
+Y si queremos iterar sobre estas
+propiedades
+
+00:37.680 --> 00:39.840
+que tienen los objetos innumerables,
+
+00:39.840 --> 00:41.760
+nosotros vamos a utilizar el
+forIn.
+
+00:41.760 --> 00:44.920
+Así que vayamos a nuestra consola para
+poder ver un ejemplo.
+
+00:44.920 --> 00:47.560
+Entonces, empecemos generando un
+comentario
+
+00:47.560 --> 00:50.440
+para poder rayar sin errores en la consola.
+
+00:50.440 --> 00:52.520
+Vamos a hablar de
+forIn.
+
+00:52.520 --> 00:54.760
+forIn principalmente lo vamos a
+utilizar
+
+00:54.760 --> 00:58.440
+para poder iterar sobre objetos innumerables.
+
+00:58.440 --> 01:02.840
+En este caso, el ejemplo más real es objetos.
+
+01:02.840 --> 01:07.520
+Y objetos, a diferencia de un Array o un
+String,
+
+01:07.520 --> 01:12.520
+es una estructura de datos que consta de
+dos cosas.
+
+01:12.520 --> 01:16.120
+Propiedades,
+
+01:16.120 --> 01:19.000
+que a su vez tienen un
+valor.
+
+01:19.000 --> 01:24.640
+Los Arrays o Strings lo que tienen son
+simplemente elementos adentro
+
+01:24.640 --> 01:26.160
+que generan una
+lista.
+
+01:26.160 --> 01:29.840
+Los objetos van a tener una propiedad y la
+propiedad va a tener un valor.
+
+01:29.840 --> 01:33.200
+Entonces, si nosotros queremos iterar
+sobre las propiedades o los valores,
+
+01:33.200 --> 01:36.080
+ocupamos un forIn de forma específica.
+
+01:36.080 --> 01:38.600
+Y la estructura para esto es el for,
+
+01:38.600 --> 01:40.840
+el for que es la palabra
+reservado.
+
+01:40.840 --> 01:44.400
+Adentro, entre paréntesis, ponemos la
+variable,
+
+01:44.400 --> 01:46.600
+que es la que va a estar haciendo la
+iteración,
+
+01:46.600 --> 01:52.200
+el in y el objeto al que vamos a estar
+iterando.
+
+01:52.200 --> 01:54.440
+Y ya que eso esté, entonces corchetes,
+
+01:54.440 --> 01:57.400
+y aquí es donde vamos a generar nuestro
+código,
+
+01:57.400 --> 01:58.960
+que es el código que se va a ejecutar.
+
+01:58.960 --> 02:00.240
+Pero la traducción
+es,
+
+02:00.240 --> 02:05.080
+por cada elemento o propiedad en este objeto,
+
+02:05.080 --> 02:09.240
+ejecútame este código y va a regresar
+evidentemente algo.
+
+02:09.240 --> 02:11.080
+Vamos a un ejemplo
+entonces.
+
+02:11.080 --> 02:14.400
+Aquí vamos a generar un primer
+objeto
+
+02:14.400 --> 02:19.360
+que va a ser como nuestra lista de algo
+para poder iterar en un forIn.
+
+02:19.360 --> 02:22.520
+Vamos a comenzar con un
+const.
+
+02:22.520 --> 02:27.720
+Este const se va a llamar lista de compras.
+
+02:27.720 --> 02:30.080
+Y esto, como te comenté, es un objeto.
+
+02:30.080 --> 02:32.480
+Entonces es igual a un
+corchete.
+
+02:32.480 --> 02:34.840
+Y dentro de los corchetes empezamos con
+las propiedades,
+
+02:34.840 --> 02:37.760
+que va a ser
+manzana.
+
+02:37.760 --> 02:41.640
+Y quiero comprar entonces cinco manzanas.
+
+02:41.640 --> 02:46.000
+Ya que tengo eso, vamos a comprar manzanas
+cinco.
+
+02:46.000 --> 02:52.080
+Vamos por pera igual a
+tres.
+
+02:52.080 --> 02:55.520
+Vamos por
+naranja.
+
+02:55.520 --> 02:57.760
+Y aquí vamos a llevar
+dos.
+
+02:57.760 --> 03:01.520
+Y
+uva.
+
+03:01.520 --> 03:04.800
+Y con uva va a ser un ramo de
+uva.
+
+03:04.800 --> 03:08.920
+Aquí tenemos que ponerle nuestra coma para
+poder llegar al siguiente.
+
+03:08.920 --> 03:13.000
+Aquí tenemos una primera estructura muy
+básica de lo que puede ser un objeto.
+
+03:13.000 --> 03:16.360
+Tenemos las propiedades del objeto y
+tenemos el valor de la propiedad.
+
+03:16.360 --> 03:19.360
+Y adentro tenemos lo que son cuatro
+propiedades.
+
+03:19.360 --> 03:22.240
+Si yo quisiera iterar sobre estas propiedades,
+
+03:22.240 --> 03:27.240
+lo que voy a utilizar es un for para poder
+hacer como esta iteración.
+
+03:27.240 --> 03:30.080
+En donde vamos a generar nuestra variable
+inicial,
+
+03:30.080 --> 03:37.240
+que es fruta, en la lista de compras.
+
+03:37.240 --> 03:42.960
+Entonces lo que quiero hacer es que console.
+log me puede imprimir de
+
+03:42.960 --> 03:44.280
+inicio la
+fruta.
+
+03:47.640 --> 03:48.440
+Ya que estoy
+acá,
+
+03:48.440 --> 03:54.000
+si yo guardo, aquí lo que va a hacer es me
+va a imprimir prácticamente cada una
+
+03:54.000 --> 03:56.960
+de las propiedades que tengo adentro de
+este objeto.
+
+03:56.960 --> 04:00.640
+Pero ¿qué pasa si yo quiero imprimir ahora
+el valor de cada una de estas
+
+04:00.640 --> 04:01.200
+propiedades?
+
+04:01.200 --> 04:03.160
+Es como, perfecto, sé que es una manzana,
+
+04:03.160 --> 04:06.080
+pero ahora quiero traer que tengo que
+comprar cinco manzanas,
+
+04:06.080 --> 04:07.440
+no solo
+manzana.
+
+04:07.440 --> 04:12.480
+Lo que vamos a hacer ahí, en ese caso voy
+a dejar ese for in,
+
+04:12.480 --> 04:13.680
+voy a abrir otro for
+in,
+
+04:13.680 --> 04:16.440
+solo para que se quede como ejemplo de este.
+
+04:16.440 --> 04:21.640
+Pero ahora en este nuevo va a ser la misma
+estructura por cada fruta en mi
+
+04:21.640 --> 04:25.280
+lista de manzanas, mi lista de compras.
+
+04:25.280 --> 04:30.920
+Venimos aquí, utilizamos el console.
+log para poder imprimir.
+
+04:30.920 --> 04:33.800
+Aquí es donde se pone
+distinto.
+
+04:33.800 --> 04:34.760
+Aquí lo que vamos a hacer
+es,
+
+04:34.760 --> 04:38.360
+queremos nosotros inyectar el valor de una
+variable.
+
+04:38.360 --> 04:38.760
+¿Qué va a
+hacer?
+
+04:38.760 --> 04:43.200
+Inyectar el valor de esta variable y ahora
+queremos entrar al valor de cada
+
+04:43.200 --> 04:48.600
+una de las propiedades y la forma de
+hacerlo es, bien, pues venimos,
+
+04:48.600 --> 04:53.520
+decimos que quiero que me imprima la fruta
+y estando aquí, por separado,
+
+04:53.520 --> 04:58.800
+quiero que me imprima de mi lista, venimos,
+
+04:58.800 --> 05:05.680
+de mi lista de compras con corchetes
+cuadrados, la fruta.
+
+05:09.000 --> 05:11.000
+Vamos a darle
+guardar.
+
+05:11.000 --> 05:13.720
+Entonces ya me regresa una manzana, bueno,
+
+05:13.720 --> 05:17.000
+me regresa el elemento manzana con la
+cantidad de manzanas que tengo que
+
+05:17.000 --> 05:21.200
+comprar, el elemento pea con la cantidad
+de peas que tengo que comprar,
+
+05:21.200 --> 05:25.400
+el elemento o la propiedad de naranja con
+la cantidad de naranjas y lo mismo la
+
+05:25.400 --> 05:29.120
+propiedad de uva con la cantidad de ramos
+de uvas que tengo que comprar.
+
+05:29.120 --> 05:30.600
+¿Qué está pasando
+aquí?
+
+05:30.600 --> 05:35.800
+Aquí fruta, fruta es una variable que se
+convierte en una variable numérica,
+
+05:35.800 --> 05:38.080
+que evidentemente al momento de estar
+haciendo el loop,
+
+05:38.080 --> 05:43.120
+lo que va a hacer es algo muy similar a
+estar iterando, por ejemplo, un array.
+
+05:43.120 --> 05:45.360
+Fruta aquí va a ser un
+número,
+
+05:45.360 --> 05:50.440
+va a regresar el índice de cada una de las
+propiedades que existe en el objeto.
+
+05:50.440 --> 05:55.280
+Entonces, como es un índice, prácticamente
+me está regresando un número.
+
+05:55.280 --> 05:57.920
+Entonces me está diciendo, oye, de la
+lista de compras,
+
+05:57.920 --> 06:03.440
+tráeme el índice cero, que en este caso el
+cero sería manzana.
+
+06:03.440 --> 06:08.880
+Y si nosotros intentamos poner esta esta
+sintaxis, al hacer esto,
+
+06:08.880 --> 06:11.080
+de igual forma en la
+propiedad,
+
+06:11.080 --> 06:16.920
+me está diciendo que le traiga el valor
+del índice cero, que me va a traer cinco.
+
+06:16.920 --> 06:20.080
+Entonces va a estar haciendo esta
+validación y me va a estar trayendo la
+
+06:20.080 --> 06:24.040
+propiedad y su valor, la propiedad y su valor,
+la propiedad y su valor,
+
+06:24.040 --> 06:28.400
+en donde fruta sigue siendo un número y en
+cada una de las iteraciones,
+
+06:28.400 --> 06:32.840
+ese número va a estar incrementando para
+poder llegar a cada una de las
+
+06:32.840 --> 06:36.840
+propiedades y los valores que tenemos
+adentro del objeto.
+
+06:36.840 --> 06:42.160
+Ahora, ¿qué pasa si intento utilizar,
+por ejemplo, un for off?
+
+06:42.160 --> 06:48.200
+El for off sería fruta off lista de compras.
+
+06:48.200 --> 06:54.400
+Y lo que quiero es que me regrese un console.
+log de fruta,
+
+06:54.400 --> 06:56.120
+para no entrar a mucho
+detalle.
+
+06:56.120 --> 07:00.320
+Si yo guardo aquí, lo que me está diciendo es,
+oye, tienes un error.
+
+07:00.320 --> 07:04.680
+Vemos ahí que me está regresando el primer
+for in, aquí el siguiente for in,
+
+07:04.680 --> 07:07.320
+pero en el tercero, que es el for off,
+me está diciendo,
+
+07:07.320 --> 07:10.320
+lista de compras no es
+iterable.
+
+07:10.320 --> 07:13.400
+Y recordemos que al inicio de la clase,
+
+07:13.400 --> 07:17.800
+yo estoy comentando que for in lo
+utilizamos para iterar sobre objetos
+
+07:17.800 --> 07:20.480
+innumerables, no
+iterables.
+
+07:20.480 --> 07:23.440
+Los objetos iterables son los arrays y los
+strings.
+
+07:23.440 --> 07:28.120
+Los objetos innumerables son prácticamente
+solo los objetos.
+
+07:28.120 --> 07:31.600
+Así que cuando tengas un objeto y tengas
+que iterar sobre las propiedades,
+
+07:31.600 --> 07:33.720
+utilizamos un for
+in.
+
+07:33.720 --> 07:58.720
+Cuando tengas un string o un array, vamos
+a utilizar el for off.
+

subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y Lógica/08-Lecturas recomendadas.txt

@@ -0,0 +1 @@
+https://github.com/platzi/basico-js