diff --git a/.gitattributes b/.gitattributes
index fe6833a7fbfdb2c84e8160125b093010fa2907b1..956ade8e32be80941307a4c139e50561819a0a53 100644
--- a/.gitattributes
+++ b/.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
diff --git "a/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/07-Lecturas recomendadas.txt" "b/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/07-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..0cf45bc41c7c80805a49f0cb0b053e7e2297c6c6
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/07-Lecturas recomendadas.txt"
@@ -0,0 +1 @@
+https://github.com/platzi/basico-js
diff --git "a/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/07-N\303\272meros y Operaciones Matem\303\241ticas en JavaScript.vtt" "b/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/07-N\303\272meros y Operaciones Matem\303\241ticas en JavaScript.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..82b1eca1007e061b2bd9a997ed2e3e592193c182
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/07-N\303\272meros y Operaciones Matem\303\241ticas 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.
+
diff --git "a/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/07-Resumen.html" "b/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/07-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..3c6127f9c20fdb4980b970de087399095527ed62
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/07-Resumen.html"
@@ -0,0 +1,176 @@
+
+
+
+
+
+
+ Números y Operaciones Matemáticas en JavaScript
+
+
+
+
+
+ Resumen
¿Cuál es el tipo de dato number en JavaScript?
+
En JavaScript, el tipo de dato primitivo number es esencial para el manejo de operaciones numéricas. Aunque existen diversas formas de escribir números, como enteros y decimales, todos se reconocen bajo el mismo tipo de dato: number. Esta unificación facilita la manipulación y el cálculo numérico. Veamos cómo se representan en este lenguaje:
+
+-
+
Enteros y decimales: Se escriben de forma diferente, pero en su naturaleza subyacente ambos son números.
+let entero = 42;
+let decimal = 3.14;
+console.log(typeof entero);
+console.log(typeof decimal);
+
+
+-
+
Notación científica: En JavaScript, también podemos utilizar la notación científica para representar números. Se usa la letra e para indicar una potencia de 10.
+let cientifico = 5e3;
+
+
+-
+
Infinity y NaN: La representación de números infinitos usa Infinity, mientras que un cálculo o valor indefinido se representa como NaN (Not a Number).
+let infinito = Infinity;
+let noNumero = NaN;
+
+
+
+
¿Cómo realizar operaciones aritméticas?
+
JavaScript proporciona operadores aritméticos para realizar cálculos básicos y avanzados. Entre ellos destacan:
+
Operaciones básicas
+
+- Suma (+): Adición de dos números.
+- Resta (-): Diferencia entre dos números.
+- Multiplicación (*): Producto de dos números.
+- División (/): Cociente de dos números.
+
+
let suma = 5 + 3;
+let resta = 10 - 6;
+let multiplicacion = 2 * 3;
+let division = 9 / 3;
+
+
Operaciones avanzadas
+
+
Dilemas con la precisión
+
JavaScript a veces enfrenta problemas de precisión en operaciones decimales.
+
+
Para redondear resultados a un número fijo de decimales, podemos utilizar .toFixed().
+
console.log(resultado.toFixed(2));
+
+
¿Qué operaciones avanzadas podemos hacer con Math?
+
JavaScript brinda el objeto Math para operaciones matemáticas avanzadas:
+
+-
+
Raíz cuadrada (Math.sqrt): Calcula la raíz cuadrada de un número.
+let raizCuadrada = Math.sqrt(16);
+
+
+-
+
Valor absoluto (Math.abs): Devuelve el valor absoluto de un número.
+let valorAbsoluto = Math.abs(-7);
+
+
+-
+
Número aleatorio (Math.random): Genera un número aleatorio entre 0 y 1.
+let aleatorio = Math.random();
+
+
+
+
El tipo de dato number en JavaScript es fundamental en el desarrollo de aplicaciones donde se requiere manejo de números y cálculos matemáticos, asegurando versatilidad y facilidad en su implementación.
+
+
+
+
\ No newline at end of file
diff --git "a/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/07-clase-number_acc7d1d1-5270-488c-88fc-349f8c28432c.js" "b/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/07-clase-number_acc7d1d1-5270-488c-88fc-349f8c28432c.js"
new file mode 100644
index 0000000000000000000000000000000000000000..fd71e8e7f8ff84acabbc38d07c628d01104a351f
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n 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)
diff --git "a/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/08-Conversi\303\263n de Tipos en JavaScript Impl\303\255cita y Expl\303\255cita.mp4" "b/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/08-Conversi\303\263n de Tipos en JavaScript Impl\303\255cita y Expl\303\255cita.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..3e55d1e300ec373b147f07d86031ce35fe12aa6f
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/08-Conversi\303\263n de Tipos en JavaScript Impl\303\255cita y Expl\303\255cita.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:63ba91178eef23a3a1032d09d5ac176f04f431d15dd50a3b96a07d7eed5dfced
+size 112265141
diff --git "a/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/08-Conversi\303\263n de Tipos en JavaScript Impl\303\255cita y Expl\303\255cita.vtt" "b/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/08-Conversi\303\263n de Tipos en JavaScript Impl\303\255cita y Expl\303\255cita.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..55d055b99a619606d9151b826ae7a1b01ecc4e0b
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/08-Conversi\303\263n de Tipos en JavaScript Impl\303\255cita y Expl\303\255cita.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.
+
diff --git "a/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/08-Resumen.html" "b/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/08-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..53ec11db1422298670d4a2beb8ed6f049a528177
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/08-Resumen.html"
@@ -0,0 +1,122 @@
+
+
+
+
+
+
+ Conversión de Tipos en JavaScript: Implícita y Explícita
+
+
+
+
+
+ Resumen
¿Qué es la conversión de tipos en JavaScript?
+
La conversión de tipos es un concepto fundamental en JavaScript, un lenguaje de programación caracterizado por su flexibilidad y capacidad para adaptarse a diferentes tipos de datos durante la ejecución del código. Este proceso es esencial porque el código que escribimos como seres humanos debe ser traducido para que sea comprensible para el programa de ordenador. JavaScript, un lenguaje interpretado, maneja esta conversión de manera dinámica, lo que significa que decide cómo tratar los tipos de datos sobre la marcha, mientras el código se ejecuta.
+
¿Cómo funciona JavaScript como lenguaje interpretado?
+
JavaScript es un ejemplo clásico de un lenguaje interpretado. A diferencia de los lenguajes compilados como C o Swift, donde el código es traducido completamente antes de ejecutarse, JavaScript traduce su código conforme se ejecuta. Esto se asemeja a tener a alguien traduciendo instrucciones a medida que cocinamos, versus tener la receta ya traducida antes de empezar. Este enfoque permite a JavaScript ser altamente flexible, pero también implica que el chequeo de tipos sucede de manera dinámica.
+
¿Qué significa que JavaScript tenga un "tipado débil"?
+
El tipado débil es una de las características que distingue a JavaScript. Esto significa que JavaScript permite más flexibilidad al asignar valores a las variables. Por ejemplo, puedes asignar un número a una variable y luego asignar un string al mismo espacio de memoria sin errores. Así, JavaScript maneja situaciones inusuales, como sumar un número y un valor booleano, mediante la conversión implícita de tipos, convirtiendo los valores a un tipo compatible para seguir la ejecución.
+
const numero = 2;
+const booleano = true;
+const resultado = numero + booleano;
+
+
En este ejemplo, JavaScript convierte el booleano true a un número 1 para realizar la operación de suma.
+
¿Cuáles son los tipos de conversión en JavaScript?
+
JavaScript permite dos tipos de conversión: implícita y explícita.
+
+-
+
Conversión implícita: JavaScript realiza automáticamente sin que el programador precise intervención, como en el caso de sumar un número con un booleano.
+
+-
+
Conversión explícita: El programador decide convertir manualmente un tipo de dato a otro, por ejemplo, transformando un booleano en un string o en un número.
+
+
+
let booleano = true;
+let booleanToString = booleano.toString();
+let booleanToNumber = Number(booleano);
+
+
¿Por qué es importante entender la conversión de tipos?
+
Comprender la conversión de tipos en JavaScript es crucial para evitar errores durante la ejecución, especialmente cuando el lenguaje realiza conversiones implícitas que pueden llevar a resultados inesperados. Saber cuándo y cómo utilizar la conversión explícita te permitirá tener un mayor control sobre cómo se manejan los datos en tus aplicaciones, mejorando la calidad y eficacia de tu código.
+
La conversión de tipos es un tema importante que obliga a los desarrolladores a ser conscientes de las implicaciones de cómo se manejan los datos en un lenguaje tan dinámico como JavaScript. Dominar este concepto te permitirá navegar con mayor confianza en el mundo del desarrollo web, optimizando tus soluciones y mejorando tu experiencia de codificación. ¡Sigue explorando y perfeccionando tus habilidades!
+
+
+
+
\ No newline at end of file
diff --git "a/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/09-Conversi\303\263n de Tipos en JavaScript Expl\303\255cita e Impl\303\255cita.mp4" "b/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/09-Conversi\303\263n de Tipos en JavaScript Expl\303\255cita e Impl\303\255cita.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..fee86260d5514a996058cac8c0b6a84e46ce7fdc
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/09-Conversi\303\263n de Tipos en JavaScript Expl\303\255cita e Impl\303\255cita.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1937a5016bbd3dcfbd4d37936b93e95c9f61508e8619a04f2e602b344a0635b
+size 93220895
diff --git "a/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/09-Conversi\303\263n de Tipos en JavaScript Expl\303\255cita e Impl\303\255cita.vtt" "b/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/09-Conversi\303\263n de Tipos en JavaScript Expl\303\255cita e Impl\303\255cita.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..d74afa4289968d16d0465821b40bd3ed07666e8a
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/09-Conversi\303\263n de Tipos en JavaScript Expl\303\255cita e Impl\303\255cita.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.
diff --git "a/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/09-Resumen.html" "b/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/09-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..4a756c8296f8f7722a1a1669d296f8f874f8c602
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/01-Introducci\303\263n a JavaScript/09-Resumen.html"
@@ -0,0 +1,144 @@
+
+
+
+
+
+
+ Conversión de Tipos en JavaScript: Explícita e Implícita
+
+
+
+
+
+ Resumen
¿Qué es el typecasting explícito en JavaScript?
+
Typecasting en JavaScript se refiere a convertir tipos de datos de manera explícita o implícita. Comencemos explorando la conversión explícita de tipos, uno de los métodos más comunes para manejar diferentes tipos de datos en nuestros programas.
+
Podemos convertir un string a un tipo numérico usando funciones como parseInt() y parseFloat(). Por ejemplo, podemos tener un string con un número "42" y convertirlo a un entero así:
+
const integer = parseInt("42");
+console.log(typeof integer);
+
+
De manera similar, para convertir un string decimal como "3.14" a un número flotante:
+
const float = parseFloat("3.14");
+console.log(typeof float);
+
+
JavaScript no distingue entre números enteros y decimales en cuanto al tipo de dato, ambos son considerados como number.
+
¿Cómo se convierte de binario a decimal?
+
Es posible convertir un número binario a decimal utilizando parseInt() con la base adecuada. Aquí un ejemplo práctico:
+
const binary = "1010";
+const decimal = parseInt(binary, 2);
+console.log(decimal);
+
+
Este código convierte el número binario "1010" a su representación decimal que es 10.
+
¿Qué es el typecasting implícito en JavaScript?
+
JavaScript puede realizar conversiones de tipo sin intervención explícita del programador, esto se conoce como typecasting implícito. La suma de un string con un número ilustra este caso:
+
const resultado = "5" + 3;
+console.log(resultado);
+
+
En este ejemplo, JavaScript convierte el número 3 a un string y lo concatena con "5", dando como resultado "53".
+
¿Qué sucede con los booleanos?
+
Al combinar booleanos y otros tipos de datos, JavaScript también realiza conversiones. Por ejemplo:
+
const sumaConBoolean = "3" + true;
+console.log(sumaConBoolean);
+
+
Aquí el booleano true es convertido a string y luego concatenado. Sin embargo, si sumamos booleanos con números:
+
const sumaConNumero = 2 + true;
+console.log(sumaConNumero);
+
+
El booleano true es transformado a 1, resultando en una suma numérica.
+
Prueba tus conocimientos sobre typecasting
+
Para solidificar el aprendizaje, considera resolver el siguiente ejercicio:
+
Tienes el código:
+
const numero = "596";
+const numeroConvertido = parseInt(numero);
+console.log(typeof numero);
+console.log(typeof numeroConvertido);
+
+
¿Cuáles son los tipos de datos que resultarán de los console.log? Las opciones son:
+
+- A) string y number
+- B) string y string
+- C) number y string
+
+
La respuesta correcta es A, porque el numero es inicialmente un string y después del parseInt, numeroConvertido se convierte en un number. Continúa explorando y practicando con code snippets para perfeccionar tus habilidades en typecasting en JavaScript.
+
¡Sigue asi! tu comprensión de estos conceptos básicos te permitirá escribir código más eficiente y adaptativo.
+
+
+
+
\ No newline at end of file
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/01-Lecturas recomendadas.txt" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/01-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..0cf45bc41c7c80805a49f0cb0b053e7e2297c6c6
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/01-Lecturas recomendadas.txt"
@@ -0,0 +1 @@
+https://github.com/platzi/basico-js
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/01-Operadores de Comparaci\303\263n en JavaScript Igualdad y Desigualdad.mp4" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/01-Operadores de Comparaci\303\263n en JavaScript Igualdad y Desigualdad.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..dc6365cb36e3a3cb4fbbfde67b2a36e621d3438d
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/01-Operadores de Comparaci\303\263n en JavaScript Igualdad y Desigualdad.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd028665c8b31de1437b65e26145e8c4a6d4cff10e08936c13d7e8edab3f1bc9
+size 31296513
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/01-Operadores de Comparaci\303\263n en JavaScript Igualdad y Desigualdad.vtt" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/01-Operadores de Comparaci\303\263n en JavaScript Igualdad y Desigualdad.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..b1f2e26c3f6134b2e5a3773ee71559a89cc988e7
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/01-Operadores de Comparaci\303\263n 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.
+
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/01-Resumen.html" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/01-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..2278fcdee8f4710534e50751e206a4c54bc4c110
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/01-Resumen.html"
@@ -0,0 +1,175 @@
+
+
+
+
+
+
+ Operadores de Comparación en JavaScript: Igualdad y Desigualdad
+
+
+
+
+
+ Resumen
¿Qué es la ejecución condicional en programación?
+
La ejecución condicional es un concepto clave en programación que nos permite tomar diferentes caminos en nuestro código según ciertas condiciones. Esto se logra mediante el uso de operadores de comparación, los cuales evalúan expresiones para determinar si son verdaderas o falsas. Esta evaluación nos facilita la toma de decisiones dentro del código, permitiendo ejecutar ciertas partes solo si las condiciones establecidas se cumplen.
+
¿Qué son los operadores de comparación?
+
Los operadores de comparación son herramientas esenciales en el desarrollo de software que permiten comparar dos valores. Dependiendo de la comparación realizada, estas herramientas devuelven un valor booleano (verdadero o falso).
+
¿Cómo usar los operadores de igualdad?
+
Existen dos tipos principales de operadores de igualdad:
+
+- Dos iguales (==): Este operador verifica si dos valores son iguales. Sin embargo, no considera el tipo de dato. Es decir, puede determinar que un número y un string son iguales si ambos representan el mismo valor numérico.
+
+
10 == "10"
+
+
+- Tres iguales (===): Este operador, más estricto, verifica tanto el valor como el tipo de dato. Es una buena práctica utilizar este operador, ya que evita errores al asegurarse de que tanto el valor como el tipo sean idénticos.
+
+
10 === "10"
+
+
¿Cómo funcionan los operadores de desigualdad?
+
Al igual que los operadores de igualdad, existen dos operadores que manejan la desigualdad:
+
+- Diferente (!=): Este operador comprueba si dos valores no son iguales, sin considerar el tipo de dato.
+
+
10 != "20"
+
+
+- Diferente estricto (!==): Valida que tanto el valor como el tipo de dato sean diferentes.
+
+
10 !== "10"
+
+
¿Cuándo se utilizan los operadores de mayor y menor?
+
Estos operadores nos ayudan a comparar valores para identificar cuál es mayor o menor, además de sus combinaciones con igualdad:
+
+- Mayor (>): Verifica si un valor es mayor que otro.
+
+
20 > 10
+
+
+- Menor (<): Verifica si un valor es menor que otro.
+
+
10 < 20
+
+
+- Mayor o igual (>=): Comprueba si un valor es mayor o igual a otro.
+
+
10 >= 10
+
+
+- Menor o igual (<=): Revisa si un valor es menor o igual a otro.
+
+
5 <= 10
+
+
¿Cómo aplicar operadores de comparación en la práctica?
+
Veamos un ejemplo práctico usando JavaScript.
+
Declaración de variables
+
Primero, declararemos algunas constantes que utilizaremos para nuestras comparaciones:
+
const A = 10;
+const B = 20;
+const C = "10";
+
+
Ejemplo de comparaciones
+
+- Validar igualdad de valores:
+
+
A == B
+A === C
+
+
+- Validar desigualdad de valores:
+
+
A != B
+A !== C
+
+
+- Evaluar operadores mayor y menor:
+
+
A > B
+A < B
+A >= C
+A <= B
+
+
Estos ejemplos ilustran cómo los operadores de comparación te permiten tomar decisiones basadas en las condiciones definidas, lo que es esencial en la programación para la creación de flujos lógicos.
+
¡No dejes de explorar y experimentar con estos operadores para dominar cómo las condiciones pueden manipular el flujo de tu código y tomar decisiones programáticas efectivas!
+
+
+
+
\ No newline at end of file
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/01-index_46d19b83-ac83-452d-858c-5e612b45b72f.js" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/01-index_46d19b83-ac83-452d-858c-5e612b45b72f.js"
new file mode 100644
index 0000000000000000000000000000000000000000..7129d50254f3e0e0e092186edcc4f2a50f6cebae
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/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;
+
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/02-Lecturas recomendadas.txt" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/02-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..0cf45bc41c7c80805a49f0cb0b053e7e2297c6c6
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/02-Lecturas recomendadas.txt"
@@ -0,0 +1 @@
+https://github.com/platzi/basico-js
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/02-Operadores L\303\263gicos en Programaci\303\263n AND OR y NOT.mp4" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/02-Operadores L\303\263gicos en Programaci\303\263n AND OR y NOT.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..2f1b6283ca03224f00de34c1625fdc1ce7dcc4b4
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/02-Operadores L\303\263gicos en Programaci\303\263n AND OR y NOT.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d19fe009c55fb0f04f5e475e237677010007bd0b333cbd49ebbcf7af111204bb
+size 22991528
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/02-Operadores L\303\263gicos en Programaci\303\263n AND OR y NOT.vtt" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/02-Operadores L\303\263gicos en Programaci\303\263n AND OR y NOT.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..36096af4bff398f21bffee61a0e3bcf2b16523d0
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/02-Operadores L\303\263gicos en Programaci\303\263n 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.
+
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/02-Resumen.html" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/02-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..ff8a92060caf8334f4e505d0a7dbeeb2a37f61ca
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/02-Resumen.html"
@@ -0,0 +1,128 @@
+
+
+
+
+
+
+ Operadores Lógicos en Programación: AND, OR y NOT
+
+
+
+
+
+ Resumen
¿Qué son los operadores lógicos?
+
Los operadores lógicos son fundamentales para manejar condiciones y tomar decisiones en nuestros programas. Son tres: AND, OR y NOT. Estos operadores nos permiten validar múltiples condiciones de manera simultánea o individual. Comprender su funcionamiento nos ayudará a mejorar la lógica de nuestra programación y nos permitirá crear sistemas más robustos.
+
¿Cómo funciona el operador AND?
+
El operador AND (y) se utiliza cuando queremos verificar si múltiples condiciones son verdaderas al mismo tiempo. Si todas las condiciones que se evalúan son verdaderas, el resultado será true; de lo contrario, será false.
+
Por ejemplo, consideremos los siguientes valores constantes en un código JavaScript:
+
const A = 10;
+const B = 20;
+const C = "10";
+
+
Si queremos verificar si A es igual a B y A también es estrictamente igual a C, nuestro código sería:
+
if (A === B && A === C) {
+
+}
+
+
En este caso, el resultado sería false porque, aunque el valor de A es 10 y coincide con el valor numérico de C, no son del mismo tipo (el primero es un número y el segundo un string).
+
¿Qué hace el operador OR?
+
El operador OR (o) es útil cuando queremos que al menos una de varias condiciones se cumpla. Si al menos una condición es verdadera, el resultado será true.
+
Siguiendo el ejemplo anterior:
+
if (A !== B || A == C) {
+
+}
+
+
De este código, resulta true porque A es efectivamente diferente de B. Aunque A no es igual a C en tipo, el operador OR solo necesita que una de las condiciones se cumpla.
+
¿Cómo se utiliza el operador NOT?
+
El operador NOT (no) resulta muy útil cuando queremos invertir el resultado de una evaluación. Si aplicamos NOT a una condición, convertimos true en false y viceversa.
+
Tomemos el siguiente ejemplo:
+
if (!(A === C)) {
+
+}
+
+
Aquí, A === C es false porque no son del mismo tipo de datos, pero al aplicar el operador NOT, el resultado final es true.
+
Aplicaciones de los operadores lógicos
+
En el desarrollo de software, los operadores lógicos son esenciales para construir algoritmos complejos que requieren decisiones condicionadas. Estas decisiones no se limitan solo a operaciones numéricas; se expanden a la validación de parámetros de entrada, la gestión de errores, y la aplicación de lógica comercial en sistemas de software, entre otros.
+
El dominio de estos operadores incrementa nuestra capacidad para manejar situaciones complejas dentro del código y nos prepara mejor para enfrentarnos a los retos del desarrollo de software.
+
+
+
+
\ No newline at end of file
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/02-logica_f00b3100-7500-4fb8-b9b3-dea80a95bc8c.js" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/02-logica_f00b3100-7500-4fb8-b9b3-dea80a95bc8c.js"
new file mode 100644
index 0000000000000000000000000000000000000000..e5a866b96697718d07b9956eb662c81655915d72
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/02-logica_f00b3100-7500-4fb8-b9b3-dea80a95bc8c.js"
@@ -0,0 +1,14 @@
+/*
+
+Operadores Lógicos
+
+*/
+
+&&
+||
+!
+
+const a = 10;
+const b = 20;
+const c = "10"
+
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/03-Estructuras Condicionales Uso de IF ELSE y ELSE IF en JavaScript.mp4" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/03-Estructuras Condicionales Uso de IF ELSE y ELSE IF en JavaScript.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..5068904333463fbe21fd452eaaf918ca0005f0c3
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/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
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/03-Estructuras Condicionales Uso de IF ELSE y ELSE IF en JavaScript.vtt" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/03-Estructuras Condicionales Uso de IF ELSE y ELSE IF en JavaScript.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..7ee93d3aff87ff0fa509dfa1284bf28a920e915a
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/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.
+
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/03-Lecturas recomendadas.txt" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/03-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..0cf45bc41c7c80805a49f0cb0b053e7e2297c6c6
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/03-Lecturas recomendadas.txt"
@@ -0,0 +1 @@
+https://github.com/platzi/basico-js
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/03-Resumen.html" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/03-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..fe2bd16ca38273a6c748d2fb7aba660b3c7efca7
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/03-Resumen.html"
@@ -0,0 +1,134 @@
+
+
+
+
+
+
+ Estructuras Condicionales: Uso de IF, ELSE y ELSE IF en JavaScript
+
+
+
+
+
+ Resumen
¿Cómo funcionan las estructuras condicionales en JavaScript?
+
Al programar, uno de los conceptos fundamentales a dominar son las estructuras condicionales, también conocidas como estructuras de control. Estas estructuras nos permiten decidir qué parte de nuestro código se ejecutará basado en ciertas condiciones. En JavaScript, la estructura condicional más básica es la sentencia if, que nos permite ejecutar un bloque de código sólo si una determinada condición es verdadera.
+
Para utilizar la estructura if, se deben emplear operadores que nos ayuden a crear condiciones lógicas que puedan evaluarse como verdaderas o falsas. Estos operadores pueden ser de comparación como ==, ===, !=, !== o de relación como <, >, <=, >=.
+
¿Cómo se usa la estructura if?
+
Aquí se explica cómo funciona la estructura if con ejemplos prácticos:
+
let nombre = "Diego";
+
+if (nombre === "Diego") {
+ console.log("Hola Diego");
+}
+
+
En este ejemplo, hemos definido una variable nombre y la hemos comparado usando el operador de comparación estricta ===. Si nombre es igual a "Diego", entonces se ejecutará el bloque de código dentro del if.
+
¿Qué es el else y cómo funciona?
+
El else se utiliza cuando queremos que se ejecute un bloque de código diferente si la condición del if no se cumple. Sirve como una instrucción por defecto en caso de que ninguna de las condiciones anteriores sea verdadera.
+
let nombre = "Nico";
+
+if (nombre === "Diego") {
+ console.log("Hola Diego");
+} else {
+ console.log("Nombre no encontrado");
+}
+
+
En el ejemplo anterior, si la variable nombre no es igual a "Diego", se ejecutará el bloque de código dentro del else, mostrando "Nombre no encontrado".
+
¿Cómo se implementa else if para múltiples condiciones?
+
Para evaluar múltiples condiciones, se puede extender la estructura con else if. Esto nos permite comprobar varias condiciones en serie.
+
let nombre = "Nico";
+
+if (nombre === "Diego") {
+ console.log("Hola Diego");
+} else if (nombre === "Nico") {
+ console.log("Hola Nico");
+} else {
+ console.log("Nombre no encontrado");
+}
+
+
Aquí, primero se verifica si nombre es igual a "Diego". Si no es así, se comprueba la siguiente condición else if para "Nico", y en caso de que ninguna de las condiciones anteriores sea verdadera, se ejecuta el bloque dentro del else.
+
¿Por qué usar estructuras condicionales es crucial en programación?
+
Las estructuras condicionales son esenciales porque nos permiten tomar decisiones dentro del código basadas en condiciones dinámicas. Facilitan la creación de programas más interactivos y adaptativos, donde el flujo de ejecución puede variar dramáticamente dependiendo de los datos de entrada. Gracias a la capacidad de evaluar condiciones, podemos crear código robusto y flexible que responde según diferentes escenarios, lo que es crucial para el desarrollo de aplicaciones y la automatización de procesos.
+
Además, es importante mencionar que, al utilizar correctamente estas estructuras, podemos hacer nuestro código más legible y reducir la posibilidad de errores lógicos, mejorando así el mantenimiento y en la evolución del código a largo plazo.
+
¡Nunca dejes de explorar y aprender sobre estas funciones fundamentales en programación! Las estructuras condicionales son la base para empezar a construir lógica más compleja y detallada en tus proyectos.
+
+
+
+
\ No newline at end of file
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/03-index_fe9ea1fe-4786-4cef-8d43-ddbe3a1d4f46.js" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/03-index_fe9ea1fe-4786-4cef-8d43-ddbe3a1d4f46.js"
new file mode 100644
index 0000000000000000000000000000000000000000..f058e12aca833536a374d768600c88286f342122
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/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");
+}
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/04-Juego de Adivinanza Programaci\303\263n con Estructuras Condicionales.mp4" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/04-Juego de Adivinanza Programaci\303\263n con Estructuras Condicionales.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..47c2369e4dde14583805e91f3e278a723f83d698
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/04-Juego de Adivinanza Programaci\303\263n con Estructuras Condicionales.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5b4757d26440e757933d84d44cbea04068f31061189ec4cbbe3ef5d8cc4f8a10
+size 68039498
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/04-Juego de Adivinanza Programaci\303\263n con Estructuras Condicionales.vtt" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/04-Juego de Adivinanza Programaci\303\263n con Estructuras Condicionales.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..c562f618be355f7472efe52327a34d8a2a64d533
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/04-Juego de Adivinanza Programaci\303\263n 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.
+
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/04-Lecturas recomendadas.txt" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/04-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..cfa0308cb422b9c1886af709115c9794d0d3b3f4
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/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
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/04-Resumen.html" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/04-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..e373cb5cc0bd33d2204baebb67031c8a58f68d32
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/04-Resumen.html"
@@ -0,0 +1,136 @@
+
+
+
+
+
+
+ Juego de Adivinanza: Programación con Estructuras Condicionales
+
+
+
+
+
+ Resumen
¿Cómo crear un juego de adivinanza en JavaScript usando estructuras condicionales?
+
Crear un juego de adivinanza de números es una excelente manera de aprender sobre estructuras condicionales en JavaScript. En este ejercicio, usaremos funciones matemáticas y estructuras de control para desarrollar una sencilla pero divertida aplicación interactiva.
+
¿Cómo se crea un número secreto aleatorio?
+
Para desarrollar este juego, necesitamos generar un número aleatorio que el jugador tendrá que adivinar. Para ello, puedes emplear dos métodos de JavaScript: Math.random() y Math.floor(). Aquí te muestro cómo utilizarlos:
+
const numeroSecreto = Math.floor(Math.random() * 10) + 1;
+
+
+Math.random() genera un número decimal aleatorio entre 0 y 1.
+- Multiplicamos
Math.random() por 10 para obtener un rango entre 0 y 9.
+- Luego sumamos 1 para modificar el rango entre 1 y 10.
+Math.floor() se utiliza para redondear hacia abajo al número entero más cercano.
+
+
¿Cómo solicitamos al jugador que adivine el número?
+
Utilizaremos un prompt para que el jugador ingrese un número. También emplearemos parseInt para asegurarnos de que estamos trabajando con un número entero:
+
const numeroJugador = parseInt(prompt("Adivina el número secreto entre 1 y 10"), 10);
+console.log(`Este es el número con el que juegas: ${numeroJugador}`);
+
+
¿Cómo implementamos la lógica condicional para verificar la adivinanza?
+
Ahora que tenemos el número secreto y la adivinanza del jugador, podemos utilizar estructuras condicionales para verificar si el jugador ha adivinado correctamente:
+
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.");
+}
+
+
+if: Compara si el número del jugador coincide con el número secreto.
+else if: Si la adivinanza es incorrecta, verificamos si el número es menor.
+else: Si ninguna de las dos condiciones anteriores se cumple, asumimos que el número es demasiado alto.
+
+
¿Qué sucede si el jugador no adivina al primer intento?
+
El juego está diseñado para proporcionar retroalimentación instantánea, lo que permite al jugador ajustar su próxima adivinanza. Puedes extender este proyecto implementando un bucle para repetir el proceso hasta que el jugador acierte.
+
¿Cómo manejar variaciones y errores de validación?
+
Existen múltiples maneras de ampliar esta base de juego:
+
+- Mensajes personalizados: Diferentes respuestas pueden ser proporcionadas según la proximidad del número del jugador al número secreto.
+- Control de errores: Asegúrate de que el jugador ingrese un valor válido (número entre 1 y 10), utilizando validaciones adicionales.
+- Bucle de repetición: Implementa un
while loop para permitir múltiples intentos hasta adivinar correctamente.
+
+
Este sencillo proyecto muestra cómo la lógica condicional puede transformar tus ideas de programación en un juego interactivo y divertido. Recuerda, la práctica constante fortalece tus habilidades de programación. ¡Sigue explorando y creando!
+
+
+
+
\ No newline at end of file
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/04-juego_650efe0f-44b0-4f37-a8e6-b3215adc7ee0.js" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/04-juego_650efe0f-44b0-4f37-a8e6-b3215adc7ee0.js"
new file mode 100644
index 0000000000000000000000000000000000000000..2557d20096baa1e77e6c62591b7b3f5b68a6c774
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/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");
+}
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/05-Estructura y uso del condicional Switch en programaci\303\263n.mp4" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/05-Estructura y uso del condicional Switch en programaci\303\263n.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..5a1a073f9ab3d68f2c9ae8f710e5ff0a63946ebc
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/05-Estructura y uso del condicional Switch en programaci\303\263n.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:345b773867ccc79d9032f155949cd472afe7a1535fa43b14eac289251c791c1f
+size 90748094
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/05-Estructura y uso del condicional Switch en programaci\303\263n.vtt" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/05-Estructura y uso del condicional Switch en programaci\303\263n.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..fd6a0028124653e1c7542040f53a3489aea93607
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/05-Estructura y uso del condicional Switch en programaci\303\263n.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.
+
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/05-Lecturas recomendadas.txt" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/05-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..0cf45bc41c7c80805a49f0cb0b053e7e2297c6c6
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/05-Lecturas recomendadas.txt"
@@ -0,0 +1 @@
+https://github.com/platzi/basico-js
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/05-Resumen.html" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/05-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..4f285329a57f405cc7db96f871089d97d002f463
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/05-Resumen.html"
@@ -0,0 +1,133 @@
+
+
+
+
+
+
+ Estructura y uso del condicional Switch en programación
+
+
+
+
+
+ Resumen
¿Qué es un Switch y cómo se utiliza en programación?
+
El uso de la estructura de control Switch es fundamental en la programación para manejar múltiples escenarios basados en una expresión específica. Comparable a if, else if, else, Switch permite múltiples validaciones, pero con una diferencia esencial: evalúa solo si una expresión es verdadera y no múltiples condiciones.
+
A diferencia de los operadores comparativos en las estructuras if, Switch se utiliza exclusivamente para validar si la expresión que estamos evaluando es true. Pero, ¿cómo configuramos un Switch y qué componentes esenciales componen su estructura?
+
¿Cómo funciona la estructura básica de Switch?
+
La estructura de un Switch comienza definiendo una expresión entre paréntesis. Esta expresión es la condición a evaluar. Después, mediante la creación de múltiples casos (case), se especifica qué debe suceder si la expresión coincide con un valor determinado. Veamos cómo se configura:
+
let expresion = 'papayas';
+
+switch (expresion) {
+ case 'naranjas':
+ console.log('Las naranjas cuestan 20 pesos el kilo.');
+ break;
+ case 'manzanas':
+ console.log('Las manzanas cuestan 43 pesos el kilo.');
+ break;
+ case 'plátanos':
+ console.log('Los plátanos cuestan 30 pesos 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 ' + expresion);
+}
+
+
¿Cuál es la importancia de 'break' y 'default' en Switch?
+
La instrucción break en un Switch es crucial porque evita la ejecución de casos posteriores una vez que se ha encontrado un true. En caso de que ninguna condición se cumpla, podemos definir un default para gestionar escenarios no previstos y ofrecer respuestas predefinidas.
+
+break: Interrumpe la ejecución del Switch de manera que, una vez validado un caso, no se continúa evaluando los siguientes.
+default: Se utiliza como el "else" de un Switch, proporcionando una salida cuando ninguna condición es verdadera.
+
+
¿Cuándo es ideal usar un Switch en lugar de if-else?
+
Switch es ideal cuando se debe evaluar una sola variable o expresión contra múltiples valores literales. A diferencia de if-else, que es más flexible para comparaciones complejas (como mayor o menor que), Switch funciona únicamente con comparación estricta (como si usáramos el triple igual ===). Por lo tanto, al elegir entre ambos, considere:
+
+- Mayor legibilidad:
Switch para condiciones con muchas ramas predefinidas.
+- Comparaciones simples:
Switch es más eficiente para igualdad exacta.
+- Casos especiales: Use
if-else para complejidad lógica o comparaciones avanzadas.
+
+
A través del uso de Switch, los programadores pueden diseñar flujos de decisión más organizados y eficientes en situaciones donde solo se necesita verificar igualdad de valores. ¡Experimenta con él y verifica por ti mismo la agilidad que puede ofrecer a tus códigos!
+
+
+
+
\ No newline at end of file
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/05-index_de4c8b16-5dec-44cd-9c4f-a920b62de0bf.js" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/05-index_de4c8b16-5dec-44cd-9c4f-a920b62de0bf.js"
new file mode 100644
index 0000000000000000000000000000000000000000..85fd3a2c79d147cc5e8b55233a092ce122e628a9
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/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?");
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/06-Ciclo For Iteraci\303\263n de Listas y Uso de Consolelog en JavaScript.mp4" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/06-Ciclo For Iteraci\303\263n de Listas y Uso de Consolelog en JavaScript.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..be62411976c8ff774e061b6007146d71498d5dad
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/06-Ciclo For Iteraci\303\263n 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
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/06-Ciclo For Iteraci\303\263n de Listas y Uso de Consolelog en JavaScript.vtt" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/06-Ciclo For Iteraci\303\263n de Listas y Uso de Consolelog en JavaScript.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..1c105e5d3cf4786acf36930aa8ba403084745453
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/06-Ciclo For Iteraci\303\263n 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.
+
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/06-Lecturas recomendadas.txt" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/06-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..0cf45bc41c7c80805a49f0cb0b053e7e2297c6c6
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/06-Lecturas recomendadas.txt"
@@ -0,0 +1 @@
+https://github.com/platzi/basico-js
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/06-Resumen.html" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/06-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..134d113aef6b8414e980afec1e5a0875ede5392c
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/06-Resumen.html"
@@ -0,0 +1,147 @@
+
+
+
+
+
+
+ Ciclo For: Iteración de Listas y Uso de Console.log en JavaScript
+
+
+
+
+
+ Resumen
¿Cómo utilizar un bucle "for" en JavaScript?
+
El "for" es una de las estructuras más fundamentales y poderosas en JavaScript para realizar iteraciones o loops, permitiendo recorrer elementos dentro de una lista o array. Tal vez te preguntes, ¿cómo funciona y por qué es tan valioso? Aquí te lo explicaré de manera sencilla y práctica.
+
¿Qué es el método "for" y cómo estructurarlo?
+
El método "for" en JavaScript es una herramienta que nos permite repetir la ejecución de un bloque de código hasta que una condición especificada sea falsa. Consta de tres pasos principales dentro de sus paréntesis:
+
+- Inicialización: Se define una variable de control (comúnmente 'i'), asignando un valor inicial. Por ejemplo,
let i = 0.
+- Condición: Evalúa la condición que debe cumplirse para que el loop continúe. Normalmente, se compara la variable de control con una longitud. Un ejemplo es
i < lista.length.
+- Incremento: Modifica la variable de control en cada iteración, generalmente incrementándola en uno (
i++).
+
+
La estructura básica es la siguiente:
+
for (let i = 0; i < lista.length; i++) {
+
+}
+
+
¿Cómo iterar con "for" sobre un array?
+
Para hacerlo más práctico, haremos un ejemplo. Supongamos que tenemos un array con varios elementos que deseamos imprimir en la consola.
+
Ejemplo práctico de iteración con "for"
+
Primero, definimos nuestro array:
+
let lista = ["eat", "sleep", "code", "repeat"];
+
+
Luego, implementamos el loop "for":
+
for (let i = 0; i < lista.length; i++) {
+ console.log(lista[i]);
+}
+
+
Entendiendo el código
+
+- Definición del array:
lista contiene cuatro elementos de tipo cadena de texto.
+- Inicialización y condición del bucle: Comienza desde
i = 0 y sigue mientras i < lista.length (4 en este caso).
+- Iteración: Por cada ciclo,
console.log(lista[i]); imprime el elemento actual basado en el índice i.
+- Incremento:
i++ garantiza que el bucle avance al siguiente índice del array.
+
+
El resultado al ejecutar este código será:
+
eat
+sleep
+code
+repeat
+
+
¿Qué ocurre dentro del ciclo "for"?
+
Cada vez que el loop "for" se ejecuta, realiza los siguientes pasos:
+
+- Verifica la condición: Si la condición es verdadera, se ejecuta el bloque de código dentro del loop.
+- Ejecución del código: Imprime el elemento actual del array.
+- Incremento: Aumenta el valor de
i para moverse al siguiente elemento.
+- Reevaluación: Vuelve a comprobar la condición; si sigue siendo verdadera, repite el ciclo. Si no, se detiene.
+
+
Consideraciones y consejos prácticos
+
+- Simplicidad e inicialización: Usa nomenclatura consistente, como
let i = 0, para mantener claridad.
+- Evita bucles infinitos: Asegúrate de que la condición eventualmente sea falsa añadiendo un incremento adecuado.
+- Versatilidad del "for": Aunque hicimos un ejemplo básico con
console.log, el "for" puede adaptarse a tareas más complejas transformando o acumulando datos.
+
+
¡Ahora es tu turno! La práctica es clave. Intenta implementar un bucle "for" en proyectos simples para afianzar el uso de esta estructura poderosa. Y recuerda, sigue explorando y expandiendo tus habilidades en JavaScript; el aprendizaje constante abre puertas a infinitas posibilidades en el mundo de la programación.
+
+
+
+
\ No newline at end of file
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/06-index_b6ce4075-8bc9-491e-8bb3-0971a24ddf2d.js" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/06-index_b6ce4075-8bc9-491e-8bb3-0971a24ddf2d.js"
new file mode 100644
index 0000000000000000000000000000000000000000..971f5cf7f696d79a670198db0a633a76843a288a
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/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]);
+}
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/07-Iteraci\303\263n con forof en JavaScript para arrays y strings.mp4" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/07-Iteraci\303\263n con forof en JavaScript para arrays y strings.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..f554ce0d82ae53efcc39c7ab31a44f66bf19d1ee
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/07-Iteraci\303\263n 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
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/07-Iteraci\303\263n con forof en JavaScript para arrays y strings.vtt" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/07-Iteraci\303\263n con forof en JavaScript para arrays y strings.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..f724706b6578371f98d905df7b693e1d36fa755c
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/07-Iteraci\303\263n 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.
+
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/07-Lecturas recomendadas.txt" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/07-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..0cf45bc41c7c80805a49f0cb0b053e7e2297c6c6
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/07-Lecturas recomendadas.txt"
@@ -0,0 +1 @@
+https://github.com/platzi/basico-js
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/07-Resumen.html" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/07-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..c654f8a06893f94bd5c22055fdfa8451ab3c87c9
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/07-Resumen.html"
@@ -0,0 +1,126 @@
+
+
+
+
+
+
+ Iteración con for-of en JavaScript para arrays y strings
+
+
+
+
+
+ Resumen
¿Qué es el método loop for-of y cómo funciona?
+
El método loop for-of es una herramienta poderosa en programación que te permite iterar sobre objetos iterables. Aunque puede parecer complicado al principio, su aplicación se vuelve intuitiva una vez que entiendes su funcionamiento y sus aplicaciones prácticas. El nombre "for-of" ya es bastante descriptivo: se trata de recorrer elemento por elemento de una colección. En este contenido, te enseñaré a usarlo de manera efectiva.
+
¿Sobre qué tipo de objetos se utiliza for-of?
+
El for-of se utiliza sobre objetos iterables, como los arrays y strings. Estos son elementos que, por su naturaleza, están dispuestos en forma de lista que podemos recorrer o iterar. Gracias a su estructura, el for-of nos permite ejecutar código de manera repetitiva para cada elemento presente en estas colecciones.
+
¿Cuál es la estructura de for-of?
+
Para implementar un for-of, debes seguir una estructura básica:
+
+- Comienza con la palabra reservada
for.
+- Añade paréntesis
(), donde se define una variable que representa cada elemento.
+- El uso del término
of seguido del objeto iterable que estás recorriendo.
+- Finalmente, abre llaves
{} para incluir el bloque de código que se ejecutará para cada elemento.
+
+
Aquí tienes un ejemplo en código:
+
let canasta = ['manzana', 'pera', 'naranja', 'uva'];
+
+for (let fruta of canasta) {
+ console.log(fruta);
+}
+
+
En este caso, el for-of recorrerá cada elemento de la lista canasta e imprimirá "manzana", "pera", "naranja" y "uva" en la consola del navegador, una por una.
+
¿Cuáles son las ventajas de usar for-of?
+
+- Simplicidad y legibilidad: Su sintaxis es clara y directa, facilitando el seguimiento del código.
+- Versatilidad: Puede ser utilizado para cualquier objeto iterable, permitiendo un amplio rango de aplicaciones.
+- Evita errores comunes: Al manejar automáticamente los índices que controlan la iteración, se minimizan los errores potenciales en comparación con métodos más manuales.
+
+
¿Cuáles son los aspectos importantes a recordar?
+
+- Limitaciones a objetos iterables: Solo los objetos iterables como arrays y strings pueden ser utilizados, no aplica para objetos no iterables.
+- Uso práctico y específico: Recuerda que el
for-of es ideal para casos donde quieres acceder a los valores directamente, y no a los índices como ocurre con for-in.
+
+
Comprender y utilizar el for-of es una habilidad valiosa que puede mejorar significativamente la eficiencia y claridad de tu código. ¡Sigue practicando y domina su uso para convertirte en un experto en iteraciones!
+
+
+
+
\ No newline at end of file
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/07-index_415ee999-5c83-4b2a-8c39-ea8b0790bcfa.js" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/07-index_415ee999-5c83-4b2a-8c39-ea8b0790bcfa.js"
new file mode 100644
index 0000000000000000000000000000000000000000..d40187257fce6add07fa1253ff8a8e322231850d
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/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);
+}
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/08-Iteraci\303\263n sobre Objetos con forIn en JavaScript.mp4" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/08-Iteraci\303\263n sobre Objetos con forIn en JavaScript.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..19e190baef203eee29ff7f4ae28d1e4b74f0f3c6
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/08-Iteraci\303\263n sobre Objetos con forIn en JavaScript.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1e797bbfc1c1937a88cef7df279b69e1a20cb9d869c094319d1051acd89b9fc3
+size 55718947
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/08-Iteraci\303\263n sobre Objetos con forIn en JavaScript.vtt" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/08-Iteraci\303\263n sobre Objetos con forIn en JavaScript.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..7ede76c86de4c663cd1c25bfe04990bb639a3cc6
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/08-Iteraci\303\263n 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.
+
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/08-Lecturas recomendadas.txt" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/08-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..0cf45bc41c7c80805a49f0cb0b053e7e2297c6c6
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/08-Lecturas recomendadas.txt"
@@ -0,0 +1 @@
+https://github.com/platzi/basico-js
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/08-Resumen.html" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/08-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..ce0cab964bff5693586685a1454788258d92e15e
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/08-Resumen.html"
@@ -0,0 +1,165 @@
+
+
+
+
+
+
+ Iteración sobre Objetos con forIn en JavaScript
+
+
+
+
+
+ Resumen
¿Cómo utilizar el bucle forIn en JavaScript?
+
El bucle forIn es una poderosa herramienta en JavaScript, especialmente útil para iterar sobre propiedades de objetos. A diferencia del forOff, que trata con elementos iterables como arreglos y cadenas, forIn se centra en objetos innumerables. Pero, ¿por qué es tan importante entender esta distinción? Porque los objetos en JavaScript poseen propiedades, cada una con un valor asociado, y el conocimiento de cómo navegar por estas estructuras es crucial para cualquier desarrollador. Vamos a explorar en detalle cómo utilizar el bucle forIn para sacar el máximo provecho al trabajar con objetos.
+
¿Cuál es la estructura de un objeto en JavaScript?
+
Los objetos en JavaScript son estructuras de datos que permiten almacenar información de manera más compleja que los arreglos o cadenas. A diferencia de estos últimos, que son sencillamente listas de elementos, los objetos están compuestos por "propiedades" y "valores" asociados.
+
+- Propiedad: un identificador dentro del objeto.
+- Valor: cualquier tipo de dato asociado a la propiedad, que puede ser un número, string, booleano, función, u otro objeto.
+
+
Ejemplo de un objeto:
+
const listaDeCompras = {
+ manzana: 5,
+ pera: 3,
+ naranja: 2,
+ uva: 1
+};
+
+
En este caso, manzana, pera, naranja y uva son las propiedades del objeto, y los números asociados representan los valores deseados de cada fruta.
+
¿Cómo funciona el bucle forIn?
+
El forIn se utiliza principalmente para iterar sobre objetos, permitiendo acceder a todas sus propiedades y valores. La sintaxis básica del forIn es:
+
for (variable in objeto) {
+
+}
+
+
Donde:
+
+variable es la que representará cada propiedad del objeto durante la iteración.
+objeto es el objeto que estamos iterando.
+
+
Un ejemplo práctico mostrando cómo funciona:
+
const listaDeCompras = {
+ manzana: 5,
+ pera: 3,
+ naranja: 2,
+ uva: 1
+};
+
+
+for (let fruta in listaDeCompras) {
+ console.log(fruta);
+ console.log(listaDeCompras[fruta]);
+}
+
+
En este ejemplo, el bucle forIn recorre cada propiedad del objeto listaDeCompras, imprimiendo tanto la propiedad como su valor.
+
¿Por qué no usar forOff con objetos?
+
Es crucial comprender que forOff se emplea únicamente con estructuras iterables como arrays y strings. Los objetos, al no ser iterables, generan un error cuando se intenta iterar sobre ellos con forOff. Aquí se ilustra por qué usar forIn es necesario para objetos:
+
for (let fruta of listaDeCompras) {
+ console.log(fruta);
+}
+
+
+
+
El uso de forOff en un objeto lanzará un error porque JavaScript no reconoce a los objetos como colecciones sobre las cuales pueda iterar directamente. Esta diferenciación entre objetos iterables e innumerables es clave para evitar errores y garantizar que las operaciones sobre objetos se realicen correctamente.
+
Buenas prácticas al usar forIn
+
+-
+
Verificar propiedades del objeto: En casos donde estás iterando sobre objetos que pueden heredar propiedades, es recomendable verificar si la propiedad pertenece directamente al objeto.
+for (let prop in objeto) {
+ if (objeto.hasOwnProperty(prop)) {
+
+ }
+}
+
+
+-
+
Documentación clara: Al trabajar con objetos complejos, asegúrate de mantener una buena documentación sobre las propiedades y los valores que estás manejando, para facilitar la lectura y el mantenimiento del código.
+
+-
+
Considerar métodos avanzados: Aunque el forIn es útil, también existen métodos en ECMAScript más avanzados como Object.keys(), Object.values(), o Object.entries(), que pueden proporcionar un manejo más directo de las propiedades y valores de un objeto.
+
+
+
En resumen, la elección adecuada entre forIn y forOff no solo depende de la estructura de datos que estemos manejando sino también de la operación que queramos realizar, asegurando así un código eficiente y libre de errores.
+
+
+
+
\ No newline at end of file
diff --git "a/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/08-index_dee28794-1022-425a-8829-6c6370526bf3.js" "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/08-index_dee28794-1022-425a-8829-6c6370526bf3.js"
new file mode 100644
index 0000000000000000000000000000000000000000..b6b036dcdce01b5db0af6451f60d38896cc593c0
--- /dev/null
+++ "b/subir/Curso de Fundamentos de JavaScript/02-Estructuras de Control y L\303\263gica/08-index_dee28794-1022-425a-8829-6c6370526bf3.js"
@@ -0,0 +1,34 @@
+/*
+
+for in ---> objetos
+
+propiedades = valor
+
+array, string
+
+item
+
+for (varible in objeto) {
+ código
+}
+
+*/
+
+const listaDeCompras = {
+ manzana: 5,
+ pera: 3,
+ naranja: 2,
+ uva: 1,
+};
+
+for (fruta in listaDeCompras) {
+ console.log(fruta);
+}
+
+for (fruta in listaDeCompras) {
+ console.log(`${fruta} : ${listaDeCompras[fruta]}`);
+}
+
+for (fruta of listaDeCompras) {
+ console.log(fruta);
+}