YT YouTube2Text

YouTube2Text → Transcripts → Aprende JavaScript - Curso Completo desde Cero

Aprende JavaScript - Curso Completo desde Cero — Transcript

by freeCodeCamp Español · 77,530 words · 12,111 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00hola bienvenido bienvenida a este curso
0:02de iab sketch soy estefanía y en las
0:04próximas horas aprenderás paso a paso
0:07cómo programar en javascript el curso es
0:10perfecto para ti si quieres aprender a
0:12programar o si quieres repasar tus
0:14conocimientos veremos los aspectos
0:16principales de este lenguaje de
0:18programación paso a paso con ejemplos y
0:20ejercicios los temas están basados en el
0:23currículum de freak orcam así que si
0:26deseas practicar tus conocimientos
0:27puedes hacer clic en el enlace que está
0:30en la descripción y resolver ejercicios
0:32adicionales interactivos así que
0:35comencemos
0:39como puedes instalar javascript en tu
0:41dispositivo en realidad no están las
0:44llaves script en tu dispositivo como
0:47instalar y hasta el tono otros lenguajes
0:48de programación sino que javascript se
0:51ejecuta en los browsers
0:56en el browser que usas para acceder a
0:58internet como por ejemplo google chrome
1:00todos los browsers web modernos ejecutan
1:04código de javascript así que puedes
1:07ejecutar el código de javascript en una
1:09gran variedad de dispositivos y de
1:11sistemas operativos
1:12veamos algunas opciones para ejecutar tu
1:15código algunas de las opciones incluyen
1:17descargar editores de código por ejemplo
1:21una alternativa buenísima es 10 code
1:25pujol estudio code una herramienta que
1:27te va a permitir escribir tu código de
1:29javascript y luego vas a poder
1:31ejecutarla en un browser lo primero que
1:34debes hacer
1:35para poder escribir y ejecutar tu código
1:39de javascript es crear un archivo
1:42index.hr ml este tipo de archivo html
1:46cuando se combina con esto que tenemos
1:49aquí nos va a permitir ejecutar el
1:51código en el browser como creas un
1:53archivo en 10 con haces clic en find you
1:56file un archivo nuevo
1:59vas a ver algo parecido a esto y luego
2:02los guardas
2:05seis bajas o seis y le asignas un nombre
2:09que debe terminar con punto h tm l eso
2:14define el tipo de archivo que estás
2:16creando
2:17html normalmente se usa para desarrollo
2:20web en este caso nosotros lo vamos a
2:22usar para poder escribir nuestro código
2:24de javascript y ejecutarlo al hacer clic
2:27sobre el archivo dentro de ese archivo
2:30debes escribir esto que tenemos aquí dos
2:33etiquetas que se llaman etiquetas script
2:35ellas le dicen al browser que este
2:39código que tenemos aquí en el medio
2:42entre esas etiquetas
2:43corresponde a código de javascript así
2:46que debe ejecutarlo como un código de
2:48javascript en este caso esta línea va a
2:52mostrar el mensaje hola mundo en lo que
2:54nosotros llamamos la consola que es
2:57donde vamos a ver el resultado de
2:59nuestro código gracias a esta función
3:01que tenemos aquí una vez que tienes tu
3:04archivo
3:06index.html no necesariamente el nombre
3:08tiene que ser index pero normalmente es
3:10un estándar usado comúnmente en
3:13desarrollo web hace doble clic en mi
3:15caso yo tengo google chrome hace doble
3:17clic y luego para ver el resultado de
3:21ese código hay dos opciones o usas el
3:24atajo del teclado
3:32aquí puedes ver un panel y aquí vas a
3:34ver tu mensaje el resultado de tu código
3:37si haces clic en control y giras la
3:40ruedita del mouse puedes ver el mensaje
3:43con una letra más grande estas son las
3:46herramientas de desarrolladores de camps
3:48y allí podemos ver el resultado de
3:50nuestro código otra forma de abrir este
3:53panel es hacer clic derecho luego hacer
3:56clic en inspector y aquí vemos cançó y
3:59vemos nuevamente el mensaje hola mundo
4:02esas son alternativas en las que tienes
4:03que instalar el editor de código en tu
4:06dispositivo pero otra alternativa
4:09buenísima el editor de código que
4:11tenemos en frica simplemente ingresas a
4:13la página de frisco el cam punto org sly
4:16en español y haces clic aquí empieza es
4:19gratis luego de esto vas a hacer clic
4:22aquí en la certificación de algoritmos
4:24de javascript y estructuras de datos vas
4:27a entrar aquí y donde dice cursos en
4:29javascript básico puedes hacer clic en
4:32cualquiera de estos retos nosotros
4:34necesitamos usar este panel que tenemos
4:37aquí blanquito que es donde podemos
4:39escribir nuestro código y el resultado
4:42se va a mostrar aquí abajo cuando lo
4:44escribamos por ejemplo puedes ver con su
4:46punto lo hola mundo aquí ves el
4:49resultado hola mundo aquí tenemos la
4:52descripción del ejercicio que
4:53corresponde pero si solo que debemos
4:55usarlo como un editor de código podemos
4:58arrastrar esta parte hacia la izquierda
5:01y ya tenemos nuestro editor si queremos
5:05aumentar el tamaño de la letra podemos
5:07aquí y aquí podemos ver el resultado en
5:10la consola
5:11este es el editor de código que yo voy a
5:13usar durante el curso puedes usar
5:16cualquiera de estas herramientas todas
5:18son buenísimas y te van a permitir
5:20escribir y ejecutar tu código de ya
5:23busquets ya estás muy cerca de comenzar
5:25a aprender javascript así que pasemos a
5:29nuestro primer tema del curso
5:33comenzamos con nuestro primer tema del
5:35curso
5:36lo primero que veremos sobre javascript
5:38van a ser los comentarios que es un
5:40comentario un comentario es una parte de
5:43nuestro código que en realidad no es
5:45código cuando el programa se ejecuta
5:48simplemente se ignoran y ellos sirven
5:51para darnos precisamente comentarios o
5:54datos sobre el código para nosotros y
5:56para otros desarrolladores normalmente
5:59nuevos comentarios explicamos un poquito
6:00más sobre la lógica del código sobre lo
6:04que alguna línea representa un bloque de
6:06código en javascript podemos crear un
6:09comentario de una línea con este par de
6:11símbolos una doble barra puedes ver que
6:14es su color cambia a verde y aquí
6:17podemos escribir comentarios de una
6:19línea esto es simplemente lo que
6:22nosotros queramos escribir para
6:24describir nuestro código este par de
6:26símbolos las barras inclinadas
6:28convierten todo el resto de la línea en
6:30un comentario así que todo esto va a ser
6:33ignorado y solo se va a tomar como un
6:35comentario si nosotros escribimos código
6:38por ejemplo digamos esta línea de código
6:42que vas a aprender en un próximo tema en
6:44unos minutos esta parte de la línea si
6:47se consideraría código y se va a
6:49ejecutar cuando ejecuta el programa pero
6:52esta parte no se va a ejecutar y no se
6:55va a tomar como parte del código
6:57simplemente se va a ignorar también
6:59podemos escribir comentarios de varias
7:01líneas y cómo lo podemos hacer bueno
7:03abrimos el comentario con una barra
7:06seguido de un asterisco y allí podemos
7:09escribir lo que queramos para describir
7:11nuestro código por ejemplo este es un
7:13comentario de varias
7:18líneas para cerrar el comentario y
7:21decirle al programa que ya allí terminó
7:24nuestro comentario y queremos empezar a
7:25escribir código escribimos este par de
7:28símbolos en el orden opuesto primero el
7:30asterisco y luego la barra
7:33y puedes ver que antes teníamos como un
7:35pequeño error aquí que desaparece cuando
7:37cerramos el comentario también este
7:40comentario puede tener cualquier número
7:41de líneas lo importante es que abramos
7:44el comentario con estos dos símbolos y
7:45los cerremos posteriormente puede estar
7:48en la misma línea puede estar en una
7:49línea diferente y todo lo que está en el
7:52medio se va a considerar como un
7:53comentario y se va a ignorar genial
7:56pasemos a nuestro siguiente tema ya
7:58vamos a empezar a ver cómo escribir
8:00código en javascript
8:04en ya ves que tenemos que trabajar con
8:07valores y esos valores tienen un tipo
8:10específico de datos cada uno de ellos
8:12dependiendo de su propósito dentro del
8:15código incluyendo and find no no
8:19significa nulo en español lo podemos ver
8:22cuando un objeto en el código es nulo no
8:25existe donde find lo vamos a ver
8:28frecuentemente en el curso y normalmente
8:31lo encontramos cuando no existe un valor
8:34asignado
8:35julián es un tipo de datos que en
8:38español lo denominamos buljan o los
8:41valores de verdad verdadero y falso true
8:44y fowles en inglés strange es el tipo de
8:47dato que usamos para representar cadenas
8:50de caracteres
8:51tiempo este tipo de datos no lo vamos a
8:54usar durante el curso pero si te invito
8:57si tienes curiosidad a investigar más
8:58sobre este tipo de dato en la
9:00documentación number significa el número
9:03en español se usa para representar un
9:05número en nuestro código y object se usa
9:08para representar un objeto un objeto es
9:11una estructura que nos va a permitir
9:13relacionar propiedades y funciones bajo
9:16una misma estructura que llamamos objeto
9:18bien vamos a comenzar hablando sobre el
9:21concepto de variable veámoslo aquí una
9:25variable es como una cajita donde
9:27podemos guardar un valor en la realidad
9:31una variable lo que hace es crear un
9:33espacio la memoria del dispositivo para
9:36que guardemos un valor específico en ese
9:38lugar de memoria como lo podemos crear
9:41ya busquets usamos la palabra clave para
9:45luego escribimos el nombre de la
9:47variable en este caso podría ser mi
9:50variable oa un número
9:54durante el curso no vamos a incluir
9:57acentos en el código que esto lo vamos a
10:01hacer a propósito porque normalmente
10:03intentamos no introducir caracteres que
10:06no sean estándar el inglés en nuestros
10:08proyectos para evitar cualquier tipo de
10:10problema que pueda haber ahora nuestro
10:13ejemplo va a ser var mi variable y a esa
10:17variable le vamos a asignar un valor lo
10:19hacemos con este símbolo que tenemos
10:21aquí y de igual esto se llama el
10:23operador de asignación
10:25asigna un valor a esta variable
10:28digamos que queremos asignar este valor
10:31recall camps como puedes ver está en
10:33otro color porque lo rodeamos con
10:35comillas cuando rodeamos una secuencia
10:38de letras o de caracteres entre comillas
10:41estamos creando una cadena de caracteres
10:44que es otro tipo de datos uno de los
10:47tipos de datos que acabamos de ver
10:49ese valor lo vamos a asignar a la
10:52variable y por lo tanto como tenemos ya
10:55la variable creada en nuestro programa
10:57podemos acceder a ella y usar su valor
11:00en el programa por ejemplo podemos
11:03mostrarla en algo que llamamos la
11:05consola para mostrar ese valor y poder
11:08verlo ver que la variable en verdad
11:10tiene este valor podemos llamar a esta
11:13función console que en español significa
11:16consola seguida de un punto y lo que
11:19esto nos va a permitir mostrar el valor
11:22que pasemos entre paréntesis y también
11:26ella va a escribir es importante
11:27resaltar que estas líneas deberían
11:29terminar en punto y coma si abrimos aquí
11:32la consola esto lo que vamos a denominar
11:35la consola que va a ser el lugar donde
11:38vamos a ver el resultado de nuestro
11:40código por ejemplo aquí estoy mostrando
11:42el valor de mi variable y podemos ver
11:45ese valor aquí en la consola se
11:47actualiza automáticamente
11:49el valor de mis variables es free col
11:51cam en este momento en este punto del
11:54código de la ejecución del programa ese
11:57valor puede cambiar
12:00digamos que ahora en lugar de una cadena
12:03de caracteres queremos asignarle un
12:05número entero a esa variable escribimos
12:09el nombre de la variable seguido de un
12:11signo igual y el valor nuevo que
12:13queremos asignar
12:15nuevamente podemos mostrar ese valor
12:17para confirmar que se actualizó
12:20vemos el valor inicial bricor camps y
12:23luego 16 que es el nuevo valor de la
12:25variable así podemos asignar cualquier
12:28valor que queramos a la variable por
12:31ejemplo un número negativo por ejemplo
12:34un valor de verdad ya que significa
12:37verdadero en español false que significa
12:40falso en español o cualquier otro tipo
12:42de valor con el cual queramos trabajar
12:46también podemos asignarle un nombre
12:48descriptivo a la variable por ejemplo si
12:52queremos crear una variable que contenga
12:55un nombre digamos mi nombre estefanía el
13:00nombre de esta variable debería ser
13:03descriptivo de su valor de lo que
13:05representa ese valor porque este nombre
13:09de la variable es el que vamos a usar en
13:11todo nuestro programa donde necesitemos
13:13usar este valor y si por ejemplo
13:16asignamos un nombre que no sea
13:18descriptivo por ejemplo o equis hoya y
13:22usamos esta variable en la línea digamos
13:25una línea 500 del programa no vamos a
13:29saber a qué nos estamos refiriendo que
13:31representa este valor por lo tanto
13:34siempre se recomienda ser descriptivo
13:36otra cosa importante es que en llaves
13:39que usamos esta convención para los
13:42nombres de las variables cuando tienen
13:44más de una palabra la primera letra de
13:48cada palabra comienza con mayúscula y la
13:51primera letra en general comienza con
13:53minúscula esta convención se llama como
13:57case
13:58en inglés como case porque se asemeja a
14:02las jorobas de un camello pero recuerda
14:04que la primera letra es minúscula y
14:06después para cada palabra la primera
14:09letra es mayúscula sin espacios esto no
14:11puede estar separado por un espacio
14:13porque si no tendríamos un error
14:16bien también tenemos otras alternativas
14:20para definir esta variable en lugar de
14:23pagar podemos usar la palabra clave let
14:26o la palabra clave const son tres
14:29alternativas pero vamos a hablar más
14:32sobre sus diferencias durante el curso a
14:34medida que aprendas más conceptos y cómo
14:36se usan las variables en programación
14:40genial
14:41si quieres actualizar este valor a tu
14:43nombre y vas a ver cómo se muestra en la
14:45consola pasemos a nuestro siguiente tema
14:51ok vamos a hacer un repaso rápido de
14:54cómo podemos asignar un valor a una
14:57variable esta línea es válida en java 7
15:00estamos creando la variable a en nuestro
15:03programa usando la palabra clave par y
15:06después tenemos var
15:08igualados puedes ver que hay una
15:11diferencia entre estas dos líneas en
15:13esta no estamos asignando ningún valor y
15:16aquí estamos asignando le el valor a la
15:19variable me la estamos creando y a la
15:22misma vez le estamos asignando un valor
15:25qué pasa si nosotros queremos mostrar la
15:28variable
15:29y mostrar la variable b en este punto en
15:33estas líneas del programa hasta este
15:35momento puedes ver que no tiene un valor
15:38asignado así que podemos predecir que
15:41esto va a resultar en un error pero con
15:44la variable b si podemos trabajar porque
15:48tiene un valor así que podemos mostrarla
15:51en la consola si mostramos estos valores
15:53en la consola podemos ver que en lugar
15:55de un error tenemos un valor que se
15:57denomina and spain recuerdas que
16:00anteriormente vimos los tipos de datos
16:02que pueden usar en java esker y uno de
16:04esos eras on the fine and find es el
16:07valor que se asigna por defecto a una
16:09variable cuando no le asignamos un valor
16:11solo la estamos creando eso lo vamos a
16:14ver más adelante con más detalle en sólo
16:17unos minutos cuando veamos cómo declarar
16:19una variable pero aquí estamos
16:21trabajando con una variable p que si
16:23tiene un valor asignado y por eso
16:26tenemos el valor 2 aquí
16:29genial ya sabes que las variables tienen
16:31un valor que se asigna por defecto que
16:33se llama audi find que nos dice que la
16:35variable todavía no tiene un valor
16:37asignado ahora vamos a cerrar la consola
16:39y vamos a ver cómo podemos asignarle un
16:42valor a la variable y ya la tenemos aquí
16:45creada ya esta es parte de nuestro
16:48programa pero no tiene un valor todavía
16:50es donde find el val el valor será dios
16:53y como lo asignamos con este signo igual
16:56que se denomina el operador de
16:58asignación déjame escribir el comentario
17:01aquí para que lo veas visualmente
17:04ese es el signo igual el operador de
17:06asignación en javascript que asigna el
17:08valor que está a la derecha a la
17:10variable que está a la izquierda
17:12si nosotros tratamos de mostrar el valor
17:15de esta variable luego de asignarle el
17:18valor vamos aquí a quitar esta línea ya
17:21no necesitamos trabajar con b solo vamos
17:24a mostrar el valor de a antes de
17:26asignarle un valor y el valor de luego
17:29de la asignación debería tener un valor
17:32ahora si abrimos la consola vemos que
17:35antes el valor de un default y ahora el
17:38valor es 10 y le asignamos este valor a
17:41la variable y podemos trabajar con ella
17:43en nuestro programa
17:48bien ahora veamos cómo puedes asignar el
17:51valor de una variable a otra variable si
17:55definimos una variable a con el valor 5
17:59creamos otra variable b y vamos a
18:02tenerla con punto y coma pero esta vez
18:04en lugar de escribir un valor en este
18:06lugar preciso de la línea vamos a
18:09escribir el nombre de la variable que
18:11definimos anteriormente la variable a
18:14esa variable tenía el valor 5 y como
18:18podemos trabajar con esa variable y
18:20usarla en nuestro programa también
18:21podemos asignar la a otra variable en
18:24este caso vamos a asignar a la variable
18:26be en realidad estamos asignando en su
18:29valor estamos asignando 5 a b así que
18:33vamos a comprobar todo esto que estamos
18:35diciendo
18:36usando con su punto lo que vamos a
18:39mostrar el valor de a y después vamos a
18:41mostrar el valor de p
18:43si abrimos la consola vemos aquí los dos
18:46números 5 y 5 ambos tienen el mismo
18:49valor porque 5 inicialmente era el valor
18:52de a luego lo asignamos a b y ambos
18:55tienen el mismo valor
18:57también existe otra versión alternativa
19:00de cómo podemos asignar el valor de una
19:02variable a otra y otra vez declaramos la
19:05variable a y le asignamos un valor
19:06tenemos la misma línea pero esta vez
19:08vamos a cambiar la segunda línea en
19:11lugar de asignarle un valor directamente
19:13vamos solamente a crear ese nombre en
19:15nuestro programa de esta forma usamos la
19:18palabra clave pagar el nombre de la
19:20variable y luego punto y coma y qué es
19:23lo que vamos a hacer en lugar de
19:25asignarlo directamente en la misma línea
19:27podemos asignarlo en otra línea distinta
19:31ya una vez que las hemos creado en el
19:34programa podemos trabajar con ellas en
19:36cualquier línea que necesitemos así que
19:38podemos asignar el valor de a a la
19:40variable ve nuevamente si mostramos el
19:43valor de a y mostramos el valor de b
19:46abrimos aquí la consola podemos ver los
19:48dos valores 5 y 5 así que el efecto fue
19:52exactamente el mismo podemos asignarlo
19:54en una línea distinta o podemos
19:56asignarlo directamente aquí genial ya
19:59sabes cómo asignar el valor de una
20:00variable a otra sabes que así que
20:03comencemos con nuestro siguiente tema
20:09ahora que ya sabes cómo funciona todo
20:11este proceso de crear variables
20:13declararlas y asignarles valores vamos a
20:16repasar la terminología técnica antes de
20:18seguir con nuestro siguiente tema del
20:20curso lo primero que vamos a hacer es
20:22declarar una variable x pero no sólo
20:25estamos declarando declarar significa
20:27solamente crear el nombre en nuestro
20:29programa que sería algo así lo vamos a
20:33ver más adelante sería algo así sino que
20:35también le estamos asignando un valor en
20:37el mismo momento que la estamos
20:39declarando cuando nosotros asignamos un
20:43valor a la variable la estamos inicial
20:45izando
20:46inicial izando la variable o inicializar
20:52la variable en este caso estamos inicial
20:54izando la variable x con el valor 9 la
20:58estamos creando ya la misma vez estamos
21:00asignando un valor por ejemplo podemos
21:03tener esta variable mi idioma español y
21:08punto y como al final de la línea de
21:10aquí tenemos una cadena de caracteres y
21:12como puedes observar también esto es muy
21:13importante en javascript nosotros
21:16seguimos una nomenclatura que se
21:18denomina kabul que es
21:21si la palabra que estamos escribiendo el
21:24nombre de la variable tiene más de una
21:25palabra la primera palabra comienza con
21:29minúscula y después cada una de las
21:31palabras inicia con mayúscula entonces
21:34visualmente estamos separando las
21:35palabras con las mayúsculas y esa es una
21:38nomenclatura estándar que usamos por
21:40convención en javascript no
21:42necesariamente necesitas usar o sea
21:44funcionalmente separar las palabras con
21:47un andrés cold con un guión bajo va a
21:49funcionar pero normalmente en javascript
21:52usamos esta convención genial recuerda
21:56que también para definir una variable
21:58puedes usar las palabras let y con esto
22:00las vamos a ver en más detalle más
22:02adelante en el curso así que pasemos a
22:05nuestro siguiente tema
22:11ahora vamos a ver otro término
22:12importante en programación que debes
22:15saber es de una variable no inicializa
22:18da
22:19este es el término que usamos para
22:21referirnos a una variable que todavía no
22:23tiene un valor asignado si nosotros
22:25declaramos una variable aquí y creamos
22:29ese nombre en nuestro programa le
22:31asignamos un espacio en memoria
22:33esa variable no ha sido inicializa da
22:36porque no tiene un valor
22:38recuerda que el valor asignado es andy y
22:41find luego vamos a verificar el valor de
22:45amd
22:46aquí podemos ver que el valor es andy
22:48find porque no hemos asignado un valor
22:50no está inicializa da esa variable
22:53entonces vamos a asignarle un valor el
22:56valor de a base de 56 una vez que ya le
22:59asignamos el valor esta variable podemos
23:02mostrar el valor en la consola y aquí
23:05vemos el número 56 genial ya podemos
23:08comenzar con nuestro siguiente tema ya
23:10sabes declarar variables como asignarles
23:12valores y sabes la diferencia entre
23:14variables inicializa das y variables no
23:17inicializa das
23:21bien ahora veamos una característica muy
23:23importante de javascript que debes saber
23:25cuando estás escribiendo tu código sabes
23:28que es un lenguaje de programación que
23:30es sensible a las mayúsculas y las
23:32minúsculas una mayúscula no es
23:34equivalente a una minúscula en un nombre
23:36que tú crees en el código ya vas a ver a
23:39qué me refiero con esto debes tener
23:41mucho mucho cuidado porque puede ser la
23:44diferencia entre tener un error en el
23:45código y que el código funcione
23:47correctamente
23:48si nosotros definimos una variable con
23:51la palabra clave bar y le asignamos un
23:54nombre en este caso va a ser mi variable
23:56y también le asignamos un valor 5 o sea
23:59que está inicializa da la variable vamos
24:02a ver qué pasó si nosotros tratamos de
24:04referirnos a esa variable en nuestro
24:06programa con otra combinación de
24:08mayúsculas de minúsculas
24:09inicialmente puedes pensar que si
24:12escribimos mi variable con otra
24:13combinación de mayúsculas y minúsculas
24:15se puede reconocer pero en este caso no
24:19es así sino si nosotros aquí escribimos
24:23ese mismo nombre todo en mayúsculas qué
24:27es lo que vamos a tener un error si
24:29vemos aquí en la consola tenemos
24:31reference el error de referencia mi
24:35variable que es el nombre que usamos
24:37aquí y es not different significa que
24:40esa variable no está definida en el
24:42programa porque porque no hay ningún
24:44nombre con esa combinación de mayúsculas
24:46y minúsculas definida esta combinación
24:49específica es la que hemos definido
24:51veamos otro ejemplo si tratamos de
24:54cambiar la combinación digamos comenzar
24:56con una mayúscula y que el resto de las
24:57letras sean minúsculas
24:59también vamos a tener el mismo error
25:02vamos a comentar esta línea
25:05error de referencia mi variable que es
25:08ahora este nombre que estamos usando
25:10aquí en conxunto log y es notifight no
25:13está definida esta variable en nuestro
25:15programa
25:16comentemos esta línea y vamos a ver otra
25:20combinación tú también puedes intentarlo
25:22se está siguiendo el curso de forma
25:24interactiva con el editor de código
25:25prueba cualquier combinación por ejemplo
25:28me come pequeña variable esto también
25:32resultará en un error si abrimos la
25:34consola aquí vemos error de referencia
25:36ni variable no está definida pero quizás
25:40también te preguntes si escribir la
25:42variable todo en minúscula si funciona
25:45en quizás bueno vamos a ver qué pasa
25:48esto también va a resultar en un error
25:51tiene que ser la combinación exacta de
25:53mayúsculas y minúsculas aquí puedes ver
25:55error de referencia mi variable en
25:58minúscula no está definida genial ya
26:01sabemos que el nombre de la variable
26:02tiene que ser exactamente como lo
26:04escribimos en nuestro programa así que
26:07vamos a copiar y pegar este nombre
26:09para mostrarlo en la consola aquí
26:12finalmente podemos ver el valor de la
26:14variable que es 5
26:16esa es la variable que nosotros
26:17definimos y es la única que va a
26:19reconocer el programa con su convención
26:21su combinación específica de mayúsculas
26:23y minúsculas y esto es lo que en inglés
26:25se denomina case sensitive es una forma
26:29de referirnos a que es sensible a
26:31mayúsculas y minúsculas en los nombres
26:33del programa
26:38bien ya podemos tachar variables en
26:40javascript de nuestra lista de temas
26:42pendientes así que vamos a comenzar a
26:45ver las operaciones aritméticas en
26:47javascript
26:49así que vamos a comenzar primero veremos
26:53la suma cómo podemos sumar dos números
26:56en ya busquets primero que todo lo más
26:59útil es definir o declarar una variable
27:02para guardar el valor de esa suma para
27:05que podamos utilizarla en nuestro
27:07programa sino si solamente la mostramos
27:09en la consola se va a perder y no la
27:11podemos usar después como podemos hacer
27:14esto primero declaramos la variable como
27:17tenemos aquí luego con el operador de
27:19asignación
27:21vamos a asignar el resultado de la suma
27:25por ejemplo 7 + 12 usamos el símbolo de
27:30suma ese mismo símbolo es el que se usa
27:32para sumar dos valores en java es que
27:35normalmente también se recomienda dejar
27:37un espacio a cada lado del operador para
27:40que sea más fácil de leer el código si
27:43no dejamos estos espacios igual va a
27:45funcionar pero va a ser más difícil de
27:46leer así que ya que tenemos el valor de
27:50la suma podemos mostrar la vamos a ver
27:52cuál es el resultado con con su punto lo
27:55que si abrimos la consola aquí vemos el
27:57valor 19 que es exactamente el resultado
28:00de 7 + 12
28:06ahora veamos cómo puedes restar un
28:07número de otro en javascript
28:11normalmente asignamos el resultado a una
28:13variable así que vamos a declarar la
28:15aquí y vamos a inicializar la con un
28:18valor pero cual valor va a ser el
28:20resultado de restar
28:2215 menos 5 para eso usamos el guión que
28:26es el símbolo de restar símbolo del
28:28resto también se usa en house que en
28:32este caso vamos a tener un resultado
28:34positivo
28:35y podemos mostrarlo en la consola resta
28:40tenemos aquí el valor 10 15 5 10 ahora
28:45vamos a ver si podemos actualizar el
28:47valor de esta variable a un valor
28:49negativo en este caso vamos a invertir
28:51el orden de los operan dos de los
28:54valores que usamos en la operación vamos
28:57a restar 5 menos 15 en este caso el
29:01resultado va a ser negativo vamos a
29:03mostrar el valor actualizado de la
29:06variable resta aquí asignamos un valor
29:09inicial pero aquí estamos cambiando ese
29:11valor
29:12inicialmente era 10 porque es que
29:14restamos 15 menos 5 y después actualizó
29:17a menos 10 en esta línea esta línea la
29:19actualiza y aquí se muestra el valor
29:23genial ahora confirmamos que el
29:25resultado puede ser 0 restamos 15 menos
29:2915 el resultado va a ser cero pero
29:33comprobemos esto una vez más y si vemos
29:37la consola
29:3810 -
29:401000 es el que tenemos acá el resultado
29:42de 15 menos 15
29:48también podemos multiplicar dos números
29:50en java es que vamos a ver cómo podemos
29:52hacerlo cuál es el operador primero
29:55definimos una variable producto para
29:57guardar el resultado y luego vamos a
30:00hacer la operación vamos a multiplicar 5
30:02por 3 el operador que usamos para
30:05multiplicar es este que tenemos aquí el
30:08asterisco
30:09siempre a cada operador aritmético se
30:11recomienda rodearlo con un espacio a
30:14cada lado para que sea más fácil leer
30:16esa expresión esa secuencia de valores y
30:20operadores aquí multiplicamos 5 por 3 y
30:24luego vamos a mostrar el resultado
30:26producto
30:28y vemos el valor 15 que tenemos por acá
30:31exactamente lo que esperábamos luego
30:34podemos actualizar ese valor vamos a
30:37actualizar el valor de la variable
30:39producto al resultado de multiplicar por
30:41ejemplo 9 por 0
30:43sabemos matemáticamente que todo número
30:46x 0 a 0
30:48así que si abrimos la consola aquí
30:50podemos ver que el segundo resultado fue
30:52de 0 también podemos tener operaciones
30:55en las cuales el resultado es negativo
30:58vamos a ver menos 5 por 6 bien aquí
31:02tenemos esto menos 5 por 6 debería ser
31:04menos 30 asignamos ese resultado la
31:07variable producto y la mostramos
31:11aquí podemos ver los -30 es el tercer
31:14valor que mostramos en la consola el
31:17resultado del producto el signo correcto
31:20se va a conservar dependiendo de las
31:21operaciones matemáticas que correspondan
31:24aquí puedes verlo el tercer número que
31:26tenemos aquí es 30 que es este número el
31:30resultado de este producto de dos
31:32números negativos es positivo genial ya
31:35sabes cómo multiplicar dos números en
31:37javascript
31:42y finalmente para cubrir las cuatro
31:44operaciones aritméticas básicas veamos
31:47cómo puedes dividir un número entre otro
31:49en javascript bien primero vamos a
31:52definir la variable consciente y le
31:55vamos a asignar el resultado de una
31:57división así que vamos a dividir los
32:00números 20 y 220 entre 2 el resultado es
32:04díaz y este es el valor que vamos a
32:06guardar en la variable cociente con su
32:09punto loc
32:11consciente vamos a mostrar este
32:13resultado vemos que es un número entero
32:15r el valor es 10 bien luego podemos
32:19actualizar el valor de ese cociente
32:21digamos que el resultado no es un número
32:23entero sino un número decimal también
32:26podemos manejar este caso en javascript
32:28podemos dividir 17 entre 31 y mostrar
32:32ese resultado consciente aquí puedes ver
32:35que el resultado tiene muchos muchos
32:38muchos decimales para poder representar
32:39esa fracción pero el número de decimales
32:42es finito porque la computadora puede
32:45guardar un número finito de decimales el
32:48número final es el resultado de
32:50redondear una secuencia de números que
32:53estaría por acá ese no pero no es
32:56exactamente este que tenemos acá esta es
32:58una aproximación y finalmente vamos a
33:01ver este caso que seguro que te debes
33:03estar preguntando qué va a pasar si
33:05intentamos dividir entre 0 lo cual no
33:08está definido matemáticamente vamos a
33:11tener algo que es ciertamente inesperado
33:15lenguaje de programación es algo que sea
33:17tan intuitivo uno pensaría inicialmente
33:20que habría un error pero vamos a ver
33:22cuando vemos el valor que se ha asignado
33:25a la variable cociente vemos infinity
33:28inferir significa infinito equivalente
33:32infinito en español porque estamos
33:35dividiendo entre 0 entonces
33:36jobsket en vez de dar un error generar
33:39un error retorna este valor que
33:41representa el infinito
33:47también puedes crear números decimales
33:50en javascript y ellos van a ser muy
33:53útiles para representar este tipo de
33:55número de nuestro programa veamos un
33:58ejemplo podemos definir una variable que
34:01se llame mi número decimal y para crear
34:04el número decimales en el programa
34:06simplemente escribes tu número con un
34:09punto ese punto que separa la parte
34:12entera de la parte decimal del número
34:15nos dice inmediatamente que estamos
34:18trabajando con un número decimal en el
34:20programa veamos un ejemplo con más
34:22contexto por ejemplo quisiera
34:24representar un peso en un programa
34:27digamos 78 puntos 34 kilos ese peso lo
34:32puede representar usando un número
34:34decimal
34:35inmediatamente cuando veas el punto aquí
34:37separando la parte entera de la parte
34:39decimal estás trabajando con un número
34:42decimal en javascript
34:44bien ya sabes cómo crear números
34:46decimales en javascript ahora veamos
34:49cómo puedes realizar las operaciones
34:51aritméticas básicas con estos valores
34:58también puedes operar con los números
35:00decimales de igual forma que opera o
35:03realiza operaciones aritméticas con los
35:05números enteros
35:06veamos cómo puedes multiplicar dos
35:08números decimales en javascript
35:10vamos a definir o declarar nuestra
35:12variable y multiplicamos por ejemplo 3.4
35:16x 10.4
35:18veamos el resultado de este producto
35:20vamos a mostrarlo en la consola aquí
35:23podemos ver el resultado
35:2535.36 es el resultado de este producto
35:29multiplicamos dos valores decimales y el
35:31resultado es un número decimal ahora
35:34podemos actualizar ese variable para
35:36hacer distintos tipos de operaciones
35:38para que veas cómo podemos operar con
35:41este tipo de datos podemos multiplicar
35:44por ejemplo un número decimal por un
35:46número entero 2.4 por 4 y eso también
35:50nos va a retornar un número décima aquí
35:54podemos ver que el resultado es 9.6
35:57vamos a ir ir comentando estas líneas
36:00para sólo mostrar el producto que
36:03estamos mostrando en el momento con el
36:05que estamos trabajando
36:07podemos invertir el orden también en el
36:09primer factor podría ser un número
36:11entero y el segundo un número decimal y
36:14así mostramos el producto en este caso
36:18podemos ver el redondeo que ocurre este
36:21producto no se puede representar como un
36:24número decimal con finitos decimales o
36:27la computadora tiene que aproximar ese
36:29valor entonces como no lo puede
36:31representar 100% de forma exacta lo
36:34representa con cierto número de
36:36decimales y en este caso vemos que es un
36:374 seguido en muchos ceros y un 6 al
36:40final en teoría el resultado si lo
36:43hacemos manualmente sería
36:4553.4 pero la computadora no puede
36:48representarlo de forma exacta así que
36:50representa una aproximación
36:52también podemos multiplicar por cero
36:56digamos que queremos multiplicar 3.6 por
36:58cero esta operación es completamente
37:01válida así que el producto si comentamos
37:04aquí esto y sólo ejecutamos esta línea
37:07sería 0 también el 0 se puede
37:10representar como un número décima
37:13es equivalente en este caso son dos
37:15tipos distintos de datos pero el valor
37:18es el mismo
37:20y también podemos tener un producto que
37:23sea un resultado negativo 5.7 x 3.4
37:31aquí comentamos esta línea y finalmente
37:34aquí tenemos aquí tenemos el resultado
37:36menos 19.38 negativo porque uno de los
37:40factores es negativos
37:47otra operación aritmética que podemos
37:49realizar con los números decimales en
37:51javascript es dividir los números
37:53decimales así que vamos a ver cómo
37:55puedes hacerlo tenemos un cociente de
37:57números decimales y aquí podemos dividir
38:00por ejemplo 5.0 entre 2.0
38:04ahora puedes pensar algo específico
38:07porque yo estaré interesado o interesada
38:10en representar este valor con un punto
38:13cero si en verdad no existe el decimal
38:15no hay un decimal yo puedo escribir esto
38:17así como un 2 y el resultado es
38:20exactamente el mismo tienes razón pero
38:22la diferencia del tipo de datos que
38:24estamos usando por ejemplo aquí este
38:27dato se representa como un número
38:28decimal un flow pero este dato es un
38:32entero
38:33entonces se representan de forma
38:35distinta en el programa vamos a ver si
38:38cambiar ese tipo de datos cambia algo en
38:41el resultado vamos a mostrar el cociente
38:43vemos que si dividimos los dos flautas
38:47los dos números decimales el resultado
38:49es 2.5
38:50pero si dividimos los dos enteros en
38:53resultados también es 2.5 así que en
38:56este caso es equivalente
38:57ahora actualizamos esta variable al
39:00cociente entre dos puntos 3 y 6.7
39:04estamos dividiendo dos números decimales
39:06que seguramente van a resultar en un
39:09número decimal
39:11redondeado porque no va a poder ser
39:13representado de forma exacta vamos a ver
39:17comentó esta línea para que solo se
39:20muestre esta línea aquí podemos ver la
39:23aproximación de este número es un número
39:25con muchísimos muchísimos decimales y
39:28este 3 seguramente es el resultado de un
39:30redondeo también podemos intentar ver
39:33qué ocurre si dividimos un número
39:35decimal entre 0.0
39:38cambiará en algo el resultado vamos a
39:41ver recuerda que cuando deberíamos entre
39:430 el valor asignado era infinito o
39:46infinito y no no hay cambio el valor es
39:49infinito también las reglas de los
39:52signos se van a preservar en la división
39:59ahora veamos cómo puedes obtener el
40:01resto de una división en ya ves que esta
40:04operación es particularmente importante
40:06cuando queremos verificar si un número
40:08es par o impar vemos aquí una variable
40:12que se va a denominar resto como podemos
40:15obtener el resto de dividir 15 entre 5
40:19bueno con este operador el símbolo de
40:21porcentaje es el operador que nos
40:24permite obtener el resto de la división
40:27como vamos a obtener ese resto si
40:30dividimos 15 entre 5 el cociente estrés
40:33porque 3 por 5 es 15 pero el resto que
40:37es lo que nos interesa en esta operación
40:39va a ser cero porque nos sobró nada en
40:42la división entonces el resultado
40:44debería ser cero vamos a ver una consola
40:48aquí vemos el valor cero
40:51vamos a actualizar esta variable para
40:54obtener todos los restos de 5 dividido
40:56entre 1 entre 2 entre 3 entre 4 y entre
40:595 y vemos cómo se va actualizando ese
41:02valor 5 entre
41:0515 y aquí lo tenemos vamos a comentar
41:08esta línea aquí tenemos el ser ahora si
41:12actualizamos esto a 5 entre 2 y buscamos
41:16el resto 5 entre 2 es 2
41:20y del resto tendríamos uno si no
41:23queremos empezar a agregar decimales el
41:25resultado debe en realidad sería 2.5
41:28pero si sólo queremos llegar a la parte
41:31entera del cociente el resto sería 1 y
41:34esto lo que tenemos aquí entre 3 el
41:38resto sería dos porque el cociente sería
41:421 y nos faltarían todos para llegar a 5
41:45entre 4 el resto sería 1 porque nos
41:49faltaría 1 para llegar a 5 y en 35 el
41:52resto sería cero porque el cociente
41:55sería 1
42:01bien ya cubrimos los tipos de datos
42:03principales sabes cómo realizar las
42:06operaciones aritméticas con números
42:07enteros y decimales así que vamos a ver
42:10cómo puedes empezar a modificar el valor
42:13de una variable ya busquets vamos a ver
42:16una alternativa que no es asignar un
42:18nuevo valor directamente sino
42:20incrementar su valor actual vamos a
42:23definir una variable que se va a llamar
42:25libros comprados
42:27representa la cantidad de libros
42:29comprados por una persona en cierto
42:31periodo de tiempo digamos que la persona
42:33de verdad le gusta leer y compro 105
42:36libros en ese periodo aquí tenemos el
42:39valor 105 bien ya sabemos que
42:43inicialmente su valor es 105
42:45nuestra primera opción para incrementar
42:47ese valor a 106 en caso de que la
42:50persona decida comprar otro libro nuevo
42:52es esta que tenemos aquí esta es la
42:55primera opción vamos a colocar opción 1
43:00podemos escribir el nombre de la
43:02variable y asignarle su mismo valor + 1
43:07qué es lo que hace esta línea esta línea
43:10se evalúa primero de este lado lado
43:13derecho se analiza que nosotros decimos
43:16técnicamente se evalúa cuando resulta en
43:19un valor específico se evalúa ese lado
43:21derecho la expresión y ese valor
43:24resultante se asigna a esta variable
43:28aquí estamos tomando el valor actual de
43:30la variable que 105 le estamos sumando 1
43:34y a ese valor lo estamos asignando con
43:37este operador a la variable libros
43:39comprados son independientes ok primero
43:43tomamos el valor aquí el valor actual y
43:45luego se asigna a esta variable luego de
43:49hacer esto incrementar la en 1 vamos a
43:52mostrar su valor aquí puedes ver
43:55inicialmente el valor era 105 pero luego
43:59de esta línea donde incrementamos el
44:01valor de libros comprados y lo mostramos
44:03nuevamente tenemos 106 bien ya podemos
44:06incrementar la variable el valor de la
44:08variable pero hay otra opción que es
44:11todavía más concisa y es en general la
44:14que nosotros tendemos a usar en
44:16javascript cuando queremos incrementar
44:18el valor en uno solo funciona para
44:20incrementarlo en uno que que es lo que
44:23usamos para incrementar en uno
44:25escribimos el nombre de la variable y en
44:27lugar de escribir esta línea completa lo
44:30que hacemos es escribir dos signos más
44:32seguido de un punto y coma
44:35estos dos signos más lo que hacen es
44:37incrementar el valor de la variable en
44:39uno y lo asignan a la variable
44:42toma el valor actual le suma 1 y lo
44:45asigna a la variable básicamente esto de
44:48forma más compacto y conciso y más fácil
44:50de leer luego de hacer esto podemos
44:54mostrar el valor en la consola
44:57y lo vemos aquí
44:59305 se incrementó a 106 con esta línea y
45:03luego se incrementó a 107 con esta línea
45:06ambas líneas tuvieron el mismo efecto
45:09sobre la variable incrementaron su valor
45:11actual el 1 genial ya sabes cómo
45:15incrementar el valor de una variable en
45:171 ya estás avanzando bastante en
45:19javascript ya sabes cómo trabajar con
45:21variables y operadores
45:27también puedes reducir el valor de una
45:30variable en javascript
45:32veamos cómo puedes reducir ese valor el
45:34valor actual de una variable en uno
45:37vamos a crear una variable llamada
45:40número de estudiantes recuerda que no
45:44incluimos el acento aquí para no
45:46introducir caracteres que no sean
45:48estándar en inglés esta variable va a
45:52tener como valor
45:53256 digamos que estamos creando un curso
45:57y este curso tiene 256 estudiantes
46:00registrados
46:01vamos a mostrar ese valor en la consola
46:04aquí lo podemos ver
46:06256 como podemos reducir el valor actual
46:10de esta variable en 1
46:13lo que tenemos que hacer es asignar el
46:16nuevo valor a la variable así que
46:18escribimos el nombre de la variable
46:20seguido del signo igual y escribimos
46:23esto que tenemos aquí que es muy
46:25parecido a como incrementamos el valor
46:28de la variable en uno tomamos el valor
46:31actual de la variable le restamos uno y
46:35ese resultado lo asignamos a la variable
46:39nuevamente
46:40digamos que una estudiante se retiró
46:44ahora veamos el valor actualizado
46:48abramos la consola y aquí lo vemos de
46:51256 pasamos a tener
46:54255 estudiantes en el curso pero hay una
46:57forma mucho más concisa de escribir esta
47:01misma línea
47:02simplemente escribimos el nombre de la
47:04variable seguido de dos signos menos
47:10para incrementarla y usábamos dos signos
47:13más ahora usamos dos signos menos esto
47:18le dice javascript que queremos reducir
47:20el valor de la variable en uno y asignar
47:24ese resultado a la misma variable vamos
47:27a ver el valor actualizado a ver si el
47:30efecto es exactamente el mismo y aquí lo
47:33podemos ver
47:34256 se reduce 255 por esta línea y luego
47:39esta línea hace el mismo efecto reduce
47:43en 1 el valor actual a
47:45254 genial ya sabes cómo reducir el
47:49valor de una variable en 1
47:55bien ya podemos incrementar el valor de
47:58nuestra variable en 1 y reducirla en 1
48:01pero qué pasa si nosotros necesitamos
48:04reducirla o incrementar la en otro valor
48:07que no sea 1
48:09en este caso vamos a definir una
48:11variable llamada a con un valor inicial
48:1323
48:15digamos que queremos incrementar el
48:18valor de a en 5 en vez de 23 ahora
48:22queremos que el valor sea 28 si
48:25escribimos esta línea como normalmente
48:27la hemos escrito hasta este momento
48:29escribiríamos algo así
48:32es igual a 5
48:35estamos tomando el valor actual de a le
48:38estamos sumando un valor y el resultado
48:40lo estamos asignando a la variable esto
48:44va a funcionar si nosotros mostramos el
48:46valor de a en la pantalla vemos que el
48:49valor es 28 el valor es 28 porque
48:53funcionó a esta línea de actuar y pero
48:56hay una forma más concisa mucho más
48:58concisa de escribirla que es la que
49:00normalmente usamos en lugar de escribir
49:03todo esto lo que hacemos es tomamos la
49:05variable y tomamos el valor y todo esto
49:10lo vamos a eliminar
49:11acuerdate variable y valor y luego
49:14decimos que es lo que quiero hacerle esa
49:16variable
49:17quiero aumentarla en 5 y luego quiero
49:21asignarle ese valor a la variable el
49:24resultado
49:25el operador de asignación compuesta que
49:27usamos para una suma para adición
49:30esta sintaxis lo que nos dice es
49:33añade 5 al valor actual y asignarlo a
49:37esa variable es equivalente a hacer esto
49:41es igual a más 5
49:44pero como puedes ver es más concisa y
49:46más fácil de leer vamos a borrar esta
49:49línea y hoy confirmemos que el resultado
49:52es el mismo el resultado es el mismo 28
49:56se puede sumar cualquier cantidad usando
49:59está sintaxis no necesariamente 5 o un
50:02número entero veamos un ejemplo un
50:04poquito más elaborado si tenemos un
50:06total de ventas digamos que un local
50:08específico vendió 13 mil 567 punto 34
50:12dólares en un día
50:14podemos mostrar ese valor y luego
50:17mostrar el valor actualizado de las
50:19ventas digamos que tuvimos una venta de
50:22último minuto que queremos agregar al
50:25total lo que hacemos es escribir el
50:28nombre de la variable seguido de el
50:31operador que vimos aquí lo podemos
50:33separar con una línea para verlo mejor
50:34el nombre de la variable seguido del
50:37operador y luego el monto que queremos
50:40agregar al total por ejemplo tuvimos una
50:42venta buenísima de 345 puntos 67 dólares
50:46a último minuto muy bueno para el
50:49negocio entonces lo que hacemos lo que
50:51podemos hacer para ver que el resultado
50:53se haya actualizado es mostrarlo en la
50:56consola la variable y ese valor si
50:59abrimos la consola podemos ver el
51:02resultado que actualizado sumamos este
51:04monto este valor al valor inicial con
51:08este operador más igual estamos
51:10incrementando el valor de la variable en
51:13este valor que tenemos acá
51:20así como podemos incrementar el valor de
51:22una variable en otro valor específico
51:24podemos reducir el valor de una variable
51:28ya vas a ver cómo lo vamos a hacer aquí
51:30tenemos un ejemplo con la variable b
51:33inicialmente su valor es 23 pero
51:35queremos reducir ese valor en 3 como lo
51:39podemos hacer bueno con la sintaxis
51:41anterior la normal la que hemos usado
51:44hasta ahora de asignar un valor a una
51:46variable podemos usar esto que tenemos
51:48acá el valor actual debe menos 3 y
51:53asignamos ese resultado a b si mostramos
51:56el resultado el valor actualizado de la
51:59variable p podemos verlo aquí en la
52:01consola
52:02el resultado es 20 que es exactamente 23
52:05menos 3 esto funciona pero tenemos una
52:08forma más concisa de revisar esta
52:11operación de escribir la nuestro código
52:13tomamos el nombre de la variable y el
52:16valor con el cual queremos actualizar el
52:19valor actual de saberí variable
52:21estos tres elementos el operador de
52:23asignación el nombre de la variable y el
52:26signo menos los vamos a borrar y luego
52:31vamos a escribir el signo menos y el
52:33signo igual eso nos dice que vamos a
52:36restar el valor 3 y luego vamos a
52:39asignar ese resultado a la misma
52:41variable p
52:42básicamente estamos solo reduciendo el
52:45valor de b en 3
52:47nuevamente mostramos el resultado en la
52:49consola aquí podemos ver el valor 2020
52:53que es exactamente lo que esperábamos es
52:55equivalente a la sintaxis anterior se
52:58puede restar cualquier cantidad
53:01veamos un ejemplo similar al del tema
53:04anterior en este caso en vez del total
53:06de ventas para estar un poco más felices
53:08vamos a decir que tenemos un total de
53:11deudas pero ya vas a ver por qué digo
53:12felices digamos que tienes una deuda de
53:152 mil 446 dólares cómo podemos reducir
53:19esa deuda en
53:22345 porque digamos que realizaste un
53:24trabajo extra y pudiste pagar parte de
53:27esa deuda lo que hacemos es escribir
53:30menos igual y 345 el monto por el cual
53:36queremos reducir la deuda total vamos a
53:39mostrar el valor de edad de deuda antes
53:41de hacer esa actualización y el valor
53:43después de haber hecho la actualización
53:45siempre recuerda colocar el punto y la
53:48coma al final de estas líneas
53:51vamos a ver el resultado en la consola
53:54inicialmente vemos
53:562.446 que es el valor inicial de la
53:58total de la deuda y finalmente después
54:01de haber hecho esta actualización aquí
54:04mostramos el valor 2101 así que esta
54:08sintaxis funciona como esperábamos
54:09cuando estés listo lista continuemos con
54:12la siguiente parte del curso
54:20podemos usar la misma sintaxis de
54:22asignación compuesta para realizar
54:24también una multiplicación con el valor
54:27actual de una variable por ejemplo vamos
54:29a definir una variable ce con el valor
54:32inicial 23 y vamos a multiplicar ese
54:35valor inicial por 2 esto es lo que
54:38tendríamos inicialmente si no usáramos
54:40el nuevo operador
54:42tomaríamos el valor inicial de ce el
54:45valor actual de cee lo multiplicamos por
54:472 y a ese resultado de esta expresión lo
54:51asignaremos a la variable ce nuevamente
54:54si mostramos el valor actualizado en la
54:58consola
54:59podemos ver este resultado 46 pero como
55:02podemos escribir esto de forma más
55:04concisa igual como hemos hecho hasta
55:07ahora primero escribimos el operador que
55:09representa la operación que queremos
55:11realizar y luego asignamos ese resultado
55:14a la variable aquí estamos diciendo toma
55:17el valor actual de la variable se
55:18multiplica por dos y luego asignas el
55:21valor a la variable
55:23si mostramos resultado en la consola
55:26podemos ver el valor 46 que es el doble
55:29que 23 vamos a ver un ejemplo con más
55:32contexto también por ejemplo si tenemos
55:35un salario digamos que ganamos 45 mil
55:38dólares al año no suena mal no entonces
55:42vamos a mostrar ese salario antes del
55:45cambio y digamos que ya nos va a
55:47quintuplicar nuestro salario lo podemos
55:50hacer con este operador multiplicamos el
55:52salario por 5 y luego asignamos este
55:56resultado la variable salario
55:59vamos a ver el resultado en la consola
56:02vemos el valor inicial del salario
56:0445.000 y el valor actualizado que es 225
56:08menos el efecto del operador fue
56:11esperado
56:15y ahora finalmente para cubrir las
56:18cuatro operaciones principales que
56:20podemos realizar con asignación
56:22compuesto veamos la división tenemos la
56:25variable t a la cual vamos a asignarle
56:28el valor 39 y que queremos hacer con esa
56:31variable queremos dividirla entre 3 el
56:34resultado sería 13 si mostramos el
56:37resultado en la consola podemos ver el
56:40número 13 pero la forma más concisa de
56:43escribir esta operación sería borrar
56:45estos tres elementos dividimos el valor
56:48de de entre 3 y lo asignamos nuevamente
56:51a 3
56:53ahora si vemos el resultado en la
56:54consola
56:56vemos el valor 13 así que esto es
56:58equivalente a la línea que teníamos
56:59previamente
57:01como otro ejemplo vamos a decir que
57:04tenemos lo contrario del ejemplo
57:06anterior estamos ganando 45.000 dólares
57:08anuales y hay que hacer recorte del
57:11presupuesto en la empresa o en la
57:13organización donde trabajamos y el
57:15salario se reduce a la mitad aquí
57:18podemos ver los dos valores de 45.000
57:21dólares vamos a pasar a ganar 22 mil 500
57:23dólares
57:24así que ya sabes cómo puedes dividir el
57:28valor de una variable entre otro número
57:31usando este operador que es más compacto
57:34ya sabes cómo realizar las cuatro
57:36operaciones principales que podemos usar
57:38con la asignación compuesta ahora vamos
57:41a comenzar a trabajar con cadenas de
57:43caracteres así que te veo en el próximo
57:45tema
57:51vamos a trabajar con las cadenas de
57:53caracteres usamos cadenas de caracteres
57:55para representar texto en nuestro código
57:58por ejemplo si queremos representar un
58:01nombre
58:02podemos crear una cadena de caracteres
58:05que tenemos acá y la podemos asignar a
58:08una variable para poder usarla en
58:11nuestro programa las cadenas de
58:13caracteres se definen o se crean en el
58:15programa rodeando las con comillas éstas
58:18pueden ser comillas dobles o comillas
58:21simples ambas funciones hay una ligera
58:24diferencia o restricción que tenemos
58:26cuando usamos una versión a otra pero ya
58:28lo vas a ver en tan solo unos minutos
58:30cuando lleguemos a esa parte del tema y
58:33todos los caracteres que estén en el
58:35medio dentro de las comillas son
58:38considerados parte de la cadena de
58:40caracteres incluyendo los espacios este
58:44espacio tiene un lugar específico en la
58:46cadena y se considera como otro carácter
58:49también cualquier símbolo que nosotros
58:52podamos escribir con el teclado también
58:54se considera un carácter
58:57cualquier letra cualquier número
58:59cualquier símbolo por ejemplo un guión
59:02bajo suma resta pierde sus propiedades
59:05especiales en el lenguaje por ejemplo
59:08aquí no tenemos operador suma ni para
59:10los restos sino que son sólo símbolos
59:12podemos definir otra aquí que diga
59:14apellido alan turing aunque ya sabes
59:18cómo crear y definir cadenas de
59:20caracteres recuerda que es prácticamente
59:23equivalente definirlas con comillas
59:25dobles o comillas simples lo importante
59:27es que seas consistente no puedes
59:30comenzar con una comilla simple y
59:32terminar con una comilla doble porque
59:35vas a tener un error por ejemplo aquí se
59:37han terminado string literal eso
59:40significa en español literal de cadena
59:42de caracteres quien no ha terminado aquí
59:44podemos ver el mensaje del error este es
59:47el mensaje que vamos a obtener esta
59:50parte nos dice el tipo de error que está
59:52ocurriendo en este caso un error de
59:54sintaxis
59:55sintaxis significa sintaxis y error
59:58significa error esta parte nos describe
1:00:02qué es lo que está pasando aunque
1:00:05pereira significa que no ha culminado no
1:00:07ha sido cerrada una constante de cadenas
1:00:10de caracteres constante es constante y
1:00:13string es cadenas de caracteres la
1:00:15cadena no ha sido terminada y aquí nos
1:00:19muestra con esta flechita cuál es la
1:00:21línea que está presentando el problema
1:00:23en línea 2 donde definimos apellidos y
1:00:26aquí tenemos con un pequeño indicador
1:00:28que nos dice que aquí hay un problema en
1:00:30esta cadena porque la cadena no ha sido
1:00:33terminada no ha terminado inicia aquí
1:00:35con la comida simple pero no termina
1:00:38porque no tenemos otra comilla simple
1:00:41que la cierre las comillas dobles no se
1:00:43consideran como que están cerrando la
1:00:45cadena porque hay que ser consistente
1:00:47con sus comillas simples o comillas
1:00:50dobles nunca mezclarlas cambiamos la
1:00:52comida y vemos que el error que estaba
1:00:54aquí en rojo desaparece
1:01:01en el tema anterior aprendiste que es
1:01:03prácticamente equivalente definir una
1:01:06cadena de caracteres con comillas dobles
1:01:08o comillas simples pero hay un solo caso
1:01:11para cada una en el que pueda ser
1:01:13problemático cuál comilla escoger
1:01:16vamos a ver si definimos una variable
1:01:19llamada mi cadena y le asignamos una
1:01:21cadena de caracteres con comillas dobles
1:01:24vamos a escribir esta cadena
1:01:27soy una cadena de caracteres con
1:01:31comillas aquí ya inmediatamente puedes
1:01:34ver que se nos presenta un error porque
1:01:38porque estamos intentando incluir dentro
1:01:40de la cadena unas comillas dobles que
1:01:44son exactamente el mismo tipo de
1:01:45comillas con el que empezamos la cadena
1:01:48y la cerramos
1:01:49esto no está permitido porque porque
1:01:52javascript lo que interpreta es que la
1:01:55cadena comienza aquí en las primeras
1:01:57comillas y cierra o termina en las
1:02:00segundas comillas que consigue y esas no
1:02:03necesariamente son las comillas que
1:02:04nosotros queremos si son del mismo tipo
1:02:07esta parte del texto no se cuenta como
1:02:10parte de la cadena de caracteres cómo
1:02:13podemos solucionar este problema hay
1:02:15varias formas pero la primera que vamos
1:02:18a ver en este caso va a ser usar un
1:02:21símbolo que se usa para escapar comillas
1:02:24en cadenas escapar es una traducción
1:02:28literal en inglés se dice es skype
1:02:31en el contexto real sería como omitir
1:02:33las comillas como considerar las partes
1:02:36de la cadena y no como un carácter
1:02:38especial que tiene una función dentro de
1:02:40la cadena sino que es un carácter más en
1:02:42la cadena de caracteres eso lo logramos
1:02:44con la barra invertida esta barra que
1:02:47tenemos aquí que va de izquierda a
1:02:50derecha
1:02:51solo tenemos que colocar una barra
1:02:53invertida antes de cada una de las
1:02:56comillas que queremos que se considere
1:02:58parte de la cadena si nosotros tratamos
1:03:02de mostrar la cadena en la consola vas a
1:03:05ver cómo se muestra soy una cadena de
1:03:09caracteres con comillas y puedes ver que
1:03:11las comillas fueron incluidas bien ya
1:03:14sabes cómo escapar las comillas en una
1:03:16cadena con la barra invertida antes de
1:03:19las comillas
1:03:26también puedes definir cadenas de
1:03:28caracteres con comillas simples vamos a
1:03:31ver un ejemplo que nos va a permitir
1:03:33escribir la cadena de una forma más
1:03:36concisas vas a ver que va a ser mucho
1:03:38más fácil de leer lo primero que vamos a
1:03:40hacer es declarar una variable llamada
1:03:42mimética y que va a ocurrir si yo trato
1:03:45de asignarle una cadena de caracteres a
1:03:47esta variable que contiene comillas
1:03:50dobles y la defino con comillas dobles
1:03:52va a pasar esto cuál es mi meta es
1:03:54aprender a programar con freak o work
1:03:57and si agregamos aquí las comillas
1:04:00dobles como viste en el tema anterior
1:04:02vamos a tener un error pero podemos
1:04:04solucionarlo rápidamente con estas
1:04:07barras que van a permitirnos escapar las
1:04:10comillas dobles y nos va a permitir que
1:04:13ellas aparezcan como parte de la cadena
1:04:15pero esto hace que la cadena sea más
1:04:17difícil de leer porque le estamos
1:04:19agregando caracteres que en realidad no
1:04:21van a mostrarse en el resultado cómo
1:04:23podemos adaptar esto lo que necesitamos
1:04:26hacer bueno lo que podemos hacer es
1:04:28primero vamos a borrar estas barras
1:04:31invertidas que ya no las vamos
1:04:33y qué es lo que vamos a hacer en vez de
1:04:35definir la cadena con comillas dobles
1:04:38vamos a definirla con comillas simples
1:04:40aquí las reemplazamos y vemos que el
1:04:43error desapareció si usamos el otro tipo
1:04:46de comillas para definir la cadena por
1:04:48ejemplo comillas simples aquí podemos
1:04:51usar las comillas dobles dentro de la
1:04:53cadena eso sí está permitido en
1:04:56javascript y de igual forma también
1:04:58podemos definir la cadena con comillas
1:05:00dobles y dentro de la cadena usar
1:05:03comillas simples y ellas se van a
1:05:06mostrar en el resultado veamos el
1:05:09resultado con con su punto lo que vemos
1:05:13aquí que tenemos nuestras comillas
1:05:15simples cuál es tu meta aprender a
1:05:17programar con free your cam vemos aquí
1:05:19las comillas simples y también podemos
1:05:21ver el resultado si cambiamos
1:05:25esta combinación a comillas simples para
1:05:27definir la cadena y comillas dobles
1:05:29dentro de la cadena ahora aquí vemos las
1:05:32comillas dobles rodeando la palabra
1:05:34africor camps compara esta nueva versión
1:05:37de la cadena con la versión anterior
1:05:40vamos la barra invertida es mucho más
1:05:42fácil de leer y todos los caracteres que
1:05:44se van a mostrar son los que son parte
1:05:46de la cadena genial ya sabes cómo
1:05:48definir cadenas de caracteres con
1:05:51comillas simples y dobles
1:05:57ahora veamos algo que se denomina una
1:05:59secuencia de escape tenemos varias
1:06:03secuencias de escape que podemos usar en
1:06:04javascript las secuencias de escape son
1:06:07una combinación de caracteres que no se
1:06:10representan a sí mismos en una cadena de
1:06:13caracteres aquí tenemos una tabla que
1:06:15nos muestra algunas de esas secuencias
1:06:17de escape que podemos usar por ejemplo
1:06:19cuando nosotros usamos una barra
1:06:21invertida seguida de una letra n esa va
1:06:25de invertir de la letra n no se van a
1:06:27mostrar como tal en la cadena sino que
1:06:30se van a traducir a una línea nueva en
1:06:33la cadena o en el output en la
1:06:34presentación de nuestro código vamos a
1:06:37ver algunos ejemplos aquí tenemos lo que
1:06:39he visto en los temas anteriores
1:06:41comillas simples y comillas dobles si
1:06:44queremos escribir una comida simple en
1:06:46una cadena que está definida con
1:06:48comillas simples tenemos que usar esta
1:06:50combinación de caracteres esta secuencia
1:06:52de escape una barra invertida seguida de
1:06:55la comida simple lo mismo con la comilla
1:06:58doble vamos a ver un ejemplo más sobre
1:07:00este tema para empezar a practicar cómo
1:07:02usar las secuencias de escape por
1:07:04ejemplo si usamos con su blog y queremos
1:07:07mostrar una cadena que diga
1:07:11estoy aprendiendo
1:07:13javascript si queremos que ya esté
1:07:16rodeado por comillas dobles no vamos a
1:07:19poder si no le agregamos una barra
1:07:21invertida antes de la comida nos va a
1:07:24dar un error una vez que agregamos esa
1:07:26barra invertida ya estamos creando lo
1:07:29que denominamos una secuencia de escape
1:07:31exactamente lo que estamos viendo
1:07:33ahorita si abrimos la consola aquí
1:07:35podemos ver el resultado estoy
1:07:37aprendiendo javascript y se muestran las
1:07:39comillas dobles pero puedes ver que no
1:07:42se muestra la barra invertida eso es
1:07:44exactamente el principio de una
1:07:45secuencia de escape no vas a ver la
1:07:48barra invertida sino que vas a ver el
1:07:50carácter que se interpreta de esa
1:07:52secuencia de caracteres que es una
1:07:53comilla doble ahora lo mismo aplica para
1:07:56la comillas simple que ya lo vimos en el
1:07:58tema anterior vamos a ver ahora cómo
1:08:00puedes incluir una barra invertida para
1:08:04incluir una barra invertida en la cadena
1:08:07de caracteres como la barra invertida ya
1:08:09es un carácter especial que tiene una
1:08:11función dentro de la cadena
1:08:13tenemos que usar 2 barras invertidas
1:08:16para que se muestre una barra invertida
1:08:19digamos de esta forma
1:08:23y aquí puedes ver el resultado la barra
1:08:25invertida se muestra si solamente
1:08:27hubiéramos escrito una sola barra
1:08:29invertida puedes ver que en nada se
1:08:32mostraría en ese lugar de la cadena
1:08:33porque la barra invertida tiene una
1:08:36función especial para las cadenas de
1:08:37caracteres y para quitarle esa función a
1:08:40special escribimos dos barras invertidas
1:08:43otra secuencia de escape muy muy
1:08:46utilizada que seguramente la vas a
1:08:47utilizar en tus proyectos es la barra
1:08:50invertida seguida de una n ésta
1:08:52representa una línea nueva en la cadena
1:08:54vamos a ver un ejemplo con esta
1:08:57secuencia de escape que es muy muy
1:08:58utilizada digamos que quiero mostrar la
1:09:02palabra javascript en otra línea estoy
1:09:05aprendiendo podemos colocar dos puntos
1:09:08por ejemplo y queremos que javascript se
1:09:10muestre en otra línea si veamos el
1:09:13resultado en la consola vemos aquí que
1:09:16dice estoy aprendiendo
1:09:18javascript puedes ver que ya va a
1:09:20escribir te está en otra línea y haces
1:09:22el principio de las secuencias de escape
1:09:24no aparece por sí misma sino que se
1:09:26traduce en caracteres web o elementos
1:09:29especiales aquí podemos ver un espacio
1:09:32adicional porque aquí tenemos un espacio
1:09:34adicional antes de ya busquets si
1:09:37eliminamos ese espacio ya vemos que el
1:09:40espacio se elimina del resultado general
1:09:44también tenemos muchos otros ejemplos de
1:09:46secuencias de escape
1:09:48aquí tenemos algunos en la tabla retorno
1:09:50de carro que en inglés se denomina que
1:09:52ritcher tabulación saab en inglés
1:09:57retroceso estaba invertida seguido una
1:10:00vez salto de página para invertida efe y
1:10:03muchos otros más si te interesa aprender
1:10:06más sobre secuencias de escape puedes
1:10:08conseguirlas en la documentación de
1:10:09javascript
1:10:17sabes que también podemos unir cadenas
1:10:20de caracteres a veces esto puede ser muy
1:10:22útil cuando necesitamos formar una sola
1:10:25cadena a partir de varias cadenas y
1:10:28podemos hacerlo con el operador de suma
1:10:31el operador más sorprendentemente si el
1:10:34operador de suma se puede usar para
1:10:36operar con otros tipos de datos además
1:10:38de los números podemos usarlo para unir
1:10:42o concatenar cadenas de caracteres
1:10:43veamos un ejemplo
1:10:45vamos a referirnos al nombre completo de
1:10:48una persona como la combinación de su
1:10:50nombre y su apellido para este ejemplo
1:10:53entonces en este caso digamos que
1:10:55queremos unir el nombre de la persona
1:10:58con su apellido touraine y cuál es el
1:11:01resultado de esta línea bueno vamos a
1:11:03tener una cadena de caracteres que
1:11:07resulta de la unión de estas dos cadenas
1:11:09alan turing vamos a mostrar el resultado
1:11:12en la consola
1:11:14aquí puedes ver el resultado pero hay
1:11:17algo muy particular que seguramente
1:11:19estás notando no hay un espacio entre
1:11:22las cadenas están pegadas no hay
1:11:25separación entre las cadenas cómo
1:11:27podemos agregar ese espacio bueno lo que
1:11:29podemos hacer es agregar el espacio a
1:11:32cualquiera de las cadenas podemos
1:11:34agregarlo al final de la primera cadena
1:11:37y aquí puedes ver que el espacio se
1:11:39agregó al resultado podemos agregarlo al
1:11:43principio es la segunda cadena como
1:11:45puedes ver aquí tenemos touring y aquí
1:11:49podemos ver el espacio es equivalente la
1:11:52cadena resultante lo que va a hacer es
1:11:54tomar estos caracteres y combinarlos con
1:11:56estos caracteres que tenemos aquí
1:11:58incluyendo el espacio recuerda que en
1:12:01las cadenas de caracteres el espacio es
1:12:04muy importante porque está también tiene
1:12:06su propio lugar dentro de la cadena y se
1:12:08cuenta como un carácter más otra
1:12:11alternativa si no queremos agregar el
1:12:13espacio a ninguna de las dos cadenas lo
1:12:15que podemos hacer
1:12:16es en lugar de agregar el espacio
1:12:18concatenar un espacio entre ambas
1:12:23aquí lo podemos ver a alan se mantiene
1:12:26intacto tenemos la misma cadena y turín
1:12:29también no agregamos ningún espacio lo
1:12:31que estamos haciendo aquí es concatenar
1:12:33estas dos cadenas con dos operaciones
1:12:36con el operador de suma a un espacio
1:12:39aquí esto está diciendo toma la cadena a
1:12:42adam y añádele en este espacio y luego
1:12:46agrega esta cadena al final del
1:12:48resultado y eso lo que vamos a tener
1:12:50como el nombre completo
1:12:57también puedes construir cadenas con
1:12:59variables como lo podemos hacer con el
1:13:02mismo operador que usábamos para
1:13:04concatenar las cadenas pero ahora
1:13:06también vamos a incluir una variable que
1:13:09contiene a una cadena por ejemplo si
1:13:12tenemos una variable que contiene un
1:13:14verbo que representa un verbo por
1:13:16ejemplo programar podemos usar esta
1:13:19variable para concatenar las cadenas y
1:13:22generar un mensaje por ejemplo estoy
1:13:26aprendiendo a agregamos un espacio para
1:13:31que haya una separación y así es que las
1:13:34concatena mos con el operador de suma
1:13:36aplica dos cadenas de caracteres
1:13:39decimos estoy aprendiendo a y como
1:13:42tenemos un espacio en las cadenas van a
1:13:44estar separadas y el verbo que es esta
1:13:47variable va a ser reemplazada con la
1:13:49cadena programa si mostramos el mensaje
1:13:52en la consola aquí podemos ver lo estoy
1:13:56aprendiendo a programar la primera
1:13:58cadena llega hasta este espacio y la
1:14:00segunda cadena comienza después del
1:14:03espacio también podemos concatenar esta
1:14:06variable que contiene una cadena en
1:14:09cualquier punto de la cadena en
1:14:11cualquier punto del mensaje de la nueva
1:14:13cadena donde la necesitemos para ello
1:14:17solamente
1:14:18escribimos el operador de suma para
1:14:20seguir concatenando más cadenas
1:14:23y describimos la cadena que necesitamos
1:14:25agregar en este caso es con frijol que
1:14:28siempre debes recordar incluir el
1:14:30espacio porque cuando usamos el operador
1:14:33más el operador que concatena cadenas el
1:14:36espacio no se asume si no van a estar
1:14:38todas sin separación y aquí puedes ver
1:14:41el resultado estoy aprendiendo a
1:14:43programar con frito el campo tenemos
1:14:45tres partes para formar esta cadena bien
1:14:50ya sabes construir cadenas con variables
1:14:52esto es muy muy útil cuando quieres
1:14:55personalizar el valor de una cadena
1:14:57porque puedes simplemente tomar el valor
1:14:59de una variable y va a aparecer como el
1:15:01mensaje o como un resultado que puedes
1:15:03usar en tu programa
1:15:10también puedes usar una sintaxis un
1:15:12operador que aprendiste en los temas
1:15:15anteriores para concatenar
1:15:17cadenas de caracteres que están
1:15:19asignadas a variables veamos como puedes
1:15:22hacerlo si nosotros tenemos una variable
1:15:25que contiene una cadena que va a
1:15:27representar un mensaje completo pero
1:15:30nosotros queremos ir armando esa cadena
1:15:32poco a poco y le vamos a agregar la
1:15:34parte final del mensaje en el programa
1:15:38estoy aprendiendo a programar vamos a
1:15:42usar el mismo ejemplo del tema anterior
1:15:43estoy aprendiendo a programar dejamos un
1:15:46espacio aquí y digamos que la parte
1:15:49final la tenemos guardada o asignada en
1:15:53otra variable
1:15:54esto podría ser en una situación real
1:15:56por ejemplo que esa parte del mensaje
1:15:58sea personalizada para el usuario o que
1:16:02el usuario tenga que ingresar algún
1:16:03valor para tener la cadena completa eso
1:16:06serían algunos casos más realistas de
1:16:09cuando podrías usar este operador
1:16:12entonces tenemos esta cadena y la
1:16:14tenemos dividido en dos partes esta es
1:16:16la cadena que queremos que contenga el
1:16:18mensaje completo y esto es sólo la parte
1:16:21final
1:16:23qué es lo que vamos a hacer vamos a
1:16:24mostrar el mensaje completo
1:16:27antes de concatenar la parte final y
1:16:31luego vamos a concatenar la parte final
1:16:33simplemente lo que vamos a usar con este
1:16:36operador va a ser el nombre de la
1:16:39variable que queremos concatenar tenemos
1:16:42dos variables esa es la diferencia con
1:16:44los temas anteriores en lugar de estar
1:16:46trabajando directamente con la cadena
1:16:49aquí estamos guardando la en una
1:16:52variable primero y luego usando la
1:16:54variable aquí esto va a tomar la cadena
1:16:58actual de esta variable el mensaje
1:17:01completo y va a agregar la parte final a
1:17:04esa cadena va a concatenar las
1:17:08aquí podemos ver las dos etapas del
1:17:10mensaje estoy aprendiendo a programar
1:17:12fue el resultado de esta línea antes de
1:17:15hacer el proceso de concatenación y aquí
1:17:18vemos el mensaje completo una vez que ya
1:17:21está actualizado estoy a pensar
1:17:23programar con free core camps la parte
1:17:26final se agregó al final del mensaje
1:17:28completo bien ya sabes cómo formar
1:17:31cadenas concatenando otras cadenas que
1:17:34están guardadas o asignadas a una
1:17:37variable buen trabajo hasta ahora ya has
1:17:39aprendido bastante sobre los distintos
1:17:41tipos de datos de javascript así que
1:17:43continuemos ya o script es un lenguaje
1:17:45de programación asombroso y poderoso que
1:17:47puedes usar para muchas aplicaciones
1:17:49distintas así que cuando estés listo
1:17:52lista comencemos con nuestro siguiente
1:17:53tema
1:18:01vamos a ver cómo puedes realizar una
1:18:03operación que es extremadamente común en
1:18:06programación encontrar la longitud de
1:18:09una cadena la longitud del tamaño es
1:18:11simplemente cuántos caracteres tiene una
1:18:14cadena de caracteres
1:18:15incluyendo espacios y cualquier símbolo
1:18:18que pueda contener vamos a ver algunos
1:18:20ejemplos si declaramos la variable en mi
1:18:23cadena vamos a asignar distintos valores
1:18:26por ejemplo la cadena puede estar
1:18:29formada por un solo carácter cualquier
1:18:31carácter esto puede ser un símbolo puede
1:18:33ser un espacio puede ser una letra y
1:18:36digamos que nuestro programa necesitamos
1:18:38saber cuántos caracteres contiene esa
1:18:40cadena lo que podemos hacer es escribir
1:18:43el nombre de la variable
1:18:46y en donde necesitemos usar ese valor en
1:18:50la longitud escribimos un punto
1:18:53inmediatamente después del nombre de la
1:18:55cadena no puede haber ningún espacio que
1:18:57tenemos el punto y después escribimos
1:19:00lane line en inglés significa longitud
1:19:03esta propiedad de la cadena nos va a
1:19:06permitir saber cuántos caracteres
1:19:08contienen
1:19:10vamos a ver en la consola a ver cuál es
1:19:12el resultado
1:19:13el resultado es 1 y eso es correcto
1:19:16porque esta cadena contiene un solo
1:19:18carácter
1:19:20ahora qué pasa si nosotros actualizamos
1:19:22esta cadena a la cadena ave por ejemplo
1:19:25ya lo tenemos dos caracteres y vemos el
1:19:29resultado 2 aquí para la propiedad le
1:19:32ahora puedes preguntarte también si los
1:19:34espacios se cuentan si yo agrego un
1:19:37espacio entre estas letras hay tres
1:19:40caracteres bueno veamos en la consola y
1:19:43aquí podemos ver que si hay tres
1:19:45caracteres la longitud de la cadena es
1:19:48tres también cuenta si agregamos el
1:19:51espacio al principio o al final aquí
1:19:53puedes ver que el resultado sigue siendo
1:19:55tres con el espacio al principio y sigue
1:19:57siendo tres si colocamos el espacio al
1:19:59final ahora vamos a ver otro ejemplo
1:20:01otra cadena cuantos caracteres tiene
1:20:04esta cadena pero no necesariamente
1:20:06sabemos a simple vista cuántos
1:20:08caracteres tiene así que vamos a
1:20:10necesitar usar esta propiedad y
1:20:12normalmente en los programas vas a
1:20:14necesitar usar esta propiedad para
1:20:17trabajar con ese valor si vemos en la
1:20:20consola podemos ver que el javascript
1:20:22tiene 10 caracteres en este caso son 10
1:20:24letras qué te parece si también
1:20:27incluimos algunos símbolos en nuestro
1:20:28ejemplo estoy aprendiendo a programar en
1:20:31este caso tenemos signos de exclamación
1:20:35esta cadena tiene 31 caracteres
1:20:38incluyendo sino exclamación puedes ver
1:20:40que si quitamos alguno de esos signos de
1:20:42exclamación la longitud va a disminuir
1:20:45aquí puedes ver que ahora es 30 y si
1:20:48quitamos los dos es 29 así que si están
1:20:50contando también cualquier otro símbolo
1:20:53que podamos incluir en la cadena cuenta
1:20:56por ejemplo un arroba
1:20:59un hashtag unam per sant cualquier
1:21:03símbolo que esté en la cadena cuenta
1:21:05para su longitud
1:21:07bien ya aprendiste algo muy muy
1:21:09importante en programación cómo obtener
1:21:11la longitud o tamaño de una cadena de
1:21:13caracteres
1:21:20vamos a ver la notación de corchetes en
1:21:23ya ves que esta es una notación que nos
1:21:26permite acceder a los caracteres
1:21:28individuales de una cadena veamos cómo
1:21:32puedes acceder al primer carácter de una
1:21:34cadena vamos a definir una variable que
1:21:37se llama lenguaje de programación
1:21:39y le vamos a asignar la cadena de
1:21:42caracteres javascript
1:21:45esa cadena de caracteres tiene una
1:21:47estructura interna que nos va a permitir
1:21:49acceder a sus caracteres
1:21:52veamos un pequeño diagrama está aquí
1:21:55esta es la cadena y estos son los
1:21:58índices la cadena de caracteres
1:22:01contiene estos caracteres estoy dejando
1:22:04una separación para que puedas verlos
1:22:06mejor
1:22:08cada uno de sus caracteres de la cadena
1:22:12tiene un índice asociado que es un
1:22:14número entero que comienza en cero y se
1:22:17incrementa en uno para cada carácter
1:22:19hacia la fecha el primer carácter de la
1:22:23cadena está ubicado en el índice cero y
1:22:26podemos usar ese índice para acceder a
1:22:28ese carácter
1:22:29vamos a usar con su punto log para
1:22:31mostrar este carácter escribimos el
1:22:34nombre de la variable que contiene la
1:22:37cadena y luego escribimos un par de
1:22:39corchetes
1:22:41inmediatamente después de ese nombre
1:22:43ningún espacio inmediatamente después
1:22:45del nombre y dentro de los corchetes
1:22:48escribimos el índice del carácter que
1:22:51queremos acceder en este caso es cero
1:22:53porque queremos acceder al primer
1:22:55carácter es importante que recuerdes que
1:22:59el primer índice de cero no es uno como
1:23:03normalmente pensaríamos y esto es muy
1:23:05común en computación comenzar a contar
1:23:07en la secuencia desde cero
1:23:10bien abramos la consola y aquí podemos
1:23:13ver el primer carácter j
1:23:16bien ya sabes cómo acceder al primer
1:23:18carácter escribes el nombre de la de la
1:23:21variable luego un par de corchetes y
1:23:24dentro de los corchetes el índice que en
1:23:26este caso es cero para el primer
1:23:29carácter en los próximos temas vas a
1:23:32practicar cómo puedes acceder a los
1:23:34otros caracteres de la cadena ya sabes
1:23:36acceder al primero genial continuemos
1:23:44ya sabes cómo acceder al primer carácter
1:23:47de una cadena y en esta parte del curso
1:23:50vamos a ver algo muy muy importante
1:23:52sobre las cadenas vamos a hablar sobre
1:23:55la inmutabilidad de las cadenas de
1:23:57caracteres que implica que sean
1:23:59inmutables mutable significa que se
1:24:01pueden cambiar e inmutables significa
1:24:04que no se pueden cambiar y es
1:24:06exactamente eso una vez que nosotros
1:24:08definimos una cadena de caracteres en el
1:24:11programa no podemos cambiar sus
1:24:13elementos individuales sus caracteres
1:24:15vamos a ilustrar esto con un ejemplo si
1:24:18decimos mi cadena y escribimos aquí en
1:24:21una cadena de caracteres y en lugar de
1:24:23hola mundo
1:24:25digamos que escribimos hola mundo una
1:24:27letra que luego vamos a querer cambiar
1:24:31digamos que luego queremos cambiar esa
1:24:35cadena solo ese carácter podemos
1:24:38mostrarlas para confirmar su valor
1:24:40anterior y luego podemos tratar de
1:24:43cambiar el carácter en el índice cero
1:24:46para ello escribiríamos el nombre de la
1:24:48variable seguido de corchetes y dentro
1:24:51de los corchetes del índice en este caso
1:24:54es el índice de cero porque el primer
1:24:56carácter de la cadena
1:24:58luego aquí asignamos la letra que
1:25:02queremos
1:25:03cambios que también es una cadena de
1:25:05caracteres pero qué es lo que va a
1:25:07ocurrir cuando lleguemos a esta línea
1:25:09durante la ejecución del programa va a
1:25:11haber un error porque las cadenas son
1:25:13inmutables no puedes cambiar los
1:25:15caracteres individuales de la cadena lo
1:25:18que puedes hacer es reasignar la cadena
1:25:20completa vamos a abrir la consola para
1:25:22que veas el error aquí ves el resultado
1:25:26de esta línea donde mostramos la cadena
1:25:29antes de llegar a esta línea que tenemos
1:25:31acá que trata de reasignar el carácter
1:25:33luego vemos este error tal error
1:25:37significa error de tipo esto ocurre
1:25:40cuando te hacemos alguna operación que
1:25:41no está permitida con un tipo de datos
1:25:44específicos que estamos trabajando y que
1:25:46dice en esta parte del error dice que no
1:25:49saben no se puede asignar el valor a una
1:25:54propiedad que solo se puede leer esto lo
1:25:57que significa hervir
1:25:59sólo se puede acceder a ese valor y no
1:26:01se puede cambiar la propiedad es cero de
1:26:05la cadena de caracteres hola mundo
1:26:08lo que sí podemos hacer es cambiar el
1:26:10valor de la cadena completamente a otra
1:26:13cadena nota que aquí no estamos tratando
1:26:16de cambiar un índice en específico sino
1:26:18que resignamos completamente el valor de
1:26:20la variable vamos a mostrar la cadena
1:26:23antes del cambio y después del cambio y
1:26:27vamos a abrir la consola aquí puedes ver
1:26:29que el cambio fue efectivo pasamos de
1:26:32hall a punto a hola mundo porque
1:26:35reasignamos la cadena completa no puedes
1:26:38cambiar ningún carácter individual de
1:26:40esta cadena aquí es porque son
1:26:42inmutables
1:26:50vamos a retomar el tema anterior que
1:26:52estábamos viendo es cómo usar la
1:26:54anotación de corchetes para acceder a
1:26:57los caracteres individuales de una
1:26:59cadena porque no solamente puedes
1:27:01acceder al primer carácter de la cadena
1:27:03puedes acceder a cualquier carácter de
1:27:06la cadena comenzando a contar desde cero
1:27:08veamos un ejemplo aquí tenemos mi cadena
1:27:11y le asignamos el valor ya busquets
1:27:14nuevamente vamos a hacer el diagrama que
1:27:17hicimos en el tema anterior
1:27:24podemos ver el índice que corresponde a
1:27:27cada uno de esos caracteres por ejemplo
1:27:30el índice 4 corresponde al carácter s el
1:27:33índice 7 corresponde al carácter i y así
1:27:36sucesivamente
1:27:37incrementando de a uno por cada carácter
1:27:40en la cadena cómo podemos acceder a cada
1:27:43uno de ellos usando sus índices y la
1:27:46anotación que ya aprendiste en el tema
1:27:47anterior escribimos en nos de la
1:27:50variable mi cadena en este caso y entre
1:27:53corchetes escribimos el índice y esta
1:27:56expresión que tenemos aquí va a evaluar
1:27:59al carácter correspondiente en este caso
1:28:02va a ser la letra j pero también por
1:28:05ejemplo si copiamos y pegamos aquí y el
1:28:08único cambio que hacemos es el índice lo
1:28:11cambiamos a 1 ahora la letra o el
1:28:14carácter va a ser la letra a si lo
1:28:17cambiamos nuevamente a 2 ahora la letra
1:28:19va a ser p y así sucesivamente
1:28:24los índices de esta cadena de caracteres
1:28:26llegan hasta el número 9 vamos a ver el
1:28:29resultado de todas estas líneas de
1:28:31código que muestran los caracteres aquí
1:28:34lo podemos ver cada uno de los
1:28:36caracteres de la cadena fue mostrado en
1:28:38una línea separada en su propia línea j
1:28:41ave usando los índices correspondientes
1:28:44así como estamos mostrando el carácter
1:28:47en la consola podemos usar cualquiera de
1:28:49estos caracteres caracteres en nuestro
1:28:51programa bien ahora vamos a ver qué pasa
1:28:54si nosotros usamos un índice que está
1:28:56fuera de los límites permitidos por
1:28:59ejemplo si escribimos aquí 10 ya aquí no
1:29:03tenemos ningún carácter que corresponde
1:29:06al índice 10 en esta cadena así que
1:29:09veamos qué pasa
1:29:11lo que tenemos aquí es el valor anti
1:29:14fine no tenemos un error como podríamos
1:29:16pensar inicialmente sino que lo que
1:29:19tenemos es el valor anti find aunque es
1:29:22el valor retornado si usamos un índice
1:29:24que no es válido si usamos un índice
1:29:26negativo por ejemplo
1:29:29-3 también tenemos el valor and i find
1:29:33si usamos un índice
1:29:35decimal también veamos qué pasa
1:29:40también vemos el valor anti find esto lo
1:29:43que podemos esperar en javascript
1:29:47bien ya sabes cómo acceder a cada uno de
1:29:49los caracteres caracteres de una cadena
1:29:51usando sus índices para practicar puedes
1:29:54escoger otra cadena de caracteres por
1:29:56ejemplo
1:29:57programar y hacer este mismo día grammy
1:30:01está así te vas acostumbrando
1:30:02a la estructura general de las cadenas
1:30:06de caracteres ves programar comenzamos
1:30:09desde cero y cada uno de los caracteres
1:30:11tiene su propio índice aumentando de uno
1:30:13en uno a medida que nos movemos hacia la
1:30:16derecha al siguiente carácter bien
1:30:19pasemos a nuestro siguiente tema
1:30:28también puedes usar la notación de
1:30:30corchetes para encontrar o para acceder
1:30:33al último carácter de una cadena
1:30:35recuerda que antes de los temas
1:30:37anteriores accedemos al primer carácter
1:30:40de la cadena luego pudimos acceder a
1:30:42cada uno de los otros caracteres pero
1:30:45qué pasa si solo queremos acceder al
1:30:47último carácter y en verdad no sabemos
1:30:50explícitamente cuál es el último índice
1:30:52cuando hicimos el ejemplo con javascript
1:30:55o hicimos un diagrama y allí colocamos
1:30:57cada uno de los índices pero no siempre
1:30:59vas a poder hacer eso y eso no es
1:31:01práctico lo que queremos es automatizar
1:31:04lo para que funcione para cualquier
1:31:06cadena y de cualquier tamaño o longitud
1:31:09así que vamos a ver cómo lo podemos
1:31:11hacer primero vamos a declarar una
1:31:13variable llamada mi cadena
1:31:16bien y vamos a analizar el ejemplo de la
1:31:19cadena javascript
1:31:21el último índice siempre es la longitud
1:31:26de la cadena menos 1 porque comenzamos a
1:31:30contar desde cero
1:31:33el último índice siempre es la longitud
1:31:36de la cadena menos 1 porque se comienza
1:31:38a contar desde cero ahorita vamos a ver
1:31:40el diagrama de jobsket y vas a darte
1:31:42cuenta que en realidad el último índice
1:31:45es la longitud menos 1 porque no estamos
1:31:47comenzando a contar desde 1 sino desde 0
1:31:50mi cadena punto lines es 10 porque tiene
1:31:5510 caracteres 1 2 3 4 5 6 7 8 9 y 10 por
1:32:01lo tanto el último índice es 9
1:32:10podemos ver aquí que en lo último 26 9
1:32:12que es la longitud de la cadena o el
1:32:15tamaño de la cadena menos 1 porque
1:32:17comenzamos a contar desde cero
1:32:20bien ya tenemos esto visualmente pero
1:32:22cómo podemos representarlo de una forma
1:32:24general que aplique a cualquier cadena
1:32:27porque digamos que no necesariamente la
1:32:29cadena tiene que ser llaves que no
1:32:31necesariamente es 9 lo que vamos a hacer
1:32:33es asignarle ese valor javascript que
1:32:36puede ser cualquier cadena y para
1:32:38acceder al último elemento lo que
1:32:41hacemos es esto ponemos mi cadena punto
1:32:43name menos 1 este va a ser nuestro
1:32:47índice para acceder al carácter tomamos
1:32:50la longitud de la cadena que puede ser
1:32:53cualquier cadena estamos usando la
1:32:55variable para poder reemplazar su valor
1:32:57si yo cambio este valor por ejemplo a
1:33:00payton que es otro lenguaje de
1:33:02programación
1:33:03este valor se va a actualizar el tamaño
1:33:06va a ser actualizado y por lo tanto el
1:33:08resultado del índice también se va a
1:33:11actualizar
1:33:11así que esto va a funcionar
1:33:13correctamente nota que aquí estamos
1:33:15escribiendo la expresión dentro de los
1:33:18corchetes los corchetes que usamos para
1:33:21escribir el índice en lugar de escribir
1:33:23por ejemplo cero o nueve o seis o cinco
1:33:28directamente lo que estamos haciendo es
1:33:30escribir una expresión que se va a
1:33:32evaluar cuando el código se ejecute y
1:33:35ese valor resultante va a ser
1:33:37reemplazado como el índice ahora veamos
1:33:40que tenemos en la consola vemos la letra
1:33:43t que efectivamente es la última letra
1:33:45de la cadena javascript
1:33:48ahora si cambiamos este valor a digamos
1:33:50python
1:33:53aquí podemos ver que la última letra es
1:33:56la que se muestra la n
1:33:57digamos también una cadena con un solo
1:34:00caracter podemos ver la letra que
1:34:03también funciona porque su longitud es
1:34:06uno cuando le restamos uno nos queda el
1:34:09índice cero que es el índice del primer
1:34:11carácter
1:34:12genial ya sabes cómo acceder al último
1:34:14carácter de una cadena de caracteres
1:34:17recuerda es la longitud de la cadena
1:34:20menos 1
1:34:28y finalmente para ya cubrir
1:34:30completamente el tema de cómo podemos
1:34:32usar la anotación de corchetes para
1:34:34acceder a los caracteres de una cadena
1:34:36si nosotros llegamos al final de la
1:34:38cadena y queremos el penúltimo del
1:34:41antepenúltimo carácter o el carácter que
1:34:43está antes del antepenúltimo también
1:34:46tenemos una forma de hacerlo de una
1:34:48forma que podemos contar desde el final
1:34:50de la cadena hacia el principio para
1:34:53tener el carácter específico vamos a ver
1:34:56esto vemos mi cadena y vamos a asignarle
1:35:00un valor mi cadena es ya busquets y
1:35:05vamos a analizar el patrón aquí vamos a
1:35:07hacerlo vamos a analizarlo con un
1:35:09comentario
1:35:10decimos el penúltimo índice
1:35:15es la longitud menos 2 aquí tenemos el
1:35:19último carácter para acceder al
1:35:21penúltimo índice el penúltimo carácter
1:35:23la letra p tenemos que restar 2 en lugar
1:35:26de 1
1:35:27porque comenzamos
1:35:31a contar desde cero
1:35:34entonces el último carácter estaría en
1:35:36el índice de la longitud menos 1 y así
1:35:39estaríamos uno para cada carácter
1:35:41siguiente de derecha a la izquierda éste
1:35:44sería menos 2 - 3 - 4 menos 5 y puedes
1:35:49ver que coincide con el número del
1:35:51carácter de derecha a izquierda menos
1:35:53dos menos tres menos 4 y menos 5 y así
1:35:57sucesivamente en este caso para este
1:36:00ejemplo mi cadena puntos line es 10
1:36:03porque javascript tiene 10 caracteres
1:36:05por lo tanto el penúltimo índice es 8
1:36:11que lo tenemos acá
1:36:13podemos ver el diagrama que hicimos
1:36:16anteriormente y aquí vemos que el
1:36:18penúltimo índice es 8 la longitud de la
1:36:21cadena 10 menos 2 así podemos analizar
1:36:25este patrón y conseguir una forma
1:36:27general de referir y referirnos a
1:36:29cualquier carácter de derecha a
1:36:31izquierda
1:36:31como lo podemos hacer veamos vamos a
1:36:35mostrar el resultado en la consola y
1:36:37decimos mi cadena mi cadena punto lane
1:36:41menos 2 en este caso porque queremos el
1:36:45segundo carácter de derecha a izquierda
1:36:47si quisiéramos el tercer carácter
1:36:49estaríamos 3 y así sucesivamente
1:36:52veamos el resultado de restar 2 vemos el
1:36:56carácter p que tenemos aquí el segundo
1:36:59carácter de derecha a izquierda si
1:37:01restamos 3 nos vamos más hacia la
1:37:03izquierda el tercer carácter de derecha
1:37:06a izquierda
1:37:07si restamos 4 llegamos a r y así
1:37:10sucesivamente puedes probar todos los
1:37:13números válidos para estos índices
1:37:14también en lugar de escribir el número
1:37:17aquí de forma explícita podríamos
1:37:21declarar una variable n aquí la podemos
1:37:25declarar por ejemplo aquí arriba y aquí
1:37:27le asignamos el valor que hemos usa y
1:37:30eso sería una forma de poder actualizar
1:37:32ambos valores como queramos en un solo
1:37:36lugar sin tener que cambiar el valor
1:37:37directamente en la expresión si vuelvo a
1:37:40cambiar estos dos el resultado es lo que
1:37:42esperábamos que es p y aquí tenemos una
1:37:44expresión general para obtener el
1:37:46enésimo carácter de derecha a izquierda
1:37:48en la cadena bien pasemos a nuestro
1:37:51siguiente tema ya cubrimos cómo puedes
1:37:53acceder a los caracteres de una cadena
1:37:55de izquierda a derecha y de derecha a
1:37:57izquierda
1:37:58así que continuemos con nuestro próximo
1:38:00tema
1:38:06ahora comenzamos nuestro primer mini
1:38:08proyecto en este proyecto vamos a
1:38:11implementar nuestra versión de un juego
1:38:14muy popular que se llama en inglés matt
1:38:16lips se traduce como historias locas o
1:38:19en nuestra versión la vamos a llamar
1:38:21como palabras en blanco que vamos a
1:38:24hacer vamos a practicar como concatenar
1:38:26cadenas de caracteres las cadenas que
1:38:28tenemos aquí tenemos cuatro cadenas que
1:38:30representan cuatro elementos distintos
1:38:33de una oración
1:38:34sustantivo adjetivo verbo y adverbios
1:38:37perro negro corrió rápidamente nuestro
1:38:41objetivo en este juego es concatenar las
1:38:43cadenas para crear una cadena que
1:38:45muestre un mensaje puedes cambiar el
1:38:47valor de las variables entonces podría
1:38:49ser en vez de perro o cualquier otro
1:38:51sustantivo que quieras
1:38:52cualquier otro adjetivo verbo o adverbio
1:38:55por ejemplo el perro negro corrió
1:38:58rápidamente a la tienda pero como puedes
1:39:01notar no todas las palabras de la
1:39:04oración están incluidas por ejemplo él
1:39:06no es parte de ninguna variable
1:39:10no es parte de ninguna de estas cadenas
1:39:12de caracteres así que vamos a tener que
1:39:16concatenar muchas cadenas para formar
1:39:18nuestra oración final este es otro
1:39:20ejemplo que podrías hacer la bicicleta
1:39:22pequeña voló a la tienda lentamente no
1:39:25necesariamente tiene que tener sentido y
1:39:27por eso es que el juego original también
1:39:29se llama historias locas puedes hacer
1:39:32cualquier oración graciosa también por
1:39:34eso que se llama historias locas
1:39:36entonces vamos a comenzar lo que tenemos
1:39:39que hacer es aquí
1:39:41reemplazar esas comillas en blanco esa
1:39:44cadena vacía por una secuencia de
1:39:47cadenas concatenadas que van a resultar
1:39:50en nuestro mensaje final si queremos
1:39:52hacer por ejemplo esta primera oración
1:39:55qué es lo que necesitamos
1:39:59y luego tenemos perros pero perro ya la
1:40:02tenemos asignada a nuestro variable mi
1:40:05sustantivo
1:40:07así que
1:40:10decimos aquí mi sustantivo y como no
1:40:13queremos que estén pegadas queremos que
1:40:16estén separadas tenemos que agregar un
1:40:18espacio podemos agregar el espacio
1:40:22individualmente de esta forma podemos
1:40:24agregarlo al final de la primera cadena
1:40:26en este caso y siempre recordar el
1:40:30operador más que nos permite concatenar
1:40:32las el perro luego tenemos el adjetivo
1:40:36negro
1:40:37corrió tenemos el verbo
1:40:41y el adverbio rápidamente
1:40:45y luego completamos esta parte de la
1:40:48oración
1:40:49a la tienda puedes ver que la línea
1:40:52continúa aquí abajo porque estamos
1:40:54usando el editor de ficus camps también
1:40:56en otros editores la línea continuaría
1:40:58ver de forma horizontal y si quieres la
1:41:00puedes dividir en varias líneas
1:41:02bien así que ya tenemos nuestra cadena
1:41:05resultante y podemos mostrarla en la
1:41:07consola veamos qué es lo que tenemos
1:41:09aquí aquí vemos un detalle que tenemos
1:41:12que corregir vemos el perro negro corrió
1:41:15rápidamente a la tienda no estamos
1:41:18incluyendo espacios entre las palabras
1:41:20entre el adjetivo / el verbo y el
1:41:22adverbio y la otra parte de la cadera
1:41:25así que vamos a hacerlo
1:41:28para agregar el espacio
1:41:31simplemente escribimos una cadena que
1:41:33contiene un espacio y la conca tenemos
1:41:36con ambas cadenas
1:41:38así separamos el sustantivo del adjetivo
1:41:40con un espacio luego otro espacio para
1:41:44la cadena antes del verbo
1:41:47otro espacio para el adverbio y aquí
1:41:51antes de la letra podemos agregar un
1:41:54espacio también
1:41:55y cuál va a ser el resultado el perro
1:41:58negro corrió rápidamente a la tienda
1:42:01podemos también agregar un punto al
1:42:03final genial ya tenemos el primer
1:42:05ejemplo creado y podéis ver como siempre
1:42:08hay que estar pendiente de los espacios
1:42:10no podemos simplemente concatenar las
1:42:12cadenas porque el espacio no se asume se
1:42:15van a concatenar pegadas o sin ninguna
1:42:17separación
1:42:18tu meta es sustituir o reemplazar esta
1:42:21parte del código para crear esta oración
1:42:25la bicicleta pequeña voló a la tienda
1:42:28lentamente para eso vas a tener que
1:42:31actualizar estas variables el sustantivo
1:42:34en lugar de perro ahora va a ser
1:42:35bicicleta el adjetivo en lugar de negro
1:42:38va a ser pequeña el verbo en lugar de
1:42:41corrió va a ser bolo y el adverbio en
1:42:45lugar de rápidamente va a ser lentamente
1:42:49aquí también tenemos que agregar una
1:42:51palabra la ok
1:42:54así que
1:42:56tómate unos segundos o unos minutos para
1:42:59hacer estas modificaciones concatena las
1:43:01cadenas y formas de esta oración cuando
1:43:04estés listo o lista vuelve para ver cómo
1:43:07podemos crear esta oración
1:43:10bien el primer cambio que tenemos que
1:43:13hacer es borrar la oración anterior aquí
1:43:16vamos a tener un error hasta que
1:43:19creemos con que tenemos las cadenas pero
1:43:21lo primero que tenemos que hacer es
1:43:23cambiar estos valores en vez de perro
1:43:26ahora tendremos bicicletas en vez de
1:43:28adjetivos ahora vamos a tener pequeña el
1:43:32verbo en vez de corrió va a ser bolo y
1:43:35el adverbio va a ser lentamente
1:43:38bien ya tenemos por lo menos los
1:43:40componentes principales de nuestra
1:43:42oración cómo podemos crear esta oración
1:43:45aquí abajo
1:43:47no está ninguna de nuestras variables
1:43:49así que la necesitamos para concatenar
1:43:51la bicicleta si es el sustantivo
1:43:54y luego tenemos el adjetivo pero
1:43:58recuerda que tenemos que separarlos con
1:44:00un espacio luego el verbo pero
1:44:02necesitamos el espacio también mi verbo
1:44:06lo escribimos a la tienda
1:44:09y podemos agregar el espacio al final y
1:44:12luego y luego mi adverbio que es
1:44:17lentamente aquí al final tenemos un
1:44:20espacio en la cadena no se ve claramente
1:44:22aquí porque el editor baja las comillas
1:44:25a la otra línea pero antes de esas
1:44:27comillas aquí tenemos un espacio
1:44:30bien así que vamos a ver el resultado a
1:44:33ver si tenemos que hacer algún cambio
1:44:35jaja aquí tenemos que hacer un pequeño
1:44:37cambio voló a la tienda tenemos que
1:44:40separar el valor y la letra a lo que
1:44:42tenemos que hacer nada más es agregar un
1:44:44espacio aquí antes de la a y ya vemos el
1:44:47resultado la bicicleta pequeña voló a la
1:44:50tienda lentamente y podemos agregar un
1:44:53punto al final de la cadena lo que
1:44:56tenemos es que concatenar una cadena que
1:44:58contenga sólo un punto
1:45:00y vemos el resultado modificado con el
1:45:03punto genial ya completaste tu primer
1:45:06mini proyecto en javascript y ya
1:45:08prácticas te como concatenar cadenas de
1:45:10caracteres recuerda siempre estar
1:45:12pendiente de los espacios y de los
1:45:14símbolos que son necesarios al principio
1:45:16y al final de la cadena buen trabajo
1:45:19vamos a seguir con nuestro siguiente
1:45:21tema
1:45:27ahora veremos otro tipo de dato muy
1:45:29importante que puedes usar en javascript
1:45:32los arreglos los arreglos son las
1:45:35estructuras de datos que nos permiten
1:45:37almacenar múltiples valores en una misma
1:45:40estructura ya vas a ver son muy
1:45:42parecidos a lo que nosotros
1:45:44consideraríamos como una lista vamos a
1:45:47definir una variable que se va a llamar
1:45:49mi arreglo y a esa variable le vamos a
1:45:52asignar un arreglo para crear un arreglo
1:45:56escribimos corchetes y dentro de los
1:45:59corchetes tendríamos los elementos de
1:46:02ese arreglo
1:46:04por ejemplo yo y 24 tenemos una cadena
1:46:08de caracteres y un número los elementos
1:46:12del arreglo están en una secuencia
1:46:14específica cada uno tiene su lugar en
1:46:17esa secuencia y la secuencia está en un
1:46:19orden específico así como podríamos
1:46:22acceder a los caracteres de una cadena
1:46:24con sus índices también vamos a poder
1:46:27acceder a cada uno de estos elementos
1:46:30con su índice correspondiente vamos a
1:46:33mostrar el arreglo y la consola a ver
1:46:36que obtenemos vemos exactamente los dos
1:46:39valores que están almacenados en el
1:46:42arreglo y puedes ver que vamos a poder
1:46:44acceder a esa estructura completa a
1:46:47través de la variable mi arreglo esa es
1:46:50la ventaja podemos agrupar valores bajo
1:46:52una misma estructura
1:46:54veamos otro ejemplo de un arreglo si
1:46:58queremos crear una lista de los
1:46:59estudiantes en un curso
1:47:02sus nombres podemos guardar todos esos
1:47:06nombres en una misma estructura en
1:47:09nuestro programa
1:47:11digamos que la llamamos estudiantes
1:47:13llamamos a este arreglo estudiantes
1:47:16simplemente creamos el arreglo con
1:47:18corchetes y escribimos los elementos que
1:47:21queremos agrupar cada elemento debe
1:47:25estar separado del otro por una coma y
1:47:27por un espacio después de la coma el
1:47:30espacio se recomienda para que el código
1:47:32sea más fácil de leer si mostramos ese
1:47:35arreglo
1:47:38estudiantes aquí lo podemos ver tenemos
1:47:41los cuatro elementos agrupados en una
1:47:43misma estructura
1:47:45otro ejemplo podría ser notas de un
1:47:47examen
1:47:48digamos 95 67 89 y 56 como cuatro
1:47:55exámenes y un estudiante saco esas
1:47:57cuatro notas en cada uno de los exámenes
1:47:59en una escala entre 1 y 100 también
1:48:02podemos agrupar esas notas bajo una
1:48:05misma estructura de datos en nuestro
1:48:07programa aquí la tenemos
1:48:09así que ya ves como los arreglos pueden
1:48:12ser muy poderosos para trabajar con
1:48:15valores relacionados en este caso
1:48:17teníamos nombres de estudiantes en este
1:48:20caso notas y en este caso digamos que
1:48:23podría ser un arreglo que es guarda el
1:48:26nombre del bona y su edad en las
1:48:28próximas partes del curso vas a aprender
1:48:30más sobre cómo puedes trabajar con los
1:48:33arreglos en javascript así que
1:48:35continuemos
1:48:41algo muy interesante sobre los arreglos
1:48:43es que pueden contener cualquier tipo de
1:48:46datos incluyendo otros arreglos si
1:48:49seguimos con nuestro ejemplo de la lista
1:48:51de estudiantes ahora podemos representar
1:48:53más sobre cada estudiante si han y damos
1:48:56los arreglos aquí tenemos un arreglo
1:48:59principal que estamos creando como los
1:49:01que trabajamos en el tema anterior vemos
1:49:03cuatro números elementos separados por
1:49:05coma y un espacio ahora si esos
1:49:08elementos en lugar de ser enteros o
1:49:10cadenas de caracteres fuesen arreglos es
1:49:14lo que llamamos un arreglo anidado aquí
1:49:17puedes ver tenemos un par de corchetes y
1:49:21otro par de corchetes separados por una
1:49:24coma y un espacio y dentro de estos
1:49:26arreglos podemos colocar los datos que
1:49:28necesitemos por ejemplo no ahora tuvo
1:49:32una nota del 97 en la materia y si no
1:49:35tuvo una nota del 78 en la materia así
1:49:38estamos creando elementos individuales
1:49:40del arreglo principal aquí podemos decir
1:49:44en el primer arreglo el primer elemento
1:49:47estamos guardando la data del estudiante
1:49:51en hora que detuvo una nota de 97 y en
1:49:54el segundo reg lo tenemos allí no cuya
1:49:57nota fue en 78
1:49:59cada uno de estos arreglos puede ser
1:50:01utilizado de forma individual pero los
1:50:03estamos guardando en una estructura más
1:50:05grande que los contiene a todos y
1:50:08podemos usar esta variable para acceder
1:50:10a esos valores si mostramos estos
1:50:13valores puedes ver que se muestran los
1:50:15arreglos anidados aquí tenemos el
1:50:18arreglo principal que es toda la
1:50:20estructura puedes ver los corchetes que
1:50:23los rodean y luego dentro de esa
1:50:25estructura de datos tenemos dos arreglos
1:50:27con sus correspondientes valores bien
1:50:30ahora veamos otro ejemplo
1:50:33digamos que yo quiero hacer una lista de
1:50:35precios tengo un inventario y quiero
1:50:39crear un arreglo sencillo para los tipos
1:50:42de elementos que vendo metiendo
1:50:45lista de precios
1:50:47creamos un arreglo que va a contener una
1:50:50secuencia de arreglos el arreglo
1:50:53principal va a tener un arreglo por cada
1:50:56elemento cada artículo que yo vendo por
1:50:59ejemplo camisa su precio es cinco puntos
1:51:0267 y el código en el almacén es ese 134
1:51:08mes así estoy agrupando todos los datos
1:51:11relacionados a las camisas para mi
1:51:14contexto en el mismo arreglo y aún así
1:51:17es parte de un arreglo principal que me
1:51:20da la data para la lista de precios o
1:51:23lista de productos vamos a cambiarle el
1:51:25nombre esta variable lista de productos
1:51:27luego digamos que vendemos celulares
1:51:30estos celulares cuestan 250 dólares y
1:51:33tienen el código en el almacén de ese
1:51:36356 también vendemos zapatos es una
1:51:40tienda muy variada vende camisas
1:51:41celulares y zapatos
1:51:4436.7 digamos que cuestan en promedio el
1:51:47código es 6 7 8
1:51:50luego en el próximo tema vas a ver cómo
1:51:53podemos acceder a cada uno de esos
1:51:55arreglos internos los arreglos anidados
1:51:57si mostramos la lista de productos en la
1:52:00consola vamos a comentar esta línea para
1:52:03que solo se vea este valor puedes ver
1:52:06este resultado tenemos un arreglo
1:52:09principal que contiene tres arreglos
1:52:11anidados bien y también para mostrarte
1:52:14que no solo podemos trabajar con enteros
1:52:16y con cadenas de caracteres podemos
1:52:19crear un arreglo con arreglos anidados
1:52:22que contengan solo números decimales por
1:52:25ejemplo si tenemos un experimento
1:52:27realizamos un experimento y recolectamos
1:52:29los datos digamos que para cada tipo de
1:52:32experimento vamos a recolectar tres
1:52:35datos tres veces vamos a repetir cada
1:52:37tipo de experimentos entonces podemos
1:52:40crear un arreglo de esta forma
1:52:43un arreglo que contiene un arreglo
1:52:45anidado para cada tipo de experimento
1:52:48con sus tres resultados
1:52:505.6 3.4 7.8 esto podría ser minutos que
1:52:54tome realizar un experimento podría ser
1:52:57algún resultado de una medida pero lo
1:52:59importante es que los estamos agrupando
1:53:01y podemos acceder a ellos como una
1:53:03estructura de datos una agrupación de
1:53:05datos relacionados con su punto los
1:53:08decimos datos y comentamos
1:53:11esta línea anterior y aquí podemos ver
1:53:14el resultado en el bien ya sabes cómo
1:53:18definir un arreglo con arreglos anidados
1:53:20y para qué se usa así que pasemos a
1:53:23nuestro siguiente tema hay mucho más que
1:53:25ver sobre arreglos así que continuemos
1:53:34una vez que ya definiste tu arreglo en
1:53:36el programa es muy importante saber cómo
1:53:39acceder a sus elementos porque para eso
1:53:41que estamos creando el arreglo para
1:53:43poder agrupar los elementos y luego
1:53:45utilizarlos usarlos en el programa
1:53:48vamos a definir una variable mi arreglo
1:53:51recuerda que es con corchetes que
1:53:54definimos un arreglo y este arreglo va a
1:53:56tener tres elementos diez veinte y
1:53:59treinta y tres números aquí voy a
1:54:02escribir un comentario para que hagamos
1:54:03un diagrama mixta que es parecido al que
1:54:06hicimos con la cadena javascript con sus
1:54:09índices aquí vemos el arreglo y aquí
1:54:12vamos a ver el índice que corresponde a
1:54:14cada uno de esos elementos igual que en
1:54:16las cadenas de caracteres teníamos un
1:54:18índice para cada carácter aquí vamos a
1:54:21tener para un arreglo un índice para
1:54:23cada elemento
1:54:24comenzando desde el cero igual que en
1:54:27las cadenas comenzamos a contar desde
1:54:29cero en lugar de 1 así que el primer
1:54:32elemento está en la posición en el
1:54:34índice 0 el segundo elemento está en el
1:54:36índice 1 el tercer elemento está en el
1:54:39índice 2 y así sucesivamente para cada
1:54:42uno de los elementos que tengamos en el
1:54:44arreglo
1:54:45así que cómo podemos acceder a estos
1:54:48elementos vamos a mostrarlos en la
1:54:50consola de esta forma escribimos el
1:54:54nombre de la variable que contiene el
1:54:55arreglo me arreglo y dentro de corchetes
1:54:59igual que indexa vamos cadenas de
1:55:01caracteres vamos a escribir el índice
1:55:04del elemento
1:55:06en este caso como es el índice 0 vamos a
1:55:09tener el elemento 10 que lo tenemos acá
1:55:11en el índice 0 si escribimos el índice 1
1:55:16podemos acceder al elemento 20 que
1:55:19tenemos acá si escribimos el índice
1:55:22todos podemos acceder al elemento 30 que
1:55:26tenemos aquí
1:55:27así que ya podemos acceder a los tres
1:55:30elementos del arreglo veamos en la
1:55:32consola aquí puedes ver cómo tenemos los
1:55:35tres elementos 10 20 y 30 en ese orden
1:55:39con los índices 0 1 y 2 si tuviéramos un
1:55:42cuarto elemento por ejemplo 40 el índice
1:55:45sería 3 y pudiéramos acceder a ese
1:55:47elemento con el índice 3 porque es
1:55:50importante acceder a estos elementos
1:55:51porque podemos usarlos en el programa
1:55:54por ejemplo si queremos sumarlos y
1:55:57decimos aquí suma podemos hacerlo hay
1:56:00otras formas más eficientes de hacerlo
1:56:02pero esto es un ejemplo de cómo se puede
1:56:03usar podemos tomar cada uno de ellos mi
1:56:08arreglo
1:56:10101 y mi arreglo 2
1:56:14estamos tomando cada uno de sus valores
1:56:17en el índice cero en el índice 1 y en el
1:56:20índice 2 y los estamos sumando y el
1:56:23resultado lo estamos asignando a la
1:56:25variable suma luego podemos mostrar ese
1:56:29valor en la consola primero deberíamos
1:56:32comentar estas líneas para no ver los
1:56:35resultados anteriores y el resultado nos
1:56:38va a mostrar la suma de los tres
1:56:40elementos que es 60 así es como podemos
1:56:44usar los elementos de un arreglo en
1:56:47nuestro programa simplemente escribimos
1:56:49el nombre de la variable seguido de
1:56:51corchetes y dentro de los corchetes del
1:56:54índice del elemento al cual queremos
1:56:56acceder
1:57:02también es muy importante saber cómo
1:57:04modificar los datos de un arreglo así
1:57:08que veamos un ejemplo si tenemos este
1:57:10arreglo con los elementos 10 20 y 30 y
1:57:14digamos que queremos actualizar
1:57:17el valor o cambiarlo de 10 a 40 cómo
1:57:22podemos hacerlo la sintaxis es muy
1:57:24parecida a cómo accedemos al elemento
1:57:28escribimos el nombre de la variable
1:57:30luego corchetes y dentro de los
1:57:32corchetes el índice del elemento que
1:57:35queremos cambiar y
1:57:38ahora lo que vamos a escribir es algo
1:57:40parecido a como asignamos el valor a una
1:57:43variable es exactamente igual en
1:57:45realidad es el lado derecho de esa línea
1:57:47tenemos el signo igual seguido del nuevo
1:57:51valor el signo igual y el número que
1:57:55queremos asignar con esta línea
1:57:57básicamente le decimos a javascript
1:58:00quiero actualizar un valor en este
1:58:03arreglo en el índice 0 ahora quiero que
1:58:06aparezca este valor eso es básicamente
1:58:08lo que hacemos con esta línea
1:58:11y como los arreglos son mutables a
1:58:14diferencia de las cadenas de caracteres
1:58:15si podemos cambiar un elemento
1:58:18individual del arreglo
1:58:20si mostramos el valor del arreglo luego
1:58:23de ese cambio podemos verlo en la
1:58:24consola aquí puedes ver que el valor en
1:58:28el índice 0 ahora es 40 en lugar de 10
1:58:31lo que teníamos inicialmente y así es
1:58:34como puedes actualizar un elemento en un
1:58:36arreglo también podríamos asignar
1:58:39valores de distintos tipos por ejemplo
1:58:42si en el índice 1
1:58:45vamos a cerrar la consola aquí para
1:58:48poder ver el código más detalle en el
1:58:50índice 1 yo quisiera asignar una cadena
1:58:53que diga hola por ejemplo en lugar de
1:58:57este número el número 20 vamos a tener
1:58:59esta cadena en el arreglo veamos la
1:59:02consola aquí lo puedes ver en el índice
1:59:061 ahora tenemos la cadena ahora en lugar
1:59:09del número original
1:59:10también podríamos asignar otros tipos de
1:59:12datos por ejemplo podemos asignar un
1:59:15arreglo como el valor en este caso
1:59:19piensa por un segundo que es lo que
1:59:21obtendríamos estamos asignando este
1:59:24valor
1:59:25al índice 1 que es lo que va a ocurrir
1:59:28es algo que vemos en un tema anterior
1:59:31veamos la una consola aquí puedes ver
1:59:34que tenemos un arreglo vanidad porque
1:59:37porque dijimos que queremos que todo
1:59:39este arreglo sea el elemento que va a
1:59:42aparecer en el índice 1 y este es el
1:59:44elemento que va a aparecer en el índice
1:59:461 igual se preservan los elementos que
1:59:50ya estaban en el arreglo antes del
1:59:51cambio 10 y 30 pero también tenemos una
1:59:54regularidad bien ya sabes cómo acceder a
1:59:57los elementos de un arreglo con su
1:59:59índice correspondiente recuerda que
2:00:01comenzamos a contar desde cero luego
2:00:03vamos a 1 luego vamos a 2 y así
2:00:05sucesivamente para cada elemento y que
2:00:08podemos asignar un valor de cualquier
2:00:10tipo de datos ahora pasemos a nuestro
2:00:13siguiente temas sobre arreglos
2:00:20así como puedes acceder a los elementos
2:00:23de un arreglo elementos como números o
2:00:25cadenas también puedes acceder a
2:00:28elementos que sean arreglos o arreglos
2:00:30anidados los arreglos que contienen
2:00:33arreglos anidados se denominan arreglos
2:00:37multidimensionales veamos un ejemplo mi
2:00:40arreglo y este arreglo solo va a
2:00:43contener arreglos anidados tenemos 1 2 3
2:00:464 5 6 7 8 9
2:00:51es un arreglo principal que contiene
2:00:54tres elementos este es el primer
2:00:56elemento este es el segundo elemento y
2:00:59este es el tercer elemento lo puedes
2:01:01distinguir visualmente por las comas que
2:01:04tenemos aquí luego del corchete que
2:01:06cierra el elemento esto es lo que nos
2:01:08separa un elemento de otro en el arreglo
2:01:11principal así que tenemos tres elementos
2:01:14pero como podemos usar los índices para
2:01:17acceder a estos números que tenemos aquí
2:01:20veamos un momentito un diagrama que
2:01:23vamos a crear aquí rapidito decimos
2:01:26arreglo después vamos a tener una
2:01:28secuencia de índices y luego vamos a
2:01:31tener una secuencia de índices internos
2:01:33para cada uno de esos elementos o de
2:01:35esos arreglos anidados vamos a copiar y
2:01:38pegar este arreglo aquí cada uno de esos
2:01:42arreglos tiene un índice que nos permite
2:01:45acceder a todo el arreglo completo como
2:01:48un elemento
2:01:50este es el índice cero este es el índice
2:01:521 y este es el índice 2
2:01:55así que si usamos el índice 1 por
2:01:57ejemplo vamos a acceder a este arreglo
2:01:59completo con todos sus tres elementos
2:02:02después si queremos acceder a algunos de
2:02:05esos elementos internos de cada uno de
2:02:07los arreglos anidados tenemos que usar
2:02:10otro índice más si vamos a usar dos
2:02:13índices porque tenemos primero que decir
2:02:15cuál arreglo queremos seleccionar de
2:02:18estos tres y después decir cuál elemento
2:02:21queremos seleccionar de ese arreglo así
2:02:24que reiniciamos o volvemos a comenzar la
2:02:27secuencia de índices desde 0 0 1 y 2
2:02:330 1 y 2 0 1 y 2 así que si cogemos por
2:02:39ejemplo primero el índice 0 vamos a
2:02:42escoger este arreglo y si queremos el
2:02:44número 3 tenemos que escoger nuevamente
2:02:46otro índice que es el 2 y así vamos a
2:02:49llegar al número que tenemos acá
2:02:51analiza esto por un segundo por ejemplo
2:02:54cómo accederían a este elemento el
2:02:58número 8 piensa esto por unos segundos
2:03:03lo primero que haríamos es usar el
2:03:06índice 2 para acceder a este arreglo
2:03:08completo y luego estaríamos el índice 1
2:03:12porque el elemento 8 el número 8 está en
2:03:15el índice 1 de ese arreglo es el segundo
2:03:18elemento recuerda que comenzamos a
2:03:20contar desde cero
2:03:22bien ya esta es la parte teórica de cómo
2:03:24va a funcionar así que veamos el cuadro
2:03:27primero vamos a comprobar que podemos
2:03:29acceder a estos arreglos de forma
2:03:31individual a todo el arreglo completo
2:03:34usando su índice mi arreglo en el índice
2:03:39cero
2:03:41será este arreglo 1 2 3
2:03:44el índice 0 no retorna esta regla en la
2:03:48consola podemos ver el arreglo 123
2:03:51exactamente lo que necesitábamos lo que
2:03:53queríamos y lo que esperábamos de ahora
2:03:56vamos a probar con los otros dos índices
2:03:58y arreglo 1
2:04:024 5 y 6
2:04:06y luego me arreglo 2
2:04:107 8 y 9
2:04:12aquí podemos ver los tres resultados
2:04:14podemos acceder a cada uno de estos
2:04:17arreglos de forma individual a todo el
2:04:19arreglo completo pero también es
2:04:22probable que necesitemos acceder luego a
2:04:24algunos de estos elementos de cada uno
2:04:27de esos arreglos como podemos hacerlo
2:04:30con el segundo índice que vimos en el
2:04:32diagrama
2:04:32digamos que queremos acceder al número 6
2:04:36que tenemos acá vamos a borrar estas dos
2:04:39líneas porque solo vamos a trabajar en
2:04:42este ejemplo con el segundo arreglo
2:04:44anidada que tenemos acá
2:04:46el arreglo está en el índice 1 pero
2:04:49luego de que accedemos a ese arreglo en
2:04:52el índice 1 tenemos que especificar el
2:04:54índice del elemento que queremos acceder
2:04:57que queremos obtener en este caso
2:04:59queremos obtener el elemento 6 el tercer
2:05:03elemento en el arreglo ya dijimos que
2:05:05este es el arreglo en el índice número 1
2:05:07y ahora tenemos que decir que el número
2:05:10está en el índice 2 el elemento que
2:05:13queremos acceder está en el índice 2
2:05:16y como puedes ver tenemos una secuencia
2:05:18de dos índices así es como podemos
2:05:21acceder a un elemento de una regla
2:05:23unidad primero especificamos el índice
2:05:26del arreglo y luego el índice del
2:05:28elemento esto ya no va a ser un arreglo
2:05:30sino que va a ser el elemento 6
2:05:33si abrimos la consola podemos verlo aquí
2:05:36tenemos el número 6 probemos con otra
2:05:39combinación por ejemplo si queremos
2:05:41exceder al elemento 7 aquí el número 7
2:05:45vemos que está en el arreglo que está en
2:05:49el índice 2 así que cambiaremos el 1 por
2:05:53el 2 y luego para acceder al número 7
2:05:56cambiaríamos este índice por 0
2:05:59primero el índice del arreglo y luego el
2:06:02índice del elemento esto resultaría en 7
2:06:06veámoslo en la consola aquí lo podemos
2:06:09ver tenemos el elemento que es el número
2:06:117 exactamente lo que queríamos
2:06:14podemos escribir la secuencia para
2:06:16ilustrar esto mejor por ejemplo si
2:06:18queremos acceder a todos los elementos
2:06:20del segundo arreglo tendríamos que ir
2:06:24incrementando el índice del elemento
2:06:26nada más nos mantenemos en el índice
2:06:29constante del índice 1 porque estamos en
2:06:32el mismo arreglo pero vamos cambiando el
2:06:34índice que corresponde al elemento y
2:06:36tendríamos 4 5 y 6
2:06:42te recomiendo practicar cómo acceder a
2:06:44los elementos de este arreglo este
2:06:47arreglo está en el índice cero y cada
2:06:49uno de los elementos está en su índice
2:06:51correspondiente práctica cómo acceder a
2:06:53cada uno de esos elementos y cuando
2:06:55estés listo o lista continúa con el
2:06:58siguiente tema
2:07:03y los arreglos son las estructuras de
2:07:05datos muy poderosas no solamente podemos
2:07:07acceder y modificar los elementos de un
2:07:10arreglo también podemos agregar
2:07:13elementos al arreglo así que veamos cómo
2:07:15puedes agregar esos elementos digamos
2:07:18que tenemos una lista de cadenas de
2:07:21caracteres que van a representar las
2:07:23estaciones del año están ordenadas en
2:07:26orden alfabético
2:07:27y cuál es la que nos falta verán a cómo
2:07:31podemos agregar esa cadena de caracteres
2:07:33al arreglo con algo llamado un método un
2:07:38método es como una función que podemos
2:07:40llamar para hacer algo con un elemento
2:07:43de nuestro código
2:07:45y los arreglos tienen métodos
2:07:47específicos que podemos llamar para
2:07:49trabajar con ellos
2:07:50el método push es muy útil porque nos
2:07:53permite añadir un elemento al final del
2:07:56arreglo y eso es exactamente lo que
2:07:58necesitamos en este caso porque queremos
2:08:01que esté ordenado en orden alfabético
2:08:04queremos agregar verano aquí al final
2:08:07como el cuarto elemento para eso
2:08:09llamamos al método puig escribimos el
2:08:12nombre de la variable se llevó un punto
2:08:14el punto es esencial porque el punto le
2:08:18dice a chabás que bueno toma este
2:08:20arreglo y para ese arreglo en particular
2:08:23realiza esta acción pues literalmente
2:08:27sería empujar pero en este contexto
2:08:30sería añadir un elemento al final del
2:08:32arreglo
2:08:33así que si mostramos el valor del
2:08:36arreglo luego de agregar ese elemento
2:08:38que es lo que resulta vemos que el
2:08:41arreglo tiene este elemento verano bien
2:08:44ahora veamos otros métodos que van a ser
2:08:46útiles para trabajar con arreglos
2:08:48también
2:08:52también tenemos un método para remover
2:08:56el último elemento de un arreglo veamos
2:08:58un ejemplo
2:09:00vamos a declarar una variable estaciones
2:09:03y vamos a inicializar su valor a un
2:09:07arreglo con las cuatro estaciones
2:09:10ordenadas alfabéticamente
2:09:13de esta forma digamos que queremos
2:09:16remover el último elemento del arreglo
2:09:19en este caso sería verano que tenemos
2:09:22que hacer simplemente llamamos al método
2:09:25pop escribimos el nombre de la variable
2:09:28luego el nombre del método pop y esto va
2:09:31a remover el último elemento vamos a
2:09:34mostrar el valor de estaciones luego de
2:09:37llamar a pop aquí lo vemos verano fue
2:09:40removido del final del arreglo invierno
2:09:43otoño y primavera
2:09:45wow también además de remover ese
2:09:48elemento lo retorna así que podemos
2:09:51asignarlo a una variable digamos que
2:09:54tenemos una variable llamada estación
2:09:58vamos a declarar la aquí arriba vamos a
2:10:01asignarle ese valor que estamos
2:10:04removiendo verano a la variable estación
2:10:07esa es otra ventaja que nos da el método
2:10:10pop podemos eliminar el elemento y
2:10:13asignarlo a una variable para trabajar
2:10:15con ese elemento de forma individual si
2:10:18lo necesitamos
2:10:20vamos a mostrar el arreglo y también
2:10:22vamos a mostrar la estación que fue
2:10:25removida aquí lo podemos ver el arreglo
2:10:28tiene tres elementos nada más y la
2:10:30estación verano esta cadena de
2:10:33caracteres que fue removida fue asignada
2:10:36exitosamente a la variable estación
2:10:39genial ya sabes cómo trabajar con el
2:10:42método pop recuerda escribes el nombre
2:10:45de la variable seguido de un punto el
2:10:47nombre del método y en este caso pop no
2:10:51toma ningún argumento así que solo
2:10:53escribes paréntesis vacíos para llamar
2:10:56al método
2:11:01tenemos otro método de arreglos que es
2:11:04muy muy útil que nos permite remover el
2:11:06primer elemento del arreglo en vez de
2:11:09removerlo del final del arreglo el
2:11:11último elemento ahora vamos a remover el
2:11:14primer elemento
2:11:15veamos
2:11:17tenemos un arreglo con las estaciones
2:11:19invierno otoño y primavera cómo podemos
2:11:22eliminar la cadena que dice invierno
2:11:24también podemos agregar verano aquí como
2:11:28podemos eliminar la primera cadena del
2:11:31arreglo invierno el primer elemento lo
2:11:34que podemos hacer es escribir el nombre
2:11:36de la variable que contiene el arreglo y
2:11:39llamar al método shift el método shift
2:11:43nos permite remover el primer elemento
2:11:46del arreglo no tenemos que especificar
2:11:48ningún valor pero los paréntesis si son
2:11:51muy muy importantes porque eso es lo que
2:11:54le dice a javascript quiero que ejecute
2:11:56esta acción y luego de ejecutar esta
2:11:59acción podemos ver el valor del arreglo
2:12:02estaciones
2:12:04otoño primavera y verano puedes ver que
2:12:07invierno fue removido exitosamente de
2:12:10nuestro arreglo luego de llamar a shift
2:12:12genial ya puedes remover el primer
2:12:15elemento del arreglo pero también
2:12:17podemos agregar un elemento al principio
2:12:20de la regla y eso lo que vamos a ver en
2:12:22el próximo tema
2:12:29ahora veamos cómo puedes agregar un
2:12:31elemento al principio de un arreglo por
2:12:35ejemplo si tenemos estas tres estaciones
2:12:37invierno otoño y primavera
2:12:39digamos que queremos agregar verano al
2:12:41principio del arreglo que aparezca aquí
2:12:44antes de invierno lo podemos hacer
2:12:46llamando al método and set ya saber cómo
2:12:50se escribe
2:12:51escribimos el nombre de las variables
2:12:53seguido en un punto y luego
2:12:57escribimos on shift
2:12:59recuerda que el método anterior era
2:13:01shift 'será para eliminar aun shift es
2:13:05para agregar al principio de la regla
2:13:08pero en este caso si tenemos que
2:13:10especificar un valor entre paréntesis
2:13:12porque tenemos que decirle a javascript
2:13:15que elemento queremos agregar al
2:13:17principio del arreglo en este caso sería
2:13:21la cadena verano podemos agregar un
2:13:24comentario aquí agregar al principio del
2:13:28arreglo y si mostramos luego de realizar
2:13:31esta operación el nuevo valor del
2:13:34arreglo lo veremos actualizado aquí
2:13:37puedes ver la consola vemos verano
2:13:39invierno otoño y primavera verano es el
2:13:42primer elemento del arreglo exactamente
2:13:46lo que queríamos al llamar a un set
2:13:49bien ya sabes los cuatro métodos
2:13:51principales puig
2:13:54shift y on sep para trabajar con el
2:13:57principio y el final de un arreglo buen
2:13:59trabajo y buen trabajo durante el curso
2:14:01ya estás avanzando muchísimo ya suaves
2:14:03operaciones importantísimas para
2:14:05programar en javascript
2:14:07así que cuando estés listo lista
2:14:08continuemos al siguiente tema
2:14:15genial ahora comenzamos nuestro segundo
2:14:18mini proyecto
2:14:20en este mini proyecto nos vamos a
2:14:22centrar en los arreglos anidados vamos a
2:14:25escribir un arreglo multidimensional que
2:14:27representa en nuestra lista de compras
2:14:29digamos que vamos a ir al supermercado y
2:14:32queremos representar nuestra lista de
2:14:34compras en javascript así que vamos a
2:14:37hacer lo primero vamos a definir una
2:14:39variable que va a tener como nombre mi
2:14:41lista de compras lo primero que hacemos
2:14:43es definir el arreglo principal con un
2:14:46par de corchetes y luego empezamos a
2:14:49escribir los arreglos anidados
2:14:52que vamos a escribir en estos arreglos
2:14:54anidados
2:14:55primero el producto que vamos a comprar
2:14:58por ejemplo serial y después la cantidad
2:15:02si son cajas es el número representaría
2:15:05cajas y esk y los representaría aquí los
2:15:07diez paquetes representaría paquetes que
2:15:10vamos a comprar tres cajas de cereal
2:15:14vamos a comprar dos cartones de leche
2:15:16vamos a comprar cuatro paquetes de
2:15:19galletas luego también tenemos que
2:15:21comprar cinco panes cinco panes de
2:15:23sándwich puede ser siete unidades de
2:15:26refresco vamos a comprar y luego
2:15:29más sano vamos a comprar 7 kilos de
2:15:31pollo eso ya no me permite representar
2:15:34nuestra lista de compras en javascript y
2:15:38qué podemos hacer con esto por ejemplo
2:15:41podríamos acceder a esos valores y
2:15:43mostrarlos en la consola
2:15:46digamos voy a comprar
2:15:50tantas unidades de y allí vamos a
2:15:54reemplazar los valores de lo que vamos a
2:15:55comprar digamos por ejemplo
2:15:58voy a comprar
2:16:00para reemplazar el valor vamos a tener
2:16:03que concatenar cadenas voy a comprar
2:16:06agregamos un espacio y luego tenemos que
2:16:10conseguir el número tantas unidades del
2:16:12producto
2:16:13por ejemplo si es para el cereal
2:16:16estaríamos accediendo al primer arreglo
2:16:190
2:16:20el índice 0 y luego el segundo elemento
2:16:23el número 3 que sería el elemento en el
2:16:27índice 1 en el índice 0 estaría serial y
2:16:31en el índice 1 estaría el número
2:16:33voy a acceder comprar tantas las
2:16:37contraten amos a unidades con un espacio
2:16:39de y luego volvemos a concatenar
2:16:44aquí pero aquí sí tenemos que colocar el
2:16:47nombre del producto que sería esta
2:16:49combinación pero tendríamos que cambiar
2:16:52el 1 por el 0
2:16:55si estamos de alguna forma invirtiendo
2:16:58el orden estamos colocando en el mensaje
2:17:01primero el valor la cantidad de unidades
2:17:03que es el segundo elemento de cada
2:17:06arreglo y luego estamos colocando el
2:17:09nombre del producto que está en el
2:17:11índice cero este segundo índice es el
2:17:13que determina el elemento que vamos a
2:17:15mostrar y el primer índice selecciona el
2:17:19arreglo que corresponde vamos a usar los
2:17:22comentarios aquí para aquí vamos a
2:17:23mostrar la data del cereal luego vamos a
2:17:27mostrar los de la leche
2:17:29para eso para la leche ahora tenemos que
2:17:31seleccionar el segundo arreglo
2:17:35que tenemos acá para eso cambiamos el
2:17:37primer índice a 1 1 y 1 y el orden del
2:17:43segundo índice se mantiene
2:17:45intacto primero el número que es el
2:17:48segundo elemento y luego el producto que
2:17:51es el primer elemento
2:17:53lo mismo podemos hacer con las galletas
2:17:57mis favoritas son las que tienen chispas
2:17:59las chispas de chocolate
2:18:02voy a comprar tantas chispas digamos dos
2:18:05en este caso como es el tercer arreglo
2:18:08el índice de ese arreglo lo tenemos que
2:18:11actualizar a 2 y así sucesivamente
2:18:14te invito a completar toda esta lista de
2:18:18compras para mostrar cuánto vas a
2:18:21comprar de cada producto nos quedaría
2:18:23mostrar la cantidad de pan la cantidad
2:18:25de refresco y la cantidad de pollo
2:18:27también puedes personalizar en tu lista
2:18:29de compras vamos a ver qué nos muestra
2:18:32hasta ahora la consola
2:18:36genial así que pasemos a nuestro
2:18:38siguiente tema
2:18:44bien excelente trabajo hasta ahora ya
2:18:47pasamos la parte más básica del curso y
2:18:50ya puedes empezar a crear programas más
2:18:52poderosos y que estén mejor
2:18:53estructurados para estructurar mejor
2:18:56nuestros programas vamos a ver un
2:18:58concepto una herramienta que podemos
2:19:00usar en nuestro código que es muy muy
2:19:02muy útil se llaman funciones
2:19:05con las funciones podemos escribir
2:19:07código que podemos reutilizar en nuestro
2:19:10programa ya vas a ver cómo funciona cómo
2:19:13definimos una función
2:19:15primero que todo escribimos la palabra
2:19:18reservada function vas a ver que cambia
2:19:21de color porque es una palabra
2:19:22específica en javascript para definir
2:19:25funciones luego tenemos que asignarle un
2:19:28nombre a nuestra función es el nombre
2:19:30que vamos a usar en nuestro programa
2:19:32cuando queramos ejecutar ese bloque de
2:19:34código esta secuencia de instrucciones
2:19:37en lugar de escribir las instrucciones
2:19:39solo escribimos su nombre y ya el
2:19:41programa sabe qué es lo que queremos
2:19:43ejecutar en este caso vamos a llamar a
2:19:46nuestra función mostrar mensajes también
2:19:49siempre después desde el nombre de la
2:19:51función tiene que tener este par de
2:19:53paréntesis inmediatamente después del
2:19:55nombre de la función los paréntesis por
2:19:58ahora van a estar vacíos
2:20:00y luego entre llaves abrimos las llaves
2:20:03y hacemos clic en enter vas a ver que la
2:20:07llave que cierra el par se coloca aquí
2:20:11abajo y la primera llave se coloca aquí
2:20:13arriba en la primera línea en la misma
2:20:16línea donde definimos la función así es
2:20:19que nos referimos a esto técnicamente
2:20:21esto se llama una definición de una
2:20:23función que vamos a hacer en esta
2:20:26función queremos mostrar un mensaje para
2:20:28eso tenemos que usar con su punto lo que
2:20:31íbamos a mostrar el mensaje
2:20:34hola mundo qué diferencia va a ser esto
2:20:37nuestro programa me imagino que te deben
2:20:38estar preguntando lo que vamos a poder
2:20:41hacer es que solamente con este nombre
2:20:44mostrar mensaje vamos a poder ejecutar
2:20:46esta línea de código sin tener que
2:20:49escribirla queremos realizar esta acción
2:20:52y podemos usarla cuántas veces queramos
2:20:55por ejemplo mostrar el mensaje
2:20:57y tenemos que para ejecutar esa acción
2:21:00igual que con los métodos necesitamos
2:21:02tener un par de paréntesis puede haber
2:21:05valores aquí pero vamos a verlo en un
2:21:07próximo tema
2:21:09y podemos ejecutarlo cuántas veces
2:21:11queramos si queremos mostrar el mensaje
2:21:13seis veces que tenemos tres y seis veces
2:21:16podemos solo escribir el nombre de la
2:21:18función seis veces y este mensaje se va
2:21:21a mostrar vamos a abrir la consola aquí
2:21:24puedes verlo hola mundo seis veces
2:21:27porque llamamos a la función seis veces
2:21:30ese es el término que usamos en
2:21:32programación cuando ejecutamos una
2:21:34función decimos que estamos llamando a
2:21:36la función estamos diciendo al programa
2:21:38ley quiero ejecutar esta funcionalidad
2:21:41que yo definía en mi función en este
2:21:44punto específico del programa son muy
2:21:47muy útiles y te van a permitir ahorrar
2:21:49mucha repetición rare mucha repetición
2:21:51de código que ese es un principio muy
2:21:54importante en programación siempre
2:21:55tratamos de no repetir código en nuestro
2:21:58programa lo menos posible en este caso
2:22:01puede ser que no veas inmediatamente el
2:22:03beneficio de la función porque solo
2:22:05tenemos una línea aquí
2:22:07pero por ejemplo
2:22:08si tuviéramos cinco diez o veinte líneas
2:22:12aquí nos estaríamos ahorrando escribir
2:22:14veinte líneas por cada vez que llamamos
2:22:17a la función ya ves que podríamos tener
2:22:19unas cientos de líneas fácilmente si no
2:22:22tuviéramos una función con la función
2:22:25sólo escribimos el código una vez y con
2:22:27su nombre la llamamos genial ya sabes
2:22:31más sobre el concepto de una función
2:22:33pero son muy poderosas y vamos a
2:22:36trabajar con ellas en los próximos temas
2:22:38del curso vas a aprender cómo
2:22:40personalizarlas y cómo aprovechar todo
2:22:42su poder
2:22:47las funciones son muy útiles porque nos
2:22:49permiten escribir códigos reutilizable
2:22:51en la parte anterior viste cómo puedes
2:22:54definir una función sencilla pero
2:22:57ahorita vamos a agregarle un poco más de
2:23:00funcionalidad a nuestras funciones vamos
2:23:03a hacer escribir una función con dos
2:23:05líneas y también vamos a agregarle la
2:23:08capacidad de recibir valores de tomar
2:23:10valores cuando la llamamos lo primero es
2:23:13la palabra reservada function en nuestro
2:23:16ejemplo va a llamarse sumar esta va a
2:23:19ser nuestra función
2:23:21sabemos que podemos sumar dos números
2:23:23con el operador de suma al operador más
2:23:25pero para que este ejemplo sea sencillo
2:23:28vamos a implementar esta operación como
2:23:30una función que es lo que vamos a sumar
2:23:33lo primero que necesitamos saber para
2:23:35una operación es que operando vamos a
2:23:38usar valores vamos a tener y para eso
2:23:40entre paréntesis vamos a escribir dos
2:23:44nombres estos se llaman parámetros son
2:23:48cualquier nombre que tú le quieras
2:23:50asignar a un valor que se va a recibir o
2:23:53que se va a tomar cuando llamemos a la
2:23:55función en este caso vamos a sumar los
2:23:58valores de a y debe así que vamos a
2:24:02escribir esos dos parámetros en la lista
2:24:04está lista normalmente le llamamos la
2:24:07lista de parámetros no necesariamente
2:24:10sus nombres tienen que ser ahí de puede
2:24:12ser número uno número dos pueden ser
2:24:16xy puede ser cualquier nombre que
2:24:20quieras asignarle o claro cualquier
2:24:22nombre es válido javascript
2:24:25entonces si nosotros decimos que vamos a
2:24:27sumar ahí ver qué es lo que vamos a
2:24:30hacer en el cuerpo de la función esta
2:24:33parte la secuencia de instrucciones que
2:24:35es parte de la función que se van a
2:24:37ejecutar cuando llamemos a la función se
2:24:40denomina cuerpo y eso lo que vamos a
2:24:42escribir el cuerpo de la función
2:24:45vamos a tomar los valores de ahí y de
2:24:48ver esos dos valores que en este momento
2:24:51no existen solamente estamos escribiendo
2:24:53esos nombres aquí en la función como
2:24:56creando un plano de qué es lo que va a
2:24:58pasar cuando tengamos esos valores a va
2:25:02a tener un valor y va a tener un valor
2:25:04cuando se reciban esos valores los vamos
2:25:06a sumar vamos a asignar ese resultado a
2:25:10una variable llamada suma pero tenemos
2:25:12que declarar esa variable dentro de la
2:25:15función y luego qué vamos a hacer con
2:25:18esa variable vamos a decir con su punto
2:25:20loc y vamos a mostrar este mensaje
2:25:24el resultado d
2:25:27digamos
2:25:30+ d
2:25:37y luego
2:25:38mostramos el resultado de la suma esta
2:25:41va a ser la cadena final estas dos
2:25:44líneas que son las que se van a ejecutar
2:25:46cuando llamemos a la función se llama en
2:25:48el cuerpo de la función estos son los
2:25:51parámetros de la función y este es el
2:25:54nombre de la función es muy importante
2:25:57que escribas el cuerpo de la función
2:25:58entre las dos llaves porque las dos
2:26:01llaves definen hasta dónde llega el
2:26:04cuerpo de la función y también puedes
2:26:06notar que aquí dejamos unos espacios
2:26:08antes de comenzar a escribir las líneas
2:26:10eso es muy recomendado en javascript
2:26:13porque nos permite diferenciar
2:26:15visualmente qué líneas son parte del
2:26:17cuerpo de la función
2:26:19normalmente se puede utilizar dos o
2:26:21cuatro espacios para eso se denomina
2:26:23intenta ción en programación este
2:26:26espacio que dejamos aquí se llama
2:26:28intenta acción ahora vamos a tratar de
2:26:31llamar a la función
2:26:33antes cuando llamábamos un método
2:26:35normalmente pasábamos un valor o
2:26:37dejábamos los paréntesis vacíos para
2:26:39ejecutarlo pero en este caso tenemos dos
2:26:42parámetros tenemos que pasar un valor
2:26:45para cada uno porque la función tiene
2:26:48que saber cuál es el valor de a y cuál
2:26:50es el valor de b
2:26:51digamos que para queremos asignar el
2:26:54valor 5 lo escribimos en ese mismo orden
2:26:58los valores se asignan en el mismo orden
2:27:01en que aparecen en la lista de
2:27:02parámetros aquí en la definición de la
2:27:05función
2:27:06el valor 5 se asigna a y el valor 3 se
2:27:09asigna a ver luego si se suman esos
2:27:12valores
2:27:13obtenemos este valor y mostramos el
2:27:15mensaje
2:27:16así que veamos que ya tenemos en la
2:27:19consola el resultado de
2:27:22538 puedes ver que los valores de aire
2:27:26fueron lo que esperábamos a fue 5 y ver
2:27:29fue 3 y la suma de ambos fue 8
2:27:335 se asignó al primer parámetro y 3 se
2:27:36asignó el segundo parámetro en ese mismo
2:27:39orden ahora
2:27:41para ilustrar porque las funciones nos
2:27:43ayudan a escribir código que es más
2:27:45conciso y más fácil de leer y que evita
2:27:48la repetición podemos llamar a esta
2:27:50función varias veces
2:27:52digamos que queremos sumar 8 y 9 o
2:27:55queremos sumar 2 y 4 también podemos
2:27:58sumar 5 y 5 aquí ya puedes ver que
2:28:01estamos escribiendo en cuatro líneas lo
2:28:04que nos tomaría aproximadamente
2:28:05ocho líneas si escribiéramos estas dos
2:28:09líneas en lugar de llamar a la función
2:28:11nada más además que estaríamos
2:28:13escribiendo mucho código repetido porque
2:28:16tendríamos que reasignar el valor de las
2:28:18variables y tendríamos que mostrar el
2:28:21mismo mensaje una y otra vez la arista
2:28:24con la función solo lo estamos
2:28:25escribiendo una sola vez en un solo
2:28:27lugar y también si tenemos que hacer
2:28:29cualquier cambio es mucho más fácil
2:28:32porque sabemos a dónde ir en vez de
2:28:34hacer cambios en todos los distintos
2:28:36lugares donde escribimos esta línea
2:28:37podemos hacerlo en un solo lugar en la
2:28:40función
2:28:42veamos que tenemos en la consola si es
2:28:45exactamente lo que queríamos 5 y 35 38
2:28:49después llamamos a la función con 8 con
2:28:5298 más 9 17 2 y 4 2 4 6 y 5 y 5 5 5 es
2:28:5910
2:29:00un término muy importante que también
2:29:03debes saber es el de argumento estos
2:29:06valores que estamos pasando para los
2:29:08parámetros se denominan argumentos los
2:29:12argumentos son los valores que asignamos
2:29:14a los parámetros esos dos conceptos
2:29:18trabajan juntos para permitir que las
2:29:20funciones sean la herramienta
2:29:21poderosísima que son en programación
2:29:24veamos otra variación que podemos tener
2:29:27cuando llamamos a una función
2:29:30en lugar de escribir los valores
2:29:32directamente aquí en la lista de
2:29:34argumentos también podemos asignarlos a
2:29:37variables y pasar las variables como
2:29:41argumentos o escribirlas aquí en la
2:29:43lista de argumentos lo que va a lograr
2:29:46esto es que podemos llamar a la función
2:29:49con el valor actual de esa variable
2:29:52estamos diciendo que el valor de x se va
2:29:54a asignar y el valor de y oye se va a
2:29:58asignar a b así que también podemos
2:30:02trabajar con las variables puedes ver
2:30:04que el resultado es el mismo el
2:30:06resultado de 53 es 8 no sólo podemos
2:30:09pasar números vamos a definir otra
2:30:12función aquí tenemos otro ejemplo con
2:30:14cadenas de caracteres primero escribimos
2:30:17la palabra function y luego decimos
2:30:19concatenar
2:30:21tres cadenas que cadenas vamos a
2:30:24concatenar cadena 1 cadena 2 y cadena
2:30:28atrás
2:30:29la función va a concatenar estas cadenas
2:30:32y va a mostrar la cadena final pero no
2:30:35solo las va a concatenar así con el
2:30:37operador de suma sino que va a agregar
2:30:39un espacio entre las cadenas y esta va a
2:30:42ser la ventaja que nos va a traer esta
2:30:43función
2:30:45podemos concatenar las cadenas con un
2:30:47espacio entre cada una de ellas aquí
2:30:49cadena uno sería un espacio cadena 12 y
2:30:52un espacio y finalmente cadena 3 luego
2:30:56cuando llamemos a la función concatenar
2:30:58tres cadenas podemos pasar un valor para
2:31:01cada una de las cadenas debemos pasar un
2:31:03valor sino tendremos un error
2:31:06la primera cadena va a ser estoy
2:31:11aprendiendo
2:31:13y la tercera ha programando puedes ver
2:31:16cómo nos borramos escribir esto con
2:31:19todos sus detalles y solamente estamos
2:31:21llamando a la función y estableciendo
2:31:23cuáles son las cadenas que queremos
2:31:24concatenar si vemos la consola
2:31:28puedes ver el resultado estoy
2:31:30aprendiendo a programar genial hay
2:31:33muchos detalles que aprender de las
2:31:35funciones pero una vez que ya estés como
2:31:37acomoda con este concepto y lo domina es
2:31:39más con la práctica vas a ver que las
2:31:41funciones son herramientas
2:31:42importantísimas así que continuamos
2:31:45aprendiendo sobre las funciones
2:31:52ahora vamos a hablar de un aspecto muy
2:31:54importante de las variables en java es
2:31:56que no todas las variables pueden usarse
2:32:00en todas las distintas partes del
2:32:02programa tenemos dos tipos principales
2:32:04de variables variables globales y
2:32:08variables locales vamos a ver cómo
2:32:11funciona cada una una variable con
2:32:14ámbito global es una variable que se
2:32:17puede usar en cualquier lugar del
2:32:19programa porque está definida en el
2:32:23programa principal
2:32:24veamos un ejemplo
2:32:26mi variable global igual a 5 esta
2:32:31variable es global porque la estamos
2:32:33definiendo en el programa principal y no
2:32:36dentro de una función así que si
2:32:39necesitamos acceder a su valor o usarla
2:32:42en el programa podemos hacerlo y también
2:32:45podemos acceder a su valor dentro de una
2:32:48función digamos que la necesitamos
2:32:51dentro de una función vamos a mostrar su
2:32:55valor dentro de la función para
2:32:57comprobar que sí existe y si está
2:32:59definida dentro de la función y también
2:33:02va a estar definida luego de la
2:33:05definición de la función básicamente en
2:33:07cualquier lugar del programa
2:33:10para comprobar que si está definida
2:33:12dentro de la función tenemos que llamar
2:33:14a la función aquí podemos ver el
2:33:17resultado tenemos tres números cinco
2:33:19tres veces estamos mostrando el valor de
2:33:23esta variable dentro y fuera de la
2:33:26función ese es el principio básico de
2:33:28una variable global es una variable que
2:33:31se puede acceder y usar y modificar en
2:33:34cualquier lugar del programa esto
2:33:37contrasta con el concepto de variable
2:33:39local que vamos a ver en la próxima
2:33:42parte
2:33:47veamos cómo funcionan las variables
2:33:50locales las variables locales como su
2:33:53nombre lo indica son locales para una
2:33:56función son variables que definimos
2:33:59dentro de una función y que solo se
2:34:01pueden utilizar dentro de esa función
2:34:04vamos a ver a qué me refiero con un
2:34:06ejemplo si definimos una función y
2:34:10dentro de esa función declaramos una
2:34:13variable usando by mi variable local con
2:34:17un valor 4
2:34:19vamos a mostrar el valor de esa variable
2:34:22dentro de la función
2:34:24y vamos a llamar a la función para
2:34:27probar que la variable esté definida
2:34:29dentro de la función vemos que esa
2:34:32variable si está definida pero luego
2:34:35digamos que queremos acceder a esa
2:34:37variable local fuera de la función
2:34:40vamos a intentar acceder a esa variable
2:34:42que es lo que va a ocurrir vamos a tener
2:34:45aquí un error de referencia hacia mi
2:34:47variable local no está definida eso es
2:34:50lo que dice aquí en inglés y es not
2:34:52spain no está definida porque porque las
2:34:55variables locales solo están definidas
2:34:58dentro de la función donde fueron
2:35:01declaradas ese es el concepto básico de
2:35:04una variable local si declaramos una
2:35:06variable dentro de una función usando
2:35:09para aquí esa variable va a ser local y
2:35:13se puede usar dentro de la función pero
2:35:16sólo dentro del par de llaves que define
2:35:19el cuerpo de la función no podemos usar
2:35:21esa variable fuera de la función en el
2:35:24programa principal o en otras funciones
2:35:27ya sabes la diferencia entre una
2:35:29variable global
2:35:30una variable local
2:35:38veamos algo muy interesante que sucede
2:35:41cuando tenemos una variable global y una
2:35:44variable local con el mismo nombre
2:35:46veamos cuál es el valor que se utiliza
2:35:49al final si nosotros tenemos una
2:35:51variable llamada mi nombre con el valor
2:35:54nora y definimos una función que diga
2:35:58por ejemplo mostrar mi nombre
2:36:00llamada por ejemplo mostrar mi nombre
2:36:03esta función no va a recibir ningún
2:36:06valor así que no vamos a tener
2:36:07parámetros
2:36:08pero vamos a definir una variable local
2:36:11llamada mi nombre nota que es el mismo
2:36:15nombre de la variable global pero esta
2:36:19va a ser local porque nota que estamos
2:36:21usando la palabra reservada var que nos
2:36:23permite declarar una variable nueva va a
2:36:27pasar algo muy peculiar cuando queramos
2:36:29verificar el valor de esta variable
2:36:32trata de adivinar analizar qué es lo más
2:36:35lógico que suceda si tenemos una
2:36:37variable global con este valor y una
2:36:40variable local con este valor qué valor
2:36:43crees que se va a mostrar
2:36:45cuando veamos la consola veamos cuál es
2:36:48el valor llamando la función el valor es
2:36:51sino el valor que se muestra porque
2:36:54porque la variable local tiene mayor
2:36:55prioridad cuando tenemos una variable
2:36:58global y una variable local la local
2:37:00tiene prioridad dentro de la función
2:37:03pero también veamos qué es lo que sucede
2:37:06si tratamos de mostrar el valor de mi
2:37:08nombre fuera de la función recuerda que
2:37:10esta es una variable local de la función
2:37:13solo existe dentro de ese pequeño
2:37:15compartimento que forma la función en
2:37:17nuestro programa y no se puede usar en
2:37:19ninguna otro lugar del programa pero
2:37:22tenemos también una variable global y
2:37:24esa variable global si se puede usar en
2:37:26cualquier lugar del programa cualquier
2:37:28línea así que si la mostramos en la
2:37:31consola vamos a ver tenemos lleno y
2:37:34luego tenemos no ahora
2:37:36sino porque estamos llamando estamos
2:37:38llamando a la función entonces dentro de
2:37:40la función se usa la variable local y
2:37:43aquí se muestra el valor no ahora porque
2:37:46estamos usando el valor de la variable y
2:37:48global y lo podemos ver esa variable
2:37:51global lo único lugar donde no se va a
2:37:54poder ver ese valor es dentro de la
2:37:57función porque hay otra variable local
2:37:59con el mismo nombre pero aquí no tenemos
2:38:01esa variable local estamos en el
2:38:04programa principal así que se usa el
2:38:07valor original de esta variable global
2:38:09que es nueva y por eso vemos este
2:38:12comportamiento este resultado en nuestro
2:38:14código
2:38:15bien ya sabes que las variables locales
2:38:18tienen precedencia sobre las variables
2:38:20globales si tienen el mismo nombre en
2:38:23una función
2:38:31las funciones pueden retornar un valor
2:38:33además de recibir valores recuerda que
2:38:37vimos que la función es forma como una
2:38:39pequeña cajita a un ambiente interno y
2:38:43propio en el programa que puede tener
2:38:46sus propias variables y tiene una
2:38:49conexión con el programa principal pero
2:38:51también tiene propiedades especiales
2:38:53esas propiedades especiales también le
2:38:55permiten tomar valores y también le
2:38:58permite retornar valores para poder
2:39:00interactuar con el programa principal
2:39:03esto es distinto a cuando mostramos el
2:39:05valor en la consola esta vez vamos a
2:39:07retornar el valor así que vamos a ver a
2:39:10qué me refiero con retornar
2:39:12vamos a tener nuestra función sumar que
2:39:15va a tomar dos parámetros de los dos
2:39:18números que se van a sumar
2:39:20antes nosotros escribíamos con su punto
2:39:23lo que nos permitía mostrar el valor en
2:39:25la consola pero para retornar ese valor
2:39:30tenemos que escribir una palabra
2:39:32reservada especial llamada arbitren esa
2:39:35palabra nos va a permitir que la función
2:39:38retorne un valor cuando se ejecuta esa
2:39:40línea nosotros que el valor vamos a
2:39:43retornar de la función vamos a retornar
2:39:45la suma de aire si nosotros llamamos a
2:39:48la función
2:39:50esta vez nota que estamos escribiendo
2:39:51aquí better no estamos escribiendo a
2:39:53camps o blog así que el resultado no se
2:39:57va a mostrar en la consola si llamamos a
2:39:59la función
2:40:00para mostrar ese valor retornado tenemos
2:40:03que usar con su punto blog o también lo
2:40:06podemos asignar una variable eso lo
2:40:08vamos a ver en un próximo tema por ahora
2:40:10vamos a mostrar ese valor
2:40:12que se retorna esta llamada a la función
2:40:15va a ser ejecutada se va a reemplazar
2:40:18por el valor retornado y luego se va a
2:40:21mostrar en la consola ya lo vas a ver
2:40:24aquí vemos el valor 8
2:40:27antes nosotros lo mostrábamos con con su
2:40:30punto lo que aquí pero ahorita lo
2:40:32estamos retornando o devolviendo también
2:40:34lo puedes conseguir traducido como
2:40:36devolver un valor de la función lo que
2:40:39va a hacer eso es que esta llamada la
2:40:41función se va a reemplazar con ese valor
2:40:44y ese valor se va a mostrar en la
2:40:47consola pero si nosotros quitamos el con
2:40:49su punto lo esto no va a mostrar nada
2:40:52nos va a mostrar nada en el programa ni
2:40:55en la consola estamos simplemente
2:40:57retornando el valor no mostrando en la
2:40:59consola bien ya sabes lo básico de
2:41:02retornar valores pero hay bastantes
2:41:04detallitos importantes y variaciones que
2:41:06puedes usar con richard así que ese va a
2:41:08ser el tema de nuestras próximas
2:41:10secciones del curso continuamos
2:41:17así como podemos retornar un valor
2:41:20específico de una función escribiéndolo
2:41:22explícitamente con pixar
2:41:25también podemos omitir esa sentencia
2:41:29podemos no retornar ningún valor de la
2:41:31función pero en este caso hay algo muy
2:41:34curioso que debes saber aún así la
2:41:36función va a retornar un valor por
2:41:38defecto ese valor va a ser anti find
2:41:41veamos un ejemplo si definimos aquí una
2:41:45función llamada sumar como nuestro
2:41:48ejemplo anterior con dos parámetros a
2:41:50ive y luego lo que hacemos es en lugar
2:41:55de retornar el valor de la suma lo vamos
2:41:57a mostrar en la consola es muy distinto
2:42:00mostrar un valor en la consola que
2:42:02retornar lo nosotros no estamos
2:42:04escribiendo esto porque no estamos
2:42:07escribiendo esto sino que solamente lo
2:42:10estamos mostrando en la consola
2:42:12como no estamos retornando ningún valor
2:42:15explícitamente
2:42:16veamos qué es lo que ocurre
2:42:20antes cuando retorna vamos un valor
2:42:22podíamos mostrar el valor retornado en
2:42:24la consola como cónsul lo
2:42:27recuerdas si llamábamos a la función con
2:42:30dos valores esto hubiera sido 8 si
2:42:34hubiéramos retornado la suma y ese valor
2:42:37se hubiera mostrado en la consola pero
2:42:39veamos qué ocurre ahora que no tenemos
2:42:41una sentencia de richard
2:42:43vemos aquí el valor que esperábamos a
2:42:46donde find la función se ejecuta
2:42:50llamamos a la función se muestra el
2:42:52valor de la suma que es 8 y luego el
2:42:55valor retornado por esa llamada la
2:42:57función se muestra en la consola ese
2:43:00valor es anti find
2:43:03anteriormente aquí hubiéramos tenido el
2:43:05valor 8 si se hubiera retornado si
2:43:07hubiéramos escrito esto así puedes ver
2:43:10aquí que tenemos 8 que lo mostramos en
2:43:12la consola y luego 8 porque lo estamos
2:43:15retornando
2:43:16nosotros solamente estamos mostrando el
2:43:19resultado en la consola y el valor que
2:43:22se está retornando aquí es anti fight
2:43:25bien era importante que supieras que por
2:43:28defecto las funciones si retornan un
2:43:29valor pero esos valores anti find así
2:43:32que continuamos a nuestro siguiente tema
2:43:34porque también puedes asignar el valor
2:43:37retornado por una función a una variable
2:43:39así que veamos esto nuestro siguiente
2:43:42tema
2:43:49cuando una función retorne un valor
2:43:51podemos asignar ese valor retornado a
2:43:54una variable y esto es muy útil cuando
2:43:56queremos usar ese valor luego en nuestro
2:43:59programa porque podemos guardarlo veamos
2:44:02un ejemplo seguimos con nuestra función
2:44:04sumar con dos parámetros que retorna la
2:44:07suma digamos que queremos llamar a la
2:44:09función sumar y vamos a pasar estos dos
2:44:12valores como argumentos 5 y 3 si
2:44:15nosotros solamente llamamos a esta
2:44:17función y el valor es retornado veamos
2:44:19qué pasa en la consola aquí podemos ver
2:44:21que está vacía la consola por qué porque
2:44:25nos estamos mostrando el resultado en
2:44:27ningún lado y tampoco lo estamos
2:44:28asignando a ninguna variable no estamos
2:44:31haciendo nada con ese valor luego de que
2:44:34la llamada la función culmine el valor
2:44:36se pierde no lo podemos usar más pero
2:44:39para evitar esto si queremos guardar ese
2:44:41valor lo que tenemos que hacer es
2:44:43asignarlo a una variable aquí tenemos la
2:44:46sintaxis para asignarle una variable
2:44:49es exactamente igual que como asignamos
2:44:51cualquier valor a una variable
2:44:53escribimos la palabra clave par luego el
2:44:56nombre de la variable el operador de
2:44:59asignación y en la llamada la función
2:45:02cuando el código se está ejecutando
2:45:04puedes pensar como si esta llamada la
2:45:07función se reemplazará por el valor que
2:45:09resulta por ejemplo puedes pensar que
2:45:13esta línea se convierte detrás de escena
2:45:16cuando se está ejecutando el código
2:45:19en esto
2:45:21porque porque llamar a su bar con cinco
2:45:24y tres como argumentos va a retornar el
2:45:26valor 8 ese valor podrías pensarlo así
2:45:30se reemplaza cuando el programa se está
2:45:33ejecutando y luego ese valor se asigna a
2:45:36la variable y aquí tenemos como puedes
2:45:38ver una asignación normal de un valor a
2:45:40una variable como con los que hemos
2:45:42estado trabajando así es básicamente
2:45:44como puedes asignar el valor retornado a
2:45:46una variable y luego puedes usar el
2:45:48valor de lo necesites por ejemplo
2:45:51podemos mostrarlo en la consola aquí
2:45:53vemos el valor 8 se asignó a la variable
2:45:56resultado veamos otro ejemplo podemos
2:45:59definir una función que retorne una
2:46:01cadena de caracteres con nuestra meta
2:46:05crear cadenas
2:46:08con método digamos con nuestra meta pero
2:46:11cuál va a ser nuestra meta vamos a
2:46:13retornar una cadena de caracteres que
2:46:16diga mi meta es aprender un espacio y
2:46:22luego vamos a concatenar la con un
2:46:25lenguaje de programación
2:46:28entonces con acá tenemos estas dos
2:46:30cadenas la cadena resultante va a ser
2:46:32retornada
2:46:33ahora si llamamos a la función y
2:46:36asignamos el valor retornado una
2:46:38variable veamos que tenemos
2:46:41crear cadenas con metal
2:46:44vamos a pasar la cadena de caracteres
2:46:47javascript o sea que el lenguaje de
2:46:49programación que tenemos aquí ese
2:46:52parámetro va a tener el valor javascript
2:46:55cuando ya vemos a la función esta vez si
2:46:57verificamos en la consola podemos ver
2:47:00que no se muestra nada porque no estamos
2:47:03haciendo nada con el valor lo que
2:47:05podemos hacer lo que sí podemos hacer es
2:47:07asignarlo a una variable llamémosla me
2:47:11meta
2:47:12y luego podemos hacer lo que necesitemos
2:47:15con la cadena por ejemplo podemos
2:47:17mostrarla en la consola mi meta es
2:47:19aprender ya busquets genial qué fue lo
2:47:23que pasó detrás de escena cuando se
2:47:25ejecutó el código puedes pensar que
2:47:28detrás de escena cuando se estaba
2:47:29ejecutando el código está llamada la
2:47:32función se reemplazó con la cadena
2:47:35resultante que sería ésta
2:47:38mi meta es aprender sabes que este es el
2:47:42valor retornado por esta llamada a la
2:47:45función nosotros no vemos el proceso
2:47:48pero puedes imaginarlo si el valor el
2:47:50valor retornado se reemplaza aquí y
2:47:52luego se asigna a la variable y es
2:47:54simplemente como una asignación normal
2:47:56de un valor una variable con las cuales
2:47:58hemos estado trabajando bien ya sabes
2:48:00cómo asignar el valor retornado a una
2:48:02variable buen trabajo continuamos con
2:48:05nuestro siguiente tema
2:48:12ahora que ya sabes cómo trabajar con
2:48:14funciones en javascript vas a aplicar
2:48:16sus conocimientos para implementar lo
2:48:18que conocemos como una cola vamos a
2:48:21hacer una variación de una cola que en
2:48:23inglés se llama activo una estructura de
2:48:25datos que nos va a permitir agregar
2:48:28elementos a una fila le damos la
2:48:31descripción del problema en informática
2:48:33una cola llamada aquí es una estructura
2:48:35de datos abstracta en la cual los
2:48:38elementos se mantienen en orden los
2:48:41nuevos elementos se pueden añadir al
2:48:43final de la cola y los elementos previos
2:48:47se retiran al principio de la cola bien
2:48:50entonces vamos a tener una estructura en
2:48:52el que vamos a añadir el elemento nuevo
2:48:54al final de la cola y vamos a retirar el
2:48:57que estaba al principio de la cola
2:48:59nuestra meta es definir una función que
2:49:01se llame próximo en la fila o próximo en
2:49:04fila tú puedes personalizar este nombre
2:49:07esa función debe tomar un arreglo que se
2:49:10va a llamar arreglo ese va a ser el
2:49:12nombre del parámetro también lo puedes
2:49:14conseguir abreviado como r
2:49:16y para tomar un número que va a llamarse
2:49:20elemento el elemento que vamos a agregar
2:49:23ese va a ser el parámetro
2:49:25ambos van a ser los argumentos tu misión
2:49:28es agregar el número al final del
2:49:30arreglo que vemos aquí que vamos a tomar
2:49:33como argumento y luego la función debe
2:49:35eliminar el primer elemento del arreglo
2:49:38es cómo vamos en un ciclo vamos a
2:49:41agregarlo al final y luego si se agrega
2:49:44un elemento significa que el primero
2:49:45debe ser eliminado como en los
2:49:47supermercados en los bancos el cliente
2:49:49que ya pasó a la caja se va y luego
2:49:53entra otro la fila la función próximo en
2:49:56la fila debe retornar el elemento que
2:49:58fue removido esas son las
2:50:00características de la función que
2:50:01debemos implementar dos parámetros
2:50:03agregar el número al final eliminar el
2:50:06primero y retornar el que fue removido o
2:50:09eliminado
2:50:11ok veamos cómo podemos implementar esta
2:50:13función lo primero es definir la función
2:50:16con la palabra reservada function
2:50:18y luego vamos a asignarle el nombre a la
2:50:21función próximo en la fila vamos a tomar
2:50:24dos parámetros arreglo lo que tenemos
2:50:27aquí y elementos podemos abreviar los
2:50:31también así
2:50:33y l esas son dos abreviaciones comunes
2:50:37que vas a conseguir en los problemas
2:50:41pero en este caso para hacer más
2:50:42explícitos podemos escribir los
2:50:44completos qué es lo que primero que
2:50:46queremos hacer cuando llamamos a la
2:50:48función para agregar un elemento a la
2:50:50fila
2:50:51agregarla al final del arreglo vamos a
2:50:55agregar ese número que va a ser el
2:50:56elemento lo vamos a agregar al final del
2:50:59arreglo que tomamos como argumento como
2:51:03lo podemos hacer con un método de
2:51:06arreglos que vimos en un tema anterior
2:51:08que se llama puig pues es el método que
2:51:12agrega un elemento al final de un
2:51:13arreglo
2:51:15cuál elemento el elemento que tomamos
2:51:18como argumento aquí podemos agregar un
2:51:21comentario agregar al final del arreglo
2:51:24luego de que lo agregamos al final del
2:51:26arreglo también debemos eliminar el
2:51:29primer elemento del arreglo
2:51:31debemos eliminar el primer elemento y
2:51:34que el método de arreglos te parece que
2:51:36podría cumplir esta función piénsalo por
2:51:39unos segundos y efectivamente el método
2:51:43es
2:51:47cif es el método que va a eliminar el
2:51:49primer elemento del arreglo no toma
2:51:52ningún argumento así que solamente lo
2:51:54llamábamos con paréntesis vacíos podemos
2:51:57agregar un comentario aquí
2:52:00remover
2:52:03el primer elemento ahora nos falta la
2:52:08parte final de lo que debe cumplir la
2:52:10función la función debe retornar el
2:52:14elemento que fue removido aquí todavía
2:52:17no vemos ninguna sentencia richard como
2:52:20lo podemos retornar bueno recuerda que
2:52:23el método shift también retorna ese
2:52:27elemento cuando nosotros llamamos a este
2:52:29método podemos asignarlo a una variable
2:52:32o también podemos retornar lo así que
2:52:35podemos escribir aquí ritter y listo
2:52:39vamos a remover el primer elemento esto
2:52:43va a ser reemplazado por ese elemento
2:52:45detrás de escena y ese elemento va a ser
2:52:48retornado vamos a probar cómo funciona
2:52:50nuestra función si definimos una
2:52:53variable mi arreglo con los números 1 2
2:52:563 4 y 5
2:52:58aquí podemos verlo queremos ver el
2:53:01estatus de nuestro arreglo antes y
2:53:04después de llamar a la función
2:53:06entonces como lo podemos hacer en
2:53:08javascript hay unas una función que es
2:53:11muy muy útil para mostrar los arreglos
2:53:14en la consola que se llama jason punto
2:53:18string file
2:53:20y pasamos el arreglo
2:53:24esto nos permite mostrar el arreglo de
2:53:26una forma más presentable en la consola
2:53:28escribe jason en mayúscula j son punto
2:53:32string y five string es cadena en inglés
2:53:35la cadena de caracteres así que estamos
2:53:38como convirtiendo el arreglo en una
2:53:40cadena de caracteres con un formato
2:53:42específico y la estamos concatenando a
2:53:45esta cadena nota que aquí tenemos un
2:53:47espacio también luego de esto vamos
2:53:51también vamos a mostrarlo después de
2:53:53hacer el cambio y en el medio tenemos
2:53:55que hacer el cambio vamos a mostrar el
2:53:58valor retornado también por eso vamos a
2:54:00rodear esa llamada con con su punto lo
2:54:02que ahora sí llegó el momento vamos a
2:54:05llamar a la función próxima la fila y el
2:54:08primer argumento que toma es el arreglo
2:54:10cual arreglo vamos a pasar como
2:54:13argumento vamos a pasar mi arreglo como
2:54:16argumento queremos mutar o cambiar este
2:54:19arreglo con los números 1 2 3 4 y 5
2:54:22y luego de que tenemos ese arreglo
2:54:24queremos agregar un elemento vamos a
2:54:27agregar el elemento 6 según las
2:54:30instrucciones el efecto de llamar a esta
2:54:32función debería hacer que el primer
2:54:34elemento
2:54:35se va a eliminar del arreglo y se va a
2:54:38agregar al final de ese arreglo el nuevo
2:54:41elemento
2:54:42el elemento removido es uno debería ser
2:54:46uno y ese es el elemento que se va a
2:54:47retornar que deberíamos ver en la
2:54:49consola
2:54:51bien vamos a ver la consola quería
2:54:54abrirla y vemos cuál fue el efecto
2:54:57y aquí lo puedes ver exactamente lo que
2:55:00necesitábamos que hiciera la función
2:55:01antes de llamar a la función el arreglo
2:55:04es 1 2 3 4 5 puedes ver cómo llamar a
2:55:08jason punto string ifai pasando el
2:55:10arreglo nos ayudó a presentarlo mucho
2:55:12mejor compararlo con como veíamos los
2:55:14arreglos antes solamente escribiendo la
2:55:16variable está mucho más representado
2:55:18vemos su estatus original y después
2:55:22cuando llamamos a la función el valor 1
2:55:24es retornado porque se remueve del
2:55:26arreglo y se muestra en la consola con
2:55:28con su bloque y después de llamar a la
2:55:32función podemos ver el estatus del
2:55:34arreglo el número 1 fue eliminado del
2:55:37principio del arreglo ahora tenemos dos
2:55:39como el primer elemento y el elemento
2:55:42nuevo que 6 fue agregado al final del
2:55:45arreglo
2:55:46así que ya implementamos una función que
2:55:48nos permite modificar nuestro arreglo
2:55:50como si fuese una fila o lo que llamamos
2:55:52en la estructura de datos una cola en
2:55:55inglés se denomina key bien hecho ya
2:55:58implementamos este mini proyecto así que
2:56:01continuemos con el curso
2:56:09vamos a comenzar a hablar un poquito
2:56:11sobre otro tipo de datos con el cual
2:56:13puedes trabajar en javascript el tipo de
2:56:17dato de valor es bull ya nos en jaws que
2:56:19formalmente ese tipo de datos se
2:56:21denominan buljan esos valores julianos
2:56:24en javascript son verdadero y falso que
2:56:28se escriben en el lenguaje de
2:56:29programación como true y fox you es
2:56:32verdadero en inglés y false es falso
2:56:36estos son los dos valores julianos con
2:56:39los cuales puedes trabajar en chabás que
2:56:41joe y fox
2:56:43pero es muy muy importante que sepas
2:56:46cómo escribirlos para que se reconozcan
2:56:48como esos valores especiales en el
2:56:50lenguaje esta es la única forma de
2:56:52escribirlos formalmente en el lenguaje
2:56:54para que se reconozcan con sus
2:56:56capacidades especiales de valores de
2:56:58verdad por ejemplo si nosotros queremos
2:57:01mostrar el valor si podemos ver que
2:57:04cuando lo escribimos en el código su
2:57:06color cambia porque es un valor especial
2:57:08en el lenguaje pero si lo escribimos
2:57:11aquí con una letra mayúscula al inicio
2:57:15tenemos que ella el color no es el mismo
2:57:17es verde pero veamos la consola a ver
2:57:20qué es lo que ocurre vemos un error
2:57:23joe el primero si es correcto y me
2:57:25mostró en la consola pero en el segundo
2:57:27la segunda línea vemos un error brass
2:57:30france r
2:57:31joe y es notifight yo no está definido
2:57:34porque porque como no lo reconoce no
2:57:37está escrito correctamente hay una t
2:57:39mayúscula aquí no lo reconoce como una
2:57:42palabra especial en el lenguaje cree que
2:57:45es una variable o cualquier otro
2:57:46elemento del código
2:57:48también si lo escribimos con cualquier
2:57:50otra combinación de mayúsculas o
2:57:52minúsculas puedes ver qué
2:57:55no va a funcionar veamos los errores
2:57:58como ya tenemos el primer error el
2:58:01código no continua vamos a comentar el
2:58:03primero para que vean los demás aquí
2:58:06puedes ver que true tampoco está
2:58:07definido cuando lo escribimos todo en
2:58:09mayúscula y esta combinación raro de
2:58:12mayúsculas y minúsculas tampoco se
2:58:13detecta
2:58:15lo mismo ocurre con el valor falso fox
2:58:19tiene que estar escrito completamente en
2:58:21minúscula cualquier otra combinación va
2:58:23a dar un error
2:58:25por ejemplo con su punto lo vamos a
2:58:28mostrar false vamos a mostrar fausto d
2:58:32mayúscula digamos distintas
2:58:33combinaciones que quizás tengas
2:58:36curiosidades si se pueden usar o no y
2:58:39ésta seguramente nunca te lo imaginaste
2:58:41pero bueno igual vamos a probarla y aquí
2:58:44vemos que si hay alguna mayúscula no va
2:58:46a estar definida vamos a comentar esta
2:58:49línea y vemos falso en mayúscula tampoco
2:58:52está definido y esta combinación rara de
2:58:55mayúsculas y minúsculas tampoco estado
2:58:57definido
2:58:58bien así que la única forma de escribir
2:59:02false como el valor juliano y que se
2:59:04interprete como el valor correcto que
2:59:07podemos usar en nuestro programa es
2:59:09escribir los triunfos completamente en
2:59:11minúscula estos valores triunfos van a
2:59:15ser muy muy útiles cuando empecemos a
2:59:17escribir condicionales cuando empecemos
2:59:20a realizar comparaciones de valores y
2:59:22cuando trabajemos con operadores lógicos
2:59:24todos esos temas los vamos a ver en el
2:59:27curso así que continuamos con nuestro
2:59:29curso del próximo tema
2:59:37en javascript puedes comparar valores
2:59:40para ver si son iguales o si no son
2:59:42iguales si representan el mismo valor
2:59:44eso lo podemos hacer con el operador de
2:59:47igualdad para mostrar el resultado vamos
2:59:50a usar con su punto lo que íbamos a
2:59:52comparar dos valores
2:59:54digamos que queremos saber si el número
2:59:565 tiene el mismo valor que el número 5
2:59:59esto que tenemos aquí se denomina una
3:00:02expresión va a evaluar a verdadero o
3:00:05falso
3:00:06o falso
3:00:07es verdadero si ambos valores son
3:00:09iguales y es falso si los valores son
3:00:12distintos ese valor final pool ya no se
3:00:16va a mostrar en la consola así que el
3:00:18resultado va a ser que veamos la consola
3:00:20aquí tenemos el valor yo
3:00:23pero si cambiamos el valor a por ejemplo
3:00:266 ahora vemos todos porque los valores
3:00:30no son iguales de igual forma podemos
3:00:33comparar cadenas de caracteres
3:00:35veamos un ejemplo o la vamos a
3:00:39compararla con la cadena de caracteres
3:00:40hola a ver si son iguales y tienen el
3:00:43mismo valor o si si contienen los mismos
3:00:46caracteres
3:00:47esta expresión es verdadera así que el
3:00:50resultado va a ser
3:00:51aquí lo podemos ver en la consola y si
3:00:55comparamos hola con cualquier otra
3:00:56cadena por ejemplo javascript el
3:01:00resultado ahora va a ser falso
3:01:02la comparación se hace también en base a
3:01:05las mayúsculas y las minúsculas por
3:01:07ejemplo si tenemos dos cadenas hola yo
3:01:10la he resultado aquí es falso porque es
3:01:14la letra h aquí es minúscula y la letra
3:01:16h aquí es mayúscula así que no son
3:01:18iguales es importante también ver que no
3:01:21deberíamos comparar arreglos con este
3:01:24operador porque porque veamos este
3:01:28ejemplo
3:01:30si nosotros tenemos dos arreglos con los
3:01:33mismos elementos 1 2 y 3
3:01:36y queremos compararlo con los otros
3:01:38arreglos que contienen los mismos
3:01:39elementos 1 2 y 3
3:01:41inicialmente uno podría pensar que el
3:01:43resultado va a ser true verdadero porque
3:01:46son iguales visualmente tienen los
3:01:49mismos elementos pero veamos el
3:01:50resultado en la consola
3:01:52el resultado es post porque porque este
3:01:55operador cuando se aplica a los arreglos
3:01:57no comparan los elementos del arreglo
3:02:00sino que compara si los arreglos en la
3:02:03memoria representan el mismo objeto lo
3:02:06importante es ver que no deberías
3:02:08comparar arreglos con este operador ok
3:02:11genial ya sabes cómo usar este operador
3:02:13vamos a ver otro operador que es muy
3:02:16parecido pero que va a permitirnos hacer
3:02:18una comparación más estricta lo veremos
3:02:20en el próximo tema
3:02:28también tenemos otro operador que nos
3:02:31permite comparar si ambos tipos de datos
3:02:34son los mismos o no este es el operador
3:02:37de igualdad estricta veamos la
3:02:40diferencia entre igualdad e igualdad
3:02:43estricta si nosotros comparamos dos
3:02:46valores del mismo tipo de datos con el
3:02:49operador de igualdad este resultado va a
3:02:52ser verdadero pero también que lo que va
3:02:55a pasar si nosotros tenemos dos valores
3:02:58que son de distintos tipos de datos pero
3:03:02que representan el mismo número el
3:03:05resultado también va a ser verdadero
3:03:08veámoslo en la consola aquí podemos ver
3:03:11el valor es verdadero para ambas
3:03:14comparaciones y en ciertas
3:03:17circunstancias también nos gustaría
3:03:19comparar si el tipo de dato es el mismo
3:03:23para ambos operando que ocurre con este
3:03:26operador antes de realizar la
3:03:28comparación ambos valores se convierten
3:03:31a un tipo de dato común
3:03:33eso es que el resultado de los 16 y 3 no
3:03:37importa que sean de distintos tipos de
3:03:39datos y representan el mismo valor pero
3:03:42si no queremos que eso ocurra y queremos
3:03:45que la comparación también determine si
3:03:48el tipo de datos es el mismo o no
3:03:51simplemente tenemos que agregar un signo
3:03:54igual a este operador para tener el
3:03:58operador de comparación de igualdad
3:04:00estricto en este caso el resultado va a
3:04:04ser porque ambos valores son iguales y
3:04:07tienen el mismo tipo de dato pero esta
3:04:11es la gran diferencia entre ambos
3:04:13operadores si comparamos 9 como un
3:04:17número y 9 como una cadena de caracteres
3:04:19con el operador de igualdad estricta
3:04:23este resultado va a ser falso porque no
3:04:27se van a convertir convertir a un tipo
3:04:29de dato común solamente se van a
3:04:32comparar en base a su valor ya su tipo
3:04:35de datos
3:04:36aquí podemos verlo estos dos valores
3:04:38true corresponden a las dos primeras y
3:04:41éstas corresponden a las dos últimas
3:04:43comparaciones en este caso tenemos true
3:04:47y luego tenemos fondo porque los tipos
3:04:50de datos son distintos si comentamos
3:04:53estas tres líneas podemos ver el
3:04:54resultado que nos interesa que es fox ya
3:04:58sabes como puedes comparar valores con
3:05:01igualdad estricta y su diferencia con el
3:05:04operador de igualdad
3:05:06si quieres que se conviertan a un tipo
3:05:08de datos común antes de comparar los usa
3:05:11el operador de igualdad y si también
3:05:14quieres comparar el tipo de datos usa el
3:05:16operador de igualdad estricta
3:05:25ahora practiquemos cómo puedes usar el
3:05:27operador de igualdad y el operador de
3:05:29igualdad estricta primero comencemos
3:05:32declarando dos variables a y b ya estas
3:05:34variables le vamos a asignar valores y
3:05:37los vamos a comparar y tu tarea es
3:05:39predecir cuál va a ser el valor de la
3:05:41comparación comenzamos a le vamos a
3:05:44asignar el valor 5 y a ver le vamos a
3:05:46asignar el valor 5 también debe de hacer
3:05:49preguntas rápidas a medida que
3:05:50escribamos las comparaciones para
3:05:52ayudarte a repasar el tema y cómo
3:05:54funciona este operador cuál es el nombre
3:05:56de este operador
3:05:58este es el operador de igualdad y qué
3:06:00valor predice que va a retornar
3:06:04en este caso el valor va a ser el show
3:06:07podemos verlo en la consola aquí
3:06:10ahora cuál es el nombre de este operador
3:06:14este es el operador de igualdad estricta
3:06:17y qué valor va a retornar este operador
3:06:19en este caso en este caso va a evaluar 3
3:06:23porque ambos valores también son del
3:06:25mismo tipo de datos son enteros son
3:06:27números me mostró youtube aquí ahora si
3:06:31decidimos cambiarle el valor a la
3:06:33variable p y mantener el valor de aunque
3:06:365 ahora vamos a ver en qué resultan
3:06:39estas comparaciones
3:06:41estamos usando el operador de igualdad y
3:06:44estamos comparando 5 y 8 5 y 8 cuál va a
3:06:49ser el valor de esta expresión
3:06:51va a ser falso
3:06:54aquí lo puedes ver falso es el último
3:06:56valor para no ir acumulando los
3:06:58resultados en la consola vamos a
3:07:00comentar estas líneas para que no se
3:07:01muestren solo la última que estamos
3:07:03escribiendo
3:07:04bien aquí tenemos falso y si usamos el
3:07:08operador de igualdad estricta
3:07:13cuál va a ser el resultado
3:07:16falso también porque porque los valores
3:07:19son distintos aunque tengan el mismo
3:07:22tipo de dato aunque sean del mismo tipo
3:07:23de datos sus valores son distintos así
3:07:26que el resultado es falso
3:07:28ahora digamos que actualizamos ver a la
3:07:31cadena de caracteres 5
3:07:33a sigue siendo el entero 5 y ve ahora es
3:07:37la cadena de caracteres 5
3:07:41si comparamos ahí ve cuál va a ser el
3:07:43valor de esta expresión con el operador
3:07:46de igualdad
3:07:48primero tenemos que comentar esta línea
3:07:51para ver este resultado vamos a agregar
3:07:53unas líneas aquí abajo para poder abrir
3:07:55la consola aquí vemos el valor che
3:07:58porque estamos usando el operador de
3:08:01igualdad no el operador de igualdad
3:08:03estricta
3:08:04ahora si usamos el operador de igualdad
3:08:07de estricta con tres signos igual cuál
3:08:09va a ser el resultado de esta expresión
3:08:11recuerda que los tipos de datos son
3:08:14distintos
3:08:17bien el resultado va a ser falso porque
3:08:20los tipos de datos son distintos ahorita
3:08:23tenemos las dos versiones y fowles que
3:08:25cambian si usamos operadores diferentes
3:08:28también podemos comparar cadenas de
3:08:31caracteres digamos javascript
3:08:36ya ves que vamos a hacer las mismas
3:08:39comparaciones que tenemos aquí ahora
3:08:42borramos los comentarios y cuál va a ser
3:08:44el resultado de ambas ambas van a ser
3:08:47verdaderas porque tienen el mismo valor
3:08:49y tienen el mismo tipo de datos general
3:08:52ya practicamos cómo comparar valores con
3:08:56estos operadores el operador de igualdad
3:08:59y el operador de igualdad de estricta
3:09:00así que comencemos con nuestro siguiente
3:09:03tema
3:09:09así como tenemos un operador de igualdad
3:09:11también tenemos un operador de
3:09:13desigualdad este operador compara dos
3:09:16valores y retorna tribus verdaderos y su
3:09:19valor es distinto y retorna a fons si
3:09:22son iguales es básicamente lo opuesto
3:09:25del operador de igualdad vamos a ver un
3:09:27ejemplo con su punto lo
3:09:31y aquí vemos nueve distintos de seis en
3:09:35inglés este operador se denominan lot y
3:09:38cuestión no igual sería la traducción
3:09:41literal estamos comparando si 9 no es
3:09:44igual a 6
3:09:46eso es verdadero 9 es distinto que 6
3:09:49entonces el valor en la consola que se
3:09:52muestra hecho esta expresión evalúa el
3:09:55valor y si tenemos dos números iguales
3:09:58por ejemplo 9 distinto de 9 allí si el
3:10:03resultado va a ser falso porque estamos
3:10:05preguntando si 9 es distinto a 9
3:10:09en ese caso va a ser falsa la condición
3:10:13aquí vemos el resultado
3:10:15la lógica es básicamente el opuesto del
3:10:18operador de igualdad si en los elementos
3:10:20son iguales va a ser falso si son
3:10:21distintos va a centrar también podemos
3:10:23comparar cadenas de caracteres por
3:10:25ejemplo sabes que estás aquí falsas
3:10:29porque son iguales
3:10:31entonces esta condición va a ser falsa
3:10:34si nosotros también cambiamos una de
3:10:37estas letras ya deja de ser dejan de ser
3:10:40iguales y sería verdadera la comparación
3:10:42aquí podemos ver que el tercer valor es
3:10:44falso porque son iguales y en el caso de
3:10:47los arreglos tenemos algo también
3:10:50interesante vamos a comentar esta es
3:10:52línea podemos intentar comparar arreglos
3:10:55con este operador pero aún así no va a
3:10:58estar comparando los en base a sus
3:10:59elementos sino en base a cómo están
3:11:02representados como objetos en la memoria
3:11:04del dispositivo porque mira el resultado
3:11:06aquí el resultado dice chuck estamos
3:11:09preguntando si este arreglo es distinto
3:11:11a este arreglo no es igual a este
3:11:13arreglo entonces el resultado es true
3:11:17pero vemos que si tienen los mismos
3:11:19elementos el chulo que representa es que
3:11:22estos dos arreglos son objetos
3:11:25independientes en la memoria de la
3:11:27máquina del dispositivo y eso es algo
3:11:29relacionado a cómo se almacenan estos
3:11:32valores en la memoria bien ya sabes cómo
3:11:34usar el operador de desigualdad recuerda
3:11:37que este es el símbolo un signo de
3:11:38exclamación seguido de un signo igual
3:11:40ese es el símbolo para la desigualdad
3:11:43ahora en la siguiente parte vamos a ver
3:11:45otro operador que se llama de
3:11:47desigualdad estricta así que comenzamos
3:11:57tenemos un operador que es similar al de
3:12:00igualdad estricta pero lo comparas
3:12:03desigualdad de estricta veamos la
3:12:05diferencia entre desigualdad y
3:12:07desigualdad estricta
3:12:09anteriormente con el operador de
3:12:12desigualdad si nosotros comprábamos si
3:12:16este valor era distinto a este valor el
3:12:20resultado sería falso porque este
3:12:23operador convierte a ambos operan 2
3:12:26ambos valores a un tipo de datos común
3:12:29antes de hacer la comparación por eso es
3:12:32que es falso el detecta que estos dos
3:12:35números son el mismo valor aunque uno
3:12:39esté representado como una cadena de
3:12:41caracteres y el otro sea un número como
3:12:44tal pero qué ocurre con el operador de
3:12:46desigualdad estricta si nosotros
3:12:49comparamos estos mismos valores con el
3:12:51operador de desigualdad de estricta
3:12:54ahora el resultado va a ser
3:12:57verdadero aquí lo podemos ver el
3:13:00resultado es true
3:13:02anteriormente era false con este
3:13:04operador y ahora el resultado es tres
3:13:06porque también está comparando si ambos
3:13:09valores son del mismo tipo de datos no
3:13:12lo convierte a un tipo de dato común esa
3:13:15es la diferencia entre el operador de
3:13:17desigualdad y el operador de desigualdad
3:13:20estricta funcionan exactamente igual
3:13:22excepto en este caso cuando los valores
3:13:26donde un de tipo distinto de datos pero
3:13:29representan el mismo valor éste lo
3:13:32convierte un tipo de dato común y éste
3:13:34no esa es la diferencia
3:13:37así que ya sabes cómo trabajar con el
3:13:40operador de desigualdad y el operador de
3:13:42desigualdad estricta y cuando debes usar
3:13:46unos versus el otro
3:13:53el javascript además de comparar si los
3:13:56valores son iguales o diferentes también
3:13:58podemos comparar el valor relativo de
3:14:01dos valores si un valor es mayor que el
3:14:03otro mayor o igual que el otro menor que
3:14:05el otro o menor o igual que el otro así
3:14:08que comenzamos a ver el operador mayor
3:14:10que ese operador tiene este simbolito
3:14:13que vemos aquí y podemos comparar los
3:14:17valores con este operador digamos por
3:14:19ejemplo que queremos saber si 6 es mayor
3:14:21que 5 si se es mayor que 5 esta
3:14:25expresión va a ser verdadera así que el
3:14:28valor que se va a mostrar es verdadero
3:14:31también podemos comparar
3:14:34valores de esta forma por ejemplo si 3
3:14:39es mayor que 10 no hay ningún problema
3:14:42si este elemento es menor lo que va a
3:14:44ocurrir es que la expresión va a ser
3:14:45falsa 3 no es mayor que 10 así que el
3:14:48resultado que tenemos aquí va a ser
3:14:50falso si mostramos los valores lores en
3:14:53la consola podemos ver que estos valores
3:14:55son los resultantes verdadero y falso
3:14:59también podemos usar este operador para
3:15:02comparar cadenas de caracteres pero que
3:15:05el criterio vamos a usar para las
3:15:06cadenas por defecto bueno ya ves que
3:15:09compara las cadenas según el orden
3:15:11alfabético que de las cadenas como
3:15:14aparecerían en un diccionario estamos
3:15:17diciendo si la letra p viene después de
3:15:20la letra en orden alfabético como
3:15:23estamos usando este operador mayor que
3:15:25cuando lo aplicamos a cadenas piensa que
3:15:27el mayor que es como si estuviera más
3:15:29allá más adentro en el diccionario si
3:15:32viene después que esta letra en el
3:15:34alfabeto eso sería hecho por orden
3:15:36alfabético si tuviéramos otra cadena por
3:15:39ejemplo acb mayor que a bs cuál crees
3:15:44que sería el resultado de esta
3:15:45comparación el resultado de esta
3:15:47comparación en realidad es bastante
3:15:49curioso porque como comparamos las
3:15:51cadenas si comienzan con la misma letra
3:15:53lo que hace javascript es comparar cada
3:15:56uno de los caracteres en su secuencia a
3:15:59es igual a a así que eso no nos ayuda a
3:16:02decidir si la cadena viene antes o
3:16:04después de la otra cadena
3:16:06así que pasa el segundo carácter de cada
3:16:08una y compara se viene después que ve en
3:16:12orden alfabético si se viene después que
3:16:15ve en orden alfabético así que allí ya
3:16:17podemos determinar el orden de las
3:16:19cadenas y sabemos que esto es trump y
3:16:22así es como se comparan cadenas de
3:16:24caracteres en ya ves que el primer par
3:16:26de caracteres en sus posiciones
3:16:28correspondientes que no sean iguales se
3:16:30comparan y esa comparación decide el
3:16:33resultado de la expresión veamos los
3:16:36resultados en la consola vamos a
3:16:38comentar estos dos resultados anteriores
3:16:40vemos que ambos son verdaderos
3:16:43ambos son true como bien planteado aquí
3:16:46también qué pasa si una cadena
3:16:50tiene más más caracteres que otras por
3:16:52ejemplo aquí ejemplo aquí estamos
3:16:54verificando si ap es mayor que a
3:16:59en este caso vas a ver que el resultado
3:17:02es verdadero
3:17:03vamos a comentar estas líneas y vemos en
3:17:06la consola es verdadero porque tiene más
3:17:10caracteres por orden alfabético también
3:17:13podemos comparar palabras por ejemplo
3:17:15mundo y ahora por orden alfabético m
3:17:19viene luego de la letra h en el alfabeto
3:17:22así que también podríamos comparar estas
3:17:25letras para nosotros tener una idea del
3:17:27orden m y h
3:17:30esta comparación es verdadera así que
3:17:34toda esta expresión va a ser verdadera
3:17:36porque el mundo viene después de ola en
3:17:39el diccionario otro dato interesante que
3:17:41seguramente vas a usar en tus proyectos
3:17:44es que podemos usar estos operadores de
3:17:47comparación con variables y normalmente
3:17:49eso es lo que vamos a hacer por ejemplo
3:17:52si tenemos la barra igual a 15 déjame
3:17:54borrar aquí estos comentarios que hemos
3:17:56escrito antes si tenemos una variable a
3:17:59igual a 15 y una variable p igual a 7
3:18:02nosotros podemos usar esas variables y
3:18:06compararlas podemos preguntar si es
3:18:09mayor que b eso sería verdadero y
3:18:13podemos preguntar si b es mayor que a lo
3:18:16cual sería falso podemos ver los
3:18:18resultados en la consola aquí vemos true
3:18:20y focs genial ya sabes cómo comparar
3:18:24números cadenas de caracteres y también
3:18:27variables para comparar sus valores con
3:18:29el operador mayor que así que pasamos al
3:18:32siguiente operador mayor o igual que y
3:18:34veamos su diferencia
3:18:41ella es que también tenemos otro
3:18:43operador que nos permite incluir el caso
3:18:46en el que ambos valores sean iguales
3:18:49se llama mayor o igual que y su símbolo
3:18:52es simplemente el mismo símbolo de
3:18:53mallorca pero con un signo igual a la
3:18:57derecha este es el símbolo de mayor o
3:18:59igual que qué es lo que vamos a comparar
3:19:02y cómo va a ser diferente del operador
3:19:04mayor que bueno veamos si nosotros
3:19:07comparamos si 5 es mayor que 5 usando el
3:19:11operador mayor que este resultado va a
3:19:14ser falso porque estamos preguntando si
3:19:165 es estrictamente mayor que 5 no
3:19:20estamos incluyendo el caso de que 5
3:19:22pueda ser igual a 5
3:19:25esto es importante y es una fuente común
3:19:28de confusiones cuando estamos
3:19:30programando tenemos que decidir si
3:19:32queremos incluir el caso en que ambos
3:19:34valores sean iguales si no lo queremos
3:19:37incluir usamos este operador y en el
3:19:39caso de que sean iguales la condición va
3:19:42a ser falsa pero si queremos incluir ese
3:19:45caso tenemos que ir a esta condición
3:19:49tenemos que escribir esta condición que
3:19:51usa el operador mayor o igual que puedes
3:19:54ver el símbolo que es igual que el mayor
3:19:56que pero con un signo igual a la derecha
3:19:59este operador si va a retornar el valor
3:20:02verdadero si ambos valores son iguales
3:20:04en este caso el valor va a ser 3 y eso
3:20:08va a ser muy muy importante porque vamos
3:20:10a empezar a escribir condiciones de
3:20:12nuestro código que van a decidir qué es
3:20:14lo que pasa en el programa y dependiendo
3:20:17del valor de estas condiciones vamos a
3:20:19ejecutar ciertos bloques de código o no
3:20:22vemos que los resultados son los
3:20:24correctos aquí
3:20:27no tomamos el caso en que son iguales y
3:20:29aquí si lo estamos tomando para el valor
3:20:31verdadero la condición sigue siendo
3:20:33verdadera si ambos valores son iguales y
3:20:36esa es la diferencia principal entre
3:20:38estos operadores en el caso de las
3:20:41cadenas de caracteres también aplica
3:20:43este cambio cuando las cadenas de
3:20:45caracteres sean iguales el valor
3:20:47retornado va a ser genial así que veamos
3:20:50nuestro siguiente operador menorca
3:20:58en chubut tenemos otro operador llamado
3:21:00menor que lo podemos expresar con este
3:21:03símbolo
3:21:04veamos un ejemplo si queremos
3:21:08verificar que 5 es menor que 6 usamos
3:21:12este operador si 5 menor que 6 lo cual
3:21:16es verdadero el resultado va a ser trump
3:21:18o verdadero
3:21:20en caso contrario si el valor a la
3:21:22izquierda es mayor que el de la derecha
3:21:24o igual va a ser falso digamos 10 menor
3:21:29que 310 no es menor que 3 así que el
3:21:32resultado va a ser falso y así es
3:21:35básicamente cómo funciona el operador
3:21:37veamos el resultado en la consola
3:21:40joe y false exactamente lo que
3:21:42esperábamos también se puede usar para
3:21:45comparar cadenas de caracteres como lo
3:21:47hicimos con el operador mayor que en
3:21:49este caso va a comparar las cadenas de
3:21:51caracteres en orden alfabético así que
3:21:55si comparamos a con ver como cadenas de
3:21:59caracteres el resultado va a ser su por
3:22:02qué
3:22:02viene antes que ve en orden alfabético
3:22:05también si la cadena de caracteres tiene
3:22:08varios caracteres el proceso va a ser
3:22:11muy similar al que ya vimos en los
3:22:13ejemplos anteriores se van a comparar
3:22:16los caracteres
3:22:17es siesta antes que se en orden
3:22:20alfabético
3:22:20así que la condición sería verdadera es
3:22:24lo que determina el valor de la
3:22:26condición veamos la consola vemos toda
3:22:29la secuencia de valores true shows
3:22:32después tú y trump aquí
3:22:35también podemos comparar los valores de
3:22:38variables que eso es exactamente lo que
3:22:39vamos a hacer en nuestros programas
3:22:41normalmente si definimos dos variables y
3:22:44las queremos comparar con este operador
3:22:47que es lo que hacemos las comparamos
3:22:49simplemente y obtenemos los resultados
3:22:53en este caso a no es menor que b esto es
3:22:57falso
3:22:58y ve si es menor que así que esto es
3:23:02verdadero vamos a comentar estas líneas
3:23:04y sólo dejamos estas dos líneas para ver
3:23:07el resultado
3:23:09vemos founds porque a no es menor que ve
3:23:13a es 15 y b 7 y 3 porque b
3:23:18es menor que de 7 y a es 15 genial ya
3:23:23sabes usar el operador menor que y
3:23:25también tenemos una versión de este
3:23:27operador que permite que ambos valores
3:23:29sean iguales
3:23:31el operador menor o igual que veremos
3:23:33más sobre este operador en la próxima
3:23:35parte
3:23:42el operador menor o igual que funciona
3:23:45básicamente igual que el operador menor
3:23:48que pero también va a incluir el caso en
3:23:50el que ambos valores sean iguales veamos
3:23:53la diferencia si nosotros verificamos si
3:23:565 es menor que 5 en la condición este
3:23:59resultado va a ser falso porque 5 no es
3:24:03estrictamente menor que 5 es igual a 5
3:24:06cuando usamos el operador menor que no
3:24:09estamos tomando en cuenta el caso en el
3:24:12que ambos valores sean iguales y eso a
3:24:14veces no también nos puede ser útil en
3:24:16los programas si necesitamos que un
3:24:18valor sea menor que el otro
3:24:20pero si necesitamos también tomar en
3:24:24cuenta el caso en el que ambos puedan
3:24:25ser iguales usamos este operador menor e
3:24:28igual que solamente le agregamos el
3:24:31signo igual aquí estamos comparando los
3:24:34valores y su resultado en este caso va a
3:24:37ser verdadero porque ambos valores son
3:24:40iguales esa es la diferencia principal
3:24:43entre ambos operas este caso sería falso
3:24:46con el operador menor qué
3:24:48y este caso sería verdadero con el
3:24:51operador menor o igual que veámoslo en
3:24:53la consola aquí vemos falso y vemos
3:24:56verdadero genial esa es la diferencia
3:24:59principal todos los ejemplos anteriores
3:25:01con el operador menor que también
3:25:04aplican con el operador menor o igual
3:25:05que lo que cuando lo ambos valores sean
3:25:08iguales el resultado también va a ser
3:25:10verdadero también cuando comparamos
3:25:12cadenas de caracteres bien ahora en la
3:25:15próxima sección vamos a comenzar a ver
3:25:16los operadores lógicos así que te veo en
3:25:20el próximo tema
3:25:27ahora vamos a ver los operadores lógicos
3:25:29sense baskets estos operadores lógicos
3:25:32nos permiten combinar distintas
3:25:36expresiones para formar condiciones un
3:25:39poco más elaboradas o más complejas el
3:25:41primer operador lógico que vamos a ver
3:25:43es el operador and que en español
3:25:46significa y
3:25:48los operadores lógicos tienen algo que
3:25:50se llama tablas de verdad que determinan
3:25:53cuál va a ser el resultado de una
3:25:56expresión que usa ese operador
3:25:59digamos que tenemos dos expresiones xy
3:26:02cher o dos valores y esos valores son
3:26:05verdaderos o falsos y los unimos con el
3:26:08operador and quién javascript es un
3:26:11doble ampersand si x es verdadero y ya
3:26:16es verdadero true entonces cuando los
3:26:19unimos con el operador and toda esa
3:26:22expresión va a ser verdadera
3:26:26en cambio si alguno de ellos es falso o
3:26:30ambos
3:26:31entonces la expresión va a ser falsa con
3:26:35el operador ante la expresión solo es
3:26:38verdadera cuando ambos operan dos son
3:26:41verdaderos
3:26:42ambos tienen que ser verdaderos para que
3:26:45el resultado sea verdadero podemos
3:26:48comprobar esto usando el operador aquí
3:26:51tenemos las distintas combinaciones que
3:26:53vemos en la tabla verdaderos verdaderos
3:26:56verdadero y falso falso y verdadero y
3:26:59falso y falso estas cuatro líneas que
3:27:02tenemos aquí en la tabla de verdad
3:27:04vamos a ver los resultados en la consola
3:27:07vemos que solamente esta expresión es
3:27:10verdadera
3:27:12porque ambos valores son verdaderos
3:27:15vamos a ver algunos ejemplos porque
3:27:17normalmente nosotros en el código no
3:27:19vamos a escribir directamente valores
3:27:22crossfox sino que vamos a escribir
3:27:25condiciones ciones
3:27:27vamos a ver lo primero que vamos a hacer
3:27:30es definir una variable con un valor
3:27:33inicial de 8 y vamos a ver cuál es el
3:27:36resultado de esta expresión a mayor que
3:27:405 y a menor que 10
3:27:45esta expresión va a ser verdadera o
3:27:48falsa pero eso depende de si esta parte
3:27:53es verdadera y si esta parte es
3:27:54verdadera o no veamos a mayor que 5 es
3:27:59verdadera porque el valor de a es 8
3:28:03luego tenemos el operador andy y esta
3:28:07también es verdadera porque a es menor
3:28:09que 10
3:28:10su valor es 8 por lo tanto el resultado
3:28:13va a ser
3:28:14trump de toda esta expresión lo podemos
3:28:19verificar aquí en la consola
3:28:21ahora digamos que cambiamos el valor de
3:28:24a ahora el valor de a va a ser todo esto
3:28:27va a cambiar si el valor de a estrés a
3:28:31mayor que 5 ahora es falsa
3:28:34y ésta sigue siendo verdadera porque
3:28:37sigue siendo menor que 10 pero como
3:28:40vimos en la tabla si alguna de ellas es
3:28:43falsa el resultado va a ser falso así
3:28:48que el resultado que se muestra en la
3:28:50consola para esta expresión va a ser
3:28:53falso exactamente lo que pensábamos si
3:28:57cambiamos el valor y ahora el valor es
3:28:5915 digamos
3:29:01a mayor que 5 ahora es verdadera pero a
3:29:05menor que 10
3:29:07es falsa
3:29:09si alguno de los valores es falso el
3:29:11resultado es falso y eso es exactamente
3:29:14lo que vemos en la consola falso genial
3:29:18nos falta el último caso en el que ambos
3:29:22son falsos
3:29:25en este caso
3:29:27vamos a cambiar la expresión para que
3:29:30ambas puedan ser falsas podemos ver que
3:29:32ambas no se pueden cumplir en simultáneo
3:29:36podemos colocar un valor para que ambas
3:29:39sean falsas si el valor de a es igual a
3:29:421 esta condición también es falsa por lo
3:29:46tanto el resultado es falso genial ya
3:29:49probamos los 4 casos que tenemos en esta
3:29:52tabla para el operador ante los
3:29:54operadores lógicos van a ser muy muy
3:29:56útiles cuando te empecemos a trabajar
3:29:59con condicionales para decidir si una
3:30:03parte del código se ejecuta o no basados
3:30:06en ciertas condiciones
3:30:09bien pasemos a nuestro siguiente
3:30:11operador lógico el operador
3:30:19ahora hablemos sobre el operador lógico
3:30:21ahora él significa o en español tiene su
3:30:25propia tabla de verdad y en javascript
3:30:28el símbolo para ese operador es dos
3:30:31barras dos barras verticales la tabla de
3:30:34verdad para org es un poco distinta a la
3:30:36tabla de verdad para andy con el
3:30:39operador por si cualquiera de los operan
3:30:42dos de los valores es verdadero
3:30:45entonces el resultado es verdadero puede
3:30:49ser uno o el otro o ambos pueden ser
3:30:52verdaderos para que el resultado sea
3:30:54verdadero pero si ambos son falsos ahí
3:30:57si el resultado es falso la expresión es
3:31:01falsa la expresión es verdadera con el
3:31:04operador por si alguno de los dos operan
3:31:06dos o ambos son verdaderos comprobemos
3:31:09la tabla de verdad aquí tenemos todas
3:31:12las combinaciones verdadero verdadero
3:31:14verdadero falso falso verdadero y falso
3:31:17falso
3:31:19en la consola vamos a ver los distintos
3:31:22valores y vemos que si alguno de ellos
3:31:25es verdadero el resultado es verdadero y
3:31:28solo es falso cuando ambos son falsos
3:31:31bien empecemos a ver algunos ejemplos
3:31:34vamos a trabajar con la misma variable
3:31:37del ejemplo anterior
3:31:39y vamos a mostrar en la consola el
3:31:41resultado de una expresión digamos que a
3:31:45es menor que 5
3:31:47es mayor que 15
3:31:49veamos si es verdadera o falsa en este
3:31:51caso a menor que 5 es falsa porque el
3:31:56valor de a es 8 y a mayor que 15 también
3:32:00es falsa
3:32:02porque el valor es 8 así que el
3:32:05resultado va a ser falso y aquí lo
3:32:08podemos ver si cambiamos el valor de a a
3:32:12digamos
3:32:132 ahora esta condición a menor que 50 es
3:32:19verdadera y por lo tanto el resultado es
3:32:22verdadero lo podemos ver aquí en la
3:32:24consola si actualizamos el valor de a a
3:32:28digamos 20 ahora es falsa porque a no es
3:32:32menor que 5 pero esta si es verdadera
3:32:35porque a es mayor que 15 así que el
3:32:38resultado es verdadero aquí lo tenemos
3:32:42sólo nos falta el caso en que ambas sean
3:32:45verdaderas pero en este caso no puede
3:32:47ocurrir porque estamos comprobando cosas
3:32:50que no pueden ocurrir simultáneamente
3:32:53hagamos una comparación
3:32:56distinta si es igual a 5 y ya es menor
3:32:59que 15
3:33:01ese caso si puede ocurrir cuando es
3:33:04igual a 5 el valor resultante sería
3:33:07verdadero y lo vemos en la consola bien
3:33:11ya sabes cómo trabajar con los
3:33:13operadores lógicos andy y ahora nos
3:33:16falta el tercer operador lógico llamado
3:33:18not y es el operador que vamos a ver en
3:33:22la próxima parte
3:33:28ahora hablemos un poquito sobre el
3:33:30tercer operador lógico que podemos usar
3:33:32en javascript el operador no en español
3:33:36no significa no y es el operador que
3:33:39usamos para negar el valor de verdad de
3:33:42otra expresión para negar una expresión
3:33:45veamos este ejemplo el símbolo que
3:33:48usamos para denotar este operador en
3:33:50javascript es un signo de exclamación es
3:33:53el signo de exclamación se coloca antes
3:33:55de la expresión que queremos negar y
3:33:58ella va a saber el resultado si la
3:34:00expresión es verdadera agregando el este
3:34:02operador convertimos el resultado en
3:34:04falso y si la expresión es falsa la
3:34:07convertimos en verdadero comprobemos la
3:34:10tabla de verdad como hicimos
3:34:11anteriormente con los otros dos
3:34:13operadores
3:34:14si nosotros escribimos ese operador el
3:34:16signo de exclamación seguido del valor
3:34:19de verdad el resultado debería ser falso
3:34:22y si escribimos ese operador con el
3:34:26valor fob el resultado lazio comprobemos
3:34:30esto en la consola aquí vemos fouz y
3:34:34luego vemos aquí bien ya comprobamos la
3:34:37tabla de verdad de noche así que veamos
3:34:39algunos ejemplos
3:34:41estos ejemplos va a ser más conciso
3:34:43porque solo necesitamos ver dos
3:34:46situaciones si la expresión es verdadera
3:34:49y si la expresión es falsa si definimos
3:34:51una variable la creamos la variable aire
3:34:54asignamos el valor 8 veamos como la
3:34:57usamos en las expresiones
3:34:59vamos a mostrar el resultado de la
3:35:01expresión
3:35:03vamos a usar el operador not el signo de
3:35:06exclamación y entre paréntesis vamos a
3:35:08escribir nuestra expresión no debe
3:35:11separar con un espacio esto que no debe
3:35:14haber separación entre el operador y la
3:35:16expresión
3:35:17queremos verificar si a es mayor que 5 y
3:35:22luego queremos negar ese valor
3:35:24veamos qué es lo que va a ocurrir cuando
3:35:26se evalúe esta expresión
3:35:29a mayor que 5 es verdadero porque su
3:35:33valor es 8 entonces lo que tenemos aquí
3:35:35es una negación del valor ya que resulta
3:35:40en el valor fob bien ya tenemos nuestra
3:35:43primera expresión ahora veamos un
3:35:45resultado que nos dé hecho
3:35:48estamos verificando si a es menor que 5
3:35:51y luego estamos negando su valor
3:35:54si escribimos aquí la expresión
3:35:57estamos negando el valor fox porque esta
3:36:00expresión es falsa no es menor que 5 si
3:36:04lo negamos con este operador el operador
3:36:06no es el resultado va a ser
3:36:10bien vamos a agregar unas líneas aquí y
3:36:12abrir la consola podemos ver los valores
3:36:15falsos y ser mostrados aquí en la
3:36:18consola enviando ya tenemos nuestros
3:36:21tres operadores que podemos usar en el
3:36:23código para escribir condiciones más
3:36:25complejas y para controlar qué es lo que
3:36:27pasa en nuestro código porque ellas van
3:36:30a ser vitales para poder escribir
3:36:32condicionales y ese va a ser el próximo
3:36:35tema del curso vamos a adentrarnos en
3:36:37condicionales que van a ser herramientas
3:36:39importantísimas para programar y para
3:36:41crear programas más elaborados así que
3:36:43comencemos con nuestra siguiente parte
3:36:45del curso
3:36:51bien ya llegamos a una parte del curso
3:36:53en el que vas a aprender herramientas
3:36:55que van a hacer poderosísimas para crear
3:36:57programas en javascript básicamente la
3:37:00vas a usar en casi todos los proyectos o
3:37:02programas que escribas te prometo que
3:37:04las vas a usar muy a menudo ellos son
3:37:06los condicionales los condicionales nos
3:37:09permiten decidir si un bloque de código
3:37:12se ejecuta o no dependiendo de una
3:37:15condición
3:37:16básicamente nos da más control sobre qué
3:37:18es lo que va a ocurrir en el programa
3:37:20para escribir un condicional lo primero
3:37:23que escribimos es la palabra clave if y
3:37:26efe en español significaría algo como si
3:37:29un sí condicional si esta condición es
3:37:32verdadera la condición va a estar entre
3:37:34paréntesis
3:37:35entonces hacemos lo que está dentro de
3:37:38las llaves la palabra clave o la palabra
3:37:41reservada y luego la condición dentro de
3:37:44los paréntesis y luego una secuencia de
3:37:47instrucciones que va a estar aquí
3:37:49inventado dentro llaves
3:37:52esta condición tiene que ser verdadera
3:37:54para que se ejecuta este código así que
3:37:58vamos a comenzar solo escribiendo el
3:38:00valor aquí verdadero así que siempre se
3:38:03va a ejecutar este código que vamos a
3:38:06hacer vamos a mostrar un mensaje que
3:38:08diga la condición es verdadera
3:38:13aquí ves la estructura general del
3:38:14condicional veamos la consola la
3:38:17condición es verdadera puedes ver que
3:38:19este código se ejecutó porque esta
3:38:21condición es verdadera pero normalmente
3:38:24no vamos a escribir el valor de verdad
3:38:26directamente no vamos a escribir true
3:38:29lo que vamos a escribir es una condición
3:38:31veamos un ejemplo si definimos una
3:38:34variable x y le asignamos el valor 5 y
3:38:38en lugar de escribir el valor
3:38:39directamente aquí decimos si x es mayor
3:38:42que 2
3:38:43entonces muestra este mensaje y este es
3:38:47un ejemplo de un condicional como los
3:38:49que normalmente vas a encontrar en la
3:38:51ficha basket la palabra clave es una
3:38:54condición más elaborado también puede
3:38:56ser mucho más compleja esta condición
3:38:58podemos usar operadores lógicos and or
3:39:01not
3:39:02podemos usar otro tipo de operador de
3:39:04comparación pero siempre va a ser una
3:39:06expresión que evalúa verdadero o falso
3:39:08si es verdadera este código se ejecuta
3:39:12puede tener muchas líneas tantas como
3:39:14necesitamos que estén condicionadas y si
3:39:17es falso este código no se va a ejecutar
3:39:20y simplemente va a seguir la ejecución
3:39:23del programa luego del condicional
3:39:24cualquier línea que esté por aquí va a
3:39:26ser ejecutada y se salta este código
3:39:29veamos la consola la condición es
3:39:32verdadera como x es mayor que 2 esta
3:39:36condición fue verdadera y se ejecutó
3:39:38esta línea
3:39:39ahora vamos a cambiar el operador y
3:39:41vamos a decir si x es menor que 2
3:39:43ejecutar este código pero como es que es
3:39:46igual a 5 no es menor que 2 esta
3:39:49condición es falsa y esta condición es
3:39:51falsa y este código no se ejecuta y lo
3:39:54puedes ver aquí en la consola porque no
3:39:56tenemos ningún mensaje mostrado en la
3:39:58consola así es básicamente como
3:40:00funcionan los condicionales también
3:40:02podemos escribir condiciones más
3:40:04elaboradas por ejemplo si x es mayor que
3:40:072 y menor que díaz
3:40:09ejecuta esta línea de código
3:40:12puedes ver cómo estamos combinando los
3:40:14operadores de comparación y los
3:40:16operadores lógicos para formar
3:40:18condiciones más complejas también
3:40:20podríamos usar más paréntesis aquí si
3:40:23creemos que eso ayuda a que el código
3:40:26sea más fácil de leer en este caso
3:40:27también podríamos omitir los bien veamos
3:40:30un ejemplo con las estaciones
3:40:32estación recuerda que no estoy
3:40:34incluyendo los acentos porque
3:40:36normalmente tratamos de omitir
3:40:39caracteres que no sean estándar en
3:40:41inglés que es lo que decimos en nuestro
3:40:43condicional si el valor de la variable
3:40:47estación es igual a invierno que vamos a
3:40:51hacer mensaje si me encanta el invierno
3:40:55y en este caso la condición es verdadera
3:40:58porque el valor de estación es invierno
3:41:01como la condición es verdadera se va a
3:41:04ejecutar esta línea de código y si vemos
3:41:06en la consola podemos verlo si me
3:41:09encanta el invierno ahora si la
3:41:11condición es falsa porque la estación no
3:41:14es la que nosotros colocamos en la
3:41:16condición por ejemplo si ahorita estamos
3:41:18en verano y la condición dice que tiene
3:41:20que ser invierno para que esto ocurra
3:41:22qué es lo que va a ocurrir en este caso
3:41:25nada porque la condición era falsa este
3:41:29código no se ejecuta y como no tenemos
3:41:31más líneas aquí el programa simplemente
3:41:33termina podemos mostrar un mensaje aquí
3:41:37que diga
3:41:39después del condicional para que veas
3:41:42que cualquier línea que esté luego de
3:41:44esta llave que cierra el condicional va
3:41:47a ser ejecutada si la condición es falsa
3:41:50y también va a ser ejecutada si la
3:41:52condición es verdadera cuando se termine
3:41:54de ejecutar este bloque de código
3:41:56ahorita la condición es falsa no se
3:41:59ejecuta este código así que saltamos a
3:42:01esta línea y vemos después del
3:42:03condicional si la condición es verdadera
3:42:06se ejecuta esta línea se ejecuta esta
3:42:08línea aquí vemos el mensaje y también
3:42:11seguimos en la ejecución normal del
3:42:13programa después del condicional genial
3:42:16ya sabes cómo escribir un condicional
3:42:18básico con una condición pero también
3:42:20podemos manejar varias condiciones y
3:42:22decidir qué es lo que pasa si la
3:42:24condición es falsa así que esto lo
3:42:26veremos en las próximas partes del curso
3:42:28te espero allí
3:42:35también podemos expandir nuestros
3:42:37condicionales para decidir qué es lo que
3:42:39ocurre si la condición del condicional
3:42:42es falsa vamos a escribir el condicional
3:42:45sí y decimos si la condición es
3:42:48verdadera escribamos aquí una vez el
3:42:50valor you vamos a inicialmente a
3:42:53trabajar con el valor de verdad para
3:42:55ilustrar qué es lo que ocurre la
3:42:57condición es verdadera
3:43:00si no la condición es falsa
3:43:03esta es la cláusula
3:43:05que podemos agregar a los condicionales
3:43:07tenemos la misma estructura con la que
3:43:10trabajamos anteriormente pero ahora
3:43:13luego de la llave que cierra la cláusula
3:43:16y
3:43:16escribimos la palabra oms esta es una
3:43:19palabra especial reservada en javascript
3:43:22para esta cláusula con cláusula
3:43:25simplemente uno se refiere a una parte
3:43:27de una estructura que podemos usar en el
3:43:30código en este caso la estructura sería
3:43:32un condicional y 11 es una parte de esa
3:43:35estructura una cláusula que nos permite
3:43:38decidir qué es lo que pasa si la
3:43:40condición es falsa
3:43:43escribimos ellos otro par de llaves y
3:43:46dentro de las llaves escribimos lo que
3:43:49queremos que ocurra en este caso vamos a
3:43:51mostrar el mensaje de la condición es
3:43:53falsa si la condición es verdadera
3:43:57esta condición que tenemos aquí se
3:44:00ejecuta este código el que pertenece a
3:44:03la cláusula pero si la condición es
3:44:06falsa que es lo que va a ocurrir este
3:44:10código no se ejecuta vamos a cambiar
3:44:12esto aquí por font y puedes ver que
3:44:15cambia el enfoque del código aquí porque
3:44:17esta es la cláusula que se va a ejecutar
3:44:19la cláusula outs el código que
3:44:22corresponda eus se va a ejecutar es uno
3:44:25u otro nunca se va a ejecutar los dos la
3:44:28condición o es verdadera y se ejecuta
3:44:31este código o es falsa y se ejecuta este
3:44:34código nunca ambos a la vez y como
3:44:37hablamos de que normalmente no vamos a
3:44:39escribir los valores de verdad en la
3:44:41condición vamos a ver un ejemplo vamos a
3:44:44definir la variable x con un valor
3:44:47inicial 5
3:44:49la condición va a ser que x sea menor
3:44:52que 2 si x es menor que 2 esta condición
3:44:55es verdadera y por lo tanto esta línea
3:44:58de código se ejecuta y se muestra un
3:45:00mensaje si la condición es falsa
3:45:03entonces vamos a ellos y se ejecuta esta
3:45:05línea
3:45:06veamos qué es lo que ocurre abriendo la
3:45:08consola puedes ver aquí que la condición
3:45:12es falsa
3:45:13este mensaje se muestra porque esta
3:45:15línea se ejecuta esta línea no se
3:45:18ejecuta porque la conexión es falso
3:45:21genial vamos a seguir con nuestro
3:45:23ejemplo de estaciones estación y decimos
3:45:28si la estación es verano qué vamos a
3:45:31hacer
3:45:32vamos a escribir oa mostrar este mensaje
3:45:35comenzó el verano ya podemos ir a la
3:45:40playa
3:45:41si no ya quiero que llegue el verano
3:45:45para poder ir a la playa bien ya tenemos
3:45:50nuestro condicional de esta condición va
3:45:53a depender qué es lo que ocurre en el
3:45:55programa si es verdadero se ejecuta esta
3:45:58línea y si es falsa vamos a la cláusula
3:46:012 y se ejecuta esta ley
3:46:04en este caso la condición es falsa
3:46:06porque el valor de estación no es igual
3:46:08a verano en este caso podríamos usar el
3:46:11operador de igualdad pero también se
3:46:13recomiendo usar guardada estricta para
3:46:15verificar el tipo de dato que vamos a
3:46:18abrir la consola y aquí vemos ya quiero
3:46:21que llegue el verano para poder ir a la
3:46:23playa
3:46:24este mensaje se demostró porque la
3:46:27condición era falsa bien ya sabes cómo
3:46:30trabajar con la cláusula euros la
3:46:32cláusula ellos sirve como un respaldo y
3:46:35si siempre va a estar ubicada luego de
3:46:38la cláusula if la cláusula ife es como
3:46:40la principal y esto es simplemente un
3:46:43respaldo de qué es lo que pasa si la
3:46:45condición es falsa bien también puedes
3:46:48manejar varias condiciones y para eso
3:46:51tenemos una cláusula llamada else if la
3:46:54vamos a ver en el próximo tema
3:47:01los condicionales también pueden
3:47:03verificar y manejar varias condiciones
3:47:06en este ejemplo vamos a ver cómo puedes
3:47:08usar una cláusula llamada else y es que
3:47:11nos permite hacer exactamente eso
3:47:12manejar condiciones alternativas y
3:47:15decidir qué pasa si alguna de ellas es
3:47:17verdadera esta vez vamos a trabajar con
3:47:20funciones vamos a definir una función
3:47:23que se va a llamar clasificar valor esta
3:47:26función va a tomar un valor como un
3:47:29parámetro y va a determinar si el valor
3:47:31es divisible entre 2 divisible entre 3 o
3:47:35si no es divisible entre ninguno de esos
3:47:37números vamos a hacerlo con un
3:47:38condicional escribimos si el valor es
3:47:41divisible entre 2 es decir si el valor
3:47:44dividido entre 2 genera un resto igual a
3:47:47cero mostramos el mensaje que diga
3:47:50divisible entre 2 ya conoces cómo
3:47:53escribir el quiz la cláusula if y
3:47:56también conoces cómo escribir la
3:47:58cláusula eus vamos a agregar la acción
3:48:01de una vez porque ya la conoces vamos a
3:48:04decir no es divisible
3:48:06entre las opciones
3:48:10ahora entre y james vamos a poder
3:48:13agregar una cláusula nueva que se llama
3:48:15el if como le agregamos luego de la
3:48:19llave que cierra y escribimos eos if
3:48:23separadas con un espacio el aussie live
3:48:28y nuevamente escribimos un par de llaves
3:48:30las llaves son vitales en javascript
3:48:32porque le dicen al programa hasta dónde
3:48:34llega a cada bloque de código cada parte
3:48:37de la estructura lo clave aquí es que
3:48:40tenemos que escribir una condición luego
3:48:43de la palabra if esa condición también
3:48:46se puede verificar vamos a ver ya la
3:48:48lógica de esa condición decimos si el
3:48:51valor es divisible entre 3 entonces
3:48:54mostramos este mensaje
3:48:57es divisible entre 3 y ya tenemos
3:49:00nuestra función es nuestra función con
3:49:02nuestro condicional pero cómo funciona
3:49:05este condicional cuál es la lógica del
3:49:07código si esta condición es verdadera la
3:49:11primera que encontramos en el
3:49:12condicional esta línea se ejecuta todo
3:49:16lo que corresponda a este bloque de
3:49:18código entre el primer par de llaves
3:49:21sino si esta condición es falsa se
3:49:24verifica y se verifica que es falsa este
3:49:27código no se ejecuta y pasamos
3:49:30directamente a esta parte del código la
3:49:32segunda cláusula se verifica esta
3:49:35condición se evalúa la expresión si es
3:49:38verdadera se ejecuta el código que
3:49:40corresponde a esa cláusula y si es falsa
3:49:43pasamos a la siguiente cláusula o en su
3:49:47defecto a la cláusula 2 si existe una en
3:49:50el condicional y se ejecuta este código
3:49:54si todas las condiciones anteriores son
3:49:56falsas en el condicional
3:49:59sirve como un respaldo vamos a llevar la
3:50:01función con distintos valores para que
3:50:03veas cómo funciona este condicional
3:50:06digamos que el valor es 2 lo cual
3:50:10sabemos que va a ejecutar este línea de
3:50:14código porque el valor es divisible
3:50:16entre 2 está condición va a ser
3:50:19verdadero y este código se va a ejecutar
3:50:21veamos la consola como es divisible
3:50:25entre 2 este mensaje se muestre lo vemos
3:50:27en la consola
3:50:29ahora si el valor es 15 sabemos que no
3:50:32es divisible entre 2 en esta condición
3:50:35va a ser falsa pero esta condición si
3:50:38iba a ser verdadera porque es divisible
3:50:40entre otras así que veamos la consola
3:50:43vemos los dos mensajes pero déjenme
3:50:45comentar aquí esta línea y ahorita vemos
3:50:48solo es divisible entre 3
3:50:51que es el resultado de llamar a esta
3:50:54función con este valor genial y
3:50:57finalmente vamos a llamar a la función
3:51:00con un valor que no cumpla ninguno de
3:51:02esos criterios no es divisible entre 2 y
3:51:04no es divisible entre otras
3:51:07entonces allí iríamos a esta cláusula 2
3:51:09y se mostraría el mensaje
3:51:13no es divisible entre las opciones el
3:51:15mensaje que tenemos aquí y así es
3:51:18básicamente cómo funciona un condicional
3:51:20que tiene una cláusula offer si las
3:51:22condiciones anteriores son falsas se
3:51:24evalúa su condición y se ejecuta su
3:51:26código si la condición es verdadera pero
3:51:29solamente uno de estos bloques de código
3:51:32se va a ejecutar eso es clave en los
3:51:34condicionales es clave que sepas cómo
3:51:36funciona esta parte de los condicionales
3:51:38solo un bloque de código se va a
3:51:40ejecutar el bloque de código que
3:51:43corresponda a la primera condición que
3:51:45es verdadera si hay muchas condiciones
3:51:48que puedan ser verdaderas solo la
3:51:49primera que sea verdadera se va a
3:51:51ejecutar y después el programa va a
3:51:53continuar con su ejecución normal bien
3:51:56así que pasemos a nuestro siguiente tema
3:52:04veamos otro ejemplo de un condicional
3:52:06porque es muy importante que entiendas
3:52:08cómo funciona cada una de sus cláusulas
3:52:11y cuál va a ser el resultado del código
3:52:15así que vamos a definir una función que
3:52:17se va a llamar clasificar valor esta
3:52:21función va a tomar un valor como
3:52:23argumento así que definimos aquí el
3:52:26parámetro de la función y dentro de la
3:52:29función vamos a escribir un condicional
3:52:31este condicionar va a verificar dos
3:52:34condiciones de ese valor primero va a
3:52:37verificar si el valor es menor que cinco
3:52:39estrictamente menor que cinco si ese es
3:52:42el caso entonces vamos a mostrar el
3:52:45mensaje menor que cinco en la consola
3:52:49si no si tenemos que verificar la
3:52:52siguiente condición porque este no es el
3:52:55caso y esta condición es falsa vamos a
3:52:58pasar a la cláusula es decir esa
3:53:02cláusula va a haber y si el valor es
3:53:03menor que 10 si ese es el caso vamos a
3:53:06mostrar este mensaje menor que 10 si
3:53:10ambas condiciones son falsas si el valor
3:53:12no es menor que 5 y el valor no es menor
3:53:15que 10 entonces la única opción que nos
3:53:18queda es que el valor sea mayor o igual
3:53:21a 10 esa es básicamente la estructura
3:53:24del condicional en este ejemplo pero
3:53:27veamos cómo funciona con distintos
3:53:29valores que le vamos a pasar a la
3:53:31función
3:53:32y llamamos a la función de esta forma
3:53:34clasificar valor y entre paréntesis
3:53:36tenemos que pasar un valor para ese
3:53:40parámetro digamos 2 veamos cuál es el
3:53:43resultado
3:53:44el mensaje es menor que 5 porque se
3:53:48muestra este mensaje porque esta
3:53:50condición es verdadera en este valor 2
3:53:53se asigna a este parámetro y luego donde
3:53:56usamos el parámetro se va a reemplazar
3:53:59ese valor para comprobar la condición en
3:54:02este caso está en este caso estamos
3:54:04comprobando si 2 es menor que 5 esa
3:54:08condición es verdadera y por lo tanto
3:54:10este código se ejecuta sólo una de las
3:54:14cláusulas es la que se ejecuta aunque
3:54:16puedes ver que sólo vemos este mensaje
3:54:18esta parte del código y esta parte del
3:54:22código que corresponden a otras
3:54:24cláusulas no se ejecutan en este caso el
3:54:28valor era menor que 5 pero qué ocurre si
3:54:30esta condición es falsa
3:54:33veamos si actualizamos el valor a 7 aquí
3:54:36como el argumento
3:54:38vemos que el mensaje se actualiza a
3:54:39menor que 10 esta línea que tenemos acá
3:54:43porque el argumento 7 se asigna al
3:54:46parámetro valor
3:54:48esta condición se verifica y comparamos
3:54:517 con
3:54:5357 no es menor que 5 así que esta
3:54:56condición es falsa como es falsa ni
3:54:59siquiera pasamos a esta parte del código
3:55:02es como si no existía siguiente parte
3:55:04del condicional a la siguiente cláusula
3:55:06y decimos el valor es menor que 10 esa
3:55:11condición ahora sí es verdadera porque
3:55:13el valor era 7 así que es estrictamente
3:55:16menor que 10 y por eso vemos esta línea
3:55:20que tenemos acá esa línea se ejecuta y
3:55:23vemos el mensaje menor que 10 nota algo
3:55:26curioso que tenemos aquí en nuestro
3:55:28ejemplo anterior cuando pasábamos el
3:55:31valor 2 como argumento
3:55:34estas dos condiciones eran verdaderas no
3:55:37sé si lo notas te anteriormente cuando
3:55:39estábamos viendo el ejemplo pero es algo
3:55:41importante de resaltar porque en este
3:55:43caso el valor era 2 el valor era menor
3:55:46que 5 y era menor que 10
3:55:49ambas eran verdaderas pero solamente se
3:55:52muestra un mensaje aquí porque solo se
3:55:55ejecuta el código de la primera
3:55:58condición que sea verdadera en la
3:56:00secuencia así que es importante export
3:56:04and test que analices bien el orden en
3:56:07que escribes estas cláusulas si nosotros
3:56:10hubiéramos puesto esta condición primero
3:56:12aquí arriba hubiéramos invertido el
3:56:15orden de las condiciones
3:56:16el mensaje hubiera sido distinto veamos
3:56:19a qué me refiero si nosotros cambiamos
3:56:21las condiciones aquí ponemos 10 y aquí
3:56:24ponemos 5 aquí ponemos 10 y aquí ponemos
3:56:275 puedes ver que aquí el mensaje ahora
3:56:31es menor que 10 porque esta fue la
3:56:34primera condición verdadera y se ejecuta
3:56:36este código
3:56:38así que es muy importante que escojas el
3:56:40orden de las condiciones adecuadamente
3:56:42para que la primera condición que sea
3:56:44verdadera sea la que se ejecute ahora si
3:56:47regresamos toda la normalidad vamos a
3:56:50probar qué es lo que ocurre si ninguna
3:56:52de las condiciones es verdadera si ambas
3:56:54son falsas y vamos a estas cláusulas
3:56:56else si pasamos el valor por ejemplo 15
3:56:59como argumento se asigna ese valor al
3:57:02parámetro y como quien seno es menor que
3:57:055 esta condición es falsa no es menor
3:57:08que 10 esta condición es falsa nos vamos
3:57:11a esta cláusula que sirve como un
3:57:13respaldo y por lo tanto esta línea este
3:57:16bloque de código que podría ser de más
3:57:18de una línea se ejecuta en este caso
3:57:21vemos el mensaje mayor o igual a 10
3:57:24genial ya sabes cómo funciona la lógica
3:57:28de las cláusulas if el if years puedes
3:57:32agregar más de una cláusula dependiendo
3:57:35de cuántas condiciones deseas verificar
3:57:37en el condicional lo importante es que
3:57:39la cláusula ypf tiene que ser la primera
3:57:42cláusula
3:57:43el cif tiene que ser la segunda cláusula
3:57:46tercera y así sucesivamente y la
3:57:49cláusula 2 siempre tiene que estar al
3:57:51final es la última porque sirve como
3:57:54respaldo en la siguiente parte vamos a
3:57:57ver cómo puedes escribir un condicional
3:57:59con más de una cláusula o sea vamos a
3:58:02tener un ejemplo con el índice de masa
3:58:04corporal así que te veo allí
3:58:11bien ahora vamos a ver un ejemplo de un
3:58:13condicional con dos cláusulas el shift
3:58:16vamos a verificar varias condiciones
3:58:19primero vamos a definir una función y
3:58:22nuestro ejemplo va a estar enfocado en
3:58:24interpretar el índice de masa corporal
3:58:26de una persona vamos a tomar ese valor
3:58:30del índice de masa corporal y luego
3:58:32vamos a clasificarlo con un condicional
3:58:34los valores van a estar clasificados de
3:58:37acuerdo a dar una tabla que puedes
3:58:39conseguir en el centro de control de
3:58:40enfermedades de eeuu el civis y
3:58:43comenzamos a implementar nuestra función
3:58:45vamos a llamarla interpretar y mc el
3:58:49índice de masa corporal
3:58:51y en nuestro parámetro podemos asignarle
3:58:53un nombre explícito o un nombre más
3:58:56descriptivo llamado índice de masa
3:58:58corporal o también podemos llamarlo
3:59:01valor o índice para hacer más concisos
3:59:04vamos a intentar con dos espacios este
3:59:07condicional una vez que tenemos este
3:59:10valor tenemos que ver en qué rango de
3:59:13valores está ubicado vamos a verificar
3:59:16si el índice de masa corporal es menor
3:59:18que 18.5 estrictamente menor que 18.5 si
3:59:24ese es el caso entonces vamos a mostrar
3:59:27este mensaje bajo peso
3:59:31bien en el caso de que el índice de masa
3:59:36corporal sea mayor o igual que el 18.5
3:59:39mayor o igual
3:59:41esta condición es falsa
3:59:44entonces pasaríamos a la siguiente
3:59:47condición
3:59:48allí vamos a verificar si el índice de
3:59:51masa corporal
3:59:54es menor o igual que 24.9 ya sabemos que
3:59:59es mayor o igual a 18.5 porque esta
4:00:02condición fue falsa
4:00:05ahora queremos también verificar si es
4:00:08menor o igual que 24.9 si está en ese
4:00:11rango entonces el peso se clasifica como
4:00:14normal ese índice es normal y las
4:00:17personas de los rangos normales
4:00:18si no vamos a la tercera posibilidad
4:00:22si el índice de masa corporal es menor o
4:00:26igual a 29.9 entonces eso significa que
4:00:31la persona tiene sobrepeso
4:00:33se clasifica como sobrepeso y ese no sin
4:00:38ninguna de estas condiciones es
4:00:40verdadera eso significa que el índice de
4:00:43masa corporal es mayor que 29.9
4:00:47recuerda que aquí estamos como creando
4:00:49intervalos o rangos de valores aquí
4:00:53esta condición va a ser verdadera si el
4:00:56valor del índice de masa corporal es
4:00:58menor a 18.5 si es falsa significa que
4:01:02el valor es mayor o igual a 18.5 luego
4:01:05vamos a la segunda condición sabemos que
4:01:08es mayor o igual a 18.5
4:01:10también queremos confirmar si es menor o
4:01:13igual a 24.9 puedes ver como creamos
4:01:16como un intervalo de valores posibles
4:01:18para cada condición
4:01:20y si eso no es verdad si esta condición
4:01:23es falsa sabemos que el valor es mayor
4:01:25que 24.9
4:01:28así que pasamos a esta condición es
4:01:31mayor de 24.9 pero también queremos
4:01:34confirmar si es menor o igual a 29.9 en
4:01:38ese caso tiene sobrepeso pero sin
4:01:41ninguna de las condiciones es verdadera
4:01:43sabemos que es mayor que 29.9 y eso
4:01:47clasificaría su índice de masa corporal
4:01:49como
4:01:50obeso obesidad bien ya tenemos nuestra
4:01:54función implementada vamos a llamarla
4:01:57con distintos valores para probar cada
4:01:59una de las opciones del condicional
4:02:01primero veamos 17.8 este valor es menor
4:02:05que 18.5 así que esta condición es
4:02:08verdadera y vemos el mensaje bajo peso
4:02:12exactamente lo que tenemos aquí ahora si
4:02:16cambiamos este valor a 22.2 este es un
4:02:19valor que es mayor que 18.5 así que esta
4:02:23condición es falsa pasamos a esta
4:02:26condición
4:02:27si es menor o igual que
4:02:2924.9 así que esta condición es verdadera
4:02:33y este código se debería ejecutar así
4:02:37que deberíamos ver el valor normal
4:02:39perfecto ahora pasemos a otro valor
4:02:4328.5 en ese caso esta condición es falsa
4:02:48esta condición es falsa porque no es
4:02:51menor o igual que 24.9 y evaluamos esta
4:02:54condición
4:02:56ahora esta condición si es verdadera
4:02:58porque el valor 28.5 es menor o igual a
4:03:0229.9 así que el mensaje que deberíamos
4:03:06ver es sobrepeso ya tenemos aquí
4:03:09sobrepeso y sino en este caso en el caso
4:03:13de que todas las condiciones sean falsas
4:03:16veamos qué ocurre si tenemos el índice
4:03:19de masa corporal
4:03:2032.2 no es menor que 18.5 no es menor o
4:03:25igual a 24.9 no es menor o igual a 29.9
4:03:30así que pasamos aquí
4:03:33la cláusula bosque sirve como un
4:03:35respaldo y ese es el mensaje que
4:03:37veríamos acá
4:03:39es que así es como se clasifica el
4:03:43índice de masa corporal
4:03:46genial ya sabes cómo funciona la lógica
4:03:49de los condicionales y recuerda que solo
4:03:52al código de la primera condición
4:03:54verdadera es el que se ejecuta ninguna
4:03:57de las otras condiciones se evalúa o se
4:03:59ejecuta después de la primera que sea
4:04:01verdadera
4:04:03bien ya sabes cómo trabajar con
4:04:05condicionales y con varias cláusulas
4:04:07rousseff así que pasemos a nuestro
4:04:10siguiente tema
4:04:18comencemos con nuestro mini proyecto en
4:04:21este mini proyecto va a aplicar sus
4:04:23conocimientos de operadores de
4:04:25comparación y de condicionales también
4:04:28vamos a definir una función así que vas
4:04:30a practicar varios de los conceptos que
4:04:32hayas aprendido vemos aquí en el juego
4:04:34de color cada hoyo tiene un par que
4:04:37representa el número promedio de golpes
4:04:40que se espera que haga un golfista para
4:04:43introducir la pelota en el hoyo hay un
4:04:45nombre diferente dependiendo de que
4:04:48están por encima o por debajo del par
4:04:51esté en tus golpes sea por ejemplo si el
4:04:54par es 5 y hiciste 7 golpes si estás
4:04:58jugando con esa diferencia esa
4:05:01diferencia de dos golpes más comparadas
4:05:03con el promedio tienen un nombre
4:05:05específico en el lenguaje técnico del
4:05:08golf vamos a implementar una función que
4:05:10nos retorne ese nombre específico ese
4:05:12nombre especial dependiendo de esa
4:05:14diferencia la función tu función
4:05:17toma tu función tomarán los argumentos
4:05:20par y golpes
4:05:21es el promedio de los golpes esperados y
4:05:25golpes es el número de golpes que en
4:05:27verdad realizaste organizó el golfista
4:05:30que está jugando en ese hoyo específico
4:05:33el propósito es que escribas una función
4:05:36que retorne la cadena correcta según
4:05:38esta tabla la que tenemos aquí abajo que
4:05:41muestra los golpes y sus nombres en
4:05:43orden de mayor a menor prioridad este es
4:05:46uno de los términos más conocidos de
4:05:48golf el hoyo en uno en inglés se llama
4:05:50how you want vamos a mantener la
4:05:53terminología del inglés que para este
4:05:56ejercicio si el valor de los golpes es
4:05:58menor o igual que palmer 2 decimos que
4:06:01es hugo aguilar si es para menos 1 verdi
4:06:06que es como una forma de decir pajarito
4:06:09qué significa park par +1 boxing
4:06:14por las dos doble bogeys
4:06:16y es mayor o igual que palmas 3 entonces
4:06:20go home' ve a casa esas son las cadenas
4:06:23que debemos retornar para y golpes que
4:06:26son los parámetros los argumentos que
4:06:28vamos a recibir siempre serán numéricos
4:06:30y positivos así que no tenemos que
4:06:32preocuparnos por otro tipo de valor que
4:06:35pudiera ser negativo otro tipo de datos
4:06:37ya con todas estas instrucciones podemos
4:06:39comenzar a implementar nuestra función
4:06:41primero es la palabra clave function eso
4:06:44es vital para definir una función y
4:06:47vamos a llamar a la función puntaje de
4:06:49golf dijimos que la función va a tener
4:06:51dos parámetros par que es el número
4:06:54promedio de golpes esperados y el número
4:06:56de golpes ejecutados en realidad ahora
4:06:59tenemos que usar un condicional para
4:07:02implementar esta tabla porque
4:07:03dependiendo de la diferencia entre los
4:07:06golpes y por es que vamos a retornar una
4:07:09cadena específica comenzamos a escribir
4:07:11nuestro condicional cuál es el primer
4:07:14caso en la primera línea de la tabla
4:07:16vemos que es si el val de golpes es uno
4:07:19deberíamos retornar la cadena que dice
4:07:21hoy en 1 hole in one
4:07:23entonces vamos a escribir esta condición
4:07:27si golpes es igual a 1
4:07:30entonces
4:07:31retornamos esta cadena que tenemos aquí
4:07:34podemos copiar y pegar los y punto y
4:07:37coma al final de esta sentencia ritual
4:07:40también estás practicando el concepto de
4:07:42cómo retornar o devolver un valor de una
4:07:45función así que ya puedes ver que este
4:07:47proyecto va a ayudarte a repasar todos
4:07:49estos conceptos
4:07:51ahora tenemos varias condiciones o sea
4:07:53que necesitamos cláusulas aún si vamos a
4:07:56necesitar varias porque cada una de
4:07:58estas va a ser una condición especifica
4:08:01si el valor de los golpes es menor o
4:08:03igual que para menos dos tenemos que
4:08:06retornar la cadena y tenemos que
4:08:09escribir la condición aquí entre
4:08:11paréntesis si el número de golpes es
4:08:13menor o igual que pagar menos 2 siempre
4:08:17se recomienda dejar un espacio dos lados
4:08:18del operador
4:08:20entonces vamos a retornar una cadena que
4:08:23diga i go esta cadena que tenemos acá la
4:08:26copiamos y la pegamos
4:08:28bien
4:08:29vamos a la tercera línea si el valor de
4:08:32golpes es igual y aquí vemos que no
4:08:35tenemos un operador de comparación lo
4:08:37que tenemos es que si los golpes es
4:08:39igual a favor menos uno entonces
4:08:42retornábamos verdi vamos a implementar
4:08:45estos y golpes es igual a pagar menos
4:08:47uno retornamos la cadena birding puedes
4:08:52ver que estamos usando este operador que
4:08:54compara si son iguales o no bien ahora
4:08:58vamos comparar si el número de golpes es
4:09:01igual a parc que es el número promedio
4:09:03esperado retornamos la cadena para el
4:09:06shift golpes es igual a la por entonces
4:09:09retornamos la cadena que diga pagar y
4:09:12nos faltan estas tres condiciones que
4:09:14tenemos aquí si golpes es igual a pagar
4:09:17más uno tenemos bueno tenemos aquí
4:09:20entonces decimos si el número de golpes
4:09:22es igual a par más uno vamos a retornar
4:09:27la cadena que diga bowie ya lo tenemos
4:09:29aquí
4:09:30bowie como podemos copiar y pegar las
4:09:33implementamos las próximas dos
4:09:35condiciones ahora vamos a ver qué ocurre
4:09:38si el número de golpes es igual a
4:09:40formados o si es mayor o igual que parma
4:09:43es 3 si es igual a x + 2 tenemos que
4:09:46retornar doble bogey
4:09:49vamos a hacer esto
4:09:51en este caso retornamos doble bogey y
4:09:54finalmente aquí tenemos nuestra última
4:09:56condición si el número de golpes es
4:10:00mayor o igual que pagar más 3 entonces
4:10:03go home' ve a casa en este caso no vamos
4:10:06a usar una cláusula eus que maneje
4:10:09cualquier otro tipo de casos sino que
4:10:11queremos que ocurra eso solamente si el
4:10:14número es mayor o igual que pagar más 3
4:10:17ok cápsula en 11 esa cláusula ocurre por
4:10:21defecto para cualquier otro caso posible
4:10:23para asegurarnos de que el código haga
4:10:25exactamente lo que queremos vamos a
4:10:27escribir explícitamente la clausura el
4:10:29cif con su condición si golpes es mayor
4:10:33o igual que pagar más 3
4:10:36entonces tenemos que retornar go home y
4:10:40aquí lo tenemos genial ya tenemos
4:10:42nuestra función puntaje de golf
4:10:44implementada toma un par que es el
4:10:47número promedio de golpes esperados y el
4:10:51número de golpes que se ejecutaron para
4:10:53ese hoy aquí tenemos nuestro condicional
4:10:56con muchas muchas cláusulas el cef una
4:10:59para cada condición que queremos
4:11:01verificar y nota que estamos escribiendo
4:11:03las en un orden específico en el orden
4:11:07en el que se nos presentaron en las
4:11:08tablas pero es muy importante que
4:11:11analices bien el orden de las
4:11:13condiciones porque solo la primera que
4:11:16sea verdadera es la que se va a ejecutar
4:11:18en nuestra función vamos a llamarla con
4:11:21distintos valores para pagar y para
4:11:23golpes vamos a llamar a la función con
4:11:26un valor par de 4 y digamos que hicimos
4:11:31un hoyo en uno o sea que el valor de
4:11:33golpes va a ser 1 como estamos
4:11:35retornando el valor podemos asignarle
4:11:38una variedad o podemos mostrarlo en la
4:11:41consola y podemos ver hole in one hoyo
4:11:44en uno aquí esta condición fue verdadera
4:11:47y retornamos esta cadena
4:11:50ahora si cambiamos este valor a 2 ahora
4:11:53vemos ido porque el valor de poder era 4
4:11:57y el valor de golpes era 2 o sea que
4:12:01esta condición es verdadera
4:12:044 - 2 es 2 y si es menor 2 es menor o
4:12:07igual que 2 así que esta condición es la
4:12:10verdadera y vemos y 2
4:12:12si no vamos a ver qué ocurre si el valor
4:12:15es 3 si el valor es 3 estamos en este
4:12:19caso estamos en este caso el número de
4:12:22golpes es igual a pagar al menos 1 marc
4:12:25era 44 menos uno es 3 y el valor de
4:12:28golpe será 3 así que aquí tenemos a
4:12:31berlín luego también podemos probar con
4:12:334 y 4 el resultado es poder porque el
4:12:36valor de los golpes es igual al de para
4:12:39estas condiciones eran falsas falsa
4:12:42falsa y llegamos hasta acá
4:12:44vemos el número de golpes que es igual a
4:12:47par y retornamos esta cadena luego vamos
4:12:51a ver estas tres condiciones
4:12:53si el paro era cuatro hicimos cinco
4:12:56golpes tenemos un poco este que tenemos
4:13:00acá algún número de golpes es igual el
4:13:03número de armas uno si hicimos seis
4:13:05golpes tenemos un doble bogey el número
4:13:07de golpes es igual al par dos cuatro y
4:13:11seis y si hacemos siete golpes o más
4:13:15tenemos go home
4:13:17aquí tenemos go home' porque el número
4:13:19de golpes fue siete y eso es mayor o
4:13:22igual que cuatro más atrás y también se
4:13:24hicimos por ejemplo 15 golpes esta
4:13:26condición va a seguir siendo cierta
4:13:28porque estamos usando el operador de
4:13:30comparación mayor o igual que
4:13:34número de golpes es mayor que el pagar
4:13:37más 3 por eso tenemos con genial ya
4:13:40implementamos este mini proyecto y
4:13:43prácticas de los conceptos que has
4:13:44estado aprendiendo usamos los conceptos
4:13:46de parámetros argumentos usamos también
4:13:50un condicional de aquí con varias
4:13:52cláusulas joseph los operadores de
4:13:55comparación y también estamos trabajando
4:13:57indirectamente con los valores julián o
4:13:59verdadero y falso además también a
4:14:01práctica esto y como retornar valores
4:14:03desde una función y también es
4:14:06importante también que notes aquí que
4:14:07como estamos retornando un valor también
4:14:09la función se detiene inmediatamente
4:14:12luego de que el valor es retornado
4:14:15continuemos con nuestro siguiente tema
4:14:17hay bastante que aprender de javascript
4:14:19pero ya no más en este mundo de
4:14:20programación y ya has aprendido muchas
4:14:23cosas que son esenciales para programar
4:14:25y que vas a usar seguramente en tus
4:14:27proyectos de programación lo hacemos a
4:14:29nuestro siguiente tema
4:14:36espero que te haya gustado este mini
4:14:37proyecto del coro ahora vamos a ver otra
4:14:41estructura que va a ser muy útil para
4:14:43programar en chabás que en cierta forma
4:14:45la forma de reemplazar los condicionales
4:14:48en ya busquets vamos a definir una
4:14:51función que va a clasificar un valor
4:14:54nuevamente
4:14:54igual como teníamos esa función con el
4:14:57condicional que la escribimos para
4:14:59clasificar un valor y teníamos un
4:15:01condicional dentro de la función que es
4:15:04lo que vamos a hacer en este caso el
4:15:06valor va a ser un número entre 1 y 4 va
4:15:09a ser uno dos tres o cuatro y cada uno
4:15:11de esos números esos valores van a estar
4:15:14asociados a una cadena específica una
4:15:17cadena de caracteres la función va a
4:15:19retornar esa clasificación
4:15:21esa cadena a partir del número en lugar
4:15:24de usar un condicional vamos a usar lo
4:15:26que se llama una sentencia switch esta
4:15:29sentencia switch nos va a permitir
4:15:30escribir código que es muy similar al de
4:15:33un condicional pero switch nos permite a
4:15:37partir de una expresión o de un valor
4:15:40decidir qué va a pasar en base a ese
4:15:42valor solo ese valor o solo el resultado
4:15:45de esta expresión que tenemos aquí entre
4:15:47paréntesis escribimos la palabra clave
4:15:49switch y entre paréntesis el valor que
4:15:53queremos usar dentro de esta estructura
4:15:55en este caso queremos clasificar el
4:15:57valor que recibimos como argumento como
4:16:01parámetro
4:16:02entonces dentro de las llaves vamos a
4:16:05escribir esto
4:16:06si el valor es igual a 1 que es lo que
4:16:10va a ocurrir vamos a asignar la cadena
4:16:13alfa a la variable respuesta
4:16:19y luego salimos de la sentencia switch
4:16:22la sentencia suite funciona así nosotros
4:16:25definimos casos específicos para el
4:16:28valor de esta variable o de esta
4:16:30expresión si ese valor es igual a este
4:16:34valor que nosotros escribimos aquí
4:16:35después de la palabra clave case
4:16:37entonces este código se ejecuta y
4:16:41siempre es importante determinar cada
4:16:42caso cada posibilidad con una sentencia
4:16:46break ya vas a ver por qué tenemos aquí
4:16:49un segundo caso una segunda posibilidad
4:16:51si el valor de la variable es 2 entonces
4:16:56la respuesta va a ser beta y escribimos
4:16:59break cualquier final con un punto y
4:17:01coma también nuevo de la palabra break
4:17:03el tercer caso es que el valor sea 3 en
4:17:07ese caso le asignamos la cadena de
4:17:10caracteres gamma
4:17:12y el cuarto caso es que el valor sea 4 y
4:17:15en ese caso le asignamos el valor del
4:17:17está ok ya tenemos todos nuestros casos
4:17:21aquí planteados si el valor de esta
4:17:24variable es 1 esto va a ocurrir si el
4:17:27valor de estas variables es 2 esto va a
4:17:29ocurrir si el valor de esta variable es
4:17:313 esto va a ocurrir y si el valor de
4:17:34esta variable es 4 esto va a ocurrir es
4:17:37como un condicional pero un poco más
4:17:39específico porque nos permite decidir
4:17:42qué es lo que va a ocurrir solo en base
4:17:44al valor que tenemos aquí entre
4:17:46paréntesis no estamos escribiendo
4:17:48condiciones con operadores de
4:17:50comparación ni estamos usando operadores
4:17:52lógicos solamente estamos escribiendo
4:17:54aquí un valor y en base a ese valor
4:17:56vamos a ejecutar un bloque de código
4:17:59específico estas sentencias break que
4:18:01puedes ver aquí lo que hacen es detener
4:18:04el proceso de ejecución de esta
4:18:06estructura cuando el caso sea correcto
4:18:10sea verdadero y este es el valor de la
4:18:12variable este código se va a ejecutar y
4:18:15cuando se llegue a esta línea de break
4:18:18todo lo demás se va a ignorar sino que
4:18:21simplemente esta estructura se va a
4:18:23terminar y seguimos nuestra ejecución
4:18:25aquí abajo fuera de las llaves ese es el
4:18:29rol de 'break' y por eso es importante
4:18:32ponerlo al final de cada caso para que
4:18:33no se continúe ejecutando otros posibles
4:18:36casos más abajo pero puedes ver que la
4:18:39sintaxis ya es más concisa que la de un
4:18:41condicional para este caso específico y
4:18:44finalmente vamos a retornar el valor
4:18:46respuesta
4:18:48porque estamos poniendo esta línea luego
4:18:51de las llaves porque no es parte del
4:18:54switch la sentencia switch sólo nos
4:18:57permite en este caso seleccionar el
4:18:59valor de la variable respuesta y luego
4:19:02que se haya seleccionado ese valor se
4:19:04interrumpe inmediatamente su ejecución y
4:19:07se pasa a este línea donde retornamos el
4:19:11valor de la respuesta genial vamos a
4:19:14llamar a esta función clasificar valor y
4:19:18vamos a pasar cada una de esas
4:19:19alternativas del 1 hasta el 4
4:19:23clasifica el valor como estamos
4:19:25retornando el valor tenemos que
4:19:27mostrarlo en la consola o también lo
4:19:29podemos asignar una variable
4:19:31tenemos clasificar valor de uno retorna
4:19:34el valor alfa porque el valor que
4:19:37pasamos como argumento es uno aquí el
4:19:40caso 1 se cumple el valor es 1 se asigna
4:19:45el valor alfa a la variable respuesta
4:19:47luego se consigue esta sentencia aquí
4:19:50break
4:19:51inmediatamente pasamos a esta línea
4:19:53donde se retorna el valor ahora veamos
4:19:56si actualizamos el valor a 2
4:19:59tenemos el valor beta porque porque el
4:20:02caso 2 fue verdadero aquí escribiríamos
4:20:05el valor de la variable si el valor es 2
4:20:08el valor de respuesta es beta
4:20:10conseguimos la sentencia prime y vamos
4:20:13aquí a richard si el valor es 3
4:20:16ahora tenemos gamma porque el caso fue
4:20:18que el valor era 3
4:20:20ahora el valor de respuesta y gamma
4:20:23conseguimos el break aquí y saltamos a
4:20:25esta línea fuera de la sentencia switch
4:20:27y retornamos el valor y finalmente aquí
4:20:30tenemos el cuarto valor la cuarta opción
4:20:32el valor 4 y nos retorna la cadena de
4:20:36caracteres de alto luego salimos de
4:20:38switch y aquí podemos retornar el valor
4:20:41bien veamos otro ejemplo pero esta vez
4:20:44vamos a usar switch con una cadena de
4:20:46caracteres para que veas que esos
4:20:49números 1 2 3 y 4 no son necesariamente
4:20:52un número si nosotros definimos una
4:20:55variable producto y decimos que su valor
4:20:58va a ser hamburguesa necesitamos una
4:21:00tienda de comida rápida y servimos pizza
4:21:03hamburguesa y helado estamos diseñando
4:21:06una aplicación para esa tienda son tres
4:21:09productos posibles que puede pedir el
4:21:11cliente entonces para eso si tenemos un
4:21:15número específico de opciones para esta
4:21:18variable que es producto
4:21:20entonces podemos usar una sentencia
4:21:22switch entre paréntesis escribiríamos la
4:21:26variable que queremos evaluar o la
4:21:28expresión y dentro de switch entre las
4:21:31llaves vamos a empezar a escribir los
4:21:33casos cuál es el primer caso que puede
4:21:36ocurrir puede ser que el valor sea pixar
4:21:39si el valor de la variable es picks
4:21:42entonces qué queremos hacer queremos
4:21:44mostrar en el sistema cuánto cuesta la
4:21:46pizza la pizza básica cuesta y digamos
4:21:50que cuesta 10 dólares con 55
4:21:54bien al final luego de esta línea
4:21:56escribimos un break
4:21:58con punto y coma ahora si ese no era el
4:22:01caso y el valor del producto no es igual
4:22:05a pixar entonces vamos a nuestro segundo
4:22:07caso
4:22:09si el valor es hamburguesa
4:22:11mostramos este mensaje las hamburguesas
4:22:15cuestan 6 dólares con 78
4:22:20y escribimos
4:22:23y luego aquí tenemos helado ofrecemos
4:22:27una opción de postre el helado cuesta
4:22:30dos dólares con 80 y aquí escribimos
4:22:33break bien ya tenemos nuestra sentencia
4:22:37switch para las tres posibles opciones
4:22:39de la variable producto
4:22:41pizza hamburguesa y helado también
4:22:44podemos escribir esta sentencia switch
4:22:47dentro de una función como lo hemos
4:22:49venido haciendo en los ejemplos
4:22:51anteriores
4:22:52entonces en este caso como la el valor
4:22:55del producto es hamburguesa veamos que
4:22:57se ve en la consola
4:22:59las hamburguesas cuestan 678
4:23:03este es el caso este es el valor de la
4:23:05variable producto actualmente así que
4:23:08este código se ejecuta y luego como
4:23:11tenemos estas sentencias break no se
4:23:13evalúa ningún otro caso sino que
4:23:15simplemente pasamos a las líneas que
4:23:17vienen después de switch que en este
4:23:19caso no hay ninguna otra línea de código
4:23:22pero para comprobar que es el caso vamos
4:23:25a escribir aquí luego de switch
4:23:29aquí puedes verlo se muestra este
4:23:32mensaje de las hamburguesas cuestan 6.78
4:23:34y luego como conseguimos esto sentencia
4:23:37price saltamos todo el código que sigue
4:23:40y saltamos fuera de switch para
4:23:42conseguir esta primera línea luego de
4:23:44switch si cambiamos el valor de esta
4:23:47variable va a cambiar el resultado
4:23:49la pizza básica cuesta 10 dólares con 55
4:23:53porque ahora el valor de la variable
4:23:55producto es pixar y finalmente podemos
4:23:58probar el lado en el lado cuesta 2.8 así
4:24:02es básicamente cómo funcionan las
4:24:04sentencias switch son muy útiles para
4:24:07escribir condicionales cuando tenemos un
4:24:09número finito específico de opciones que
4:24:12queremos evaluar también podemos agregar
4:24:15una opción predeterminada a la sentencia
4:24:18switch que es el equivalente en la
4:24:20sentencia switch de una cláusula euros
4:24:22en un condicional sirve como un respaldo
4:24:24vas a ver cómo lo podemos hacer en el
4:24:27próximo tema así que te espero aquí
4:24:35también puedes agregar una opción
4:24:37predeterminada a la sentencia switch
4:24:40veamos cómo puedes hacerlo
4:24:42esta opción se va a ejecutarse sin
4:24:44ninguno de los valores es el valor de la
4:24:46variable o de la expresión comencemos el
4:24:48ejemplo definiendo una función esta
4:24:51función va a seleccionar el idioma que
4:24:53corresponda a un valor específico entre
4:24:561 y 3 y vamos a tener una opción
4:25:00predeterminada para el idioma en caso de
4:25:03que ninguno de los valores concuerde con
4:25:05el valor de la variable
4:25:07vamos a definir una variable idioma a la
4:25:10cual le vamos a asignar el valor del
4:25:12idioma dentro de la sentencia switch
4:25:14como una cadena aquí
4:25:17estamos escribiendo switch y entre
4:25:19paréntesis vamos a colocar la variable
4:25:22valor el valor de esa variable va a
4:25:25decidir qué es lo que ocurre tenemos
4:25:27aquí el caso de que el valor de esta
4:25:30variable sea 1 si ese es el caso
4:25:33entonces el hilo digamos que es español
4:25:36en caso de que el valor sea 2 entonces
4:25:39vamos a tener el idioma francés
4:25:43y agregamos break en el tercer caso
4:25:46vemos aquí el idioma italiano luego
4:25:50break y aquí es donde viene la parte
4:25:52nueva puedes agregar una opción
4:25:55predeterminada para esta sentencia
4:25:57switch como lo hacemos con la palabra
4:26:00clave default default literalmente
4:26:03podríamos traducir la español como por
4:26:05defecto es una opción que se ejecuta por
4:26:09defecto sin ninguno de estos valores es
4:26:11el valor de la variable
4:26:13como el equivalente a la cláusula aus es
4:26:16un respaldo sin ninguna de las
4:26:18anteriores
4:26:19concuerdo por defecto vamos a colocar el
4:26:22idioma inglés va a ser la opción
4:26:25predeterminada en caso de que el valor
4:26:27no sea ni uno ni dos ni tres y también
4:26:29se recomienda que al final de default
4:26:31también coloquemos una sentencia en
4:26:33break porque no es que no necesariamente
4:26:35disponte tiene que ser la última opción
4:26:38en esta secuencia
4:26:39normalmente es la última por convención
4:26:42como sirve como un respaldo normalmente
4:26:45la escribimos al final pero no
4:26:46necesariamente técnicamente tiene que
4:26:49ser así así que igual se recomienda
4:26:51colocar aquí un break aunque esté al
4:26:53final
4:26:55y luego qué vamos a hacer vamos a
4:26:57retornar el valor de la variable idioma
4:26:59vamos a mostrar el valor retornado por
4:27:03la función con con su logo y vamos a
4:27:06llamar a la función vamos a copiar y
4:27:09pegar aquí el nombre de la función
4:27:10seleccionar idioma y aquí vemos que
4:27:13tenemos que pasar el valor que
4:27:15corresponde al parámetro el argumento
4:27:18vamos a pasar el valor 1 si abrimos la
4:27:21consola podemos ver aquí el idioma
4:27:24español retornado porque porque pasamos
4:27:27el valor 1 para este parámetro este fue
4:27:30el caso para switch y asignamos la
4:27:33cadena de caracteres en español a la
4:27:36variable idioma luego conseguimos break
4:27:38y pasamos aquí a richard para retornar
4:27:41el valor si probamos con el valor 2
4:27:44ahora vemos francés
4:27:46si probamos con el valor 3 vemos
4:27:49italiano
4:27:51y ahora vamos a probar nuestra opción
4:27:54por defecto default vamos a pasar otro
4:27:57valor digamos 4 aquí podemos ver que el
4:28:00valor retornado fue inglés porque porque
4:28:04ninguno de estos valores era el valor de
4:28:08la variable valor aquí ninguno de estos
4:28:10números en el valor de la variable era 4
4:28:14así que por defecto como no se consiguió
4:28:16el valor específico ejecutamos este
4:28:19código y el idioma es inglés así es como
4:28:22funciona la opción default en la
4:28:25sentencia switch es muy útil porque nos
4:28:27permite manejar cualquier otro tipo de
4:28:29caso o de valor para esta variable o
4:28:32expresión bien ya sabes cómo trabajar
4:28:35cómo trabajar con la sentencia switch
4:28:37también otra variación de esta sentencia
4:28:39de la sentencia switch es realizar el
4:28:42mismo procedimiento ejecutar el mismo
4:28:45código para varios casos por ejemplo
4:28:48digamos que si el código es 2 o 3
4:28:50queremos hacer exactamente lo mismo eso
4:28:53es posible y vas a aprender cómo lo
4:28:55puedes hacer en la próxima parte
4:29:03en la sentencia switch también podemos
4:29:06escoger ejecutar un código específico
4:29:08para varios valores veamos como podemos
4:29:12hacer esto vamos a definir una función
4:29:15que se va a llamar clasificar volumen
4:29:18vamos a tener números entre 1 y 6 que
4:29:22van a representar la intensidad del
4:29:24volumen en un dispositivo
4:29:27el parámetro se va a llamar valor el
4:29:29valor que va a representar el volumen
4:29:31ese volumen va a ser una cadena de
4:29:33caracteres que debe de escribir la
4:29:36intensidad del volumen puede ser bajo
4:29:38intermedio o alto para eso para asignar
4:29:41ese valor tenemos una sentencia switch
4:29:44esa sentencia switch va a depender del
4:29:47valor del parámetro el valor o el
4:29:49argumento que pasamos a la función si el
4:29:53valor es 1 digamos que queremos asignar
4:29:56un volumen bajo y aquí tendríamos break
4:30:00al final del caso como se recomienda
4:30:02pero si también nosotros queremos
4:30:04asignar el volumen intermedio cuando el
4:30:08valor que tenemos aquí es 2 o estrés o
4:30:13sea 2 valores pueden realizar la misma
4:30:15acción como lo podemos escribir
4:30:17escribimos si el valor es 2 o si el
4:30:21valor es 3 así simplemente escribimos
4:30:25cada uno de los posibles casos y qué
4:30:27queremos hacer si ese caso es verdadero
4:30:30por ejemplo si el valor es 2 si el valor
4:30:33es 3 que queremos hacer queremos asignar
4:30:35el volumen
4:30:36intermedio a la variable ejecutamos esta
4:30:40línea y luego salimos de la sentencia
4:30:43switch con break también podemos tener
4:30:45más de 2 casos manejados de la misma
4:30:48forma por ejemplo si los números 4 5 y 6
4:30:53representan un volumen alto
4:30:56lo escribiríamos de esta forma 4 5 y 6
4:31:00siempre con la palabra que dice adelante
4:31:02y 2 puntos al final luego intentado
4:31:06podemos escribir
4:31:07el código que queremos ejecutar seguido
4:31:10de break
4:31:12y aquí retornamos el valor volumen y ya
4:31:17tenemos nuestra función para clasificar
4:31:19el volumen con una sentencia switch aquí
4:31:23tenemos un solo caso y aquí tenemos dos
4:31:25casos y qué queremos hacer si el valor
4:31:28es cualquiera de estos valores y aquí
4:31:30tenemos tres casos que se manejan de la
4:31:33misma forma ya vemos a la función
4:31:36clasificar volumen con un valor
4:31:39específico probemos con uno primero pero
4:31:42tenemos que
4:31:44mostrar el valor retornado con con su
4:31:47punto lo que aquí vemos que el volumen
4:31:50es bajo porque el valor fue 1 el valor
4:31:53era 1 ahora si el valor es 2 o estrés el
4:31:56volumen debería ser intermedio si
4:31:58cambiamos estos dos efectivamente vemos
4:32:00intermedio el valor retornado
4:32:04y si lo cambiamos a 3 también debemos el
4:32:07valor intermedio si el valor es 45 o
4:32:10seis el volumen debería ser alto 4 5 y 6
4:32:16el valor se mantiene para todos estos
4:32:19casos así que ya sabes cómo definir o
4:32:22cómo escribir una sentencia switch
4:32:24completamente ya sabes cómo escribir sus
4:32:27casos cómo manejar varios casos de la
4:32:29misma forma y cómo agregar un caso que
4:32:31se ejecute por defecto sin ninguna de
4:32:34las opciones es el valor de esta
4:32:36variable o expresión en el próximo tema
4:32:39vamos a ver un ejemplo de cómo puedes
4:32:41reemplazar
4:32:42condicionales por switch así que pasemos
4:32:46a nuestro siguiente tema eso es
4:32:47interesante porque vas a ver la
4:32:49equivalencia entre los condicionales y
4:32:51las sentencias switch
4:32:57en ciertos casos podemos reemplazar
4:33:00condicionales con sentencias switch por
4:33:04ejemplo en este caso tenemos una función
4:33:06selecciona el idioma que toma un valor 1
4:33:092 3 o si el valor es cualquier otro
4:33:13número asigna el idioma por defecto
4:33:16inglés y luego retorna ese idioma
4:33:18retorna el valor de la variable idioma
4:33:21que declaramos aquí pero qué es lo que
4:33:23ocurre nosotros podemos
4:33:25reemplazar este condicional con una
4:33:28sentencia switch porque como puedes ver
4:33:30estamos verificando casos específicos
4:33:33relacionados con el valor de esta
4:33:35variable si el valor es igual a 1
4:33:37entonces esto ocurre si el valor es
4:33:40igual a 2 esto ocurre si el valor es
4:33:42igual a 3 esto ocurre y si el valor no
4:33:45es ninguna de esas opciones entonces
4:33:47aquí tenemos la opción por defecto ya
4:33:50que te suena eso debería sonar te muy
4:33:53familiar porque es exactamente lo que
4:33:55podemos hacer con una sentencia switch
4:33:58veamos cómo podemos adaptar este código
4:34:00para trabajar con una sentencia switch
4:34:03escribimos la palabra clave switch y
4:34:06luego escribimos el nombre de la
4:34:08variable que queremos analizar o evaluar
4:34:12vamos a ir tomando los elementos del
4:34:14condicional que necesitamos para switch
4:34:16y eliminando los que no necesitamos para
4:34:19que veas esta transformación
4:34:21necesitamos una llave aquí para abrir
4:34:23las sentencias switch para abrir toda
4:34:25esa secuencia de casos ahora no
4:34:28necesitamos la palabra clave y ni el
4:34:30valor aquí en esta condición porque ya
4:34:33estamos verificando automáticamente si
4:34:35el valor es este que tenemos aquí lo que
4:34:39tenemos que escribir es case
4:34:42borramos esta llave
4:34:45intentamos de forma consistente con dos
4:34:48espacios y aquí ya tenemos nuestro
4:34:51primer caso para la sentencia switch en
4:34:54lugar de tener una condición que compara
4:34:56si el valor es igual a 1
4:34:58simplemente escribimos case 1 y si el
4:35:00valor es igual a 1 entonces vamos a
4:35:02ejecutar este código tenemos que añadir
4:35:04aquí la sentencia break ahora para el
4:35:07segundo caso no necesitamos esta
4:35:10cláusula usted ni la comparación del
4:35:13valor con 2 lo que escribimos skates 2 y
4:35:18luego intentamos este código y
4:35:21escribimos break ya tenemos nuestro
4:35:24segundo caso vamos a hacer exactamente
4:35:26lo mismo con el tercer caso intentamos
4:35:30el código para ese caso y agregamos
4:35:31break aquí
4:35:33finalmente para reemplazar la cláusula r
4:35:37que nos permite realizar una acción o
4:35:40ejecutar un código por defecto sin
4:35:42ninguno de estos casos es el que ocurre
4:35:46si el valor no es ninguno de estos
4:35:48valores
4:35:49entonces tenemos que usar default aquí
4:35:53en lugar de caso
4:35:54aus su equivalente podríamos decirlo así
4:35:58en la sentencia switch sería default en
4:36:01ese caso especificamos qué es lo que
4:36:03queremos que ocurra por defecto sin
4:36:05ninguno de estos valores es el valor de
4:36:08esta variable también podemos
4:36:10opcionalmente incluir break aquí al
4:36:12final de default y finalmente yo
4:36:15simplemente retornamos el valor de la
4:36:17variable esto se mantiene intacto y como
4:36:20puedes ver ya transformamos el
4:36:22condicional en una sentencia switch así
4:36:25que ya sabes cuando en un condicional
4:36:28estamos verificando si el valor de una
4:36:31variable una expresión es igual a otro
4:36:33valor podemos simplemente reemplazarlo
4:36:36con switch y agregar un valor por
4:36:39defecto o una acción que se va a
4:36:40ejecutar por defecto con default genial
4:36:43pasemos a nuestro siguiente tema
4:36:52ahora que ya sabes cómo funciona en la
4:36:54sentencia switch en javascript y por qué
4:36:56son muy útiles vamos a cambiar el tema
4:36:59un poquito y vamos a ver cómo puedes
4:37:02retornar de forma muy concisa valores
4:37:05julianos verdadero o falso truco faus
4:37:08desde una función veamos este ejemplo
4:37:11definimos una función que se va a llamar
4:37:13es menor que esta función va a comparar
4:37:16dos valores a y b son los parámetros que
4:37:20vamos a definir para esos valores y
4:37:23vamos a comprobar si es menor que ver
4:37:25estrictamente menor que ver si es menor
4:37:29que b entonces vamos a retornar su
4:37:31verdadero y si no vamos a retornar falso
4:37:34faus inicialmente lo podríamos hacer con
4:37:37un condicional similar a éste cristancho
4:37:41y si no return false
4:37:44lo que estamos diciendo es si es
4:37:46estrictamente menor que ve entonces
4:37:49retornamos el valor se nota que aquí
4:37:52estamos usando los valores julianas
4:37:54porque están escritos completamente en
4:37:56minúscula y se resaltan en un color
4:37:58distinto si no o si no es estrictamente
4:38:01menor que b vamos a ellos y retornamos
4:38:05false esto funciona funcionalmente va a
4:38:08cumplir su propósito pero hay una forma
4:38:11más concisa de escribirlo mucho más
4:38:14concisa que va a resultar en una sola
4:38:16línea lo que nosotros podemos hacer en
4:38:19lugar de escribir este condicional es
4:38:21simplemente retornar
4:38:23el valor de esta comparación solamente
4:38:27esto es lo que necesitamos para
4:38:28reemplazar lo que teníamos antes si
4:38:30retornamos a esto puedes ver la
4:38:33diferencia voy a colocarlo aquí como un
4:38:35comentario para quien te as la
4:38:37diferencia en complejidad contra esto
4:38:40que estamos haciendo aquí estamos
4:38:42retornando el resultado de esta
4:38:44comparación si ya es menor que b esta
4:38:47condición va a ser verdadera y el valor
4:38:50you se va a retornar si es falsa esta
4:38:54condición va a ser false va a ser falsa
4:38:57y ese es el valor que se va a retornar y
4:39:00cumple exactamente el mismo propósito
4:39:02vamos a probarlo con con su punto lo
4:39:06podemos llamar a la función es menor qué
4:39:10y podemos pasar dos valores 3 y 6 3 es
4:39:14menor que 6 así que el resultado debería
4:39:16ser cero aquí lo podemos ver es true
4:39:19pero si invertimos el orden 6 y 3 el
4:39:24resultado ahora es falso
4:39:26así que está funcionando exactamente
4:39:27como queríamos también si los valores
4:39:30son iguales el resultado es fox porque
4:39:33estamos usando aquí el operador estricto
4:39:35el operador de comparación estricta
4:39:38estamos verificando si es estrictamente
4:39:40menor que ve genial ya sabes cómo
4:39:44reemplazar un condicional usado para
4:39:46retornar un valor juliano de una función
4:39:49y ese es el valor que se va a retornar
4:39:58ahora continuando con el tema de
4:40:00funciones y de aspectos importantes que
4:40:03debes saber de las funciones veremos el
4:40:05patrón de retorno anticipado veamos que
4:40:08implica el patrón de retorno anticipado
4:40:10cuando retornamos un valor de una
4:40:12función en ese momento que retornamos el
4:40:16valor la función se detiene
4:40:18completamente cualquier línea que esté
4:40:20luego de return no se va a ejecutar
4:40:24veamos esto con una función de muestra
4:40:27una función de prueba vamos a mostrar el
4:40:30mensaje la cadena de caracteres hola y
4:40:33luego vamos a retornar una cadena que
4:40:36diga mundo luego de esa sentencia
4:40:38richard vamos a intentar mostrar otro
4:40:41mensaje que diga
4:40:44adiós ok hola y adiós qué ocurre aquí
4:40:47inmediatamente puedes ver que en el
4:40:50editor de código de frica or camps esta
4:40:52línea se torna un poco más tenue un poco
4:40:55más transparente porque porque si
4:40:57colocamos y colocamos nuestro cursor
4:40:59aquí encima de la línea nos dice que se
4:41:02ha detectado código que no se puede
4:41:04alcanzar durante la ejecución del
4:41:06programa ahora bichot bouygues se puede
4:41:09traducir literalmente como inalcanzable
4:41:11andrizzi busca un código inalcanzable
4:41:14detecta detectados
4:41:17esta línea nunca se va a ejecutar porque
4:41:20está después de una sentencia richard
4:41:22cuando esta sentencia virtual se ejecuta
4:41:25todo el código que pueda estar después
4:41:27de richter ya no se ejecuta la función
4:41:30se detiene inmediatamente
4:41:32podemos comprobarlo con una llamada a la
4:41:36función podemos también mostrar el valor
4:41:38retornado por esa llamada a la función
4:41:41aquí vemos o la que es este mensaje está
4:41:45línea antes de la sentencia de víctor y
4:41:47luego vemos la sentencia be saber esta
4:41:50sentencia richard es la que retorna el
4:41:53valor mundo que vemos aquí porque lo
4:41:55estamos mostrando en la consola pero
4:41:58pero esta línea que está por acá no se
4:42:00ejecuta y por eso no vemos ningún otro
4:42:03mensaje en la consola aquí no vemos en
4:42:05la palabra dios por que nunca se ejecuta
4:42:08y eso es algo que es importante que
4:42:10conozcas por qué porque ese patrón de
4:42:12retorno anticipado es muy útil
4:42:15específicamente es útil cuando
4:42:17necesitamos detener la función por
4:42:21alguna condición específica
4:42:23en este ejemplo vamos a
4:42:26y definir una función que se llame
4:42:28calcular raíz cuadrada esa función va a
4:42:32tomar un número como parámetro podemos
4:42:35abreviar lo como no es muy común ver la
4:42:38variación núm
4:42:40o también podrías escribirla
4:42:41explícitamente el número pero qué es lo
4:42:43que ocurre que es lo que vamos a hacer
4:42:45la raíz cuadrada de un número no existe
4:42:48por lo menos no en los números reales
4:42:51que son con los que normalmente
4:42:52trabajamos no existe si el número es
4:42:55negativo
4:42:56así que si esa condición es verdaderas
4:42:58verdaderas si el número es negativo no
4:43:01podemos calcular la raíz cuadrada y qué
4:43:04es lo que deberíamos hacer simplemente
4:43:06detener la función
4:43:08y retornar un valor en este caso lo que
4:43:12haríamos es retornar el valor and i find
4:43:15porque la operación no está definida
4:43:18estamos retornando simplemente el valor
4:43:21genérico que retornan las funciones
4:43:23cuando no se retorna un valor en el caso
4:43:26de que si el valor sea válido sea mayor
4:43:29o igual a cero entonces podemos calcular
4:43:32la raíz cuadrada del número y retornarlo
4:43:35lo haríamos con esta llamada a la
4:43:38función square blood raíz cuadrada
4:43:41escribimos más puntos square root y
4:43:45entre paréntesis pasamos el número y
4:43:47retornamos ese valor pero lo importante
4:43:51del patrón de retorno anticipado está
4:43:53aquí en este condicional si la condición
4:43:56es verdadera vamos a retornar este valor
4:43:58e inmediatamente la función se va a
4:44:01detener recuerda que las funciones por
4:44:04defecto retornan and i find cuando se
4:44:06ejecuta este habitual esta línea ni se
4:44:09alcanza no existe es como si no
4:44:11existiera
4:44:12solamente cuando se ejecuta esta línea
4:44:14primero
4:44:15pero si la condición es falsa el
4:44:19condicional no se ejecuta y pasamos a
4:44:21esta línea y se retorna el valor
4:44:24veamos vamos a probar la función vamos a
4:44:27llamarla y vamos a mostrar el valor
4:44:30retornado raíz cuadrada vamos a calcular
4:44:33la raíz cuadrada de 25 la raíz cuadrada
4:44:3725 es 5 así que deberíamos ver ese valor
4:44:40y aquí lo vemos el valor es 5 el número
4:44:44no es menor que cero así que esta
4:44:47condición es falso
4:44:49esta línea nunca se ejecuta y pasamos a
4:44:52esta línea que se calcula la raíz
4:44:54cuadrada pero si cambiamos este valor
4:44:57por un número negativo ejemplo menos 5
4:45:00esta condición es verdadera y retornamos
4:45:03el valor and i find que aquí lo puedes
4:45:06ver en la consola esta línea nunca se
4:45:09ejecuta digamos que no incluimos este
4:45:11condicional y sólo escribimos ese línea
4:45:14vamos a borrar este código lo primero
4:45:17que tendría saque sería esto nn que en
4:45:21javascript significa not el nombre este
4:45:24es un tipo de valor especial que se
4:45:26retorna cuando una operación retorno un
4:45:29valor que no es válido que no es un
4:45:30número no es un número válido para
4:45:33evitarnos eso podemos usar el patrón de
4:45:35retorno anticipado y evitar cualquier
4:45:38valor inesperado o situación o error que
4:45:41se puede presentar
4:45:43bien ya sabes cómo usar este patrón iker
4:45:45better que tiene la función
4:45:47inmediatamente y que puedes escribir más
4:45:51de una sentencia return en tus funciones
4:45:54dependiendo de donde necesitas retornar
4:45:57el valor en qué punto del código de
4:45:59punto del código necesita retornar el
4:46:01valor y detener la ejecución de la
4:46:03función
4:46:04bien pasemos a nuestro siguiente mini
4:46:07proyecto vamos a tener un mini proyecto
4:46:09de contar cartas para el fuego blackjack
4:46:12el juego de cartas blackjack tv oye
4:46:20vamos a trabajar en un mini proyecto
4:46:23centrado en representar lo que ocurre en
4:46:26un juego de casino de blackjack un juego
4:46:28de cartas vas a practicar tus
4:46:30conocimientos de funciones y de la
4:46:33sentencia switch las que acabas de
4:46:35aprender así que comencemos la
4:46:37descripción como puedes ver es un poco
4:46:39detallada así que vamos a leerla en el
4:46:43juego de casino plan chac el jugador
4:46:46puede sacarle ventaja a la casa llevando
4:46:49un registro del número relativo de
4:46:52cartas altas y cartas bajas que quedan
4:46:55en la baraja esto se llama conteo de
4:46:59cartas vamos a llevar un registro de el
4:47:02número relativo de cartas altas y bajas
4:47:05que quedan en la baraja tener más cartas
4:47:07altas en la baraja es una ventaja para
4:47:10el jugador se le asigna un valor a cada
4:47:12carta de acuerdo a la siguiente tabla la
4:47:15tabla que puedes ver aquí
4:47:17cuando el conteo es positivo el jugador
4:47:21debería apostar alto cuando el conteo es
4:47:24negativo el jugador debería apostar bajo
4:47:27de este conteo nos va a decir cómo
4:47:30debería apostar el jugador así que vamos
4:47:33también a usar un condicional vamos a
4:47:35usar ambos una sentencia switch para
4:47:37escoger qué ocurre y un condicional para
4:47:40la decisión final dependiendo de la
4:47:44carta que se vayan presentando vamos a
4:47:46aumentar el valor de conteo en uno
4:47:49aumentamos uno o restamos uno o también
4:47:53podemos no cambiar el valor y
4:47:55simplemente el valor queda exactamente
4:47:57igual nuestra meta en este programa es
4:48:00definir una función para contar cartas
4:48:03la función debe tomar un parámetro carta
4:48:06este va a ser el nombre del parámetro
4:48:09que puede ser un número o una cadena de
4:48:11caracteres y luego aumentar o reducir el
4:48:15valor de la variable global conteo
4:48:18vamos a tener dos elementos principales
4:48:21aquí el parámetro carta
4:48:24y es vamos a tener una variable global
4:48:26conteo una variable global se puede
4:48:29acceder dentro de la función eso lo que
4:48:31vamos a hacer vamos a definir conteo
4:48:33como una variable global y la vamos a
4:48:36modificar dentro de la función de
4:48:38acuerdo al valor de la carta la función
4:48:41luego debe retornar una cadena de
4:48:43caracteres con el conteo actual y con
4:48:46esta cadena alguna de estas dos opciones
4:48:49apostar si el conteo es positivo o
4:48:53esperar si el conteo es cero o negativo
4:48:55el conteo actual y la decisión del
4:48:58jugador apostar o esperar deben estar
4:49:01separados por un espacio en la cadena
4:49:03que va a ser retornada
4:49:06para que vamos a comenzar a implementar
4:49:08la función lo primero que mencionamos y
4:49:12que tenemos que definir en el programa
4:49:15es la variable global conteo va a ser
4:49:18una variable global porque está definida
4:49:20en el programa principal y la estamos
4:49:22definiendo con la palabra clave para
4:49:25inicialmente su valor va a ser cero
4:49:27porque la vamos a ir incrementando o
4:49:30disminuyendo o dejando de exactamente
4:49:32igual dependiendo del valor de la carta
4:49:35ahora vamos a definir nuestra función
4:49:37contar cartas contar
4:49:40cartas y el parámetro se llama carta esa
4:49:44carta va a tener un valor específico
4:49:46numérico o una letra dependiendo del
4:49:48tipo de carta vamos a declarar aquí una
4:49:52variable local esta variable solo va a
4:49:55ser accesible sólo va a poder usarse
4:49:57dentro de la función contar cartas esa
4:50:00va a ser nuestra decisión final de
4:50:02apostar o esperar pero primero tenemos
4:50:05que actualizar el valor del conteo para
4:50:08eso vamos a usar una sentencia switch
4:50:10esta sentencia switch va a analizar el
4:50:14valor de la carta y dependiendo de su
4:50:17valor vamos a actualizar el valor de
4:50:19conteo aquí podemos ver en la tabla que
4:50:23si el valor es dos tres cuatro cinco o
4:50:26seis cualquiera de estos números
4:50:28deberíamos aumentar el valor de conteo
4:50:31en uno así que vamos a hacerlo recuerda
4:50:35entre 2 y 6 como estamos usando una
4:50:38sentencia switch vamos a tener varios
4:50:41casos posibles para ejecutar el mismo
4:50:44código para eso escribimos muchos casos
4:50:47distintos si carta tiene un valor 2 3 4
4:50:515 o 6 que es lo que vamos a hacer vamos
4:50:55a incrementar el valor de la variable
4:50:57conteo es uno simplemente escribimos dos
4:51:01signos más a la derecha del nombre de la
4:51:04variable y un punto y coma
4:51:06esto permite incrementar su valor en uno
4:51:08y como estamos en una sentencia switch
4:51:12en uno de los casos tenemos que escribir
4:51:14aquí la sentencia break
4:51:17seguido un punto y coma ahora para la
4:51:20segunda categoría de valores 7 8 y 9
4:51:24sabemos que no tenemos que cambiar el
4:51:27valor del conteo así que en realidad no
4:51:30deberíamos incluirlo en la sentencia
4:51:32switch porque no tiene que haber ningún
4:51:34efecto sobre el conteo vamos a obviar
4:51:36esos casos pero aquí sí tenemos que
4:51:39incluir estos casos estos valores
4:51:4210 la letra j la letra q la letra k y la
4:51:46letra a en cualquiera de estos casos
4:51:48tenemos que reducir el valor de conteo
4:51:51en 1 así que vamos a implementar esto en
4:51:55switch en nuestra sentencia switch
4:51:58si el valor es 10 o el valor es j
4:52:02o el valor es la letra q o el valor es
4:52:06la letra k o el valor es la letra a que
4:52:11es lo que vamos a hacer vamos a tomar el
4:52:13valor de la variable global conteo y la
4:52:16vamos a disminuir en 1 lo vamos a
4:52:18reducir en 1
4:52:20esta es la variable global y la estamos
4:52:22modificando dentro de la función
4:52:26recuerda esta sintaxis de la misma forma
4:52:28que aumentamos el valor en 1 con dos
4:52:31signos más también podemos reducir su
4:52:33valor en 1 con dos signos menos y luego
4:52:36escribimos break genial ya tenemos
4:52:38nuestra sentencia switch implementada ya
4:52:42podemos actualizar la variable conteo
4:52:44pero todavía nos queda la última parte
4:52:47de la función debemos retornar una
4:52:50cadena a partir del valor de conteo la
4:52:54función debe retornar una cadena de
4:52:56caracteres con el conteo actual o sea
4:52:59tenemos que retornar ese conteo y
4:53:02también debemos incluir esta cadena
4:53:04alguna de estas dos apostar si el conteo
4:53:07es positivo o esperar si el conteo es
4:53:10cero o negativo para escoger la cadena
4:53:13como solo tenemos dos opciones podemos
4:53:15usar un condicional
4:53:18aquí debajo de la sentencia switch si
4:53:21conteo es mayor que cero si es positivo
4:53:26entonces la decisión sería apostar sino
4:53:30si el conteo es negativo o cero entonces
4:53:33la decisión sería espera ya tenemos el
4:53:36valor del conteo y tenemos la decisión
4:53:38apostar oa esperar entonces podemos
4:53:41simplemente ya retornar nuestro valor
4:53:43cuál debe ser el formato de esa cadena
4:53:45nos dicen que el conte actual y la
4:53:48decisión del jugador apostar o esperar
4:53:50deben estar separados por un espacio así
4:53:54que vamos aquí en la sentencia víctor
4:53:56vamos a escribir conteo
4:54:00separado por un espacio y luego la
4:54:02decisión final y esa es la cadena que
4:54:05vamos a retornar bien ya tenemos nuestra
4:54:08función implementada a contar cartas
4:54:10tenemos la decisión la sentencia switch
4:54:12que implementa las reglas de la tabla
4:54:14luego a partir del valor de conteo
4:54:17tomamos una decisión se apostará esperar
4:54:19y retornamos la cadena con el conteo y
4:54:22la decisión vamos aprobar nuestra
4:54:25función con distintas cartas contar
4:54:27cartas vamos a llamar a la función con
4:54:31distintos valores
4:54:32237 k i
4:54:36ok tenemos 5 llamadas a la función pero
4:54:40como la cadena se retorna ante la
4:54:42función tenemos que rodear estas
4:54:44llamadas con con su punto log aquí las
4:54:47tenemos si vemos en la consola vemos
4:54:50estos resultados cuando pasamos el valor
4:54:532 aquí voy a poner la consola más
4:54:56pequeñita por ahora para que podamos ver
4:54:58los primeros dos resultados si pasamos
4:55:01el valor 2 a la función que ocurre el
4:55:04valor 12 asignada carta luego estamos en
4:55:07la sentencia switch el valor es 2 el
4:55:11conteo se incrementa en 1 y luego
4:55:14pasamos por aquí como el conteo hay uno
4:55:17que es mayor que cero la decisión final
4:55:20es apostar y se retorna el valor conteo
4:55:23separado un espacio de la decisión como
4:55:26vemos aquí 1 y apostar lo mismo ocurre
4:55:30con cada una de estas opciones
4:55:31dependiendo de qué parte de la sentencia
4:55:33switch es la que corresponde en este
4:55:36caso con 3 tenemos el mismo caso
4:55:39es parte de esta secuencia de casos
4:55:42posibles aumentamos el conteo en 1 así
4:55:44que aquí vemos el valor 2 y la decisión
4:55:47es apostar porque el valor es positivo
4:55:49aquí lo tenemos el valor es positivo
4:55:52apostar y retornamos esa cadena luego
4:55:55con 7 aquí vemos el tercer resultado con
4:56:0077 no está entre los posibles casos de
4:56:03la sentencia switch así que no hacemos
4:56:06nada con la variable conteo la dejamos
4:56:08exactamente igual tiene el valor
4:56:10anterior que era 2 y por lo tanto la
4:56:12decisión es apostar y con estas letras
4:56:15ocurre lo mismo pero corresponde con una
4:56:17acción distinta acá
4:56:20es parte de la sentencia switch pero
4:56:22está en esta secuencia de casos
4:56:25acá la tenemos acá a que corresponde
4:56:27esta opción a disminuir el valor de
4:56:29conteo en uno en este caso yo disminuye
4:56:33de 2 a 1 y como todavía es positiva la
4:56:37decisión es apostar y finalmente la
4:56:40letra a también es parte de estos casos
4:56:42esta tenemos acá disminuye el valor de
4:56:44conteo y como ahora el valor de conteo
4:56:48es 0 esta condición es falsa porque 0
4:56:51vamos a la cláusula eus y la decisión es
4:56:54esperar así que retornamos esta
4:56:56combinación bien ya completamos este
4:57:00mini proyecto y ya tenemos nuestra
4:57:02función contar cartas hemos cubierto
4:57:04temas muy muy importantes que son
4:57:07básicos para programar en javascript que
4:57:09los vas a poder usar en tus proyectos de
4:57:11ahora en adelante vamos a comenzar con
4:57:13una parte del curso que va a explicar
4:57:16elementos un poco más avanzados como los
4:57:19objetos los bucles o ciclos y otros
4:57:22elementos como las funciones flechas los
4:57:25operadores restas y plantillas literal
4:57:27sigamos con nuestro siguiente tema
4:57:36ahora vamos a hablar un poquito sobre
4:57:38los objetos en javascript los objetos
4:57:42nos permiten guardar una secuencia o un
4:57:45conjunto de propiedades que están
4:57:49relacionadas con sus correspondientes
4:57:51valores ya vas a ver a qué me refiero
4:57:53por ejemplo si nosotros queremos
4:57:55describir un perro específico una
4:57:59mascota específica digamos que queremos
4:58:02representar en nuestro programa las
4:58:04propiedades de nuestro perro ese perro
4:58:07tiene varias propiedades tiene un nombre
4:58:11que podría ser por ejemplo si no tiene
4:58:15una edad específica cinco años digamos
4:58:18tiene un peso específico que podría ser
4:58:21seis kilos
4:58:23y podría tener digamos una raza podría
4:58:27ser un vigo o podría ser también de raza
4:58:30mixta esta combinación de propiedades
4:58:34como nombre edad peso y raza y de
4:58:38valores que están relacionados a esas
4:58:42propiedades lo denominamos un objeto que
4:58:45podemos usar en javascript en nuestro
4:58:47programa es como una forma de agrupar
4:58:50las todas bajo una misma estructura de
4:58:52datos que podemos usar y acceder a
4:58:55través de esta variable como puedes ver
4:58:57la sintaxis es bastante
4:59:00particular vamos a verla con detalle
4:59:03primero para definir un objeto en
4:59:06javascript debemos usar la palabra clave
4:59:09para seguida de el nombre de la variable
4:59:12si queremos asignar ese objeto a una
4:59:15variable luego con el signo igual
4:59:18estamos asignando el objeto pero aquí
4:59:20tenemos en verdad lo que representa el
4:59:23objeto en javascript
4:59:25entre llaves entre un par de llaves y un
4:59:29punto y coma al final escribimos una
4:59:32secuencia de podríamos decirlo pares de
4:59:35propiedades y valores cada propiedad
4:59:38aparece del lado izquierdo y cada valor
4:59:41correspondiente aparece del lado derecho
4:59:43y separando la propiedad del valor
4:59:46tenemos dos puntos y una espacio también
4:59:49otra cosa que es muy importante es que
4:59:52debe separar cada uno de esos pares con
4:59:55una coma excepto el último por supuesto
4:59:59y normalmente lo escribimos así en
5:00:02líneas diferentes para que sea más fácil
5:00:04de leer y de reconocer puedes usar
5:00:07números también como propiedades e
5:00:09incluso también puedes omitir las
5:00:11comillas si los nombres de las
5:00:13propiedades tienen una sola palabra no
5:00:16tienen ningún espacio y también algo
5:00:18curioso es que puedes usar números como
5:00:21propiedades por ejemplo aquí tenemos una
5:00:25propiedad cuyo nombre 5 y cuyo valor es
5:00:28esta cadena de caracteres 5
5:00:31si el objeto tiene alguna propiedad que
5:00:33no es una cadena javascript las
5:00:35convierte automáticamente en cadenas así
5:00:37que si no las rodeamos con comillas de
5:00:39igual forma van a ser comillas en la
5:00:41representación interna del programa
5:00:43genial ya sabes cómo definir objetos en
5:00:45javascript vamos a ver más detalles
5:00:48sobre los objetos porque son muy
5:00:49poderosos y muy útiles al momento del
5:00:52programa continuamos
5:01:00puedes acceder a las propiedades de un
5:01:03objeto usando algo que llamamos notación
5:01:06de puntos veamos un ejemplo
5:01:09si definimos el objeto que teníamos en
5:01:12el tema anterior en la parte anterior mi
5:01:15perro con un nombre chino edad 5
5:01:21peso 6
5:01:25raza digamos vigo podemos acceder a las
5:01:30propiedades de ese objeto porque si no
5:01:32para qué serían de utilidad en las que
5:01:34los objetos son muy útiles porque
5:01:37podemos acceder a sus propiedades por
5:01:39ejemplo si necesitamos trabajar con el
5:01:42nombre de este objeto que si no podemos
5:01:46acceder a ese valor en nuestro programa
5:01:48usando la anotación de punto como
5:01:52accederíamos a esta propiedad escribimos
5:01:54el nombre de la variable que contiene al
5:01:56objeto mi perro y luego seguido de un
5:02:00punto escribimos el nombre de la
5:02:02propiedad por ejemplo nombre no tenemos
5:02:06que colocar las comillas simplemente
5:02:09decimos el nombre de la propiedad cuando
5:02:11usamos la anotación de punto este punto
5:02:15es el que le dice a javascript que
5:02:17quiero esta propiedad de este objeto el
5:02:21punto es como la conexión la pega en
5:02:23barra que los mantiene juntos para
5:02:25mostrar ese valor vamos a usar con su
5:02:28punto bloque y aquí puedes ver el valor
5:02:31esta expresión esta anotación nos
5:02:34permitió acceder al valor chino que es
5:02:37el nombre del objeto mi perro ahora
5:02:41también podemos intentarlo con otras
5:02:43propiedades por ejemplo si queremos
5:02:45acceder a su edad
5:02:46cambiamos el nombre de la propiedad en
5:02:49la anotación de punto y aquí tenemos el
5:02:51valor 5
5:02:53podemos hacer lo mismo con peso aquí
5:02:56tenemos el valor 6 y finalmente rasa que
5:02:59sería
5:03:00pido bien ya sabes cómo acceder a las
5:03:04propiedades de un objeto recuerda el
5:03:07nombre de la variable seguido de un
5:03:09punto y luego el nombre de la propiedad
5:03:20a ver una notación alternativa que
5:03:22puedes usar para acceder a las
5:03:24propiedades de un objeto primero
5:03:28definamos un objeto y vamos a asignarlo
5:03:31a la variable mi cuaderno esto que esto
5:03:34va a tener las propiedades color su
5:03:37valor va a ser verde va a tener color
5:03:39verde
5:03:40categoría
5:03:423
5:03:42recuerda que no incluimos los acentos
5:03:45para no introducir caracteres que no son
5:03:48estándar en inglés número de páginas
5:03:50doscientas y por lo tanto número de
5:03:53hojas 100 este es nuestro objeto como
5:03:56puedes notar aquí en el nombre de estas
5:03:59dos propiedades tenemos espacios pero
5:04:03como las estamos rodeando entre comillas
5:04:05podemos escribirlas sólo podemos omitir
5:04:08las comillas cuando el nombre tenga una
5:04:11sola palabra si tienen más de una
5:04:13palabra y hay espacios en ese nombre
5:04:16tenemos que rodearla entre comillas es
5:04:19obligatorio bien vamos a ver la
5:04:21anotación que hemos usado hasta ahora la
5:04:23anotación de punto
5:04:25escribiríamos el nombre de la variable
5:04:27mi cuaderno seguido de un punto y luego
5:04:30el nombre de la propiedad digamos color
5:04:33si vemos la consola ahora el resultado
5:04:35es verde
5:04:38pudimos acceder a ese valor pero ahorita
5:04:41vamos a usar la notación de corchetes es
5:04:45una notación que es equivalente
5:04:47normalmente usamos la anotación de punto
5:04:49pero la anotación de corchetes nos
5:04:52permite acceder a este tipo de
5:04:55propiedades que tienen espacios
5:04:57propiedades que tienen espacios en su
5:04:59nombre en ese caso es obligatorio pero
5:05:02también podemos usarla para acceder a
5:05:04cualquier propiedad digamos color veamos
5:05:07la consola vemos el valor verde
5:05:10exactamente lo que teníamos con notación
5:05:12de punto así que es equivalente cuando
5:05:15usamos la notación de corchetes tenemos
5:05:18que escribir un par de corchetes y
5:05:20dentro de los corchetes el nombre de la
5:05:23propiedad rodeada por comillas
5:05:26podemos acceder a cualquier propiedad
5:05:28digamos número de páginas y aquí en la
5:05:31consola vemos el valor 200
5:05:34connotación de punto esto daría un error
5:05:37digamos que tratamos de acceder a esta
5:05:39propiedad con espacios con la anotación
5:05:42de punto puedes ver que luego del primer
5:05:44espacio hay un error porque no se
5:05:46detecta como un solo nombre
5:05:49normalmente en este caso lo que hacemos
5:05:51es unir las palabras comenzando con
5:05:54mayúsculas como los nombres de las
5:05:57variables en este caso si podríamos usar
5:06:00notación de punto o notación de
5:06:02corchetes que es equivalente
5:06:04como la anotación de puntos más concisa
5:06:07y más fácil de leer normalmente usamos
5:06:09notación de punto pero la anotación de
5:06:12corchetes es muy muy útil también cuando
5:06:14necesitamos usar el valor de una
5:06:17variable y eso es y eso es exactamente
5:06:20lo que vamos a hacer en el próximo tema
5:06:22vamos a ver como puedes acceder a estos
5:06:25valores usando variables recuerda que
5:06:29esta es la notación de corchetes un par
5:06:31de corchetes y dentro de los corchetes
5:06:33entre comillas el nombre de la propiedad
5:06:38digamos categoría correcto el valor de
5:06:41categoría en el objeto mi cuaderno
5:06:44buen trabajo pasemos a nuestro siguiente
5:06:47tema
5:06:53ahora veremos cómo puedes acceder a la
5:06:56propiedad del objeto usando una variable
5:06:59en lugar de un valor que escribimos
5:07:01directamente entre corchetes
5:07:04vamos a usar una variable si definimos
5:07:07un objeto que representa los resultados
5:07:10de una competencia vamos a asociar los
5:07:13números entre 1 y 4 del primero segundo
5:07:17tercero y cuarto lugar el usuario
5:07:19correspondiente digamos que es una
5:07:21competencia de programación y los
5:07:24competidores se registraron con un
5:07:26nombre específico de usuario y 1 577 en
5:07:31tercer lugar llegó este 5 543 y en
5:07:35cuarto lugar llegó guiar a 566 estos son
5:07:40los cuatro finalistas de la competencia
5:07:41ahora si queremos acceder a algunos de
5:07:45esos resultados específicos algunos de
5:07:48esos valores específicos
5:07:51podríamos usar una variable posición
5:07:53queremos acceder en este caso al usuario
5:07:56que estaba en la posición 4 como podemos
5:07:59hacer no podemos escribir el nombre del
5:08:02objeto el nombre de la variable que
5:08:05contiene ese objeto y entre corchetes
5:08:08pasamos en lugar de el nombre de la
5:08:10propiedad el nombre de la variable
5:08:13posición esto es equivalente a
5:08:16simplemente escribir 4 pero como estamos
5:08:19escribiendo una variable podemos
5:08:21trabajar con esa variable en nuestro
5:08:23programa y hacer que este acceso a la
5:08:27propiedad sea más flexible más dinámico
5:08:29porque este valor va a depender del
5:08:31valor de la variable no es un valor fijo
5:08:35para mostrar ese resultado podemos usar
5:08:38los llamara con su blog tenemos los
5:08:41resultados usamos la posición y aquí
5:08:45vemos el valor que ahora 566 que ahora
5:08:48566 que corresponde a la propiedad 4 si
5:08:52actualizamos el valor de la variable
5:08:54sigamos a 2
5:08:56ahora tenemos 1 577 que corresponde a la
5:08:59propiedad 2 puedes ver que ese valor se
5:09:02está usando como el valor de la
5:09:05propiedad el nombre de la propiedad que
5:09:07tenemos aquí y eso nos da mucha más
5:09:10flexibilidad porque quizás esta variable
5:09:13esté en un lugar específico de tu
5:09:15programa y el aus es muchas muchas veces
5:09:17y se actualiza en tu programa y luego
5:09:19cuando llegue a este punto en el
5:09:21programa cuando necesitas acceder a esa
5:09:23propiedad
5:09:24ese resultado va a estar personalizado
5:09:28al valor actual de la variable genial ya
5:09:31sabes cómo acceder a propiedades de
5:09:33objetos usando una variable esto no lo
5:09:36podemos hacer con la anotación de punto
5:09:38solamente con la anotación de corchetes
5:09:42porque la notación de puntos tenemos que
5:09:44escribir explícitamente el nombre de la
5:09:47propiedad no podemos usar una variable
5:09:49de pasemos a nuestro siguiente tema y
5:09:52sigamos viendo las distintas opciones
5:09:53que tenemos para trabajar con objetos en
5:09:56javascript
5:10:04además de crear un objeto en tu programa
5:10:06y acceder a sus propiedades
5:10:09también puedes actualizar el valor de
5:10:11esas propiedades para permitir que tu
5:10:13objeto cambie durante la ejecución del
5:10:16programa en este caso vamos a ver un
5:10:19ejemplo con un objeto que vamos a llamar
5:10:22mochila su color va a ser azul su tamaño
5:10:27va a ser mediano podemos también asignar
5:10:31otros tipos de datos otras estructuras
5:10:33de datos como los valores de las
5:10:35propiedades por ejemplo una botella de
5:10:37agua y un cuaderno
5:10:40ese es el contenido de la mochila una
5:10:43vez que ya tenemos estas propiedades
5:10:45definidas en nuestro programa vamos a
5:10:48acceder a ellas y vamos a tratar de
5:10:51actualizar las para acceder a la
5:10:53propiedad color
5:10:55escribimos el nombre de la variable
5:10:57mochila seguido de un punto y luego el
5:11:00nombre de la propiedad que es color
5:11:03vamos a mostrar el valor inicial que es
5:11:07azul aquí lo podemos ver azul pero luego
5:11:11digamos que queremos cambiar el color de
5:11:13nuestra mochila para actualizar el valor
5:11:16de la propiedad lo que hacemos es
5:11:18escribir el nombre de la variable que
5:11:21contiene el objeto seguido de un punto
5:11:23el nombre de la propiedad que queremos
5:11:26actualizar y luego le vamos a asignar el
5:11:29valor que queremos asignar verde en este
5:11:32caso una cadena de caracteres esto va a
5:11:35actualizar el valor de azul a verde y lo
5:11:38podemos comprobar mostrando lo otra vez
5:11:41mochila punto color vamos a abrir la
5:11:44consola y vemos el resultado
5:11:46exactamente lo que esperábamos
5:11:49inicialmente el valor es azul y luego de
5:11:52reasignar o de cambiar ese valor ahora
5:11:56es verdad aquí en esta línea es verde
5:11:58así es cómo resignamos o cambiamos el
5:12:01valor
5:12:02también podemos trabajar con sus valores
5:12:05para modificarlos por ejemplo si
5:12:08nosotros queremos agregar algo a la
5:12:09mochila tendríamos que acceder al valor
5:12:13de la propiedad contenido así que vamos
5:12:17a ver cómo podemos actualizar este valor
5:12:19podemos usar notación de puntos mochila
5:12:22punto contenido y vemos aquí el arreglo
5:12:26botella de agua y cuadernos son los dos
5:12:29valores iniciales digamos que queremos
5:12:31agregar un lápiz a nuestra mochila cómo
5:12:34podemos hacerlo mochila punto contenido
5:12:37el único que falta es que llamemos al
5:12:39método puig
5:12:41recuerdas de ese método cuando
5:12:43trabajamos con arreglos este es un
5:12:45método que nos permite agregar un
5:12:47elemento al final de la regla así que
5:12:51vamos a agregar la cadena de caracteres
5:12:53que diga el lápiz ok y luego de eso
5:12:57vamos a volver a mostrar el valor del
5:13:00contenido de la mochila vamos a abrir la
5:13:02consola y aquí lo podemos ver
5:13:05inicialmente sólo tiene una botella de
5:13:07agua y un cuaderno y luego de que
5:13:10ejecutamos esta línea el nuevo contenido
5:13:13es los dos elementos anteriores más el
5:13:16lápiz que se agregó al final del arreglo
5:13:18genial eso es en el caso de que queramos
5:13:21agregar o quitar un elemento de la lista
5:13:24si quisiéramos quitar aquí podríamos
5:13:27usar por ejemplo pop
5:13:29pero si queremos reasignar el contenido
5:13:31de esa propiedad completamente por otro
5:13:35arreglo completamente nuevo también
5:13:37podemos hacerlo igual que resignamos el
5:13:41valor de otras propiedades en mochila
5:13:43punto contenido que es el nombre de la
5:13:46propiedad igual y asignamos otro arreglo
5:13:49completamente nuevo y luego si mostramos
5:13:53esa propiedad
5:13:54mochila punto
5:13:57contenido
5:14:01bien ya sabes cómo actualizar las
5:14:03propiedades de un objeto recuerda
5:14:06primero el nombre de la variable seguido
5:14:08de un punto el nombre de la propiedad y
5:14:12asignamos el valor correspondiente
5:14:13también lo puedes hacer connotaciones
5:14:16corchetes en lugar de notación de punto
5:14:18aquí puedes usar la anotación de
5:14:20corchetes y va a funcionar
5:14:27también puedes agregar nuevas
5:14:29propiedades a un objeto en javascript
5:14:33veamos un ejemplo ahora vamos a tener un
5:14:35objeto que va a representar un curso
5:14:38el curso va a tener un título y es su
5:14:41título va a ser aprende javascript desde
5:14:45cero bien también luego podemos
5:14:47especificar el idioma del curso y
5:14:51también tendríamos aquí la duración
5:14:53digamos que es un curso de 30 minutos o
5:14:5530 horas dependiendo del estándar que
5:14:58usemos para en este valor que tenemos un
5:15:01objeto con tres propiedades ahora como
5:15:04podemos añadir una cuarta propiedad la
5:15:07propiedad se va a llamar vistas va a ser
5:15:10el número de vistas que ha tenido ese
5:15:12curso desde que se publicó la sintaxis
5:15:15es exactamente la misma que usamos para
5:15:17actualizar el valor de una propiedad
5:15:19pero en este caso vamos a escribir el
5:15:22nombre de la propiedad que queremos
5:15:24agregar el nombre de la variable seguida
5:15:28de un punto el nombre de la propiedad
5:15:30nueva y luego el valor que queremos
5:15:33asignar aquí tenemos
5:15:36nuestra propiedad nueva que podemos
5:15:39comprobar
5:15:40mostrando la en la consola vamos a abrir
5:15:43la consola puedes ver que el valor es 34
5:15:46mil 500 vistas exactamente lo que
5:15:49asignamos en esta línea cuando creamos
5:15:51la propiedad si hubiéramos intentado
5:15:54acceder a esta propiedad antes de
5:15:56crearlo el resultado hubiera sido aun de
5:15:59find y esto es muy importante que lo
5:16:01sepas también si intentas acceder a una
5:16:04propiedad que no existe en un objeto en
5:16:07ese momento en particular del programa
5:16:09el resultado o el valor que se va a
5:16:12retornar el haundi find y por eso es
5:16:15bueno también verificar que el valor no
5:16:18sea anti find cuando estás trabajando
5:16:19con propiedades y también estoy segura
5:16:23de que te debes estar preguntando si
5:16:24podemos hacer esto mismo connotación de
5:16:27corchetes vamos a ver si cerramos la
5:16:30consola y usamos notación de corchetes
5:16:33para crear la propiedad vista
5:16:36luego intentamos acceder a ella aquí
5:16:40podemos ver el valor
5:16:4234.500 que era exactamente lo que le
5:16:45asignamos a la propiedad vistas genial
5:16:48ya sabes agregar propiedades nuevas a un
5:16:50objeto
5:16:56ahora vamos a ver cómo puedes eliminar
5:16:59una propiedad de un objeto en ya buscar
5:17:02la palabra clave aquí es la palabra
5:17:05delete qué significa eliminar o borrar
5:17:08en español vamos a ver cómo la puedes
5:17:11usar aquí tenemos el objeto que usamos
5:17:14en nuestro ejemplo anterior con sus tres
5:17:16propiedades títulos idioma y duración
5:17:20si queremos borrar
5:17:21digamos la propiedad duración ya no
5:17:24queremos tener un registro de la
5:17:26duración del curso tenemos que escribir
5:17:28la palabra clave delete seguida de el
5:17:33nombre del objeto el nombre de la
5:17:35variable que contiene el objeto luego un
5:17:38punto y el nombre de la propiedad
5:17:41duración y punto y coma y eso es todo lo
5:17:45que tenemos que hacer para borrar esa
5:17:47propiedad la palabra delete separada de
5:17:50un espacio el nombre de la variable
5:17:52punto y el nombre de la propiedad veamos
5:17:56y en realidad si se eliminó a esta
5:17:58propiedad del objeto curso vamos a
5:18:02acceder a la propiedad antes de borrarla
5:18:04y vamos a intentar acceder a ella luego
5:18:07de borrar la puedes ver que inicialmente
5:18:10su valor era 30 aquí cuando accedemos a
5:18:13ella antes de borrarla pero luego de
5:18:16eliminarlo de borrarla del objeto el
5:18:18valor es antifaz porque ya la propiedad
5:18:22no existe en el objeto si cambiamos está
5:18:25línea de código por una línea de código
5:18:26que nos muestre el objeto completo este
5:18:30es el objeto que se nos presenta tiene
5:18:32un título y tiene un idioma pero ya no
5:18:35tiene la propiedad duración luego de que
5:18:37la borramos con delete bien vamos a ver
5:18:41cómo podemos hacer esto con otra
5:18:42propiedad
5:18:43digamos que queremos borrar la propiedad
5:18:46idioma
5:18:48inicialmente ese valor va a ser español
5:18:52pero luego de borrar lo tendríamos que
5:18:54actualizar aquí el nombre de la
5:18:56propiedad y aquí abajo para mostrarlo
5:18:59pero lo que va a ocurrir es que el valor
5:19:01va a ser on design aquí lo vemos en la
5:19:04consola español es lo que tenemos aquí
5:19:07antes de borrar la propiedad luego la
5:19:09borramos y si intentamos acceder a ella
5:19:13luego de borrarla tenemos el valor anti
5:19:16file
5:19:17genial la clave está en delete así que
5:19:21pasemos a nuestro siguiente tema
5:19:29a ver cómo podemos usar un objeto para
5:19:32reemplazar una sentencia switch con esta
5:19:35estructura que tenemos aquí vamos a
5:19:38analizar el código y luego lo vamos a
5:19:40modificar tenemos una función que se
5:19:42llama buscar el elemento químico que va
5:19:45a tomar el símbolo del elemento químico
5:19:47como argumento y a partir de ese símbolo
5:19:50va a retornar el nombre completo del
5:19:53elemento químico
5:19:54aquí tenemos la variable elemento
5:19:57químico le asignamos un valor
5:19:58dependiendo del valor de símbolo y luego
5:20:01retornamos ese valor el nombre completo
5:20:04del elemento qué es lo que ocurre si
5:20:07analizamos la estructura de switch aquí
5:20:09podemos ver que a partir del valor de
5:20:11símbolo vamos a asociar ese símbolo con
5:20:15su nombre completo con el elemento
5:20:17químico al estaría como asociado
5:20:21aluminio ese estaría asociado a azufre
5:20:23cl a cloro h
5:20:27de áporo oro y el litio
5:20:31básicamente lo que estamos haciendo es
5:20:33una asociación entre dos valores en este
5:20:36caso y para esta sentencia switch o
5:20:39específica cuando tienes una sentencia
5:20:42switch con esta estructura que asociados
5:20:44valores fácilmente podemos escribir
5:20:47código más conciso con un objeto
5:20:49recuerda que los objetos nos permiten
5:20:52asociar una propiedad con su valor en
5:20:55este caso vamos a crear un objeto que
5:20:57asocie los símbolos químicos con sus
5:21:00elementos químicos correspondientes
5:21:03veamos cómo podemos hacerlo vamos a
5:21:05tener la sentencia switch aquí abajo
5:21:07como referencia y vamos a ir escribiendo
5:21:09el código vamos a llamar a nuestro
5:21:12objeto símbolos químicos también podrías
5:21:14llamarlo elementos químicos dependiendo
5:21:17lo estamos asociando símbolos a los
5:21:19elementos así que es equivalentes
5:21:22ahora las propiedades de este objeto van
5:21:25a ser los símbolos químicos y vamos a
5:21:27usar esas propiedades para acceder a sus
5:21:30valores correspondientes que van a ser
5:21:32los nombres completos de los elementos
5:21:35químicos al aluminio
5:21:39ese azufre
5:21:42cloro
5:21:44h lo tenemos aquí abajo sería el yo
5:21:49el yo
5:21:51luego tenemos boro y el litio
5:21:55genial ya tenemos nuestro objeto estamos
5:21:59reestructurando nuestro código de una
5:22:01forma específica para poder realizar
5:22:04exactamente lo mismo que tenemos en
5:22:06switch pero de forma más concisa aquí ya
5:22:09estamos logrando asociar cada símbolo
5:22:11con su elemento químico correspondiente
5:22:14ahora vamos a borrar nuestra sentencia
5:22:16switch porque ya asociamos estos valores
5:22:18el único cambio que nos falta por hacer
5:22:22es acceder al símbolo químico para
5:22:25obtener su valor correspondiente acceder
5:22:28a esta propiedad ya no vamos a necesitar
5:22:30esta variable así que la borramos y
5:22:33simplemente usamos el nombre de este
5:22:35objeto podemos trabajar con este objeto
5:22:38como ha aprendido en las partes
5:22:39anteriores del curso podemos acceder a
5:22:42sus propiedades con notación de
5:22:43corchetes y podemos pasar el valor de
5:22:46esta variable símbolo del parámetro
5:22:50esto nos va a retornar el valor asociado
5:22:53a ese símbolo el nombre completo del
5:22:56elemento químico así que esto va a ser
5:22:59el nombre completo del elemento químico
5:23:00y el valor se va a retornar
5:23:03exactamente lo que queríamos y puedes
5:23:06ver como nuestro código es mucho más
5:23:08conciso si lo modificamos para trabajar
5:23:12con un objeto en lugar de switch en este
5:23:14caso ahora veamos cada uno de los
5:23:17posibles casos para confirmar que
5:23:19retorna el valor apropiado tenemos
5:23:22aluminio tenemos azufre tenemos cloro
5:23:25helio boro y litio así que estamos
5:23:30verificando todos los casos vamos a
5:23:31abrir la consola
5:23:34y podemos ver todas las opciones
5:23:36aluminio azufre cloro helio oro y litio
5:23:39así que la función retorna a los valores
5:23:42que esperábamos y tenemos código mucho
5:23:44más conciso simplemente usando un objeto
5:23:47para asociar una propiedad a su valor
5:23:50correspondiente bien ya sabes cómo usar
5:23:53objetos para escribir código más conciso
5:23:55en casos como éste en el cual
5:23:57necesitamos asociar propiedades a
5:23:59valores bien pasemos a nuestro siguiente
5:24:02tema del curso
5:24:08otra operación muy importante que debes
5:24:12aprender a realizar con un objeto es
5:24:14verificar si ese objeto tiene una
5:24:17propiedad o no recuerda que hace algunos
5:24:19minutos en una parte anterior vimos que
5:24:22después de borrar una propiedad cuando
5:24:25ese objeto ya no tiene la propiedad
5:24:27el resultado retornado si intentamos
5:24:29acceder a ella es indiferente pero para
5:24:33ello podemos verificar si la propiedad
5:24:35existe o no antes de usarla como podemos
5:24:39verificar eso vamos a ver vamos a crear
5:24:42un objeto llamado mi cuaderno con estas
5:24:45propiedades color verde categoría 3
5:24:50y precio
5:24:514.56 para verificar si el objeto tiene o
5:24:56no una propiedad específica
5:24:58escribimos el nombre del objeto el
5:25:01nombre de la variable y luego escribimos
5:25:04esto que tenemos aquí estamos llamando
5:25:08al método más o un print
5:25:12de espanyol podríamos traducirlo como
5:25:14tiene esta propiedad estamos preguntando
5:25:17si este objeto que tenemos aquí tiene la
5:25:21propiedad que vamos a especificar entre
5:25:23paréntesis
5:25:24digamos color en este caso el objeto si
5:25:28tiene la propiedad color así que el
5:25:30resultado va a ser ser el resultado
5:25:32retornado en esta línea por la llamada
5:25:36al método
5:25:38para mostrar el resultado en la consola
5:25:40vamos a usar con su block y aquí podemos
5:25:43ver el resultado
5:25:45exactamente lo que esperábamos porque la
5:25:48propiedad si existe este método es muy
5:25:50útil cuando estamos trabajando por
5:25:53ejemplo con un condicional en un
5:25:55condicional podemos escribir esto como
5:25:58la condición y si el objeto tiene esa
5:26:01propiedad la condición va a ser
5:26:03verdadera y si no la condición va a ser
5:26:05falsa ahora veamos qué ocurre si
5:26:08intentamos
5:26:09verificar una propiedad que no existe en
5:26:14el objeto digamos origen como el país de
5:26:16origen
5:26:18este resultado debería ser falso falso
5:26:21porque el objeto mi cuaderno no tiene
5:26:24una propiedad llamada origen si lo
5:26:26verificamos en la consola aquí tenemos
5:26:28el valor fob falso porque esta propiedad
5:26:32no existe en el objeto para ilustrar
5:26:34cómo este método es muy muy útil en un
5:26:37condicional vamos a crear oa definir una
5:26:40función
5:26:41la función va a verificar
5:26:45si un objeto tiene una propiedad o no
5:26:49y va a mostrar un mensaje adecuado para
5:26:52tomar dos parámetros el objeto y la
5:26:55propiedad así que decimos sí
5:26:59esta condición es verdadera es decir si
5:27:02el objeto tiene la propiedad que
5:27:06especificamos aquí como parámetro
5:27:09entonces qué es lo que vamos a retornar
5:27:12aquí una cadena que va a ser la unión de
5:27:15esta cadena con el valor de la propiedad
5:27:17en ese objeto ya aquí sabemos que este
5:27:20valor no va a ser anti find porque la
5:27:23condición fue verdadera es decir que el
5:27:25objeto tiene esa propiedad que
5:27:28especificamos y podemos trabajar con
5:27:30ella de forma segura sabiendo que no va
5:27:33a ser aún de find sino si el objeto no
5:27:36tiene la propiedad vamos a retornar esta
5:27:38cadena de caracteres el objeto no tiene
5:27:41esta propiedad
5:27:44y esto es básicamente nuestra función
5:27:47vamos a probar la causa punto y llamamos
5:27:51a verificar propiedad vamos a pasar un
5:27:54objeto que vamos a definir aquí mi
5:27:57cuaderno
5:27:58color verde categoría 3 y precio
5:28:024.56
5:28:04vamos a verificar si mi cuaderno tiene
5:28:07la propiedad color veamos el resultado
5:28:10en la consola si tienes la propiedad
5:28:13color porque vemos su valor el valor de
5:28:16esa propiedad es verde esta condición
5:28:19fue verdadera y aquí se reemplazó el
5:28:22valor de la propiedad si tratamos de
5:28:24pasar una propiedad que no existe por
5:28:27ejemplo origen aquí vemos que el objeto
5:28:30no tiene esta propiedad esta condición
5:28:33fue falsa así que fuimos a la cláusula
5:28:36else y retornamos esta cadena de
5:28:38caracteres el objeto no tiene esta
5:28:41propiedad también podríamos agregar el
5:28:43puntito aquí bien ya sabes cómo usar
5:28:45este método hash un propio en un
5:28:48condicional y también de forma
5:28:50independiente para verificar si un
5:28:52objeto tiene una propiedad o no esto es
5:28:54muy muy útil a medida que trabajes con
5:28:57los objetos porque te garantizan que
5:29:00cuando trates de acceder a una propiedad
5:29:01el valor no va a ser dónde find buen
5:29:04trabajo
5:29:05ahora vamos a empezar a manipular
5:29:07objetos más complejos que son el tipo de
5:29:10objeto con el cual trabajaría por
5:29:12ejemplo en desarrollo web
5:29:19ya sabes cómo trabajar con objetos en
5:29:22javascript y todas sus operaciones
5:29:24principales así que vamos a comenzar a
5:29:27trabajar con objetos más complejos
5:29:29tienen combinaciones de distintos tipos
5:29:32de datos como sus valores los valores de
5:29:35las propiedades puedes ver que esta
5:29:37variable orden es de pizzas contiene un
5:29:41arreglo aquí podemos ver los corchetes
5:29:43abriendo y cerrando el arreglo esto nos
5:29:46dice que es un arreglo de objetos porque
5:29:49aquí tenemos las llaves que abren y
5:29:51cierran el objeto y dentro de cada
5:29:54objeto que tenemos aquí en nuestro
5:29:56arreglo tenemos secuencias de
5:29:58propiedades y sus valores que siguen un
5:30:00formato muy similar las mismas
5:30:02propiedades asociadas a distintos
5:30:04valores esto es un formato que
5:30:06normalmente usamos y es muy similar al
5:30:08formato jason así que si en algún
5:30:11momento planeas de aprender desarrollo
5:30:13web aprender a manipular este tipo de
5:30:15objetos es vital
5:30:17veamos cómo lo puedes hacer primero que
5:30:20todo lo esencial es entender que estamos
5:30:23trabajando inicialmente con un arreglo
5:30:25así que cada uno de estos objetos tiene
5:30:28un lugar en ese arreglo como si fuera un
5:30:31elemento como si tuviéramos un arreglo
5:30:33con dos cadenas de caracteres o dos
5:30:35números pero en este caso tenemos dos
5:30:37objetos luego cada objeto tiene su
5:30:41conjunto de propiedades y los valores de
5:30:45esas propiedades veamos la estructura
5:30:47tipo de pixar el primer objeto
5:30:50representa una pizza margarita pero el
5:30:53segundo objeto representa una pizza de
5:30:55cuatro quesos ambos tienen la misma
5:30:58propiedad pero sus valores son distintos
5:31:00luego tenemos el tamaño de la pizza
5:31:03individual y el segundo objeto es de
5:31:05tamaño familiar
5:31:06la segunda pizza precio 5 con 67 aquí
5:31:10puedes ver que podemos mezclar valores
5:31:13de distintos tipos no necesariamente
5:31:15todos los valores tienen que ser del
5:31:17mismo tipo de datos
5:31:19luego vemos toppings los toppings están
5:31:23representados como otro arreglo sí es
5:31:26cierto tenemos un arreglo
5:31:29externó que contiene a los objetos luego
5:31:32tenemos el objeto y dentro del objeto
5:31:35tenemos otro arreglo como el valor de
5:31:38una propiedad con este ejemplo puedes
5:31:40ver que los objetos son muy muy
5:31:42versátiles y podemos trabajar con ellos
5:31:45para representar prácticamente cualquier
5:31:47data que necesitemos
5:31:49aquí representamos los toppings como un
5:31:51arreglo porque necesitamos varios
5:31:54elementos porque el cliente puede pedir
5:31:57más de un topping luego para llevar es
5:32:00un valor booleana verdaderos y la pizza
5:32:03se ordenó para llevar o falsos y la
5:32:06pizza se ordenó para comer en el lugar
5:32:08toda la data que necesitamos de la pizza
5:32:10está representada en estos objetos para
5:32:13cada una de las órdenes como podemos
5:32:15acceder a estos objetos vamos a trabajar
5:32:18con con su logo la estructura de datos
5:32:21principal que contiene los objetos es un
5:32:23arreglo
5:32:24ese reglón tiene las mismas propiedades
5:32:27que aprendiste cuando empezamos a
5:32:29trabajar con arreglos el primer objeto o
5:32:33el primer elemento está en el índice 0
5:32:35el segundo objeto está en el índice 1 y
5:32:39los objetos están separados con una coma
5:32:41esto es muy importante ok también cuando
5:32:44los objetos son parte de un arreglo
5:32:46también hay que separarlos con comas
5:32:48porque son elementos distintos del
5:32:50arreglo
5:32:52entonces para acceder al primer objeto
5:32:54usamos el índice cero el nombre de la
5:32:57variable y el índice cero este índice
5:33:01cero nos va a retornar el primer objeto
5:33:03y también si queremos el segundo objeto
5:33:06podemos cambiar el índice cero por el
5:33:09índice uno y sería este objeto el
5:33:12resultado veámoslo en la consola aquí
5:33:15puedes ver el primer objeto
5:33:17tipo tamaño precio toppings y para
5:33:22llevar y luego aquí tenemos
5:33:26otro objeto
5:33:28tipo tamaño precio toppings y para
5:33:32llevar accedemos al primer objeto
5:33:34primero y luego al segundo objeto con
5:33:37sus índices correspondientes
5:33:38ahora digamos que queremos acceder al
5:33:42tipo de pizza que corresponde al primer
5:33:44objeto
5:33:45digamos que queremos saber si esa ticks
5:33:48es margarita o cualquier otro tipo de
5:33:50pizza solo la del tipo del primer objeto
5:33:53como lo podemos hacer vamos a trabajar
5:33:56con el primer objeto y luego puedes
5:33:58replicar lo que estamos haciendo para el
5:34:00segundo objeto simplemente cambiando el
5:34:03índice de 0 a 1 para acceder a esa
5:34:05propiedad usamos notación de punto
5:34:08también podemos usar notación de
5:34:10corchete accedemos al primer objeto y
5:34:13luego accedemos a su propiedad tipo eso
5:34:16nos debería retornar el valor margarida
5:34:18y efectivamente aquí tenemos el valor
5:34:21margarida fue el tipo del primer objeto
5:34:24de la primera orden de pizza si queremos
5:34:27usar en lugar de notación de punto
5:34:29notación de corchete también lo podemos
5:34:32hacer con comillas
5:34:34aquí las tenemos usamos los corchetes y
5:34:37escribimos el nombre de la propiedad
5:34:39entre comillas e igual tenemos el valor
5:34:41margarita podemos tratar de acceder a
5:34:44cualquier otra propiedad por ejemplo
5:34:46precio
5:34:485.67 la tenemos aquí y si usamos
5:34:52notación de corchetes tenemos 5.67 el
5:34:55mismo valor bien si queremos acceder a
5:34:58la lista de toppings también podemos
5:35:00hacerlo
5:35:02aquí tenemos los toppings del primer
5:35:04objeto y si queremos acceder a los
5:35:06toppings del segundo objeto simplemente
5:35:09cambiamos el índice a uno aquí vemos
5:35:11extra queso y pimentón que corresponden
5:35:14al segundo objeto a la lista de toppings
5:35:17bien ahora vamos a ver cómo puedes
5:35:19agregar una tercera orden de pizza a
5:35:22este objeto recuerda que siempre tenemos
5:35:24que separar los objetos con una coma
5:35:26cuando están contenidos en un arreglo
5:35:29cuando son parte de un arreglo así que
5:35:32agregamos una coma y luego en la
5:35:35siguiente línea colocamos un par de
5:35:38llaves
5:35:39normalmente el editor de código que
5:35:41estamos usando para alinear las llaves
5:35:44verticalmente y podemos comenzar a
5:35:47escribir nuestro código tipo 2 puntos
5:35:50digamos napolitana tamaño individual
5:35:56precio
5:35:586.78 toppings
5:36:01lista vacía
5:36:03y
5:36:05para llevar esto
5:36:08la pizza se pidió para llevar no tiene
5:36:12ningún topping agregado de tamaño
5:36:14individual es una napolitana y su precio
5:36:16fue de 6.78 lee ya tenemos un tercer
5:36:21objeto en nuestro arreglo y podemos
5:36:23acceder a él con el índice 2 porque es
5:36:26el tercer elemento de nuestro arreglo
5:36:28genial ya sabes cómo trabajar con este
5:36:31objeto que ya es un poco más complejo en
5:36:33su estructura simplemente accedes al
5:36:35objeto que corresponde y luego accedes a
5:36:38su propiedad
5:36:44bien en la parte anterior viste cómo
5:36:48puedes trabajar con objetos más
5:36:50complejos con una estructura más
5:36:52elaborada ahora vamos a empezar a hablar
5:36:54sobre los objetos anidados que son
5:36:57objetos contenidos dentro de otros
5:37:00objetos esto te debe sonar familiar
5:37:03porque es parecido al concepto de un
5:37:05arreglo ni dado que es un arreglo dentro
5:37:08de un arreglo en este caso tenemos un
5:37:11objeto dentro de otro objeto
5:37:13en este ejemplo estoy intentando el
5:37:16código con cuatro espacios para que
5:37:18podamos ver mejor la estructura del
5:37:21objeto en javascript puedes intentar tu
5:37:24código con dos o con cuatro espacios lo
5:37:27importante es mantener la consistencia
5:37:29en todo el código en todo el programa
5:37:31bien ahora que ya mencionamos esto
5:37:34comenzamos a analizar la estructura de
5:37:36este ejemplo tenemos un objeto principal
5:37:39que está asignado a la variable en mi
5:37:41receta ese objeto principal tiene tres
5:37:45propiedades descripción costo e
5:37:47ingredientes nosotros nos vamos a
5:37:50centrar en esta propiedad que tenemos
5:37:52aquí cuyo valor es un objeto esto ya es
5:37:56un objeto unidad es un objeto dentro de
5:37:59un objeto
5:38:00y luego tenemos aquí propiedades masas y
5:38:03coberturas que a su vez tienen otros
5:38:07objetos como propiedades así que tenemos
5:38:10una estructura mucho más elaborada con
5:38:12distintos niveles de objetos anidados
5:38:15vamos a ver cómo podemos acceder a sus
5:38:18elementos por ejemplo si queremos
5:38:20acceder a este valor oa este valor como
5:38:23podemos hacerlo
5:38:25veamos vamos a comenzar accediendo a las
5:38:27propiedades principales del objeto mi
5:38:30reserva descripción costo e ingredientes
5:38:35recuerda que primero escribimos el
5:38:37nombre de la variable y luego el nombre
5:38:39de la propiedad en este caso descripción
5:38:42luego costos y luego ingredientes si
5:38:47abrimos la consola para ver el resultado
5:38:51podemos ver aquí en los distintos
5:38:53valores la descripción es mi postre
5:38:55favorito el costo es 15.6 y aquí el
5:38:59ingrediente es la parte clave de este
5:39:01ejemplo es que tenemos un objeto es un
5:39:05objeto anidado que corresponde a la
5:39:08propiedad ingredientes vamos a trabajar
5:39:11con este objeto así que ella podemos
5:39:14borrar estas líneas ya tenemos acceso a
5:39:17este objeto
5:39:18digamos que queremos acceder a los
5:39:20ingredientes necesarios para crear la
5:39:23masa de la receta la masa cómo podemos
5:39:27hacerlo usando notación de punto
5:39:29escribimos la propiedad que queremos
5:39:31acceder puedes ver que estamos creando
5:39:34como un camino de mi receta vamos a
5:39:37ingredientes que es la propiedad del
5:39:39objeto
5:39:40y luego vamos a la siguiente propiedad
5:39:42del objeto ni dado que es masa si
5:39:46verificamos el valor en la consola
5:39:49podemos ver aquí que es el objeto que
5:39:52corresponde a masa harina sal y agua
5:39:55harina sal y agua
5:39:59vemos el objeto que corresponde a masa
5:40:01genial ya estamos adentrándonos en la
5:40:04estructura del objeto
5:40:07una vez que tenemos ese objeto que
5:40:09corresponde a massa podemos seguir
5:40:11adentrándonos aún más podemos acceder al
5:40:14valor de harina de sal y de agua para
5:40:17saber cuánto necesitamos de cada uno
5:40:20tenemos masa vamos a acceder al valor de
5:40:25la harina y luego al valor de sal cuánta
5:40:29sal necesitamos y luego a cuánta agua
5:40:32necesitamos
5:40:34arena sal y agua
5:40:37la propiedad correspondiente
5:40:39veamos en la consola podemos ver 100
5:40:43gramos de harina una cucharadita de sal
5:40:46y una taza de agua que es exactamente
5:40:50los valores que tenemos aquí 100 gramos
5:40:52una cucharadita y una taza de agua
5:40:56genial
5:40:58hasta ahora hemos estado usando la
5:41:00anotación de punto pero también podemos
5:41:03usar la anotación de corchetes en este
5:41:06caso lo único que tenemos que hacer es
5:41:08reemplazar el punto por corchetes bar de
5:41:11corchetes y escribir la propiedad entre
5:41:14comillas dentro de los corchetes el
5:41:17resultado va a ser exactamente igual
5:41:19vamos a
5:41:21adaptarlo aquí anotación de corchetes
5:41:25cada una de estas propiedades y vas a
5:41:28ver el resultado
5:41:29100 gramos una cucharadita y una taza
5:41:32exactamente lo que teníamos antes con la
5:41:35anotación de punto así que todo funciona
5:41:38perfectamente como esperábamos la
5:41:42ventaja de usar notación de corchetes es
5:41:44que podemos escribir aquí una variable
5:41:47así que podríamos personalizar los
5:41:50valores que accedemos dependiendo del
5:41:52valor de una variable esto es muy útil
5:41:55por ejemplo si estás interactuando con
5:41:57el usuario y el usuario escoge una
5:41:58opción si quiere la cantidad de harina o
5:42:01la cantidad de azúcar la cantidad de
5:42:02chocolate podemos personalizar este
5:42:06camino que nos lleva a ese valor con
5:42:09esas variables pero solamente es
5:42:12obligatoria la anotación de corchetes
5:42:14cuando el nombre de la propiedad tiene
5:42:16un espacio y si necesitas usar una
5:42:18variable si necesitas usar la notación
5:42:20de corchetes bien veamos ahora cómo
5:42:23podemos acceder a los elementos de la
5:42:25cobertura en lugar de la masa
5:42:28vamos a borrar esta parte de la línea y
5:42:31nuevamente volvemos a ingredientes
5:42:34luego de acceder al objeto que
5:42:36corresponde ingredientes vamos a acceder
5:42:39a la cobertura con notación de punto
5:42:42veamos la consola aquí tenemos a azúcar
5:42:45chocolate y mantequilla que es el objeto
5:42:49que corresponde a cobertura una vez que
5:42:51tenemos ese objeto podemos acceder a sus
5:42:54valores vamos a hacerlo con notación de
5:42:56punto aquí tenemos a azúcar chocolate y
5:42:59mantequilla cada una de estas líneas no
5:43:02retorna el valor de la propiedad
5:43:04específica 120 gramos de azúcar 4
5:43:07cucharadas de chocolate y 200 gramos de
5:43:10mantequilla
5:43:12perfecto ya sabes cómo usar la anotación
5:43:15de punto puedes ver cómo estamos
5:43:17formando como un camino vamos a ir paso
5:43:20por paso en este camino comenzamos con
5:43:23el nombre de la variable que contiene el
5:43:25objeto principal
5:43:27luego vamos a ingredientes que es la
5:43:29propiedad que queremos acceder luego en
5:43:33cada uno de ellos accedemos a cobertura
5:43:36estamos yendo cada vez más adentro en la
5:43:38estructura de afuera hacia adentro
5:43:40y luego de cobertura accedemos a la
5:43:43propiedad que corresponde a azúcar
5:43:45chocolate y mantequilla al final para
5:43:48llegar a este valor podemos detenernos
5:43:51en cualquier punto del camino por
5:43:53ejemplo si solo necesitamos acceder al
5:43:56objeto de la cobertura podemos acceder
5:43:58al objeto art sin acceder a algunas de
5:44:01sus propiedades así verdad con este
5:44:03valor podemos trabajar en nuestro
5:44:05programa si lo necesitamos o podemos
5:44:08seguir adentrándonos en su estructura
5:44:11con notación de punto y también podemos
5:44:14usar notación de corchetes en cualquier
5:44:16punto de este camino por ejemplo
5:44:19podríamos usar aquí la notación de
5:44:21corchetes para acceder a la cobertura
5:44:23vamos a reemplazarlo en cada uno de
5:44:26estos
5:44:28de estas líneas y
5:44:31vemos exactamente los mismos valores
5:44:33porque el código funciona exactamente
5:44:36igual esto es muy útil si necesitamos
5:44:38reemplazar el valor de una variable para
5:44:41cambiar el resultado dependiendo del
5:44:43valor de la variable genial ya sabes
5:44:46acceder a cada uno de estos elementos
5:44:48vamos a cambiar nuevamente anotación de
5:44:51punto
5:44:52ahora veamos el recorrido que estamos
5:44:54haciendo mi receta ingredientes
5:44:57cobertura y luego vamos a cada uno de
5:45:00ellos azúcar chocolate mantequilla
5:45:02cuando accedamos a los elementos de la
5:45:04masa y vamos de mi receta a ingredientes
5:45:07luego a masa y harina sal y agua nos
5:45:11vamos adentrando en la estructura es muy
5:45:13importante que sepas trabajar con
5:45:15objetos anidados porque ellos son muy
5:45:18importantes para el formato jason jason
5:45:21significa javascript up the nation es un
5:45:25formato que es muy muy utilizado en
5:45:27desarrollo web así que si te interesa
5:45:30esa área o cualquier área relacionada
5:45:32con javascript va a ser muy útil saber
5:45:34cómo trabajar con objetos anidados
5:45:37comencemos con nuestro siguiente tema
5:45:46también podemos acceder a arreglos
5:45:48anidados que son las reglas que se
5:45:50encuentran dentro de estructuras más
5:45:52complejas como por ejemplo dentro de un
5:45:55objeto que es parte de un arreglo
5:45:58veamos cómo podemos acceder a sus
5:45:59elementos si definimos un arreglo que va
5:46:04a contener dos objetos con listas de
5:46:06plantas en este caso la primera
5:46:09propiedad va a ser tipo no las vamos a
5:46:12rodear con comillas pero ya va script lo
5:46:15va a ser automáticamente por nosotros
5:46:17porque solo tienen una palabra el nombre
5:46:19de la propiedad cuál va a ser nuestra
5:46:22lista de flores rosas
5:46:24tulipanes y dientes de león bien este es
5:46:29nuestro primer objeto en el arreglo
5:46:32ahora para nuestro segundo objeto vamos
5:46:35a usar las mismas propiedades vamos a
5:46:38escribirlas
5:46:40el tipo de planta va a ser árboles
5:46:44y vamos a tener una lista de árboles
5:46:46abetos
5:46:48vino
5:46:50y abedul tres árboles y aquí quitamos
5:46:54las líneas en blanco que sobra y tenemos
5:46:58nuestro arreglo de objetos estos
5:47:02arreglos más pequeños que puedes ver
5:47:04aquí son lo que llamamos los arreglos
5:47:06anidados los arreglos son parte de un
5:47:09objeto y a su vez ese objeto es parte de
5:47:12otro arreglo entonces la sintaxis que
5:47:15tenemos que usar para acceder a sus
5:47:17elementos individuales es distinta vamos
5:47:21a ver cómo podemos acceder a esos
5:47:23elementos si queremos acceder a este
5:47:27elemento por ejemplo la primera flor
5:47:30en la estructura
5:47:32vamos a crear una variable llamada
5:47:35primera flor y vamos a asignarle ese
5:47:37valor y luego le vamos a mostrar pero
5:47:40como podemos acceder a ese valor
5:47:42recuerda que la estructura principal la
5:47:44estructura que contiene a los objetos es
5:47:47un arreglo toda esta estructura es un
5:47:49arreglo cada objeto es un elemento de
5:47:52ese arreglo este objeto está en el
5:47:55índice cero y este objeto está en el
5:47:57índice 1 así que inicialmente tenemos
5:48:01que usar el índice 0 para acceder a este
5:48:03objeto que contiene este elemento al
5:48:06cual queremos acceder
5:48:08escribimos el nombre de la variable mis
5:48:12plantas
5:48:13y usamos el índice de 0 para acceder a
5:48:18este objeto luego que tenemos ese objeto
5:48:20tenemos que acceder a la propiedad
5:48:22correspondiente lista como la propiedad
5:48:25tiene una sola palabra podemos usar la
5:48:28anotación de punto aquí y accedemos a
5:48:32esta lista y luego que accedemos a esa
5:48:35lista en este momento ya tenemos este
5:48:38arreglo completo pero para acceder a la
5:48:41primera flor
5:48:43necesitamos usar su índice
5:48:45correspondiente recuerda que este
5:48:47elemento es parte de este arreglo es el
5:48:50primer elemento de la regla
5:48:53normalmente esto es un cambio en nuestra
5:48:56visión general de las estructuras porque
5:48:58normalmente estamos acostumbrados a
5:49:00trabajar con arreglos horizontalmente
5:49:03pero piensa que esto es simplemente un
5:49:05arreglo en orden vertical los espacios
5:49:08no afectan en nada es como si tuviéramos
5:49:10esto así creo que esto puede ser útil
5:49:13para que visualices la estructura así
5:49:17aquí rosa sería el primer elemento en el
5:49:20índice cero
5:49:22así que lo agregamos aquí luego de
5:49:25acceder a la lista pero normalmente en
5:49:28javascript cuando estamos usando este
5:49:30tipo de formato podemos utilizar
5:49:33esta forma de escribir el arreglo
5:49:35vertical y vemos cada uno de los
5:49:38elementos en líneas separadas
5:49:41aquí vemos cómo podemos acceder a la
5:49:44primera flor vamos a mostrarla en la
5:49:46consola
5:49:48y efectivamente tenemos el valor rosas
5:49:51la cadena de caracteres rosas repasemos
5:49:54cómo llegamos hasta rosas comenzamos con
5:49:57el nombre de la variable principal mis
5:50:00plantas que contiene el arreglo
5:50:02luego accedemos al primer objeto del
5:50:05arreglo que es este
5:50:07luego accedemos a la propiedad lista de
5:50:10ese arreglo esto
5:50:13y finalmente accedemos a el elemento en
5:50:16el índice 0 del arreglo este que tenemos
5:50:19acá y finalmente llegamos al valor rosas
5:50:22bien ahora vamos a intentarlo con otro
5:50:25elemento pero ahora vamos a acceder a
5:50:27este objeto de árboles vamos a definir
5:50:30una variable que se llame segundo árbol
5:50:33como podemos acceder al segundo árbol de
5:50:35la lista el pino
5:50:39para acceder a ese valor lo primero que
5:50:41tenemos que hacer es usar la variable
5:50:43principal luego tenemos que usar el
5:50:46índice del objeto en este caso es el
5:50:49segundo objeto de la lista así que
5:50:51usamos el índice uno aquí luego
5:50:53accedemos a la lista lista
5:50:56y finalmente usamos el índice del
5:50:59elemento en el arreglo en este arreglo
5:51:02como es el segundo elemento
5:51:04sería el índice uno aunque y esa es la
5:51:09secuencia que seguimos la variable
5:51:11principal luego el objeto
5:51:13luego su propiedad el arreglo y el
5:51:17índice que corresponde genial vamos a
5:51:19mostrar el segundo árbol en la consola y
5:51:23aquí vemos pino el segundo árbol de la
5:51:26lista efectivamente bien ahora intenta
5:51:29acceder a estos elementos abedul a
5:51:32tulipanes a dientes de león y también
5:51:35puedes intentar acceder a abetos a los
5:51:39elementos que no accedemos en el ejemplo
5:51:41puedes ver que simplemente estamos
5:51:43siguiendo un recorrido a través de la
5:51:45estructura vamos en la variable
5:51:47principal que contiene el arreglo luego
5:51:50entramos en ese arreglo a través de sus
5:51:52índices y luego vamos dentro de los
5:51:55objetos con sus propiedades y los
5:51:57valores de las propiedades
5:51:59bien ya sabes cómo acceder a un elemento
5:52:02de un arreglo anidada ya sabes cómo
5:52:05trabajar con estructuras más complejas
5:52:07en javascript
5:52:13comencemos con nuestros mini proyectos
5:52:16este medio proyecto está enfocado en
5:52:18actualizar una colección de discos vamos
5:52:22a practicar tus conocimientos de objetos
5:52:24de condicionales de cómo puedes acceder
5:52:27actualizar y eliminar las propiedades de
5:52:30un objeto y mucho más así que comencemos
5:52:33leamos esta descripción que tenemos aquí
5:52:35este comentario tenemos un objeto que
5:52:38representa parte de una colección de
5:52:40álbumes musicales cada álbum tiene un
5:52:44número de identificación único al cual
5:52:46lo vamos a llamar haití y de en inglés
5:52:50haití se refiere al número de
5:52:51identificación único este haití está
5:52:55asociado a otras propiedades con un
5:52:57objeto anidado aquí tenemos la colección
5:52:59de discos
5:53:00puedes ver que aquí tenemos un objeto
5:53:03asignado a una variable y dentro de su
5:53:06objeto tenemos dos propiedades estos
5:53:09números son digamos los haití o los
5:53:12números de identificación único de cada
5:53:14uno de esos álbumes
5:53:16esos números están asociados a objetos
5:53:19anidados que describen en más detalle el
5:53:23álbum tenemos un álbum con la data
5:53:25completa título del álbum artista y
5:53:28canciones y tenemos otro álbum que no
5:53:31tiene todas esas propiedades por eso
5:53:35aquí vemos que no todos los álbumes
5:53:36tienen la información completa
5:53:39aquí vemos una descripción de cómo debe
5:53:41ser la función define una función
5:53:44llamada actualizar discos que tome los
5:53:46siguientes parámetros va a tener cuatro
5:53:49parámetros discos que es el objeto que
5:53:52representa la colección de discos el
5:53:55aire y del disco del álbum que queremos
5:53:58modificar o con el cual queremos
5:54:00trabajar la propiedad que puede ser
5:54:03artista o canciones y el valor de esa
5:54:06propiedad
5:54:07tu mente es completar la función
5:54:09implementando las siguientes reglas para
5:54:12modificar el objeto pasado la función
5:54:15que si valor es una cadena vacía
5:54:19elimina la propiedad del álbum
5:54:21correspondiente es lo que debes hacer
5:54:23debes simplemente eliminar esa propiedad
5:54:26vamos a ir implementando cada una de
5:54:28estas reglas paso a paso pero como el
5:54:30proceso detallado
5:54:32primero vamos a definir la función
5:54:35escriba aquí function y el nombre era
5:54:39actualizar discos
5:54:42va a tener cuatro parámetros discos ay
5:54:46de
5:54:46propiedad y valor para implementar la
5:54:50primera regla tenemos que confirmar si
5:54:53el valor del parámetro valor es una
5:54:57cadena vacía
5:54:59si esto es verdadero aquí estamos usando
5:55:02el operador de igualdad estricta para
5:55:05confirmar que el valor sea igual a una
5:55:07cadena de caracteres vacía en este caso
5:55:10nos piden que eliminemos la propiedad
5:55:13que pasamos aquí como argumento y como
5:55:16hacemos esto bueno borramos la propiedad
5:55:21del álbum correspondiente
5:55:23primero accedemos al objeto que contiene
5:55:27los álbumes en este caso discos también
5:55:29la podemos llamar colección luego
5:55:32connotación de corchetes aquí estamos
5:55:35accediendo al álbum a partir de su haití
5:55:38de su número de identificación único
5:55:40esto nos va a retornar el objeto anidado
5:55:43que corresponde al álbum por ejemplo si
5:55:47el haití es este que tenemos aquí este
5:55:50sería el objeto anidado eso es lo que
5:55:53tendríamos aquí y luego nos falta
5:55:55acceder a la propiedad que especificamos
5:55:58como argumento artista o canciones o
5:56:01cualquier otra propiedad en este caso
5:56:03vamos a acceder a la propiedad y vamos a
5:56:05eliminarlo
5:56:06genial ya tenemos la primera regla
5:56:09implementada ahora vamos a la segunda y
5:56:11a la tercera regla que están
5:56:13estrechamente relacionadas
5:56:15si propiedad el valor de ese parámetro
5:56:17es igual a la cadena de caracteres
5:56:20canciones canciones pero el álbum no
5:56:24tiene esa propiedad no tiene una
5:56:27propiedad llamada canciones crea un
5:56:29arreglo vacío
5:56:31vacío y agrega valor a ese arreglo vamos
5:56:36a dar ver esto con más detalle al leerlo
5:56:39otra vez si propiedad es igual a la
5:56:42cadena de caracteres canciones significa
5:56:44que queremos trabajar con esa propiedad
5:56:46pero el álbum que especificamos si ese
5:56:49álbum no tiene una propiedad llamada
5:56:51canciones debemos crear un arreglo vacío
5:56:55y agregarle valor a ese arreglo vamos a
5:56:58crear la propiedad vamos a inicializar
5:57:00su valor a un arreglo vacío y luego
5:57:03vamos a agregar el valor a ese arreglo
5:57:05vamos a hacerlo aquí en nuestra segunda
5:57:08condición el set
5:57:11si propiedad es igual a canciones aquí
5:57:15estamos usando el operador de igualdad
5:57:17estricta vamos a implementar parte de
5:57:20esta regla porque nuestra implementación
5:57:23va a combinar la segunda y la tercera
5:57:24regla ya vas a ver aquí estamos
5:57:27accediendo al objeto correspondiente de
5:57:30la objetualidad luego accedemos a la
5:57:32propiedad canciones porque ya sabemos
5:57:34aquí que propiedad es igual a canciones
5:57:38y le asignamos un arreglo vacío luego
5:57:41para agregar el valor a ese arreglo
5:57:44vacío llamamos al método push
5:57:47y agregamos el valor que pasamos como
5:57:50argumento
5:57:51aquí vamos a tener un arreglo porque
5:57:55estamos asignando un arreglo vacío y
5:57:58luego les vamos a agregar el valor que
5:58:00va a ser el primer elemento pero hay un
5:58:02detalle no estamos verificando si el
5:58:05objeto contenía esa propiedad o no si
5:58:08canciones ya existía en el objeto o no
5:58:11por qué porque vamos a implementar la
5:58:14tercera regla en esta misma parte de
5:58:17nuestro código en esta misma cláusula la
5:58:20tercera regla dice si propiedad es igual
5:58:22a la cadena de caracteres canciones aquí
5:58:26tenemos ya esa condición que especifica
5:58:28que es igual a canciones
5:58:31y valor no es una cadena vacía
5:58:35o sea si esta condición es falsa y esta
5:58:39es verdadera
5:58:42entonces debes agregar el valor al final
5:58:45del arreglo de canciones del álbum
5:58:47correspondiente
5:58:49lo que esto no estoy diciendo es
5:58:51simplemente que si queremos agregar una
5:58:53canción a la lista de canciones y esa
5:58:56propiedad ya existe en el álbum
5:58:58correspondiente debemos agregar ese
5:59:00valor al final del arreglo del álbum que
5:59:03corresponde claro lo que vamos a hacer
5:59:06en este caso va a ser usar una sintaxis
5:59:08que es concisa y fácil de usar en
5:59:10javascript pero que es nueva no la hemos
5:59:13visto hasta ahora en el curso aquí la
5:59:16tenemos que debe resultar familiar este
5:59:19operador
5:59:20este es el operador lógico ahora lo que
5:59:22este operador nos permite hacer es
5:59:24escoger entre dos opciones primero se va
5:59:27a intentar acceder a esa propiedad en el
5:59:29álbum correspondiente con esta parte de
5:59:32la expresión si ese valor no es anti
5:59:35find
5:59:37este va a ser el valor resultante y se
5:59:39va a asignar a la propiedad o sea se va
5:59:42a mantener intacto la lista de canciones
5:59:44pero si este valor es anti find el
5:59:48operador over nos permite como
5:59:50especificar un valor de respaldo que en
5:59:53este caso va a ser un arreglo vacío esto
5:59:57nos permite evitar el caso en el que
5:59:59podamos intentar llamar a un método o
6:00:01usar ese valor y sea aún diferente ese
6:00:04valor lo que va a generar un error si
6:00:07este valor es dónde find vamos a tener
6:00:10un arreglo vacío que sirve como un
6:00:12respaldo con un arreglo vacío aquí si
6:00:15vamos a poder llamar al método push de
6:00:18forma segura y agregar ese valor no
6:00:20vamos a tener ningún error así ya
6:00:23estamos cubriendo la segunda y la
6:00:25tercera regla si este valor no es anti
6:00:28find lo asignamos y luego le agregamos
6:00:31el valor y si este valor es handy find
6:00:34entonces asignamos un arreglo vacío como
6:00:37el valor inicial y le agregamos su valor
6:00:40bien ahora podemos con la cuarta y
6:00:43última regla si valor no es una cadena
6:00:46vacía o sea si esta condición es falsa y
6:00:51propiedad no es igual a la cadena de
6:00:54caracteres canciones asigna el valor del
6:00:57parámetro valor a la propiedad si la
6:01:01propiedad no existe debes crearla y
6:01:03asignar este valor todo esto lo podemos
6:01:06implementar simplemente con la cláusula
6:01:08euros que sirve como respaldo porque
6:01:12debemos realizar esto si ambas
6:01:14condiciones son falsas y en ese caso qué
6:01:17es lo que vamos a hacer vamos a
6:01:19asignar el valor a la propiedad con esta
6:01:24línea simplemente lo que estamos
6:01:27haciendo aquí es tomando el valor y lo
6:01:29asignamos a la propiedad del álbum
6:01:31específico si la propiedad no existe se
6:01:35va a crear y si ya existe se va a
6:01:37actualizar así que estamos cubriendo
6:01:39esos casos posibles
6:01:41bien ahora vamos a
6:01:44probar nuestra función llamándola
6:01:47primero vamos a acceder a la propiedad
6:01:50título del álbum de la colección de
6:01:53discos vamos a acceder a la propiedad
6:01:56título del álbum del álbum
6:01:58correspondiente en la colección de
6:02:01discos vamos a acceder a esa propiedad
6:02:03antes de hacer el cambio y después
6:02:06aquí estamos llamando a la función
6:02:08actualizar discos pasamos como argumento
6:02:12la colección de discos en este caso no
6:02:15lo estamos usando como una variable
6:02:17global sino que la estamos pasando como
6:02:19argumento pasamos el ai 17 8 5 3 que
6:02:23corresponde aquí al álbum de los vikings
6:02:277 853
6:02:29pasamos el nombre de la propiedad que
6:02:32queremos actualizar título del álbum y
6:02:34el valor es una cadena vacía porque
6:02:36vamos a probar esta primera condición
6:02:38esta línea debería permitirnos borrar
6:02:42esa propiedad título del arco así que
6:02:44aquí el resultado debería ser dónde find
6:02:47vamos a ver y aquí lo podemos ver
6:02:50bitches quest es el título del álbum al
6:02:54principio y luego tenemos a different
6:02:56porque borramos esa propiedad
6:02:59bien ahora actualizamos esto al otro
6:03:02álbum 5 439 de abba gold
6:03:06cambiamos aquí el haití del álbum y
6:03:09vamos a probar la segunda condición si
6:03:13la propiedad es igual a canciones veamos
6:03:16qué ocurre
6:03:17vamos a agregar la canción
6:03:20mamma mía
6:03:22actualmente el objeto al principio no
6:03:24tiene una propiedad canciones aquí lo
6:03:27puedes ver solo tiene un título del
6:03:29álbum así que nuestra función debería
6:03:33asignar un arreglo vacío y luego agregar
6:03:36el valor que en este caso es mamá mía a
6:03:39esa propiedad
6:03:41para ver la propiedad de canciones vamos
6:03:45a cambiar la anotación de punto aquí y
6:03:47veamos la consola
6:03:49exactamente lo que esperábamos primero
6:03:51vemos donde find porque la propiedad
6:03:53canciones no existía y luego vemos un
6:03:56arreglo con el valor mamá mía
6:03:59vamos a seguir trabajando con el álbum 5
6:04:02439 y en este caso vamos a asignar el
6:04:07artista que va a ser el grupo abba
6:04:11bien vamos a cambiar aquí la propiedad
6:04:14para poder verla en la consola y lo que
6:04:18esperábamos de dónde find la propiedad
6:04:21de artista pasó a ser haba antes no
6:04:24existía y aquí la estamos agregando con
6:04:26la cláusula euros que sirve como un
6:04:29respaldo bien buen trabajo ya
6:04:32completamos nuestro mini proyecto y
6:04:35prácticas de cómo trabajar con funciones
6:04:37parámetros argumentos condicionales como
6:04:40eliminar una propiedad de un objeto cómo
6:04:42acceder a una propiedad aprendí esto
6:04:45esta nueva sintaxis que nos permite
6:04:47asignar un valor que sirva como respaldo
6:04:50si este valor es aun de find y
6:04:53trabajamos también con todas las
6:04:54cláusulas de un condicional infeliz y
6:04:56else buen trabajo hasta ahora durante el
6:04:59curso y felicitaciones por llegar hasta
6:05:01este mini proyecto pasemos a nuestro
6:05:03siguiente tema
6:05:10ya sabes cómo trabajar con objetos en
6:05:12javascript este es un tema muy
6:05:14importante así que ahora vamos a pasar a
6:05:17otro aspecto del lenguaje de
6:05:19programación que nos va a permitir
6:05:20escribir programas muy poderosos mucho
6:05:24más poderosos de los que hemos podido
6:05:26escribir hasta ahora estos son los
6:05:28ciclos o bucles los ciclos o bucles nos
6:05:31permiten repetir una secuencia de
6:05:34instrucciones un número específico de
6:05:36veces tenemos dos tipos de ciclos ciclos
6:05:39o bucles while y ciclos o bucles faure
6:05:43vamos a comenzar viendo los ciclos web
6:05:45en español traducimos el término a ciclo
6:05:49o bucle se usan de forma prácticamente
6:05:53equivalente en inglés el término
6:05:55original se denomina el loop yo
6:05:59normalmente me voy a referir a ellos
6:06:01como ciclos pero bucles también es una
6:06:03traducción muy muy aceptada y se usa de
6:06:05forma equivalente
6:06:07vamos a hablar sobre los ciclos web los
6:06:10ciclos wayne se usan cuando no tenemos
6:06:14un número específico de iteraciones una
6:06:17instalación es una repetición del bloque
6:06:19de código que queremos repetir cuando no
6:06:22sabemos el número específico de
6:06:24iteraciones que queremos realizar pero
6:06:26si sabemos qué es lo que tiene que ser
6:06:29cierto para continuar el proceso usamos
6:06:33un ciclo web hasta este momento con lo
6:06:36que has aprendido cómo mostraría un
6:06:38mensaje tres cuatro o cinco veces en la
6:06:42consola por ejemplo el mensaje hola
6:06:44mundo me imagino que lo que harías hasta
6:06:46este momento es escribir con su punto lo
6:06:50con el mismo mensaje tantas veces como
6:06:53quieres mostrar el mensaje pero puedes
6:06:55ver que rápidamente esto no va a ser
6:06:58práctico porque por ejemplo si
6:07:00quisiéramos repetir este mensaje 20
6:07:03veces tendríamos que tener 20 líneas
6:07:07para algo tan sencillo como mostrar un
6:07:09mensaje o hacer una tarea repetitiva
6:07:12no deberíamos tomar tantas líneas que
6:07:14van a hacer que nuestro código sea casi
6:07:16imposible de leer e ineficiente para
6:07:19escribir imagínate los programas mucho
6:07:21más complejos que controlan funciones
6:07:23muchísimos más complejas para eso para
6:07:27evitarnos todo este problema de repetir
6:07:28código tenemos los ciclos web nos
6:07:32permiten escribir ese código simplemente
6:07:35con una estructura específica y
6:07:37repetirlo vamos a definir una variable y
6:07:40igual a cero le asignamos ese valor
6:07:44y decimos while esta es la palabra clave
6:07:47que usamos para definir un ciclo while
6:07:51dentro de los paréntesis tenemos que
6:07:53escribir la condición que tiene que ser
6:07:56verdadera para continuar el proceso
6:08:00puedes pensarlo así la palabra while
6:08:02significa en español mientras
6:08:05entonces diríamos mientras esta
6:08:08condición sea verdadera ejecutamos el
6:08:11código que va a estar entre llaves
6:08:13digamos que por ejemplo mientras sea
6:08:16menor o igual que 3 entonces vamos a
6:08:19mostrar un mensaje cual mensaje va a ser
6:08:23con su punto lo hola mundo pero tenemos
6:08:27que hacer una pequeña actualización aquí
6:08:30vamos a explicar todos estos elementos
6:08:32esta es la condición que tiene que ser
6:08:34verdadera para que estas líneas de
6:08:36código se repitan un número de veces
6:08:40en el momento en que la condición sea
6:08:42falsa y se vuelva a evaluar el proceso
6:08:45se detiene
6:08:46como inicialmente cero esta condición es
6:08:50verdadera y estas líneas se van a
6:08:52ejecutar
6:08:53mostramos el mensaje e incrementamos el
6:08:56valor de i porque si no si dejamos el
6:08:59valor de ir siempre en cero
6:09:01esta condición siempre va a ser
6:09:02verdadera y nunca se va a detener el
6:09:04proceso claro en teoría en la práctica
6:09:07normalmente podemos detener esos ciclos
6:09:10que se llaman ciclos infinitos que no se
6:09:13detienen por lógica del programa
6:09:16por eso tenemos que actualizar la
6:09:19variable y la estamos incrementando así
6:09:22que eventualmente esta condición va a
6:09:24ser falsa y el proceso se va a detener
6:09:26se evalúa la condición cada vez que
6:09:28vamos a repetir el código sigue siendo
6:09:31verdadera si es verdadera este código se
6:09:33ejecuta sigue siendo verdadera este
6:09:36código se ejecuta sigue siendo verdadera
6:09:39este código se ejecuta y luego si es
6:09:42falsa ya el código no se ejecuta y se
6:09:46continúa el proceso normal más allá del
6:09:49ciclo pues si tuviéramos líneas de
6:09:51código aquí se ejecutaría luego de que
6:09:54el ciclo terminará veamos la consola
6:09:57para que veas aquí podemos ver son
6:10:00cuatro veces que se ejecuta el código
6:10:02porque la condición sigue siendo
6:10:06verdadera hasta que el valor de iu sea
6:10:08mayor que 3
6:10:10en la primera instalación el valor es
6:10:12cero se ejecuta este código y se muestra
6:10:14esta línea luego se incrementa el valor
6:10:17de y ahora el valor de iu es 1 sigue
6:10:21siendo menor o igual que 3 se ejecuta
6:10:23este código se muestra por segunda vez y
6:10:26se incrementa el valor de y ahora el
6:10:28valor de iu es 2 este código se ejecuta
6:10:312 y se incrementa el valor de iu y luego
6:10:35como el valor de estrés esta es la
6:10:38última repetición que se ejecuta se
6:10:40incrementa el valor de iu a 4 y en ese
6:10:44punto ya la condición es falsa
6:10:46el proceso se detiene eso es básicamente
6:10:49la lógica de un ciclo uruguay mientras
6:10:52la condición sea verdadera el proceso
6:10:54continúa y apenas sea falsa el proceso
6:10:56se detiene y puedes ver lo poderoso que
6:10:58puede ser esto porque en este caso
6:11:01estamos repitiendo los 4 veces nada más
6:11:03pero si necesitáramos repetirla por
6:11:05ejemplo 15 veces aquí puedes ver la
6:11:08cantidad de líneas de código que nos
6:11:10estamos ahorrando usando un ciclo
6:11:13gracias a los ciclos podemos escribir
6:11:15programas mucho más poderosos veamos
6:11:18otro ejemplo de un ciclo web vamos a
6:11:21definir una variable llamada mía regla y
6:11:24también vamos a declarar una variable y
6:11:26vamos a mostrar el valor inicial del
6:11:29arreglo en la consola y luego vamos a
6:11:33ejecutar un ciclo while que queremos
6:11:36hacer queremos agregar los números entre
6:11:380 y 9 a este arreglo como lo podemos
6:11:42hacer con un ciclo while fácilmente
6:11:45mientras y sea menor que 10 que es lo
6:11:50que queremos hacer queremos agregar ese
6:11:53valor
6:11:55al arreglo usamos el método push
6:11:58y le vamos a agregar ese elemento a mi
6:12:01arreglo el valor y y luego aumentamos o
6:12:05incrementamos el valor de y es
6:12:08importante incrementar el valor de que
6:12:10veamos cuál es el resultado aquí vemos
6:12:12que no tenemos un resultado porque
6:12:15piensa porque no tenemos el resultado
6:12:17porque el arreglo sigue siendo un
6:12:20arreglo vacío
6:12:21porque el valor inicial de iu no está
6:12:24definido si nosotros inicializa mos el
6:12:27valor de y a cero podemos incrementar lo
6:12:30de uno en uno como estamos haciendo aquí
6:12:33y así vamos a añadir cada uno de estos
6:12:35elementos entre 0 y 9
6:12:38inicialmente es un arreglo vacío y luego
6:12:41de ejecutar este ciclo el arreglo tiene
6:12:44estos elementos cómo funciona el proceso
6:12:47inicialmente el valor de i es cero así
6:12:51que se ejecuta esta línea que agrega el
6:12:53valor de y el valor cero al arreglo y
6:12:57luego se incrementa el valor de y a 1 1
6:13:00sigue siendo menor que 10 así que se
6:13:03ejecutó otra vez esta línea y se agrega
6:13:05el valor 1 se incrementa el valor de iu
6:13:07a 2 y como 2 sigue siendo menor que 10
6:13:11se agrega el valor 2 al arreglo y se
6:13:14vuelve a incrementar y así sucesivamente
6:13:16hasta que la condición sea falsa cuando
6:13:19llegamos a este punto del ciclo el valor
6:13:23de y es 9 se agrega ese valor al arreglo
6:13:26y luego se incrementa ese valor a 10
6:13:29cuando llega a 10 esta condición ya no
6:13:33es verdadera porque estamos usando un
6:13:35operador que compara si y es
6:13:37estrictamente menor que díaz esa
6:13:40condición si es 10 sería falsa y
6:13:43continuamos a esta línea porque ya el
6:13:46ciclo terminó y se muestra el arreglo
6:13:49este es un detalle que siempre tienes
6:13:51que tener presente cuando escribas
6:13:53ciclos while los operadores que uses
6:13:55para las condiciones van a determinar
6:13:58cuántas iteraciones se van a realizar si
6:14:01nosotros cambiamos este operador por el
6:14:03operador menor o igual que se va a
6:14:05ejecutar una iteración más veamos el
6:14:08resultado
6:14:09aquí puedes ver que ahora si se incluye
6:14:11el valor 10 porque cuando el valor de y
6:14:15es 10 está condición sigue siendo
6:14:17verdadera y se ejecuta el código una vez
6:14:20más cuando llega a 11 ya esta condición
6:14:23es falsa y el proceso se detiene así que
6:14:26tienes que escoger estos operadores de
6:14:29comparación
6:14:30cuidadosamente cuando trabajas con los
6:14:33ciclos while
6:14:34veamos otro ejemplo si tenemos un
6:14:37arreglo de números
6:14:39que contiene de los números 2 3 4 5 6 8
6:14:449 y 34 una secuencia de números y usamos
6:14:48un ciclo un peón para quitar ciertos
6:14:50números de ese arreglo es la condición
6:14:53podemos usar en la longitud o el tamaño
6:14:57del arreglo
6:14:58decimos mientras la longitud del arreglo
6:15:01sea mayor que 4 queremos continuar el
6:15:04proceso o sea que se va a detener cuando
6:15:07la longitud sea menor o igual a 4 y qué
6:15:11va a ocurrir en cada iteración se va a
6:15:13remover el último elemento de la regla y
6:15:16cuando queden cuatro elementos el
6:15:18proceso se va a detener si mostramos el
6:15:21arreglo luego de este proceso puedes ver
6:15:24que sólo quedan cuatro elementos 2 3 4 y
6:15:285 que son los primeros 4 elementos
6:15:31los otros 4 elementos al final del
6:15:33arreglo fueron eliminados con el método
6:15:36para bien esta fue la introducción a
6:15:39cómo funciona el ciclo while en
6:15:41javascript es muy importante que
6:15:43recuerdes actualizar las variables para
6:15:46que esta condición en algún momento sea
6:15:48falsa si esta condición nunca es falsa
6:15:52en el proceso en teoría nunca se va a
6:15:54detener así que continuemos porque ahora
6:15:57tenemos que ver el segundo tipo de ciclo
6:15:59bucle el ciclo farc en javascript
6:16:07ahora veamos el ciclo bucle for en
6:16:10javascript y cómo funciona usamos el
6:16:14ciclo for cuando sabemos cuántas
6:16:16iteraciones van a ser necesarias y el
6:16:18ciclo for nos actualiza de esa variable
6:16:21que antes teníamos que actualizar
6:16:23nosotros mismos con el ciclo web la
6:16:26actualiza automáticamente
6:16:28ya vas a ver aquí tenemos un ejemplo
6:16:31vamos a hacer algo equivalente a lo que
6:16:34hicimos con el ciclo web agregar los
6:16:36números desde el 0 hasta el 9 a un
6:16:38arreglo pero con el ciclo force la forma
6:16:41de escribir el código es un poco
6:16:43diferente aquí tenemos la palabra clave
6:16:46for por eso suele llamar los ciclos
6:16:48fuera la secuencia de instrucciones
6:16:51entre llaves que se van a repetir se
6:16:53denominan el cuerpo del ciclo que vamos
6:16:55a escribir aquí en lugar de escribir una
6:16:58condición como escribíamos en el ciclo
6:17:00web
6:17:01para un ciclo forma tenemos que
6:17:04especificar tres aspectos de cómo va a
6:17:07ejecutarse el ciclo
6:17:10lo primero que tenemos que hacer es
6:17:12inicializar el valor de una variable que
6:17:16se va a usar y actualizar en el ciclo
6:17:19por ejemplo si inicialmente nosotros
6:17:21queremos trabajar con una variable i y
6:17:25su valor inicial va a ser cero
6:17:27escribimos esto aquí con barack y esto
6:17:29también puede ser led recuerda que
6:17:32cuando vemos cómo se puede declarar una
6:17:34variable puede observar o puede ser led
6:17:36o puede ser como en un ciclo puede ser
6:17:39bar o led y la diferencia es donde va a
6:17:42estar definida esta variable esta es la
6:17:45primera parte de las condiciones de
6:17:47forma que determina cómo va a iniciar el
6:17:49valor de esta variable que se llama la
6:17:51variable del ciclo en inglés la
6:17:54llamaríamos luke pero con la variable
6:17:57del ciclo esa variable es la que va a
6:17:59decidir si el ciclo se continúa
6:18:01ejecutando o no aquí luego separado por
6:18:04un punto y coma tenemos la condición que
6:18:07va a decidir
6:18:09ciclo continúa o no mientras sea menor
6:18:13que 10 el ciclo va a continuar y luego
6:18:18separado otra vez por un punto y coma y
6:18:20un espacio tenemos que decirle a
6:18:22javascript cómo queremos actualizar esa
6:18:25variable en cada tracción por ejemplo si
6:18:28queremos incrementar el valor de i en 1
6:18:31escribimos y + + entonces básicamente
6:18:35eso es lo que tenemos aquí como iniciar
6:18:38el valor de la variable cuál es la
6:18:40condición que va a permitir que el ciclo
6:18:43se continúe ejecutándose y como
6:18:45actualizamos el valor de la variable
6:18:47bien qué vamos a hacer en el cuerpo del
6:18:51ciclo
6:18:52vamos a añadir el valor de ir al arreglo
6:18:56en este ejemplo
6:18:58desde 0 hasta 9 y vamos a mostrar el
6:19:02arreglo aquí puedes ver que tenemos los
6:19:05números desde 0 hasta 9 así que lo que
6:19:08escribimos es equivalente a nuestro
6:19:10ejemplo anterior con un ciclo while la
6:19:13ventaja que tienen los ciclos por es que
6:19:15podemos especificar todas las
6:19:17condiciones importantes para el ciclo
6:19:19aquí tenemos el valor inicial de la
6:19:22variable del ciclo tenemos la condición
6:19:25que tiene que ser verdadera para que el
6:19:27ciclo continúe ejecutándose y también
6:19:30tenemos aquí lo que queremos hacer con
6:19:33esa variable cada vez que comience una
6:19:36iteración o cada vez que termine una
6:19:38iteración es equivalente
6:19:39queremos en este caso incrementar el
6:19:41valor de iu en uno pero no
6:19:43necesariamente tenemos que incrementar
6:19:45este valor de uno en uno podemos
6:19:47incrementar lo en otro valor
6:19:49en este caso escribiríamos algo así le
6:19:52asignamos a la variable y más 2
6:19:55veamos el resultado aquí vemos 0 2 4 6 y
6:20:008
6:20:01inicialmente era 0 luego fue 2 4 6 y 8 y
6:20:05cuando la condición esta condición es
6:20:08falsa el ciclo se detiene en este caso
6:20:11después de 8 se sumó 2 era 10 y como
6:20:15estamos usando comparación estricta esta
6:20:17condición era falsa
6:20:19pero hay una forma más compacta de
6:20:21escribir esto recuerda que operador
6:20:23podemos usar también podemos usar este
6:20:26operador aquí incrementamos el valor
6:20:29actual de iu en 2 y lo asignamos a la
6:20:31variable y aquí podemos ver el resultado
6:20:34exactamente el mismo pero escribimos
6:20:36esto de una forma más concisa podemos
6:20:39usar cualquier operador para esta
6:20:41condición cualquier operador de
6:20:43comparación operadores normalmente esta
6:20:46condición involucra a la variable del
6:20:48ciclo pero no necesariamente tenemos que
6:20:51usar la variable del ciclo en el ciclo
6:20:54en el cuerpo de ciclo por ejemplo si
6:20:56queremos simplemente agregar un valor
6:20:58fijo
6:21:00también podemos hacerlo aquí puedes ver
6:21:02que se agrega ese valor una vez por cada
6:21:05iteración
6:21:06esto sólo para ilustrar que no necesitas
6:21:09usar el valor de iu en el ciclo
6:21:10necesariamente pero está allí para
6:21:13ayudar a javascript a decidir si el
6:21:15ciclo debería continuar o no genial ya
6:21:18sabes lo básico de los ciclos while los
6:21:20ciclos forest vamos a ver algunos
6:21:22ejemplos en los próximos temas
6:21:29veamos un ejemplo con el ciclo bucle
6:21:33form lo primero que tenemos que hacer es
6:21:36declarar el arreglo en ya busquets
6:21:39porque vamos a guardar los números
6:21:42impares en ese arreglo vamos a tener los
6:21:45números impares entre 1 y 19 inclusive
6:21:49como lo podemos hacer con un ciclo forma
6:21:52veamos cómo podemos escribir las
6:21:53condiciones aquí queremos iniciar con un
6:21:56valor de igual a 1 así que escribimos
6:21:59exactamente eso aquí inicialmente iba a
6:22:03ser 1 y queremos continuar mientras el
6:22:05valor de y sea menor que 20
6:22:09estrictamente menor que 20 que sería
6:22:12equivalente a escribir menor o igual que
6:22:1419
6:22:15pero normalmente podríamos usar también
6:22:1820 y qué queremos hacer para obtener los
6:22:21números impares si tenemos el número 1
6:22:24para obtener el siguiente número impar
6:22:27tendríamos que sumar 2 que sería teatres
6:22:30del resultado si tenemos tres tendremos
6:22:33que sumar dos para obtener cinco y así
6:22:36sucesivamente
6:22:37así que lo que podemos hacer es
6:22:40actualizar el valor de la variable
6:22:42incrementando lo en dos por cada
6:22:45iteración y así vamos a tener un valor
6:22:48impar para y en cada iteración
6:22:51comenzando en 1 y luego incrementando de
6:22:54dos en dos que vamos a hacer aquí vamos
6:22:58a agregar ese número con el método push
6:23:01al arreglo al final del arreglo el
6:23:05número contenido en la variable
6:23:08luego de ejecutar este ciclo vamos a
6:23:12mostrar el arreglo en la consola a ver
6:23:14que obtenemos aquí podemos ver todos los
6:23:17números impares entre 1 y 19 genial con
6:23:21solo tres líneas podemos hacer lo que
6:23:23nos tomaría muchísimas líneas para
6:23:25escribir en ya busquets y solamente con
6:23:28tres líneas hicimos exactamente
6:23:29actualmente eso y podemos expandir
6:23:32nuestro código digamos que queremos
6:23:34todos los números impares desde uno
6:23:37hasta digamos 50 aquí los puedes ver
6:23:41veamos el resultado puedes ver que
6:23:44tenemos todos los números impares que
6:23:46cumplen esa condición es muy fácil
6:23:49realizar operaciones más complejas sin
6:23:51escribir más líneas de código y también
6:23:53podemos realizar procesos de forma más
6:23:55eficiente un reto interesante que quizás
6:23:58te gustaría realizar es escribir un
6:24:00ciclo for que agregue los números pares
6:24:03entre 2 y 26 a un arreglo
6:24:06te dejo este ejercicio por si quieres
6:24:08intentarlo
6:24:09así que pasemos a nuestro siguiente tema
6:24:19también podemos contar hacia atrás con
6:24:21un ciclo o bucle form
6:24:24veamos cómo podemos hacerlo hasta ahora
6:24:26habíamos incrementado el valor de i de
6:24:29la variable del ciclo pero ahora también
6:24:31podemos de reducir su valor veamos cómo
6:24:35podemos hacerlo tenemos un ejemplo de un
6:24:38ciclo fuerte el valor inicial de iba a
6:24:40ser 15 y vamos a continuar ejecutando el
6:24:45ciclo mientras el valor de iu sea mayor
6:24:48o igual a 10
6:24:50esa es la condición que tiene que ser
6:24:52verdadera para que el proceso se sigue
6:24:55ejecutando
6:24:56pero no está aquí algo interesante el
6:25:00valor inicial de i es mayor que el valor
6:25:03que debería ser el valor final de y para
6:25:06detener el proceso por eso tenemos que
6:25:11ir reduciendo el valor de ir y cómo lo
6:25:13podemos hacer así como incrementamos el
6:25:16valor de y en 1 cada vez interacción e
6:25:19interacción podemos reducirlo en uno
6:25:21cada iteración vamos a ver el resultado
6:25:25en cada interacción vamos a mostrar el
6:25:27valor de iu en la consola abramos la
6:25:30consola aquí lo podemos ver 15 14 13 12
6:25:3511 y 10
6:25:37mientras el valor de iu es mayor o igual
6:25:40a 10 el proceso continúa y el valor de y
6:25:44se va reduciendo de uno en uno cuando el
6:25:47valor de ya es menor que 10 porque ya se
6:25:51mostró el valor 10 aquí entonces para la
6:25:53próxima iteración el valor de y sería 9
6:25:56cuando el 9 ya esta condición es falsa
6:26:00así que el proceso se detiene y eso es
6:26:03básicamente lo que pasa cuando
6:26:05ejecutamos este programa también tenemos
6:26:08otra opción en lugar de reducir este
6:26:10valor de un 1 podemos reducirlo de dos
6:26:12en dos también es otra opción
6:26:15podríamos ir del valor 15 al valor 13 y
6:26:20luego al valor 11 y aquí se detendría el
6:26:23proceso porque 11 menos 2 sería 9 y ya
6:26:27esta condición sería falsa para la
6:26:29próxima iteración
6:26:30como veis podemos actualizar el valor de
6:26:33iu como queramos podemos también
6:26:35multiplicarlo por 2 o dividirlo entre 2
6:26:37bien veamos un ejemplo con un arreglo
6:26:41vamos a definir un arreglo aquí a
6:26:43crearlo y a este arreglo le vamos a
6:26:46agregar ciertos valores
6:26:48cuáles valores bueno y el valor inicial
6:26:51de iu va a ser igual a díaz y queremos
6:26:54continuar el proceso mientras sea mayor
6:26:57que 0 puedes ver que el valor inicial de
6:26:59i es mayor que su valor final así que
6:27:02tenemos que reducir el valor de iu para
6:27:05que no tengamos un ciclo infinito como
6:27:08lo vamos a hacer vamos a reducir el
6:27:10valor de y de dos en dos en cada
6:27:12iteración y así vamos a poder agregar
6:27:16estos valores al arreglo y los mostró en
6:27:19la consola
6:27:21aquí podemos ver el resultado 10 8 6 4 y
6:27:262 se va reduciendo de dos en dos y
6:27:30cuando ya el valor en la próxima
6:27:32iteración sería cero dos menos dos como
6:27:36actualizamos la variable sería cero ya
6:27:39esta condición es falsa así que no hay
6:27:41una próxima iteración y allí se detiene
6:27:44el proceso
6:27:46genial ya hemos visto cómo puedes
6:27:49trabajar con los ciclos for y definir
6:27:51distintas condiciones siempre tienes que
6:27:54estar muy pendiente de este operador que
6:27:57estás usando aquí está condición
6:27:59determinar cuántas iteraciones se van a
6:28:02realizar y si usas un operador estricto
6:28:05aquí el resultado los números de
6:28:07iteraciones puede ser distinto aquí
6:28:10puedes ver solo con usar este operador
6:28:13ya estamos realizando una iteración más
6:28:15porque cuando el valor es igual a cero
6:28:18también está con verdadera y se realiza
6:28:21una iteración adicional en el ciclo buen
6:28:24trabajo pasemos a nuestro siguiente tema
6:28:33también puedes usar los ciclos for para
6:28:36enterar sobre un arreglo y tener sobre
6:28:39un arreglo significa que vas a obtener
6:28:41cada uno de los elementos de ese arreglo
6:28:44y los vas a poder usar en el cuerpo del
6:28:48ciclo ya vas a poder hacer algo con cada
6:28:50uno de los elementos de ese arreglo
6:28:52vamos a ver un ejemplo definimos este
6:28:55arreglo que inicialmente va a tener los
6:28:58valores 4 6 8 y 2 los mismos principios
6:29:02que vas a ver ahorita aplican para
6:29:04cualquier tipo de datos que puedas tener
6:29:06aquí para cualquier tipo de elementos
6:29:09incluyendo objetos incluyendo cadenas de
6:29:12caracteres incluyendo arreglos anidados
6:29:15y cualquier otro tipo de datos vamos en
6:29:18este caso vamos a sumar todos estos
6:29:21valores usando un ciclo y el total de la
6:29:24suma la vamos a acumular e ir acumulando
6:29:26en esta variable total que inicialmente
6:29:29tiene un valor cero veamos como
6:29:31escribimos este ciclo fuera para sumar
6:29:34todos los valores tenemos que ir
6:29:36acumulando cada uno de estos valores en
6:29:38el total
6:29:40para eso vamos a tener que acceder a
6:29:42cada uno de esos valores en una
6:29:44iteración del ciclo vamos a necesitar
6:29:47cuatro iteraciones porque tenemos cuatro
6:29:50elementos
6:29:51inicialmente el valor de i va a ser cero
6:29:54la variable del ciclo porque vamos a
6:29:57usar la variable y como índice el índice
6:30:00del arreglo recuerda que los índices de
6:30:03los arreglos comienzan desde cero y
6:30:06luego se incrementan 0 1 2 y 3 así que
6:30:10vamos a comenzar con cero y cuál va a
6:30:13ser la condición para que el proceso
6:30:15siga
6:30:16mientras el valor de iu sea
6:30:19estrictamente menor que la longitud o el
6:30:23tamaño del arreglo sea mientras i sea un
6:30:27índice válido porque es menor que la
6:30:30longitud del arreglo
6:30:32entonces vamos a continuar el proceso y
6:30:35vamos a incrementar el valor de iu en 1
6:30:38antes de la próxima iteración porque
6:30:41aquí tenemos un operador estricto un
6:30:44operador de comparación estricta y no
6:30:47puede ser igual el tamaño del arreglo
6:30:49porque estamos comenzando a contar desde
6:30:51cero recuerde que los índices comienzan
6:30:54desde cero entonces el último índice va
6:30:58a ser la longitud del arreglo menos uno
6:31:00ese es el último índice válido para ese
6:31:04arreglo por eso es que estamos usando
6:31:06este operador estricto si usáramos el
6:31:08operador menor e igual que cuando if sea
6:31:12igual que la longitud no está definido
6:31:14ese índice para ese arreglo vamos a
6:31:17implementar qué es lo que va a ser el
6:31:19ciclo vamos a agregar un valor a la
6:31:22variable total con este operador vamos a
6:31:25sumar el valor en el índice y del
6:31:29arreglo aquí puedes ver que estamos
6:31:31usando la variable del ciclo y que
6:31:34inicialmente cero
6:31:36así que inicialmente este valor va a ser
6:31:39el valor que está en el índice cero
6:31:42este número cuatro luego para la
6:31:45siguiente iteración la variable y se va
6:31:47a actualizar este elemento luego va a
6:31:50ser el número seis y así sucesivamente
6:31:53en la variable y para la próxima
6:31:56iteración va a ser 2 el número 8 va a
6:31:59corresponder a esta parte y luego el
6:32:02número 2 para cada declaración vamos a
6:32:04ir acumulando esos números en el total y
6:32:07podemos mostrar el total en la consola
6:32:10luego del proceso aquí tenemos el número
6:32:1320 4 6 10 + 8 18 + 220 y esto es
6:32:18exactamente lo que ocurrió podemos verlo
6:32:21con más detalle lo que ocurre en el
6:32:24ciclo si usamos con su punto log dentro
6:32:27del ciclo vamos a mostrar el valor de y
6:32:30vamos a mostrar el valor de mi arreglo
6:32:34en el índice i
6:32:36antes para separarlo vamos a colocar un
6:32:39mensaje iteración y vamos a concatenar
6:32:42lo con el valor de y vamos a mostrar
6:32:45iteración 0 iteración una iteración 2
6:32:48bitter acción 3 el número va a
6:32:50corresponder al valor de i y aquí vamos
6:32:53a ver el elemento que vamos a acumular
6:32:55es el elemento que estamos usando aquí
6:32:58que vamos a abrir la consola y vemos
6:33:01esto aquí iteración 0 cuando el valor de
6:33:04y es igual a 0
6:33:05tenemos 4 iteración 1 el valor es 6 que
6:33:10es el segundo elemento iteración 2 el
6:33:12elemento es 8 y iteración 3
6:33:16el elemento 2 finalmente todo se suma y
6:33:19vemos el total que es 20 aquí estamos
6:33:22empezando a contar desde cero porque
6:33:24quería mostrarte el valor de la variable
6:33:27y para cada trazo usar con su punto love
6:33:30dentro del ciclo es muy útil para
6:33:32entender cómo funciona y cómo se van
6:33:35actualizando los valores a medida que se
6:33:38ejecutan las iteraciones te recomiendo
6:33:40totalmente usar con su punto long dentro
6:33:43de un ciclo
6:33:44si quieres visualizar cómo funciona
6:33:47genial veamos otro ejemplo
6:33:49reiterar sobre un arreglo digamos que
6:33:52tenemos un arreglo de cadenas de
6:33:54caracteres que representan lenguajes de
6:33:57programación ya los que payton
6:34:00jabón y sep los flash vamos a escribir
6:34:04este nombre lenguaje vamos a asignarle
6:34:07ese nombre a la variable pero también
6:34:10puedes llamarla lenguajes de
6:34:11programación digamos que queremos
6:34:13mostrar cada una de esas cadenas en
6:34:16mayúscula queremos convertir todos sus
6:34:18caracteres a mayúsculas entonces lo que
6:34:21podemos hacer es integrar sobre el
6:34:23arreglo porque queremos hacer algo con
6:34:26cada uno de sus elementos como podemos
6:34:29integrar sobre el arreglo iniciamos el
6:34:31valor de la variable y en cero para
6:34:34poder usarla como índice como hicimos en
6:34:36nuestro ejemplo anterior y vamos a
6:34:38continuar integrando mientras el valor
6:34:41de i sea menor que la longitud del
6:34:45arreglo lenguajes mientras eso ocurra
6:34:48esta condición es prácticamente fija si
6:34:51comienzas desde cero y quieres integrar
6:34:53sobre todos los elementos de un arreglo
6:34:55ok
6:34:57así que esto se va a volver algo
6:35:00rutinario que vas a escribir normalmente
6:35:02en javascript mientras sea menor que la
6:35:05longitud del arreglo y vamos a
6:35:08incrementar el valor de i en uno bien
6:35:11ahora vamos a mostrar el elemento que
6:35:13queremos mostrar pero que debemos
6:35:15mostrarlo en mayúscula para eso vamos a
6:35:18llamar a un método específico primero
6:35:21necesitamos acceder al elemento a la
6:35:24cadena de caracteres que corresponde a
6:35:26la iteración para eso escribimos el
6:35:29nombre del arreglo lenguajes y entre
6:35:32corchetes
6:35:33el índice de ese elemento que es el
6:35:36valor de la variable i y para convertir
6:35:39esa cadena de caracteres a mayúscula
6:35:41tenemos un método muy útil que es su opi
6:35:44que es el pri que jms en español
6:35:47significa mayúscula entonces esto lo
6:35:50convierte a mayúscula convierte la
6:35:52cadena de caracteres a mayúsculas usamos
6:35:55un punto el nombre del método y lo
6:35:57llamamos con paréntesis vacíos
6:36:00todo esto va a resultar en un elemento
6:36:03de este arreglo convertido a mayúscula y
6:36:07luego lo mostramos veamos en la consola
6:36:10el resultado
6:36:12puedes verlo aquí ya vásquez luego
6:36:14python
6:36:16luego java y luego simples los nuevos
6:36:20sep los pros ya puedes ver este patrón y
6:36:22cómo se repite cuando queremos integrar
6:36:25sobre los elementos de un arreglo
6:36:27estamos inicial izando la variable con
6:36:30el valor cero
6:36:31continuamos mientras ese valor sea menor
6:36:34que la longitud del arreglo
6:36:36incrementamos la variable del ciclo en
6:36:38uno cada iteración y luego accedemos a
6:36:42cada elemento del arreglo con el valor
6:36:44de y como el índice veamos otro ejemplo
6:36:47más que tengo aquí para ti en este caso
6:36:50vamos a trabajar con un ciclo por dentro
6:36:52de una función vamos a definir una
6:36:55función que va a contar la cantidad de
6:36:58números pares en un arreglo va a tomar
6:37:02un parámetro llamado arreglo
6:37:04y va a mantener
6:37:06un registro al mantener un acumulado del
6:37:09total de números pares que hemos
6:37:12encontrado hasta el momento ese
6:37:15acumulado este total se va a actualizar
6:37:17a medida que consigamos números pares en
6:37:20el arreglo porque vamos a integrar sobre
6:37:22todos sus elementos dentro de la función
6:37:25podemos escribir un ciclo fuera
6:37:28y cómo vamos a instalar sobre el arreglo
6:37:30usamos el mismo patrón que ya hemos
6:37:33visto inicializa mos del valor de acero
6:37:36y continuamos el proceso mientras i sea
6:37:39menor que la longitud del arreglo y
6:37:43actualizamos el valor de e
6:37:45incrementándolo en uno cada vez para
6:37:47cada iteración luego decimos el elemento
6:37:51que corresponde a esta integración es
6:37:54par si el resto de su división entre dos
6:37:57es igual a cero
6:38:00entonces
6:38:03incrementamos el total en 1 eso es lo
6:38:06que estamos haciendo aquí estamos
6:38:09incrementando el valor de la variable en
6:38:111 y luego cuando el ciclo termine y ya
6:38:14hayamos procesado todos los elementos
6:38:16del arreglo para contar cuántos pares
6:38:18hay vamos a retornar el valor de la
6:38:21variable total bien vamos a probar con
6:38:24con su punto olor a ver cómo funciona
6:38:27esta función contar números pares y
6:38:31entre paréntesis vamos a pasar un
6:38:33arreglo que no tiene ningún número par
6:38:35para ver si funciona correctamente y nos
6:38:38retorna el valor cero aquí podemos ver
6:38:40el valor cero ahora si agregamos un
6:38:44número par
6:38:45digamos 2 ahora vemos el número 1 porque
6:38:48hay un número par si agregamos 2 números
6:38:52pares más ahora tenemos tres números
6:38:54pares y el resultado es correcto y
6:38:57también podemos mezclar los números
6:38:59pares en el medio porque estamos
6:39:00haciendo una instalación por cada
6:39:03elemento del arreglo así que no importa
6:39:05donde aparezcan de igual forma se van a
6:39:08detectar y aquí podemos ver que hay tres
6:39:11números pares 1 2 y 3 lo cual es
6:39:15correcto bien ya vimos varios ejemplos
6:39:18de cómo puedes trabajar con un ciclo for
6:39:20para integrar sobre los elementos de un
6:39:22arreglo buen trabajo pasemos a nuestro
6:39:25siguiente tema del curso
6:39:33ya sabes cómo trabajar con ciclo for y
6:39:36ciclos web también es muy útil poder
6:39:39escribir ciclos dentro de otros ciclos
6:39:42eso es lo que nosotros llamamos ciclos
6:39:44anidados vamos a ver un ejemplo de un
6:39:47ciclo for anidado vamos a tener un ciclo
6:39:49for dentro de otro ciclo four son muy
6:39:52útiles para procesar estructuras de
6:39:54datos multidimensionales por ejemplo
6:39:57digamos que tenemos un arreglo y ese
6:40:00arreglo contiene arreglos
6:40:05123456789 como podemos hacer alguna
6:40:09operación con cada uno de los elementos
6:40:11de cada uno de los arreglos si nosotros
6:40:15usamos un ciclo for para operar sobre
6:40:17los elementos de este arreglo veamos que
6:40:20obtenemos vamos a usar el mismo patrón
6:40:23que hemos usado hasta ahora para enterar
6:40:25sobre los elementos de un arreglo
6:40:28iniciamos con la variable igual a cero
6:40:30la condición es que sea menor que la
6:40:32longitud o el tamaño del arreglo e
6:40:35incrementamos el valor de y el uno por
6:40:37cada instalación
6:40:39vamos a mostrar cada uno de esos
6:40:41elementos que obtenemos mi arreglo en el
6:40:45índice y
6:40:47iba a tomar los valores 0 para este
6:40:51arreglo 1 para este arreglo y 2 para
6:40:54este arreglo porque recuerda que como
6:40:57son arreglos anidados cada uno ocupa un
6:41:00índice específico del arreglo externo
6:41:03puedes repasar este tema en la parte del
6:41:06curso sobre arreglos anidados cada uno
6:41:08tiene su índice correspondiente cuál es
6:41:11el resultado aquí lo podemos ver primero
6:41:14se toma el arreglo 1 el arreglo en el
6:41:17índice 0 luego se toma el arreglo en el
6:41:21índice 1 y finalmente se toma el arreglo
6:41:25en el índice 2 necesitamos trabajar con
6:41:28el arreglo anidado esto es usted cuando
6:41:32necesitamos trabajar con el arreglo
6:41:34anidado pero qué pasa si queremos
6:41:37trabajar con los elementos de ese
6:41:39arreglo anidado algo que podríamos hacer
6:41:42es asignar ese arreglo anidado a una
6:41:44variable
6:41:45y luego podemos cerrar sobre los
6:41:49elementos y luego podemos escribir otro
6:41:52ciclo fork para integrar sobre ese
6:41:55arreglo anidado aquí creo que puedes ya
6:41:58empezar a ver el patrón vamos a hacer
6:42:00exactamente lo mismo que hicimos con el
6:42:02arreglo externo pero con el arreglo
6:42:05anidado es el mismo patrón nota que
6:42:08estamos usando una variable distinta
6:42:10cuando usas ciclos anidados es mejor
6:42:13usar variables con un nombre distinto
6:42:15para el ciclo anidado para evitar
6:42:17cambios inesperados en la variable del
6:42:20ciclo en este caso estamos usando jota y
6:42:23normalmente vas a conseguir ese tipo de
6:42:25letra y jk pero esta vez queremos
6:42:28instalar sobre el arreglo anidado por
6:42:31eso escribimos aquí arreglo unidad y
6:42:34escribimos su longitud conseguimos un
6:42:36longitud porque tenemos que mantener la
6:42:38misma condición lo que es que estamos
6:42:40cambiando de arreglo y lo que hacemos es
6:42:42incrementar el valor de jota esto es muy
6:42:46importante tienes que incrementar el
6:42:47valor de jota y una fuente común de
6:42:50errores es incrementar y nuevo aquí
6:42:52tienes que incrementar a j para que
6:42:55funcione correctamente o la variable que
6:42:57corresponda al ciclo unidad luego de
6:43:00esto qué es lo que vamos a hacer vamos a
6:43:04mostrar cada uno de esos elementos
6:43:08arreglo anidado j
6:43:11este es un elemento del arreglo anidado
6:43:13un número y este es el arreglo unidad
6:43:17estamos como desglosando el contenido de
6:43:20la estructura de datos primero para cada
6:43:23una de las iteraciones vamos a conseguir
6:43:26un arreglo uno de estos arreglos
6:43:28completos y luego vamos a tener una
6:43:32instalación por cada elemento de ese
6:43:34arreglo podemos hacer algo con cada uno
6:43:37de esos elementos vamos a mostrar unos
6:43:39mensajes en la consola para poder
6:43:41entender mejor el proceso nueva
6:43:44iteración arreglo y aquí vamos a mostrar
6:43:51ciclo anidado elemento
6:43:56vamos a mostrar aquí el mensaje
6:43:59principal con símbolos especiales para
6:44:01poder distinguirlos ciclón y dad ya vas
6:44:05a ver que va a ser muy útil esta
6:44:06anotación también sería bueno mostrar el
6:44:08arreglo aquí podemos concatenar lo con
6:44:11el arreglo anidado estoy preparando todo
6:44:15aquí para que sea más fácil entender qué
6:44:19es lo que está pasando cuando los ciclos
6:44:21se van ejecutando
6:44:22nueva iteración corresponde al ciclo
6:44:25externo ok
6:44:27luego tenemos el arreglo anidado y aquí
6:44:30cuando veamos ciclo anidado y elemento
6:44:33vamos a ver el elemento correspondiente
6:44:36aquí podemos ver el resultado nueva
6:44:39iteración comienza el ciclo externo el
6:44:42arreglo que seleccionamos es el arreglo
6:44:45que corresponde a uno dos tres que
6:44:47tenemos aquí
6:44:48luego estamos en el ciclo anidado y
6:44:51vamos a analizar obtener elemento por
6:44:54elemento el elemento es 1 así que vemos
6:44:57aquí 1 ciclo 'en y dado comienzo otra
6:45:00vez el elemento es 2 se actualizó el
6:45:03segundo elemento del arreglo luego
6:45:05tenemos el elemento 3
6:45:08y comenzamos una nueva interacción
6:45:10porque porque ya se ejecutó una
6:45:13iteración por cada elemento de este
6:45:16arreglo ahora comenzamos con el otro
6:45:18arreglo pero para eso comenzamos una
6:45:22nueva iteración del ciclo externo
6:45:24seleccionamos un nuevo arreglo 4 5 y 6 y
6:45:28vamos a tener tres iteraciones del ciclo
6:45:30anidado una para cuatro una para cinco y
6:45:35una para seis
6:45:36luego comenzamos otra interacción del
6:45:39ciclo externo de este ciclo que tenemos
6:45:42aquí afuera para seleccionar el próximo
6:45:45arreglo anidado que tiene los números 7
6:45:498 y 9 y tenemos tres iteraciones del
6:45:53ciclo unida 2 7 8 y 9 y allí termina el
6:45:58proceso esto es lo que estamos haciendo
6:46:00básicamente si quitamos los mensajes con
6:46:04con su punto los puedes ver que el
6:46:06código es más compacto podemos verlo
6:46:10mejor para cada uno de los arreglos
6:46:12vamos a
6:46:13tener una iteración y después para cada
6:46:17instalación vamos a tener tres
6:46:18iteraciones porque es una por cada
6:46:20elemento y así es básicamente cómo
6:46:23funcionan los ciclos anidados tenemos
6:46:27iteraciones del ciclo externo y para
6:46:29cada instalación del ciclo externo
6:46:32tenemos iteraciones del ciclo interno
6:46:35que se cumplen o se ejecutan como uno
6:46:38esperaría por cada una de las
6:46:41iteraciones del ciclo externo genial ya
6:46:44sabes cómo trabajar con ciclos anidados
6:46:47este concepto requiere práctica para
6:46:50entender cómo funciona este tipo de
6:46:52ciclo los ciclos anidados así que te
6:46:54recomiendo practicar escribiendo
6:46:56distintos tipos de ciclo for ciclos
6:46:58organizados y usa con su punto log para
6:47:01entender cómo van evolucionando las
6:47:03variables y cómo se van actualizando así
6:47:06que comenzamos con nuestro siguiente
6:47:08tema
6:47:15vamos a ver un tercer tipo de ciclo que
6:47:18podemos usar en java skate que es
6:47:21básicamente un ciclo web pero con un
6:47:23pequeño cambio en el ciclo de uruguay
6:47:27podremos traducirlo en español a hacer
6:47:31mientras hacer tal cosa mientras una
6:47:35condición es verdadera vamos a comparar
6:47:37este tipo de ciclo con el ciclo web
6:47:39comenzamos con un ejemplo del ciclo
6:47:41while declaramos una variable y le
6:47:45asignamos el valor 5 inicialmente esta
6:47:48variable va a tener valor 5 y vamos a
6:47:50decir en el ciclo wild vamos a repetir
6:47:53una instrucción mientras el valor de x
6:47:56sea menor que 10 entonces vamos a
6:47:59mostrar el valor de x en este caso
6:48:03y luego demostrar ese valor lo vamos a
6:48:05incrementar en 1 así que vamos a tener
6:48:08los números desde 5 hasta 9 aquí lo
6:48:11vemos en la consola desde 5 hasta 9 esto
6:48:15es un ciclo web pero un ciclo de uruguay
6:48:17aún nos permite hacer otra cosa ya vas a
6:48:20ver
6:48:21tenemos que tomar esta parte del ciclo
6:48:25guayo en la primera línea y escribirla
6:48:28luego de la llave que cierra
6:48:30esta llave agregamos punto y coma al
6:48:33final y aquí
6:48:35escribimos la palabra clave y puedes ver
6:48:38que está en un color distinto porque es
6:48:40una palabra clave en javascript y allí
6:48:43tenemos un ciclo de uruguay la
6:48:46diferencia de este ciclo con el ciclo
6:48:48wire es que siempre se va a ejecutar al
6:48:52menos una vez la secuencia de
6:48:53instrucciones que tenemos aquí cuando
6:48:56nosotros teníamos el ciclo aguayo
6:48:58permíteme escribirlo aquí
6:49:01nuevamente teníamos el ciclo while aquí
6:49:05esta condición se evaluaba para ver si
6:49:07era verdadera o falsa si era verdadera
6:49:10se ejecutaba esta secuencia de
6:49:13instrucciones por primera vez y será
6:49:15falsa no se ejecutaban las instrucciones
6:49:18simplemente se saltaba el ciclo y se
6:49:21seguía más allá del ciclo pero con un
6:49:23ciclo de uruguay esta secuencia de
6:49:26instrucciones se ejecuta antes de
6:49:29evaluar esta condición al menos una vez
6:49:32entramos en el ciclo se ejecuta estas
6:49:35líneas de código y luego evaluamos la
6:49:38condición si es verdadera las ejecutamos
6:49:41nuevamente y si es falsa continuamos la
6:49:44ejecución normal del programa esa es la
6:49:47diferencia que esta secuencia de
6:49:49instrucciones se va a ejecutar al menos
6:49:51una vez en un ciclo de uruguay el huevo
6:49:54no necesariamente porque esta condición
6:49:56puede ser falsa desde el principio y
6:49:58puede ser que el ciclo no se ejecuten y
6:50:01una sola vez no haya ni una sola
6:50:03iteración
6:50:05veamos un ejemplo vamos a asignarle el
6:50:07valor 16 aquí inicialmente cuando la
6:50:11definimos en el ciclo to one'
6:50:13no vamos a verificar la condición que
6:50:17tenemos acá hasta después de ejecutar
6:50:19estas dos líneas el resultado es 16 se
6:50:23muestra el valor de x se incrementa su
6:50:27valor en 1 y luego se verifica la
6:50:30condición
6:50:32esa condición en este momento es falsa
6:50:35porque el valor de x17
6:50:37cuando se mostró x era 16 luego se
6:50:41incrementó a 17 y esta condición es
6:50:45falsa así que el ciclo no continúa pero
6:50:49se ejecutado esta secuencia de
6:50:50instrucciones una vez ahora veamos el
6:50:53ciclo aguayo que pasa si tenemos esa
6:50:56misma situación nuevamente vamos a
6:50:58asignar el valor 16 a la variable x que
6:51:02ocurre en este caso si comentamos este
6:51:05ciclo anterior podemos ver que no se
6:51:07muestra ningún valor en la consola
6:51:09porque porque esta condición es falsa
6:51:12desde el inicio x no es menor que 10
6:51:15sino que su valor inicial antes de
6:51:18llegar al ciclo era 16 esta secuencia de
6:51:21instrucciones no se ejecuta ni una sola
6:51:24vez y esa es la diferencia con el ciclo
6:51:26de uruguay y estoy segura de que puedes
6:51:29preguntar para qué me va a servir un
6:51:31ciclo de uruguay y cuáles son las
6:51:33situaciones de la vida real en las que
6:51:35podría necesitarlo
6:51:37una de las situaciones ideales para un
6:51:39ciclo to work es cuando necesitas que el
6:51:42usuario ingrese un valor tienes que
6:51:44verificar si ese valor es válido o no
6:51:46pero tienes que pedírselo al usuario al
6:51:49menos una vez luego de que ingrese el
6:51:52valor aquí en esta condición la puedes
6:51:55verificar
6:51:56si es válido continúas el programa y si
6:52:00no es válido continúas pidiendo el valor
6:52:02al usuario hasta que ingrese un valor
6:52:04válido para tu programa bien ya sabes la
6:52:09diferencia entre while y two way y
6:52:11cuando puedes usar este tipo de ciclos
6:52:13puedes trabajar con ciclos fort con
6:52:15ciclos web y con ciclos de uruguay o en
6:52:18javascript en la próxima parte vamos a
6:52:21aplicar sus conocimientos para buscar un
6:52:24perfil en una lista de contactos así que
6:52:27te veo allí
6:52:34ahora vamos a combinar tu conocimiento
6:52:36de arreglos objetos ciclos y funciones
6:52:41en este mini proyecto vamos a definir
6:52:44una función que nos va a permitir buscar
6:52:47un contacto en una lista de contactos
6:52:50digamos que tenemos en nuestra lista
6:52:53tres contactos puedes ver que esos
6:52:55contactos están representados como
6:52:58objetos aquí lo vemos de forma vertical
6:53:01con cada propiedad y su valor
6:53:05correspondiente pero esos objetos siguen
6:53:08siendo elementos de un arreglo aquí
6:53:10puedes ver el corchete que abre y el
6:53:13corchete que cierra siguen siendo
6:53:15elementos de un arreglo así que cada uno
6:53:18de estos objetos ocupa un índice
6:53:21específico en ese arreglo este objeto es
6:53:24el primero así que tiene índice cero
6:53:27éste tiene índice 1 y éste tiene índice
6:53:312 así que simplemente podemos integrar
6:53:34sobre el arreglo como lo hemos hecho
6:53:36hasta ahora con un ciclo fuera
6:53:39a cada uno de esos objetos y eso es lo
6:53:42que vamos a hacer vamos a definir una
6:53:44función que va a permitirnos conseguir
6:53:48una propiedad de un contacto vamos a
6:53:51buscar el contacto en base a su nombre
6:53:53vamos a asumir que el nombre es único y
6:53:56en base a una propiedad que nosotros
6:53:59especificamos vamos a obtener su valor
6:54:01si la propiedad existe veamos como vamos
6:54:05a implementar esta función se va a
6:54:07llamar buscar perfil en la función va a
6:54:10tomar un nombre y una propiedad por
6:54:13ejemplo digamos que yo quiero conseguir
6:54:16el apellido de el contacto con el nombre
6:54:19no ahora buscamos el nombre del contacto
6:54:22y luego de conseguir al contacto
6:54:24buscamos el valor de la propiedad que
6:54:27especificamos en este caso sería
6:54:29apellido y el valor retornado sería nada
6:54:32va a funcionar con cualquier propiedad
6:54:34que pasemos aquí y si la propiedad no
6:54:36existe vamos a retornar una cadena
6:54:38específica en este caso estoy intentando
6:54:41el código con cuatro espacios para que
6:54:43puedas ver mejor la estructura del
6:54:45objeto
6:54:46también vamos a intentar la función con
6:54:48cuatro espacios en javascript puedes
6:54:51usar dos espacios o cuatro espacios lo
6:54:54importante es que sea consistente el uso
6:54:56de los espacios
6:54:57vamos a escribir un ciclo for aquí para
6:55:02poder integrar sobre los elementos del
6:55:04arreglo vamos a acceder al arreglo
6:55:09directamente en el arreglo contactos que
6:55:12es una variable global puede ser usada
6:55:15dentro de las funciones del programa
6:55:17porque está definida en el programa
6:55:20principal puedes ver el mismo patrón que
6:55:22hemos usado para integrar sobre los
6:55:25elementos de un arreglo
6:55:27inicialmente el valor de i es igual a 0
6:55:29porque vamos a usar y como un índice y
6:55:32vamos a continuar el proceso mí y vamos
6:55:35a continuar el proceso mientras el valor
6:55:38de y sea menor que el tamaño de la lista
6:55:41de contactos su longitud
6:55:43y en cada instalación vamos a
6:55:45incrementar el valor de iu en 1 así que
6:55:48escribimos y + + dentro del ciclo que
6:55:52vamos a hacer tenemos un condicional
6:55:54vamos a acceder a cada uno de los
6:55:56contactos en el arreglo usando el índice
6:56:00y recuerda que la variable i es la
6:56:03variable del ciclo y se va a actualizar
6:56:05automáticamente
6:56:07inicialmente su valor va a ser cero así
6:56:09que vamos a poder acceder al elemento
6:56:12del arreglo en el índice 0 luego cuando
6:56:15se actualice a 1 podemos acceder al
6:56:18elemento en el índice 1 que es este
6:56:20objeto y luego en el índice 2 tenemos
6:56:23este objeto y así sucesivamente para
6:56:26cualquier cantidad de contactos que
6:56:28tengamos en el arreglo entonces aquí
6:56:31estamos accediendo al contacto
6:56:33correspondiente pero en base a su nombre
6:56:37y para eso vamos a acceder a la
6:56:39propiedad nombre del contacto que
6:56:42corresponde
6:56:43aquí accedemos al objeto y aquí
6:56:46connotación de punto estamos accediendo
6:56:49a su nombre y luego lo comparamos con el
6:56:53operador de igualdad estricta con el
6:56:55nombre que queremos conseguir este es el
6:56:58nombre de contacto que queremos
6:57:00conseguir si eso es verdad si
6:57:02conseguimos al contacto que buscamos
6:57:05entonces qué vamos a hacer en ese caso
6:57:09tenemos que retornar el valor de la
6:57:11propiedad que corresponde vamos a tomar
6:57:15ese contacto el que estamos verificando
6:57:18y vamos a acceder a la propiedad que
6:57:21especificamos como parámetro aquí no
6:57:24podemos usar notación de punto porque
6:57:27esta es una variable si usáramos
6:57:29notación de punto en lugar de notación
6:57:31de corchetes se buscaría una propiedad
6:57:34cuyo nombre cuyo nombre en realidad sea
6:57:37propiedad o sea no no se va a reemplazar
6:57:39el valor de la variable aquí sino que se
6:57:43va a buscar una propiedad con este
6:57:44nombre y eso no es lo que queremos
6:57:48queremos que se reemplace aquí el valor
6:57:50de esta variable del parámetro así que
6:57:53usamos notación de corchetes
6:57:55si esa propiedad existe su valor se va a
6:57:58retornar pero también tenemos que
6:58:01manejar el caso en el que la propiedad
6:58:03no exista por ejemplo si se intenta
6:58:06acceder a una propiedad que no está en
6:58:09el objeto del contacto tenemos que
6:58:11retornar una cadena de caracteres que
6:58:15avise que ocurrió este caso hay en
6:58:17javascript hay una forma muy sencilla y
6:58:20concisa de escribirlo decimos si la
6:58:23propiedad existe retorne a esa propiedad
6:58:26pero si esa propiedad no existe este
6:58:29valor va a ser anti find y por lo tanto
6:58:32no podemos usar el operador org para
6:58:37retornar esta cadena de caracteres en su
6:58:39lugar la propiedad no existe
6:58:43en una sola línea estamos diciendo si la
6:58:45propiedad existe retorna la propiedad y
6:58:48si no existe retorna la cadena de
6:58:51caracteres que tenemos aquí es como un
6:58:53respaldo y esos son casos que tenemos
6:58:56que siempre prevenir en nuestro código
6:58:58que podría salir mal si eso no se cumple
6:59:01eso es en el caso de que el contacto en
6:59:04realidad exista porque se consiguió su
6:59:07nombre pero la propiedad no existe
6:59:09también está la posibilidad de que el
6:59:12contacto no exista el contacto en sí en
6:59:16ese caso el ciclo for va a ejecutar
6:59:19todas sus iteraciones una por cada
6:59:21contacto en la lista esta condición
6:59:24nunca va a ser nunca va a ser verdadera
6:59:27y por lo tanto se va a completar este
6:59:30ciclo y se va a pasar a la siguiente
6:59:33línea
6:59:34qué deberíamos hacer retornar una cadena
6:59:38de caracteres que diga el contacto no
6:59:41está en la lista de contactos y así
6:59:45tenemos nuestra función implementada
6:59:48vamos a enterar sobre los elementos de
6:59:51el arreglo contactos cada uno de esos
6:59:54elementos es un objeto accedemos a ese
6:59:57objeto y decidimos si su nombre es igual
7:00:00el nombre que buscamos retornamos la
7:00:02propiedad sino si la propiedad no existe
7:00:06retornamos esta cadena y si nunca se
7:00:09consigue ese contacto retornamos esta
7:00:12cadena de caracteres el contacto no está
7:00:14en la lista genial
7:00:17vamos a probar nuestra función buscar
7:00:20perfil vamos a llamar a la función con
7:00:24el nombre en ahora y digamos que
7:00:27queremos acceder a sus gustos and ahora
7:00:30le gustan la pizza y la programación
7:00:33vamos a ver en la consola vamos a ver en
7:00:37la consola pero como el resultado se
7:00:39retorna para mostrarlo en la consola
7:00:42tenemos que usar con su punto lock aquí
7:00:45abrimos la consola y veamos el resultado
7:00:47pizza y programación exactamente lo que
7:00:51esperábamos
7:00:53ahora probemos con el siguiente contacto
7:00:55ya vamos a buscar perfil
7:00:58y tenemos a harry y queremos buscar su
7:01:03apellido
7:01:04queremos saber su apellido si abrimos la
7:01:06consola aquí vemos potter vamos a borrar
7:01:10este línea aquí vemos potter solo
7:01:13mantenemos la de harry y apellido ahora
7:01:17sí quiero acceder a el número de
7:01:21teléfono de sherlock también lo puedo
7:01:24hacer y aquí veo el valor que tenemos
7:01:27aquí exactamente el mismo genial
7:01:30funciona correctamente cuando el
7:01:32contacto y la propiedad están en el
7:01:34arreglo probemos también está en el
7:01:37contacto o si el contacto no existe
7:01:40digamos que queremos acceder al contacto
7:01:42no ahora pero a una propiedad que no
7:01:46existe en ese contacto en este objeto
7:01:49sabemos que en ahora es un contacto aquí
7:01:52es el primer objeto pero no tiene una
7:01:55propiedad llamada dirección aquí en
7:01:58estas opciones
7:01:59veamos el resultado la propiedad no
7:02:02existe exactamente lo que tenemos aquí
7:02:05cuando se trata de acceder a la
7:02:07propiedad dirección en ese objeto este
7:02:11valor es anti find porque la propiedad
7:02:13no existe en ese caso se retorna esta
7:02:17cadena de caracteres ahora veamos el
7:02:20caso final en el cual el contacto no
7:02:22existe digamos que queremos acceder al
7:02:25número de pop en ese caso el contacto no
7:02:28está en la lista de retorno esta cadena
7:02:32de caracteres porque el ciclo se
7:02:34completó esta condición esta condición
7:02:37nunca fue verdadera nunca se retorno un
7:02:40valor así que el ciclo se completó y
7:02:43pasamos a esta línea y se retorna este
7:02:45mensaje genial ya completamos este mini
7:02:49proyecto puedes ver como ya puedes
7:02:51combinar todos tus conocimientos para
7:02:53trabajar con arreglos con objetos con
7:02:57funciones con parámetros argumentos
7:03:00ciclos condicionales sentencias vistas
7:03:04y cadenas de caracteres y operadores
7:03:07todo se va combinando para permitirte
7:03:10escribir programas más poderosos
7:03:18ahora vamos a ver cómo puedes generar un
7:03:21número aleatorio en javascript tenemos
7:03:23todas las herramientas que necesitamos
7:03:25para generar un número aleatorio en
7:03:27javascript simplemente tenemos que usar
7:03:30la palabra más que significa matemáticas
7:03:33vamos a definir una función que se va a
7:03:37llamar generar fracción aleatoria esta
7:03:40función no va a tomar argumentos sino
7:03:43que va a retornar un valor aleatorio
7:03:45como vamos a generar ese valor
7:03:49la clave es escribir esto que tenemos
7:03:51aquí más más con la m mayúscula si lo
7:03:55escribimos con minúscula ves que no
7:03:57tiene ningún color especial pero cuando
7:04:00lo escribimos con mayúscula si tiene un
7:04:03color especial porque representa lo que
7:04:06podemos ver aquí es un objeto que nos da
7:04:09a funciones matemáticas básicas y
7:04:11constantes
7:04:13una de esas funciones matemáticas
7:04:15básicas que podemos usar es la función
7:04:18random que significa aleatorio en
7:04:20español esta función no toma ningún
7:04:24parámetro no necesita argumentos para
7:04:27retornar un valor aleatorio
7:04:29el método retorna un valor aleatorio
7:04:32entre 0 y 1 pero 1 el 1 no está incluido
7:04:37en los posibles resultados así que en
7:04:40notación matemática tendríamos algo así
7:04:43tendríamos 0 y el 1 no estaría incluido
7:04:47en el resultado
7:04:49el 0 si estaría incluido en los posibles
7:04:52resultados
7:04:53así que para generar un rango vamos a
7:04:56tener que hacer algo específico porque
7:04:58el 1 no va a estar incluido allí vamos a
7:05:00probar nuestra función vamos a llamarla
7:05:03y vamos a mostrar en la consola el valor
7:05:06general vamos a llamarla muchas veces
7:05:09tres cuatro cinco o seis veces y vemos
7:05:13el resultado aquí vemos que los
7:05:15resultados son números aleatorios con
7:05:17muchos decimales
7:05:19esos números aleatorios van a ser muy
7:05:21útiles para generar números aleatorios
7:05:23en un rango específico por ejemplo si
7:05:26necesitamos números entre 3 y 5 entre 10
7:05:28y 15 vamos a poder hacerlo en base a
7:05:31estos valores que los vamos a tener que
7:05:33transformar un poquito
7:05:35pero este es el principio básico nunca
7:05:38uno de estos resultados puede ser uno
7:05:40que recuerda eso entre cero y uno pero
7:05:44nunca pueden ser uno exactamente no
7:05:47necesariamente necesitas llamar a más
7:05:49punto random dentro de una función
7:05:51también en este caso lo hicimos para
7:05:55definir una función que podríamos llamar
7:05:57pero también podemos llamarlo
7:06:00simplemente en nuestro programa donde
7:06:02necesitemos ese valor aleatorio o
7:06:05podemos asignar el valor una variable
7:06:07puedes ver aquí que generó un número
7:06:09aleatorio y también podemos asignarlo
7:06:13a una variable por ejemplo aquí tenemos
7:06:16var número aleatorio
7:06:19esto va a generar el valor y lo
7:06:21asignamos a una variable y luego si
7:06:24mostramos el valor de esa variable en la
7:06:27consola vamos a tener el resultado
7:06:29puedes ver el número que tenemos acá en
7:06:32la próxima parte vamos a ver cómo puede
7:06:35generar números aleatorios
7:06:37enteros en ya busquets lo veremos en la
7:06:40próxima parte así que te veo allí
7:06:48así como puede generar números decimales
7:06:51aleatorios en javascript también podemos
7:06:54escribir una expresión que nos permita
7:06:57convertir esos números decimales a
7:07:00números enteros dentro de un rango
7:07:02específico
7:07:04vamos a ver cómo puedes obtener un
7:07:07número aleatorio
7:07:09entre 0 y 19 digamos por ejemplo lo que
7:07:13tenemos que escribir es
7:07:16esto que tenemos aquí más flores esto va
7:07:20a ser toda la magia de la expresión más
7:07:22vimos que es un objeto que nos permite
7:07:25usar funciones y constantes matemáticas
7:07:27esencial es una de esas funciones
7:07:30representada como un método explore flor
7:07:34lo que hace es
7:07:36aquí nos lo explica la documentación es
7:07:39retornar el mayor número entero que es
7:07:43menor o igual a su argumento numérico al
7:07:46número que pasamos entre paréntesis lo
7:07:49que hace flor básicamente es que trunca
7:07:52la parte de encima básicamente lo que
7:07:55hace es tomar la parte entera de lo que
7:07:57está entre paréntesis
7:07:58entre paréntesis tenemos que generar ese
7:08:02número aleatorio + punto brandon
7:08:04recuerda que ese número aleatorio va a
7:08:06estar entre 0 y 10 puede ser uno de esos
7:08:10valores pero uno nunca va a ser uno de
7:08:13esos valores no incluye al valor 1 como
7:08:16podemos transformar este valor en un
7:08:18entero
7:08:19para obtener el rango que queremos hay
7:08:22que multiplicarlo por un entero
7:08:24vamos a ver la lógica que tenemos acá
7:08:27este valor va a ser un decimal entre 0 y
7:08:311 sin incluir 1 como no puede ser 1 este
7:08:35producto nunca va a ser 20 va a ser 19
7:08:39punto algo nunca 20 exactamente y como
7:08:43estamos aplicando la función flor ese
7:08:46número va a ser truncado adiós 19 si es
7:08:5019 punto algo el resultado va a ser 19
7:08:55lo que se va a asignar a esta variable
7:08:57ahí ya tenemos un límite superior para
7:09:00el rango de valores que podemos obtener
7:09:02y el valor de más punto random puede ser
7:09:060 es el mínimo valor que puede tener así
7:09:09que 0 por 20 sería 0 y cuando lo
7:09:12aplicamos flórez el resultado sería 0 y
7:09:15el valor aquí sería 0 así que estamos
7:09:18obteniendo un rango de valores que va
7:09:21desde 0 hasta 19 inclusivo y es
7:09:24exactamente lo que necesitábamos si
7:09:27mostramos este número aleatorio en la
7:09:30consola podemos verlo en este caso es 12
7:09:34el número aleatorio que se generó
7:09:36probablemente el resultado de haya sido
7:09:3812 puntos algo y este método flor lo
7:09:42redondeo o lo lo truncó truncó los
7:09:45decimales y el número 12 tomó la parte
7:09:48ente parte entera ahora vamos a hacer
7:09:51algo interesante que puedes usar en tus
7:09:53programas vamos a definir una función
7:09:56que genere un número entero aleatorio
7:09:59esa función va a tener un solo parámetro
7:10:03el límite superior del rango de números
7:10:06que queremos generar y vamos a escribir
7:10:09la expresión que teníamos antes de forma
7:10:12general vamos a retornar el valor
7:10:15y vamos a aplicar el método flor
7:10:18vamos a generar un número aleatorio
7:10:20entre 0 y 1 sin incluir 1 pero esta vez
7:10:25en lugar de multiplicar por 20 que era
7:10:27un número fijo un número que no podíamos
7:10:30cambiar vamos a multiplicarlo por el
7:10:34valor del parámetro que es el límite
7:10:36superior entonces eso ya nos está
7:10:39permitiendo generar valores enteros
7:10:41entre 0 y el límite superior sin incluir
7:10:45lo que aquí podemos agregar un
7:10:47comentario generar 3 0
7:10:51y el límite superior sin incluirlo bien
7:10:57vamos a probar esta función si la
7:11:00llamamos con un valor de 5 vamos a poder
7:11:03generar un valor aleatorio un número
7:11:06entero aleatorio entre 0 y 5 siempre va
7:11:10a ser entero el resultado porque estamos
7:11:12usando el método flores vamos a mostrar
7:11:15el valor en la consola
7:11:17y vamos a mostrar
7:11:19digamos cinco veces cinco valores
7:11:22aleatorios aquí puedes ver 0 4 3 3 y 2 0
7:11:28es una de las posibles opciones que
7:11:31podemos obtener pero 5 no es una de las
7:11:34posibilidades
7:11:35y no lo vemos tampoco entre estas
7:11:37opciones es pero estas opciones fueron
7:11:40generadas aleatoriamente si queremos
7:11:43también intentar generar muchos números
7:11:45aleatorios podemos hacerlo con un ciclo
7:11:48vamos a dejar con un ciclo vamos a dejar
7:11:51solo una de estas líneas y vamos a
7:11:53escribir un ciclo para repetir este
7:11:57proceso de generar un número aleatorio
7:12:01cuantas veces queremos repetir la
7:12:03operación
7:12:04digamos que queremos repetirla
7:12:0715 veces 15 números aleatorios
7:12:10vamos a ejecutar este código 15 veces
7:12:14esta línea y si abrimos la consola
7:12:17podemos ver estos resultados puedes ver
7:12:20que todos los números enteros están en
7:12:23el rango de 0 hasta 4 inclusive en
7:12:26ningún lado vemos el número 5 genial ya
7:12:29sabes cómo generar un entero aleatorio
7:12:32en javascript
7:12:34desde cero hasta un límite superior
7:12:36también hay una forma de generar números
7:12:39enteros aleatorios en un rango
7:12:41específico con un límite inferior y un
7:12:44límite superior es lo que vamos a ver en
7:12:46la próxima parte te espero allí
7:12:54anteriormente estábamos en parte
7:12:57limitados a generar un número entero
7:12:59entre 0 y un límite superior pero
7:13:02también podemos generar números enteros
7:13:05aleatorios en un rango específico con un
7:13:08límite inferior y un límite superior
7:13:10digamos entre 5 y 15 entre 20 y 50 entre
7:13:14cualquier rango que queramos especificar
7:13:17claro con de números enteros para eso
7:13:20tenemos que definir una función esa
7:13:23función se va a llamar rango aleatorio
7:13:25puedes asignarle cualquier nombre que
7:13:28desees
7:13:29y va a tener dos parámetros límite
7:13:32inferior y límite superior para obtener
7:13:37un número en ese rango aleatorio un
7:13:39entero vamos a tener que escribir una
7:13:42expresión parecida a la anterior pero
7:13:44con ciertos cambios primero tenemos otra
7:13:48vez flores s si lo vamos a volver a usar
7:13:51también tenemos que generar un número
7:13:54aleatorio entre 0 y 1 pero en este caso
7:13:57en lugar de sólo multiplicar por el
7:14:00límite superior vamos a tener que
7:14:03multiplicar por
7:14:04una expresión un poco más compleja esa
7:14:09expresión es el límite superior
7:14:11menos el límite inferior más 1
7:14:17y luego
7:14:19a ese resultado luego de haber
7:14:21redondeado a este resultado se les suma
7:14:24el límite inferior y esta es la
7:14:28expresión que nos permite generar un
7:14:30entero en ese rango
7:14:33seguimos usando el método flor seguimos
7:14:36usando el método random pero ahorita
7:14:39estamos multiplicando por este valor el
7:14:42límite superior menos el límite inferior
7:14:45eso nos da como el tamaño del intervalo
7:14:49más uno porque queremos incluir el
7:14:52límite inferior
7:14:54y luego a ese valor que se genera le
7:14:58vamos a sumar el límite inferior
7:15:00eso nos va a retornar un entero en ese
7:15:02rango vamos a comprobarlo con algunas
7:15:06pruebas
7:15:08llamamos a rango aleatorio y probemos
7:15:11con un límite inferior 3 y un límite
7:15:13superior 8 vamos a llamar a esta función
7:15:17varias veces a ver qué números obtenemos
7:15:20recuerda que el rango entre 3 y 8 aquí
7:15:23podemos verlo 5 5 3 4 7 y 4 son números
7:15:29enteros en el rango que especificamos
7:15:31podemos hacer como en el ejemplo
7:15:33anterior y usar un ciclo para generar
7:15:36varios digamos 15 números aleatorios y
7:15:42vemos que siempre se mantienen en ese
7:15:43rango en este caso vamos a ver que el
7:15:46límite superior si se incluye en los
7:15:49posibles resultados
7:15:50aquí lo puedes ver 7 883 8
7:15:55638 6 7 6 5 8 y 5 son todos números en
7:16:01el rango entre 3 y 8 inclusive ambos
7:16:05límites ahora vamos a ver cómo funciona
7:16:08la función pares y que nos permite
7:16:10generar un número entero
7:16:12vamos a ver en la próxima parte del
7:16:14curso
7:16:20en chabás que podemos usar una función
7:16:24específica que nos da el lenguaje para
7:16:26convertir una cadena de caracteres que
7:16:30representa un número en un número porque
7:16:33recuerda que esto no es igual que esto
7:16:37en un lenguaje de programación
7:16:40este elemento es del tipo de dato string
7:16:43o cadena de caracteres y este elemento
7:16:46es un número entero lo que vamos a ver
7:16:49ahora es cómo podemos convertir una
7:16:51cadena de caracteres que representa un
7:16:54número porque este es el número 5 cómo
7:16:56lo podemos convertir al tipo de datos
7:16:59entero para poder trabajar y operar con
7:17:03ese valor en nuestro programa veamos
7:17:06vamos a usar con su punto log para
7:17:08mostrar el resultado pero la función que
7:17:11nos interesa en este momento se llama
7:17:14parte int
7:17:16significa cómo convertir o
7:17:20procesar un entero podemos decirlo así
7:17:23esta función lo que hace es convertir
7:17:25una cadena de caracteres a un entero que
7:17:28es exactamente lo que nos dice la
7:17:29documentación aquí en inglés convertir
7:17:32una cadena de caracteres a un entero
7:17:34cual cadena de caracteres bueno la que
7:17:37vamos a pasar entre paréntesis
7:17:39la cadena de caracteres es 5
7:17:43vamos a mostrarla en la consola
7:17:46aquí podemos ver 5 también podemos
7:17:50convertir un número negativo entero
7:17:54como ves aquí tenemos menos 47 y lo
7:17:57bueno de esto es que podemos empezar a
7:17:59operar con estos valores si lo queremos
7:18:02en nuestro programa usando operaciones
7:18:04aritméticas que normalmente usaríamos
7:18:07con números también puedes convertir 0
7:18:10de cadena de carácter a un entero y un
7:18:13número decimal en ese caso el número
7:18:16decimal se trunca se convierte a un
7:18:20número en un número entero truncando o
7:18:22eliminando la parte decimal en este caso
7:18:24es 6 no se redondea porque en caso de
7:18:27que se redondeará tendríamos 7 sino que
7:18:30sólo se mantiene la parte entera aquí
7:18:33puedes ver 6.2 el resultado es
7:18:35exactamente el mismo sin importar en la
7:18:37parte decimal también puedes usar esta
7:18:40función para convertir un número decimal
7:18:42en un número entero además
7:18:44probemos funciona exactamente como
7:18:47queríamos truncó la parte decimal pero
7:18:50este era un número decimal no era una
7:18:51cadena de caracteres pero si tratábamos
7:18:54de convertir un valor que en realidad no
7:18:56representa un número vamos a tener un
7:18:58valor específico
7:18:59por ejemplo a veces esta cadena de
7:19:02caracteres no representa un número y por
7:19:05lo tanto la función va a retornar esto
7:19:08en n en javascript significa not el
7:19:12nombre significa que no es un número
7:19:15válido y por lo tanto no se pudo
7:19:17convertir a un entero bien ya sabes que
7:19:20puedes jon pero vamos a
7:19:22comprobar nosotros mismos en la práctica
7:19:25las ventajas de usar esta función
7:19:28digamos que tenemos dos variables y
7:19:31digamos que por alguna razón en nuestro
7:19:34programa esas variables tienen cadenas
7:19:36de caracteres asignadas pero en realidad
7:19:38queremos trabajar con enteros si por
7:19:43ejemplo necesitamos sumar los valores
7:19:45que es lo que vamos a obtener una
7:19:48concatenación o una unión de esas
7:19:50cadenas de caracteres que no es lo que
7:19:52queremos en este caso lo que necesitamos
7:19:54hacer
7:19:56es convertir las cadenas de caracteres a
7:19:59enteros cuando llamamos a esta función
7:20:02el valor retornado va a ser un entero
7:20:04con todas sus propiedades
7:20:06igual que aquí así que ahora sí vamos a
7:20:09poder operar con estos valores como si
7:20:12fueran números enteros aquí vemos que el
7:20:14resultado es 12 el resultado correcto de
7:20:17sumar 5 y 7 matemáticamente bien bien ya
7:20:22sabes usar la función pares y esto es
7:20:24muy importante en javascript y también
7:20:27lo puedes usar con una pequeña variación
7:20:30especificando la base esto lo vamos a
7:20:33ver en el próximo tema así que
7:20:35continuemos
7:20:41también puedes usar la función park de
7:20:45una forma que es todavía más poderosa
7:20:47digamos porque puedes convertir una
7:20:51cadena de caracteres en otro sistema
7:20:53numérico al sistema decimal como un
7:20:56entero veamos un ejemplo vamos a mostrar
7:20:59el resultado con causa
7:21:01y vamos a llamar a la función pares int
7:21:05pero en este caso
7:21:06vamos a pasar una cadena de caracteres
7:21:08con ceros y unos cual sistemas numéricos
7:21:12ese es el sistema numérico binario para
7:21:16eso para especificar que el sistema
7:21:18numérico de este número es binario
7:21:21tenemos que pasar un segundo argumento
7:21:23con un valor 2 que representa la base de
7:21:26ese sistema es base 2 vamos a ver el
7:21:29resultado el resultado es el número
7:21:32decimal 55 que tenemos aquí y es
7:21:36exactamente el equivalente de este
7:21:38número binario
7:21:40el sistema decimal puedes hacer la
7:21:43conversión en las herramientas online y
7:21:45vas a confirmar que si es el valor de
7:21:47semana también podemos pasar el número
7:21:50como un número como un número en
7:21:53javascript sin ser una cadena de
7:21:55caracteres necesariamente en este caso
7:21:58sólo escribimos el número binario y
7:22:00especificamos que la base de ese número
7:22:02es 2 y tenemos el mismo resultado que si
7:22:05lo escribiéramos como una cadena de
7:22:07caracteres
7:22:08genial nuestro es muy poderoso veamos un
7:22:11ejemplo ahora con el sistema hexadecimal
7:22:14cuya base es 16 en el sistema
7:22:18hexadecimal podemos usar ciertas letras
7:22:22este es un ejemplo de un número en el
7:22:25sistema extra decimal su equivalente en
7:22:29el sistema decimal sería vamos a ver
7:22:32tenemos que cambiar aquí la base a 16 y
7:22:35aquí tenemos el resultado 15
7:22:381882
7:22:40es exactamente el número en decimal si
7:22:42usamos cualquier herramienta online que
7:22:45convierta de hexadecimal a décimas en
7:22:48este caso no funcionaría pasarlo esta
7:22:50secuencia de caracteres sin las comillas
7:22:52nos daría un error de sintaxis o que
7:22:55sólo con el número binario que podríamos
7:22:58hacer esa excepción pero aquí como
7:23:00tenemos letras necesitamos representarlo
7:23:02como una cadena de caracteres y tenemos
7:23:05el número entero en el sistema decimal
7:23:13ahora vamos a hablar un poquito sobre el
7:23:16operador condicional también llamado el
7:23:18operador ternario este operador nos
7:23:21permite compactar lo que sería un
7:23:24condicional en una sola línea ya vas a
7:23:27ver como digamos que definimos una
7:23:29función llamada retornar mínimo
7:23:33esta función va a tomar dos valores xy
7:23:37se iba a retornar el mínimo de ambos
7:23:39valores
7:23:41como lo haríamos con un condicional como
7:23:44implementaríamos esta funcionalidad aquí
7:23:47en la condición verificaremos si x es
7:23:50menor que ya se retorna x si no se
7:23:55retorna de aquí también tenemos que
7:23:58escribir el punto y coma que es lo que
7:24:01ocurre este condicional va a funcionar
7:24:03correctamente
7:24:05pero hay una forma más concisa de
7:24:07escribir esta misma secuencia de
7:24:10instrucciones en javascript y es el
7:24:12operador condicional o ternario lo que
7:24:15vamos a hacer es compactar todo esto en
7:24:19una línea que va a comenzar con la
7:24:21sentencia richard
7:24:23vamos a borrar el condicional por ahora
7:24:26pero ya sabes qué es lo que queremos
7:24:28hacer con la función
7:24:30escribimos richard y que vamos a
7:24:32retornar el operador condicional
7:24:35comienza con una condición la condición
7:24:39va a ser esta la condición que
7:24:41escribimos en el condicional anterior si
7:24:43esa condición es verdadera vamos a
7:24:46retornar el valor x este signo de
7:24:49interrogación nos permite decir si esta
7:24:52condición es verdadera retorna este
7:24:55valor sino si la condición es falsa
7:24:58retorna este valor
7:25:00y esto es básicamente lo que vamos a
7:25:03tener es un condicional compactado en
7:25:06una sola línea con dos símbolos que
7:25:08reemplazan toda esa sintaxis esta es la
7:25:11condición y decidimos si esa condición
7:25:13es verdadera retorna o evalúa a ese
7:25:17valor que está inmediatamente luego de
7:25:20el signo de interrogación y si esta
7:25:22condición es falsa evalúa a este valor
7:25:26en este caso como tenemos una sentencia
7:25:29al victorense va a retornar cualquiera
7:25:32de estos dos valores dependiendo del
7:25:34resultado pero si no tuviéramos restaron
7:25:37por ejemplo si tuviéramos solo con su
7:25:39punto lo también lo que haríamos sería
7:25:42solo mostrar cualquiera de estos dos
7:25:44valores dependiendo del valor de esta
7:25:47condición vamos a probar vamos a probar
7:25:50la función estamos usando ahorita con su
7:25:53punto loc
7:25:54para mostrarte que puedes usar un
7:25:56condicional donde lo necesites por
7:25:59ejemplo vamos a llamar esta función con
7:26:01los valores 4 y 7
7:26:03si vemos la consola
7:26:05el resultado es 4 que es el mínimo de
7:26:07ambos valores así que funciona
7:26:09correctamente vamos a probar con otras
7:26:11combinaciones si pasamos 8 y 2 y 5 y 5
7:26:15para probar distintos tipos de
7:26:18combinaciones ahora que es el mínimo y
7:26:21qué pasa si ambos son iguales aquí vemos
7:26:24el resultado tenemos 4 para el primero
7:26:26que es el mínimo tenemos 2 para el
7:26:29segundo y 5 porque ambos valores son
7:26:32iguales
7:26:33así que está funcionando correctamente
7:26:35exactamente lo que queríamos si esta
7:26:37condición es verdadera la expresión se
7:26:40reemplaza por el valor de x y si esta
7:26:42condición es falsa la expresión se
7:26:45reemplaza por el valor de y en este caso
7:26:48estamos mostrando pero también podríamos
7:26:51retornar el valor aquí lo podemos
7:26:53retornar y lo que tendríamos que hacer
7:26:56para mostrarlo en la consola es
7:26:59simplemente escribir con su punto log
7:27:01vamos a copiar y pegar aquí y agregamos
7:27:04los paréntesis exactamente el mismo
7:27:07resultado pero ahora retornamos el valor
7:27:09x o el valor jet dependiendo de la
7:27:11condición como puedes ver en lugar de
7:27:13todas las líneas del condicional estamos
7:27:15escribiendo esto de forma muy compacta
7:27:18en una sola línea genial
7:27:21ahora vamos a ver otro ejemplo
7:27:24si definimos dos variables
7:27:275 y b igual a 9 que se va a mostrar en
7:27:32la consola si tenemos este operador
7:27:35ternario
7:27:37la condición es que sea mayor que ve en
7:27:40este caso si es mayor que ven se retorna
7:27:43a 2
7:27:46y si no se retorna ve por tres analiza
7:27:50esta estructura del operador ternario y
7:27:54trata de determinar qué valor se va a
7:27:56mostrar en la consola
7:27:59vamos a ver la consola el valor es 27
7:28:03porque esta condición es falsa no es
7:28:08mayor que ve a 5 y 29 como esta
7:28:11condición es falsa pasamos a esta opción
7:28:14que está luego de los dos puntos
7:28:17la expresión total va a evaluar a peu
7:28:19por 339 por 327 si la condición fuese
7:28:26verdadera por ejemplo si fuese 15
7:28:29veríamos 17 que es a más 2 porque la
7:28:33condición sería verdadera y en la
7:28:36primera opción sería el resultado a más
7:28:38217 porque hay 15 genial ya sabes cómo
7:28:43trabajar con el operador ternario
7:28:45recuerda esta es la estructura principal
7:28:47primero tenemos la condición luego un
7:28:51signo de interrogación el resultado si
7:28:54la expresión es verdadera
7:28:56luego dos puntos y el resultado si la
7:28:58expresión es falsa
7:29:00bien pasamos a la siguiente parte en la
7:29:03que vamos a ver cómo puedes usar
7:29:04múltiples operadores condicionales u
7:29:07operadores ternarios
7:29:15puedes combinar el poder de los
7:29:18operadores condicionales o ternarios
7:29:20escribiendo múltiples operadores
7:29:23condicionales o ternarios uno dentro del
7:29:26otro similar al concepto que vimos
7:29:28anteriormente de anidado vamos a
7:29:31escribir una función comparar números
7:29:33vamos a definir esta función
7:29:36esta función va a comparar dos números a
7:29:38ive
7:29:39sí
7:29:41es igual a b en este caso digamos que
7:29:45tenemos garantizado que ambos valores
7:29:47van a ser del mismo tipo de datos eso lo
7:29:50podemos especificar en la documentación
7:29:52de la función así que vamos a usar este
7:29:55operador de igualdad también podemos
7:29:57usar el operador de igualdad estricta si
7:30:00queremos verificar que el el tipo de
7:30:02dato es igual es el mismo pero en este
7:30:05caso vamos a trabajar con el de igualdad
7:30:07en este caso si son iguales queremos
7:30:09retornar una cadena de caracteres que
7:30:11diga que ahí ven son iguales si ese no
7:30:15es el caso entonces si es mayor que b
7:30:18queremos retornar una cadena que diga
7:30:21que a es mayor que b
7:30:24y si te ese no es el caso tampoco es
7:30:27menor que ve así que retornamos la
7:30:30cadena a es menor que b
7:30:34o el equivalente también podríamos poner
7:30:37que p es mayor que a ver ya tenemos
7:30:42nuestro condicional como podemos
7:30:44reemplazarlo con un operador condicional
7:30:47o ternario que nos permita simular la
7:30:50funcionalidad de la cláusula el cif
7:30:53veamos ya sabes lo que queremos lograr
7:30:55por eso escribí el condicional aquí
7:30:58inicialmente sabes lo que queremos
7:31:00lograr con el operador condicional así
7:31:02que vamos a comenzar a escribir lo
7:31:04primero es escribir la sentencia richard
7:31:07porque vamos a retornar el valor
7:31:09retornado por el operador condicional lo
7:31:13primero que hacemos con el operador
7:31:14condicional siempre es escribir la
7:31:16condición en este caso verificamos si es
7:31:19igual a b estamos usando el operador de
7:31:23igualdad ahora si ese es el caso que
7:31:26queremos hacer queremos retornar la
7:31:28cadena a y b son iguales
7:31:31pero si ese no es el caso que queremos
7:31:34hacer o sea cómo podemos simular que
7:31:37tenemos una cláusula el shift recuerda
7:31:40que cuando usamos un operador
7:31:41condicional o ternario este es el valor
7:31:44resultante si la condición es verdadera
7:31:47pero si la condición es falsa el valor
7:31:50que escribamos después de los dos puntos
7:31:52es el valor que se va a retornar en este
7:31:56caso como queremos seguir verificando
7:31:59otras condiciones no vamos a escribir un
7:32:02valor directamente aquí sino otro
7:32:05operador condicional cuando escribimos
7:32:07varias condiciones como vamos a hacer
7:32:10ahorita es recomendado dividir este
7:32:13operador en varias líneas para alinear
7:32:16las condiciones verticalmente ponemos
7:32:19los dos puntos aquí y aquí escribimos
7:32:21nuestra condición
7:32:24si esta condición es falsa este valor no
7:32:27se retorna y pasamos aquí
7:32:29después de los dos puntos ok escribimos
7:32:32esta condición después de los dos puntos
7:32:34y en este caso que es lo que queremos
7:32:36retornar
7:32:37queremos retornar una cadena que diga
7:32:40que a es mayor que ven y si ese tampoco
7:32:44es el caso si esta condición es falsa
7:32:46entonces queremos retornar otro valor
7:32:49otra cadena b es mayor que a
7:32:55y allí tenemos nuestro operador
7:32:57condicional o ternario es el equivalente
7:33:00al condicional que escribimos
7:33:01anteriormente tenemos nuestras dos
7:33:04condiciones y tenemos lo que sería el
7:33:08equivalente a la clausula eus como un
7:33:10valor por defecto al que va a evaluar
7:33:12esta expresión que se va a retornar si
7:33:15las condiciones son falsas
7:33:17en este caso veamos la lógica o si esta
7:33:20condición es verdadera se retorna este
7:33:21valor si esta condición es falsa pasamos
7:33:25a este operador condicional y en la
7:33:27lógica se va repitiendo si esta
7:33:30condición es verdadera este valor se va
7:33:32a retornar y si es falsa pasamos a la
7:33:36siguiente parte que es este valor que
7:33:38tenemos aquí que es como el valor de
7:33:40respaldo si ambas son falsas genial
7:33:44veamos cómo funciona la función con
7:33:46algunos casos de prueba digamos 11 y 27
7:33:50en este caso b es mayor que a así que
7:33:54deberíamos ver ese mensaje tenemos que
7:33:57mostrar este mensaje en la consola b es
7:34:00mayor que a exactamente lo que
7:34:02esperábamos
7:34:04ahora vamos a cambiar los valores
7:34:0627 y 11 ahora el mayor que ve a es mayor
7:34:10que ver y finalmente 15 y 15 para probar
7:34:14la primera condición
7:34:16ahí ves son iguales genial con 1515 esta
7:34:21condición es verdadera así que tenemos
7:34:23esta cadena de caracteres luego con las
7:34:26otras combinaciones de valores por
7:34:27ejemplo 27 y 11 está condición era falsa
7:34:31pero esta condición si era verdadera así
7:34:34que esta cadena es el retorno y luego
7:34:37con 11 y 27 ambas condiciones eran
7:34:41falsas así que este valor se retorna por
7:34:44defecto como la clausura es
7:34:46genial ya sabes cómo usar múltiples
7:34:49operadores condicionales o ternarios
7:34:52recuerda que puedes alinear estas
7:34:54condiciones para que sea más fácil de
7:34:56leer y de entender visualmente y en la
7:34:59última línea tiene el valor que se va a
7:35:02retornar si las condiciones son falsas
7:35:04bien pasemos a nuestro siguiente tema
7:35:14buen trabajo y felicitaciones por llegar
7:35:16a esta parte del curso ahora vamos a
7:35:19empezar a ver la diferencia entre
7:35:21declarar una variable comparar y
7:35:23declarar la con ley una de las
7:35:26diferencias principales es que cuando
7:35:29declaramos una variable con var por
7:35:32ejemplo en este caso digamos que
7:35:35declaramos una variable que se llama
7:35:37campista una persona que está acampando
7:35:39que es parte de un campamento como
7:35:42explicó horgan cuando la declaramos con
7:35:45la palabra clave para james y david
7:35:48vamos a poder hacerlo dos o más veces
7:35:51podemos a declarar una variable más de
7:35:54una vez vamos a mostrar el valor
7:35:57en la consola y vemos david no vemos
7:36:00ningún error porque la variable se pudo
7:36:02declarar dos veces con var
7:36:05pero cuando usamos led
7:36:07la situación es diferente porque con led
7:36:10no podemos declarar una variable más de
7:36:12una vez es como una revisión extra que
7:36:15hace en nuestro código de havas que para
7:36:18avisarnos que no podemos volver a
7:36:20declarar la digamos que la declaramos
7:36:22con led y la tratamos de volver a
7:36:25declarar ahora vemos error de sintaxis
7:36:29el identificador otra forma de
7:36:32referirnos a las variables nombre en el
7:36:34programa el identificador campista ya ha
7:36:38sido declarado absorber y pin declare
7:36:41esta parte dice que ya ha sido declarado
7:36:44ya fue declarado en el programa una vez
7:36:46no la puedes volver a declarar lo que
7:36:49podemos hacer es reasignar el valor o
7:36:52cambiar el valor pero no podemos volver
7:36:54a escribir la palabra let si borramos
7:36:57led ahora si vemos el valor actualizado
7:37:00david
7:37:02sólo podemos usarla una sola vez
7:37:05bien sigamos viendo más sobre el ámbito
7:37:08de bar y led y cómo afectan dónde
7:37:11podemos utilizar las variables en
7:37:13nuestro programa
7:37:21ahora hablemos sobre la diferencia en el
7:37:24ámbito de las variables que son
7:37:26declaradas con burt y con led cuando
7:37:28usamos vaart estamos creando
7:37:31algunas de estas dos opciones o una
7:37:33variable global si está en el programa
7:37:35principal o una variable local si está
7:37:39definida en una función esas variables
7:37:41si está dentro de una función se va a
7:37:44poder utilizar en toda esa función pero
7:37:46no fuera de la función lo que habíamos
7:37:49visto anteriormente para las variables
7:37:51globales y locales por ejemplo esta
7:37:54sería una variable global vamos a
7:37:57asignar el valor 4
7:37:59si queremos usarla en nuestro programa
7:38:02vamos a poder hacerlo sin ningún
7:38:04problema fuera de la función o dentro de
7:38:07alguna función que necesitemos podemos
7:38:10mostrar el valor de la variable global y
7:38:14actualizarla si necesitamos aquí vamos a
7:38:17llamar a la función
7:38:19para mostrar que podemos ver el valor de
7:38:22la variable global y acceder a él aquí
7:38:25tenemos 4 y 4 perfecto luego también
7:38:28podemos dentro de la función usar bajar
7:38:32para definir una variable local que solo
7:38:35puede ser usada dentro de la función
7:38:38podemos mostrar su valor también vemos 4
7:38:414 y 8 que es el valor de la variable
7:38:44local fuera de la función podemos
7:38:47acceder a la variable global pero si
7:38:50tratamos de acceder a la variable local
7:38:52vamos a ver qué es lo que pasa vamos a
7:38:55tener un error si abrimos la consola
7:38:59puedes ver esto error de referencia mi
7:39:02variable local no está definida cuando
7:39:05intentamos acceder a esta variable local
7:39:07que definimos dentro de la función en el
7:39:11programa principal tenemos un error no
7:39:14está definida la variable porque era
7:39:16local cuando usamos para ese es el
7:39:18efecto
7:39:19pero ahora cuando usamos le estamos
7:39:23restringiendo aún más el ámbito de la
7:39:26variable el bloque o la expresión
7:39:29específica donde se usa el bloque de
7:39:31código su alcance está limitado a esa
7:39:34expresión al bloque oa la declaración
7:39:37donde se define vamos a ver un ejemplo
7:39:41y aquí podemos cerrar la consola y
7:39:44borrar el código que tenemos hasta ahora
7:39:46digamos que queremos escribir un ciclo
7:39:49force en nuestro programa puede ser
7:39:51dentro de una función o en el programa
7:39:53principal hasta ahora nosotros hemos
7:39:55usado var en los ciclos para definir las
7:39:58variables digamos que queremos
7:40:00implementar este ciclo y ejecutarlo en
7:40:03el programa estamos usando var si usamos
7:40:07var en el ciclo esa variable va a tener
7:40:12el ámbito que corresponda a donde está
7:40:15definido el ciclo no está escrito el
7:40:17ciclo por ejemplo aquí estamos en el
7:40:19ámbito global porque estamos estamos en
7:40:23el programa principal si estuviera
7:40:25dentro de una función esta variable solo
7:40:27se podría usar dentro de la función y
7:40:30sería una variable local y por eso como
7:40:33es una variable global en este caso
7:40:35podemos usar la variable y aunque el
7:40:38ciclo ya haya terminado porque sigue
7:40:41presente en ese ámbito global de todo el
7:40:44programa
7:40:45veamos el resultado
7:40:47aquí podemos ver ese valor 3 para
7:40:50distinguir el mensaje vamos a vamos a
7:40:53mostrar aquí la cadena variable para
7:40:56distinguirlo de los valores que se
7:40:59mostraron en el ciclo una vez que
7:41:01terminó el ciclo entramos aquí y su
7:41:04valor es 3 porque fue incrementada antes
7:41:07de salir del ciclo pero aún así se puede
7:41:10usar fuera del ciclo esa es la
7:41:12diferencia si usamos led si escribimos
7:41:15leds aquí en lugar de parar la variable
7:41:19sólo se va a poder usar dentro del ciclo
7:41:21no vamos a usarla aquí fuera de ese
7:41:24bloque de código definido por las llaves
7:41:27vamos a ver el resultado tenemos los
7:41:30valores 0 1 y 2 que fueron mostrados por
7:41:33el ciclo for y finalmente tenemos este
7:41:36mensaje error de referencia y no está
7:41:39definida cuando llegamos a este punto
7:41:42del programa y sólo existe dentro de
7:41:46este bloque de código
7:41:47pero existe fuera así que en realidad
7:41:51para variables de ciclo normalmente
7:41:53podemos usar leds si no las necesitamos
7:41:55fuera del ciclo también
7:41:59hay una diferencia notable cuando usamos
7:42:01leds en un condicional
7:42:04vamos a ver digamos que tenemos un
7:42:06condicional que
7:42:08muestra un color
7:42:11dependiendo del valor de esta variable
7:42:13mostrar color si esta variable es
7:42:16verdadera muestra el color y si no lo
7:42:18muestra el color dentro del condicional
7:42:21que es un bloque de código específico
7:42:22podemos definir una variable usando leds
7:42:26esa variable la estamos definiendo con
7:42:29led así que solamente se va a poder usar
7:42:31en este bloque de código
7:42:34determinado por las llaves rodeado por
7:42:37las llaves podemos usarlas dentro de ese
7:42:39bloque sin problema vamos a decir mi
7:42:42color
7:42:43favorito es
7:42:47y agregamos el color
7:42:50al final de la cadena
7:42:52ahora si intentamos acceder a la
7:42:55variable color fuera de este bloque de
7:42:58código que vamos a tener
7:43:01vemos que dentro del bloque la variable
7:43:04funciona perfectamente
7:43:06aquí estamos dentro del bloque de código
7:43:08pero una vez que nos vamos fuera de ese
7:43:10bloque al programa principal tenemos
7:43:13este error de referencia porque color no
7:43:16está definida en esta parte del programa
7:43:19como usamos led no se puede acceder
7:43:22ahora diga ahora digamos que queremos
7:43:25acceder a esa variable fuera del bloque
7:43:27lo que haríamos es cambiarle por bar y
7:43:31puedes ver que ahora el error desaparece
7:43:34y podemos acceder a su valor más allá de
7:43:37ese bloque de código donde fue definida
7:43:39o declarar esas son las diferencias
7:43:42principales entre bar y let bar crea una
7:43:46variable que se puede usar a nivel
7:43:48global con ámbito global o dentro de una
7:43:51función pero les es más restrictivo y
7:43:54restringe el ámbito de esa variable al
7:43:56bloque de código o álex donde la
7:43:59variable fue declarado definida genial
7:44:03ya sabes estas diferencias y puedes
7:44:05trabajar con bari lecce y escoger cuál
7:44:08necesitas para tu programa los mismos
7:44:11principios aplican si estuviéramos
7:44:12dentro de una función va a ser va a
7:44:15permitir que la variable se use en la
7:44:17función pero si usamos led va a estar
7:44:20restringido su uso hasta el bloque de
7:44:23codhes vamos a pasar a nuestro siguiente
7:44:26tema donde vamos a empezar a hablar
7:44:27sobre la palabra reservada const que es
7:44:30la tercera opción que tenemos para crear
7:44:32o declarar una variable se ve en el
7:44:35próximo tema
7:44:42ahora es momento de ver la tercera
7:44:44opción que podemos usar para declarar
7:44:47una variable en javascript la palabra
7:44:50reservado palabra clave consiste const
7:44:53es una abreviación de constante en
7:44:56inglés constant son variables que solo
7:44:59pueden ser usadas para acceder a ese
7:45:02valor no podemos modificar el valor una
7:45:05vez que ya haya sido asignado por
7:45:08primera vez veamos un ejemplo si
7:45:11declaramos una variable con cost
7:45:15y la llamamos mi constante y le
7:45:19asignamos el valor 35
7:45:23vamos a acceder a su valor para
7:45:25mostrarte que si se puede acceder al
7:45:28valor de la constante aquí tenemos es 35
7:45:32pero veamos qué ocurre si queremos
7:45:34cambiar el valor de esta variable por
7:45:36ejemplo a 15 que va a ocurrir aquí vemos
7:45:40un error en la segunda línea error de
7:45:43tipo type r mi constante es read omb
7:45:48read audi significa que sólo se puede
7:45:51leer no se puede reasignar su valor o
7:45:54modificar su valor después de que haya
7:45:57sido asignado inicialmente
7:45:59y aquí hay algo curioso que crees que va
7:46:02a ocurrir si intentamos hacer esto
7:46:04anteriormente comparar podíamos declarar
7:46:07una variable y luego asignarle un valor
7:46:09en otra línea también lo podríamos hacer
7:46:12con led pero qué ocurre con cost vamos a
7:46:15abrir la consola y vemos nos dice error
7:46:17de sintaxis las declaraciones camps
7:46:20requieren un valor de inicialización o
7:46:24sea que no podemos partir esto en dos
7:46:26líneas tenemos que asignar
7:46:28en la misma línea y aquí vemos 35
7:46:32correctamente
7:46:34genial
7:46:36muy importante es que por convención en
7:46:38javascript las constantes como este
7:46:41valor se escriben en mayúscula y se
7:46:44separan las palabras con un guión bajo
7:46:46eso lo usamos para distinguirlas
7:46:49visualmente y para que nosotros y otros
7:46:52desarrolladores sepan que no deben
7:46:54tratar de cambiar el valor de esa
7:46:56constante si la escribimos todo en
7:46:59mayúsculas podemos ver este formato
7:47:01igual la podemos usar en con su punto
7:47:05lotes y vemos el valor 35 genial ahora
7:47:09vamos a ver un ejemplo con una función
7:47:12que vamos a usar para calcular el área
7:47:15de un círculo ya me imagino que tienes
7:47:18una idea de qué constante vamos a
7:47:20declarar en esta función una constante
7:47:23muy famosa vamos a declarar una
7:47:25constante pi
7:47:28en este caso vamos a usar el valor 3.14
7:47:31digamos que queremos usar de forma
7:47:33constante ese valor con dos decimales
7:47:35aunque sabemos que tiene infinitos
7:47:37decimales y vamos a verificar si el
7:47:41radio es menor que cero si es menor que
7:47:44cero vamos a usar el patrón de retorno
7:47:47anticipado que aprendiste durante el
7:47:49curso para retornar el valor and i find
7:47:52si ese no es el caso entonces vamos a
7:47:54retornar el valor de pi por el radio
7:47:58elevado al cuadrado
7:48:01este es el operador que nos permite
7:48:03elevar un valor al cuadrado o cualquier
7:48:07otra potencia dos asteriscos un
7:48:10asterisco multiplicación y dos
7:48:11asteriscos es elevar esta base a este
7:48:15exponente ok así estamos implementando
7:48:18la fórmula de tipo radio al cuadrado
7:48:20para el área del círculo sino
7:48:23definiéramos el pi como una constante
7:48:25algo como esto podría ocurrir en nuestro
7:48:28programa digamos qué no la estamos
7:48:32definiendo como una constante así que la
7:48:34vamos a escribir en minúscula
7:48:37yo puedo cambiar el valor de pi a
7:48:39digamos menos 45.2
7:48:41imagínate el error que va a tener
7:48:44nuestro programa si hacemos este cambio
7:48:46inesperado sin darnos cuenta ese es el
7:48:49riesgo que corremos cuando no creamos
7:48:51constantes sino variables si necesitamos
7:48:55que ese valor se mantenga exactamente
7:48:58igual durante todo el programa
7:49:00deberíamos declarar la con cost ahora
7:49:03vamos a llamar a esta función con
7:49:06distintos valores
7:49:09el resultado de
7:49:1178.5 si el radio 5 y 10 sería 314 el
7:49:17área del círculo ok ya sabes la
7:49:20importancia de usar como cuando queremos
7:49:23que el valor de una variable no cambie
7:49:25durante toda la ejecución del programa
7:49:35vamos a hablar de un aspecto de cons que
7:49:38debes tener presente cuando lo uses en
7:49:41javascript cuando declaren una variable
7:49:44con contesten ya ves que eso no
7:49:46significa que ese valor no puede cambiar
7:49:50significa que no podemos asignar un
7:49:53valor nuevo a esa variable para ilustrar
7:49:57esto vamos a ver cómo podemos mutar un
7:49:59arreglo que fue declarado con coast
7:50:02usamos como para declarar mi arreglo y
7:50:06usamos la convención establecida para
7:50:08las constantes el arreglo va a tener los
7:50:11números 1 2 3 y 4
7:50:14si intentamos reasignar el valor a otro
7:50:18arreglo completamente distinto oa otro
7:50:20arreglo en general que es lo que va a
7:50:23ocurrir un error porque definimos el
7:50:27arreglo con camps aquí lo vemos error de
7:50:29tipo de tipo de dato me arreglo es read
7:50:33omb y solo se puede leer o acceder al
7:50:36valor pero algo que sí debes tener
7:50:39presente es que no podemos asignar un
7:50:42valor nuevo esa variable pero si podemos
7:50:45cambiar los elementos de este regla
7:50:48porque por ejemplo si hacemos esto
7:50:50escribimos mi arreglo y reasignamos el
7:50:53valor en el índice 0 a 5 y resignamos el
7:50:57valor en el índice 1 a 6 y resignamos el
7:51:03valor en el índice 2 a 7 y hacemos lo
7:51:07mismo con el índice 3 a 8
7:51:11si ahora mostramos el valor de mi
7:51:15arreglo vamos a ver qué ocurre
7:51:18sorprendentemente el arreglo fue mutado
7:51:21cambio así que si podemos reasignar los
7:51:24valores individuales de esta estructura
7:51:26de datos de este arreglo que tenemos
7:51:29aquí lo que no podemos es hacer una
7:51:31asignación directa a esta variable luego
7:51:34de declarar la pero si podemos usar la
7:51:37notación de corchetes para reasignar los
7:51:40valores del arreglo ahora vamos a ver
7:51:43cómo puedes impedir la mutación de un
7:51:45objeto y te digo que va a tener que ver
7:51:48con el congelamiento si te da curiosidad
7:51:50pasar la siguiente tema del curso
7:51:58después del ejemplo de la parte anterior
7:52:00estoy segura de que te debes estar
7:52:03preguntando si existe alguna forma en
7:52:05javascript de impedir la mutación de un
7:52:08objeto de no permitir que se cambie la
7:52:11estructura de un objeto en el caso
7:52:14anterior era un arreglo pero ahorita
7:52:16estamos hablando de objetos como los
7:52:18objetos que vimos en esa parte
7:52:20específica del curso y en realidad si
7:52:23lines hay una forma de hacer que un
7:52:25objeto sea inmutable en javascript
7:52:29vamos a ver esto con un ejemplo
7:52:32definamos un objeto con led simplemente
7:52:35para comenzar a usar estas palabras
7:52:37claves para definir variables y vamos a
7:52:41asociar un color con su código
7:52:44hexadecimal
7:52:46digamos verde el tono de verde que cogí
7:52:49corresponde a este código el azul
7:52:52corresponde al código uno ve el negro
7:52:55corresponde a 0 0 0 0 0
7:53:00y finalmente blanco
7:53:02que corresponde
7:53:04efe efe
7:53:06ok ya tenemos los colores que vamos a
7:53:09necesitar y digamos que no queremos que
7:53:12es objeto mute en ningún momento no
7:53:15queremos cambiar estos valores en
7:53:18ninguna circunstancia y no queremos que
7:53:20se agreguen colores ni se borren colores
7:53:23de este objeto básicamente queremos
7:53:25congelarlo precisamente esa posibilidad
7:53:28está disponible en javascript con el
7:53:31método freeze que en inglés significa
7:53:33congelar así que piensa en el invierno
7:53:36cuando recuerdes este método cómo
7:53:39podemos hacerlo con
7:53:41objeto podemos ver la descripción nos da
7:53:45funcionalidad que es común para todos
7:53:47los objetos en javascript
7:53:49pero en particular nos da acceso al
7:53:52método freeze
7:53:54este es un método que según su
7:53:56descripción previene la modificación de
7:54:00atributos de propiedades existentes y
7:54:03sus valores y previenen la
7:54:05incorporación o edición de nuevas
7:54:07propiedades al objeto básicamente
7:54:10congela el objeto en ese estado cuando
7:54:12se ejecuta la línea entre paréntesis
7:54:15tenemos que pasar la variable que
7:54:17contiene el objeto
7:54:19y así ya lo estamos congelando veamos
7:54:22qué pasa si queremos agregar una
7:54:26propiedad nueva por ejemplo a amarillo
7:54:29con este código veamos el objeto luego
7:54:33de intentar hacer este cambio veamos la
7:54:36consola tenemos un error de tipo cuando
7:54:39intentamos agregar esta propiedad error
7:54:42de tipo no se puede agregar la propiedad
7:54:45amarillo porque el objeto no es
7:54:48extensivo lo que significa como
7:54:50extensible no se le puede agregar nuevas
7:54:52propiedades porque ya lo estamos
7:54:55congelando aquí arriba ahora si
7:54:57intentamos cambiar a cambiar el valor de
7:55:00alguna propiedad existente vamos a ver
7:55:02qué pasa digamos que queremos cambiarlo
7:55:07este valor
7:55:09este valor digamos vemos este error
7:55:11error de tipo no se puede asignar a una
7:55:14propiedad que únicamente se puede leer
7:55:17ruiz dónde recuerdas que vimos ese
7:55:19término es un tema anterior
7:55:21que significa que sólo podemos acceder a
7:55:23la propiedad y no la podemos cambiar esa
7:55:26propiedad es verde del objeto tal el
7:55:29objeto que estamos modificando
7:55:31intentando modificar que es colores bien
7:55:34así que ya puedes ver el efecto que
7:55:37tiene freeze sobre un objeto digamos que
7:55:40quiero borrar una propiedad de ese
7:55:42objeto con delete vamos a intentar
7:55:45borrar la propiedad verde a ver qué
7:55:48ocurre nuevamente error de tipo no se
7:55:51puede borrar la propiedad verde del
7:55:53objeto porque ya lo congelamos así que
7:55:57nuestro objeto está seguro de cualquier
7:55:59acción durante el programa luego de
7:56:01haberlo congelado genial ya sabes cómo
7:56:04crear objetos inmutables en chabás que
7:56:06en el próximo tema vamos a ver algo
7:56:09interesante que se llama las funciones
7:56:11flechas que nos permiten escribir
7:56:12funciones de forma más concisa en
7:56:15javascript
7:56:22ahora vamos a ver un concepto nuevo
7:56:24llamado funciones flecha las funciones
7:56:28flechas son un tipo más compacto de
7:56:31funciones que podemos escribir en
7:56:33javascript que normalmente se utilizan
7:56:35cuando necesitamos definir funciones
7:56:38anónimas funciones anónimas son
7:56:41funciones que no tienen un nombre
7:56:42específico por ejemplo a veces vamos a
7:56:45necesitar definir una función de esta
7:56:48forma en lugar de la forma tradicional
7:56:50que hemos usado que podemos hacer aquí
7:56:53podemos retornar un nuevo objeto de
7:56:55fecha esto nada más crea una un objeto
7:56:59con la fecha actual del sistema o que
7:57:02estamos retornando en este objeto y lo
7:57:05vamos a usar como ejemplo para cómo
7:57:07podemos transformar esta función en una
7:57:11función flecha vas a ver que es muy muy
7:57:13conciso aquí lo que estamos haciendo es
7:57:16definiendo una función anónima esta
7:57:19función no tiene un nombre específico
7:57:20puedes ver que sólo escribimos function
7:57:24usamos paréntesis vacíos porque no
7:57:26recibe ningún parámetro y luego el
7:57:29cuerpo de la función es solamente una
7:57:31sentencia richard y retorna un objeto
7:57:34luego asignamos esa función a una
7:57:38variable que se define con cost así que
7:57:40actúa como una constante llamada fecha
7:57:43podemos transformar esta función en una
7:57:46función flecha de esta forma quitamos la
7:57:50palabra clave function y luego quitamos
7:57:54la llave que abre la función y la
7:57:56sentencia richard en este caso porque
7:57:59sólo tenemos una sola línea y lo que
7:58:01hacemos es escribir el símbolo
7:58:03característico de las funciones flecha
7:58:06un siglo igual y en lo que llamamos
7:58:09nosotros el operador de mallorca este
7:58:12símbolo que en realidad parece una
7:58:14flechita está creando una función flecha
7:58:18que toma estos parámetros que en este
7:58:21caso es ninguno porque está vacía la
7:58:24lista
7:58:25y retorna este objeto así puedes ver
7:58:28cómo podemos definir una función de
7:58:31forma mucho más compacta si es necesario
7:58:33con las funciones flecha en las próximas
7:58:36partes vamos a trabajar con funciones
7:58:38flecha así que te espero allí
7:58:40particularmente la próxima parte vamos a
7:58:43ver cómo podemos agregar parámetros a
7:58:45estas funciones una cosa que te quería
7:58:48mencionar es que las funciones flecha
7:58:50como ésta esta es la función son muy
7:58:53útiles cuando necesitamos pasar una
7:58:55función como argumento a otra función lo
7:58:58que hacemos es escribirla directamente
7:59:00como el argumento
7:59:07vamos a ver cómo puedes definir
7:59:10funciones flechas que tomen uno o más
7:59:13parámetros en el ejemplo anterior la
7:59:16función flecha no tomaba ningún
7:59:18parámetro solo retornaba un objeto vamos
7:59:21a ver cómo podemos implementarlo en este
7:59:24ejemplo vamos a definir una función
7:59:26anónima que es va a tomar el valor x y
7:59:31va a retornar el valor x + 3 por eso
7:59:35vamos a asignar la a la variable sumar 3
7:59:38ahora digamos que queremos transformar
7:59:40esta función en una función flecha para
7:59:44escribir la de forma más concisa en el
7:59:46programa lo único que tenemos que hacer
7:59:48es eliminar las palabras clave function
7:59:51y en este caso como sólo tenemos una
7:59:54línea y esa línea retorna un valor lo
7:59:58que hacemos es eliminar la llave que
8:00:01abre el cuerpo de la función eliminar la
8:00:04palabra clave richter
8:00:06y colocar el símbolo de la flechita
8:00:09también borramos la llave que cierra el
8:00:13cuerpo de la función y aquí tenemos el
8:00:16equivalente en una función flecha como
8:00:19veis es muy muy compacto para este tipo
8:00:21de funciones y nos permite escribirla en
8:00:25una sola línea podemos llamar a la
8:00:27función con el nombre de la variable a
8:00:32la que la estamos asignando por ejemplo
8:00:34si llamamos a sumar tres pasando el
8:00:37valor 4 en el valor retornado debería
8:00:40ser 7 con su punto lo sumar 3 y en la
8:00:45consola vemos el valor 7 lo cual es
8:00:47correcto está funcionando como
8:00:49esperábamos este es el parámetro y este
8:00:52es el valor a retornar ahora vamos a
8:00:55hacer algo distinto vamos a definir una
8:00:58función anónima vamos a asignar a la
8:01:02variable concatenar y vamos a tomar dos
8:01:06parámetros arreglo uno y arreglo dos
8:01:10puedes escribir lo abreviado o más
8:01:14descriptivo arreglo uno y arreglo dos yo
8:01:17lo voy a abreviar para hacer más concisa
8:01:20en el código y que vamos a retornar
8:01:23vamos a retornar los dos arreglos
8:01:25concatenados o los dos arreglos unidos
8:01:29los elementos del arreglo todos se van a
8:01:31añadir al final del arreglo 1 así que
8:01:34vamos a hacerlo llamando al método con
8:01:37catch esto es un método que puedes
8:01:40llamar para unir un arreglo con otra
8:01:43escribimos el nombre del arreglo al cual
8:01:46le vamos a añadir esos elementos vamos a
8:01:49concatenar lo con el segundo arreglo y
8:01:52ese es el valor que vamos a retornar de
8:01:54nuestra función
8:01:56también podemos llamarla concatenar
8:01:58arreglos que hay para ser más
8:02:00descriptivos veamos el resultado inicial
8:02:03para confirmar que se comporta igual
8:02:06cuando la transformaremos a una fecha
8:02:08vamos a concatenar este rey con un
8:02:12segundo arreglo que tiene los elementos
8:02:143 4 y 5 el resultado debería ser un
8:02:18arreglo con todos los elementos y aquí
8:02:21lo podemos ver esta llamada la función
8:02:24retorno este arreglo un arreglo con los
8:02:27elementos 1 2 3 4 y 5 vamos a
8:02:31transformar esta función en una función
8:02:33flecha exactamente igual que vimos en el
8:02:37ejemplo anterior
8:02:37eliminamos la palabra expansión
8:02:40eliminamos la llave que abre el cuerpo
8:02:43de la función también borramos la
8:02:45sentencia arbitraria en la palabra clave
8:02:47y tenemos que escribir el simbolito key
8:02:50de flecha la flecha separa la lista de
8:02:53los parámetros del valor que vamos a
8:02:55retornar y borramos la llave que cierra
8:02:57el cuerpo de la función
8:03:00y así tenemos nuestra función flecha si
8:03:04abrimos la consola nuevamente podemos
8:03:06ver que los cambios no afectan los
8:03:08cambios no afectaron para nada el
8:03:10resultado tenemos código más conciso y
8:03:14el mismo resultado la misma
8:03:15funcionalidad genial estos casos que
8:03:18estamos viendo eran funciones que sólo
8:03:20tenían una línea que retornaban un valor
8:03:23si la función original tiene más de una
8:03:26línea tenemos que mantener las llaves
8:03:29veamos un ejemplo si nosotros teníamos
8:03:31una función que tomaban dos parámetros a
8:03:34ive
8:03:35la vamos a llamar sumar pero va a ser
8:03:38una suma personalizada digamos porque
8:03:41vamos a declarar aquí en este bloque de
8:03:45código porque estamos usando la palabra
8:03:47let la palabra clave let un número que
8:03:50vamos a sumar a la suma de amave aquí
8:03:55esto es sólo un ejemplo para ilustrar
8:03:57qué pasaría si la función tiene más de
8:04:00una línea
8:04:01en este caso lo que haríamos para
8:04:04definir la función flecha sería
8:04:06simplemente borrar la palabra clave y
8:04:09antes de la llave que abre el cuerpo de
8:04:13la función colocamos el símbolo de la
8:04:16flechita y allí tenemos la misma función
8:04:20que teníamos antes lo que estamos es
8:04:22removiendo quitando la palabra clave
8:04:25expansión y agregando el símbolo de la
8:04:27flechita va a funcionar exactamente
8:04:29igual podemos comprobarlo aquí si
8:04:32tenemos 1 1 y 6 el resultado debería ser
8:04:368 vamos a mostrarlo aquí vemos el
8:04:40resultado 8 genial ya sabes cómo
8:04:44convertir funciones anónimas a funciones
8:04:46flechas
8:04:55también puedes asignar un valor por
8:04:58defecto a los parámetros de una función
8:05:01flecha esto es útil cuando queremos
8:05:04permitir que el usuario omita algún
8:05:06argumento para usar el valor por defecto
8:05:09por ejemplo si definimos una función
8:05:14y la asignamos a la variable incrementar
8:05:17va a ser esta función flecha número y
8:05:22valor del incremento usamos el símbolo
8:05:25de flecha y que vamos a retornar el
8:05:29número más el valor del incremento para
8:05:31asignar un valor por defecto al
8:05:34incremento vamos a simplemente escribir
8:05:36un signo igual y el valor por defecto
8:05:39para ese parámetro así si omitimos este
8:05:43argumento se va a asignar el valor por
8:05:45defecto este principio también aplica a
8:05:48las funciones normales y a las funciones
8:05:49que hemos estado definiendo y a las
8:05:51funciones anónimas
8:05:53veamos cómo funciona si llamamos a la
8:05:56función incrementar
8:05:58y pasamos el valor 5 nada más para este
8:06:02número se debería usar el valor por
8:06:04defecto que es 1 el incremento por
8:06:07defecto y efectivamente el valor
8:06:10retornado es 65 se incrementó en 1 que
8:06:13es el valor por defecto
8:06:15pero si pasamos el valor del incremento
8:06:19como segundo argumento también debería
8:06:22funcionar y se debería personalizar el
8:06:25valor de este parámetro el resultado
8:06:27debería hacer 88 aquí lo tenemos
8:06:30exactamente lo que esperábamos así es
8:06:33como puedes asignarle un valor por
8:06:36defecto a un parámetro de tu función el
8:06:39nombre del parámetro en la lista de
8:06:40parámetros seguido de un signo igual y
8:06:43el valor por defecto que quieres asignar
8:06:52ahora vamos a ver un operador que te va
8:06:55a permitir escribir funciones muy
8:06:57versátiles en javascript se llama el
8:07:00operador rest este operador te permite
8:07:03pasar cualquier número de argumentos a
8:07:07una función y que esos argumentos se
8:07:09agrupen como un arreglo veamos un
8:07:12ejemplo para ilustrar qué es lo que hace
8:07:14este operador vamos a definir una
8:07:18función y vamos a tomar un cierto número
8:07:21de argumentos pero ese número de
8:07:23argumentos no va a ser fijo así que la
8:07:26técnica que hemos estado usando de
8:07:28explícitamente escribir parámetros en la
8:07:31lista no nos va a funcionar porque al
8:07:35momento de llamar a la función cada uno
8:07:37de esos parámetros debe tener un valor y
8:07:41no podemos pasar más valores ni menos
8:07:43valores de los que tenemos
8:07:46explícitamente declarados en la lista
8:07:49pero para solucionar ese problema y
8:07:51crear funciones que sean más versátiles
8:07:53podemos usar el operador best que
8:07:56consiste en escribir tres puntos seguido
8:08:00de la palabra arcs esta palabra no
8:08:03necesariamente es arcs es una variable
8:08:06que estamos creando ahora que se utiliza
8:08:08para abreviar la palabra argumentos pero
8:08:11no necesariamente tiene que ser este
8:08:13nombre podemos escribir cualquier nombre
8:08:16de una variable lo importante aquí es
8:08:19que antes de ese nombre tengamos tres
8:08:21puntos este es el operador rest cuando
8:08:24lo escribimos en una lista de parámetros
8:08:27vamos a mostrar los argumentos y cómo se
8:08:31recibieron en la función vamos a llamar
8:08:34a esta función con distintos números de
8:08:38argumentos si pasamos un argumento aquí
8:08:41vemos inmediatamente que tenemos un
8:08:43arreglo con un solo elemento el
8:08:46argumento que fue el valor uno pero nota
8:08:49que es un arreglo no tenemos el
8:08:51argumento como tal sino el arreglo este
8:08:55operador convierte todos los argumentos
8:08:57en elementos de un solo arreglo o sea
8:09:00este parámetro va a ser un arreglo
8:09:04y por eso es que nos permite tomar
8:09:07cualquier número de argumentos digamos
8:09:101 y 2
8:09:12este fue el resultado del operador los
8:09:16convirtió a un arreglo con dos elementos
8:09:19y podemos así agregar cualquier número
8:09:22de argumentos
8:09:241 2 3 y 4
8:09:26también si necesitamos recibir otros
8:09:30tipos de datos van a ser agregados como
8:09:33parte de ese arreglo por ejemplo digamos
8:09:36que 1 2 3 y 4 5 y 6
8:09:40son dos arreglos dos argumentos y veamos
8:09:44qué pasó los arreglos se añaden como
8:09:47arreglos anidados del arreglo principal
8:09:51o sea que puedes estar seguro segura que
8:09:54estos elementos van a ser parte de un
8:09:56arreglo y puedes luego trabajar con ese
8:09:59arreglo en la función como esta variable
8:10:02va a ser un arreglo podemos usar también
8:10:06su propiedad ley para trabajar con ese
8:10:09arreglo en la función veamos aquí cuál
8:10:12es la longitud del arreglo 2 porque
8:10:15tenemos dos argumentos dos arreglos
8:10:18ahora si pasamos un cierto número de
8:10:20argumentos digamos aquí tenemos el valor
8:10:246 porque tenemos seis argumentos pasados
8:10:27a la función que luego fueron agregados
8:10:30o añadidos a ese regla y esta propiedad
8:10:33link es muy útil si necesitamos usar un
8:10:35ciclo que es lo que normalmente haríamos
8:10:38si queremos procesar cada uno de esos
8:10:40argumentos y tirar sobre la red
8:10:44genial ahora vamos a aplicar tu nuevo
8:10:46conocimiento del operador best para
8:10:49modificar una función manteniendo su
8:10:53funcionalidad
8:10:55existente pero ahora digamos que
8:10:57queremos extender su funcionalidad para
8:11:00que podamos pasar cualquier número de
8:11:02argumentos aquí en lugar de sólo 3 para
8:11:05x jay-z
8:11:06queremos
8:11:09aplicar su función a cualquier número de
8:11:13argumentos
8:11:15esta es la definición
8:11:18este método reduce es un método que
8:11:20puedes llamar con un arreglo este es el
8:11:24arreglo de argumentos
8:11:34para adoptar esta función para que
8:11:36reciba cualquier número de argumentos lo
8:11:39que tenemos que hacer es modificar la
8:11:41lista de parámetros que tenemos aquí
8:11:43actualmente recibe tres parámetros pero
8:11:46podemos usar el operador rest para tomar
8:11:49cualquier número de parámetros aquí
8:11:52usamos los tres puntos seguidos de arx
8:11:56recuerda que este nombre no
8:11:57necesariamente tiene que ser arcs puede
8:12:00ser cualquier otro nombre que le quieras
8:12:02asignar
8:12:04ya como este valor va a ser un arreglo
8:12:06no es necesario crear otro arreglo
8:12:09separado podemos borrar esta línea y
8:12:12directamente podemos dejar esta línea
8:12:14porque ya arts va a ser un arreglo y
8:12:17podemos llamar al método reviews genial
8:12:20ya sabes cómo usar el operador rest para
8:12:23tomar cualquier número de argumentos
8:12:25ahora vamos a ver otro operador que se
8:12:27llama el operador sprint
8:12:34ahora vamos a ver un operador que hace
8:12:37exactamente lo contrario que el operador
8:12:39best este operador nuevo se llama el
8:12:42operador sprint de este operador toma un
8:12:46arreglo y prácticamente como los
8:12:48descompone en sus elementos individuales
8:12:51para que la función pueda recibirlos y
8:12:54asignarlos a sus parámetros
8:12:56correspondientes vamos a ver un ejemplo
8:12:59vamos a declarar un arreglo con tres
8:13:01números uno dos y tres y vamos a definir
8:13:05una función sumar que toma tres números
8:13:08x y y ceta y retorna la suma en este
8:13:13caso vamos a usar el operador sprite
8:13:16porque nosotros no podemos pasar
8:13:18directamente este argumento a la función
8:13:22la función toma tres parámetros necesita
8:13:27tres valores separados y nosotros
8:13:30actualmente tenemos es un arreglo en
8:13:33lugar de escribir esto y extraer los
8:13:36valores individuales tenemos un operador
8:13:39que nos permite hacer exactamente esto
8:13:42es el mismo símbolo del operador ves
8:13:45pero ahorita en lugar de usarlo en la
8:13:48lista de parámetros lo vamos a usar en
8:13:51la llamada a la función cuando pasemos
8:13:54el argumento luego escribimos el nombre
8:13:58de la variable el nombre de la variable
8:14:01que hubiéramos pasado como argumento con
8:14:04el arreglo y esto básicamente lo que va
8:14:07a hacer es descomponer el arreglo en sus
8:14:09elementos individuales y asignarlos en
8:14:12ese mismo orden a los parámetros veamos
8:14:15el resultado con la consola tenemos el
8:14:20valor 6 que es la suma de estos números
8:14:23podemos mostrar los valores también en
8:14:26la consola y vemos x es 1 que es 2
8:14:33iceta en estrés así que los valores se
8:14:37asignaron correctamente y en el orden en
8:14:40el que aparecían en el arreglo sólo
8:14:42tenemos que usar este operador y podemos
8:14:45realizar todo este proceso fácilmente
8:14:54ahora hablemos sobre la sintaxis de
8:14:57desestructuración esta sintaxis nos
8:15:00permite asignar las propiedades de un
8:15:03objeto a variables que podemos usar en
8:15:05nuestro programa digamos que tenemos
8:15:08esto un objeto que representa un usuario
8:15:11ese usuario tiene un nombre lleno smith
8:15:15y tiene una edad 34
8:15:19anteriormente si queríamos asignar las
8:15:23propiedades nombres y edad sus valores a
8:15:26variables que es lo que tendríamos que
8:15:29haber hecho
8:15:30tomábamos el objeto usuario y asigna
8:15:35vamos el valor de esa propiedad a la
8:15:37variable y lo mismo hubiéramos hecho con
8:15:40la propiedad edad pero en el nuevo
8:15:42estándar s6 podemos hacer esto mismo en
8:15:46una sola línea
8:15:47para cualquier número de propiedades que
8:15:50quisiéramos asignar
8:15:52lo primero que hacemos es escribir const
8:15:54y luego escribimos un par de llaves
8:15:57dentro de las llaves escribimos los
8:16:00nombres de las variables que queremos
8:16:02crear las que hubiéramos creado una por
8:16:06línea
8:16:09bien
8:16:11al otro lado de la asignación vamos a
8:16:14escribir el nombre del objeto usuario
8:16:18esto básicamente lo que va a hacer es
8:16:20buscar dentro del objeto usuario y va a
8:16:24decir en existe una propiedad llamada
8:16:26nombre así que voy a asignar este valor
8:16:29a esta variable y también existe una
8:16:31propiedad llamada edad así que a esta
8:16:34variable le asignó el valor esta es
8:16:37básicamente la sintaxis de
8:16:38desestructuración más simple que podemos
8:16:41usar hay varias opciones varias opciones
8:16:44vamos a ver otro ejemplo para que
8:16:46practiquemos un poco más esta sintaxis
8:16:49digamos que tenemos un objeto que
8:16:52representa unas coordenadas
8:16:54coordenada x 4 coordenada y 6 y
8:16:58coordenada z 12
8:17:00anteriormente en ese 5 cuando estaba el
8:17:04estándar anterior tuviésemos que hacer
8:17:07esto que tenemos aquí coordenadas punto
8:17:10x para llegue coordenadas
8:17:14y para z coordenadas z pero ahora con la
8:17:20sintaxis de desestructuración podemos
8:17:23hacer esto que tenemos aquí escribimos
8:17:27la palabra clave como que también la
8:17:29podemos usar aquí si queremos declarar
8:17:32variables que no pueden ser reasignadas
8:17:35y después de consta es que vimos un par
8:17:38de llaves dentro de las llaves tenemos
8:17:41los nombres de las variables que
8:17:43queríamos crear x y y ceta que son los
8:17:47mismos nombres de las propiedades del
8:17:49objeto
8:17:50del otro lado del lado derecho
8:17:52escribimos el nombre del hombre del
8:17:54objeto coordenadas y ya podemos eliminar
8:17:58estas tres líneas porque está
8:18:01funcionando como esperábamos
8:18:05si nosotros verificamos
8:18:08el valor de x de iu y de zeta
8:18:13vamos a ver el resultado
8:18:144 6 y 12 4 6 y 12 funcionó exactamente
8:18:21como esperábamos asignamos cada valor a
8:18:24su variable correspondiente
8:18:26buen trabajo también podemos usar la
8:18:29sintaxis de desestructuración de una
8:18:31forma más elaborada si el objeto tiene
8:18:34una estructura más compleja por ejemplo
8:18:36si este valor fuese un objeto un objeto
8:18:39anidado vas a aprender cómo hacerlo en
8:18:42la próxima parte así que te ve oye
8:18:52veamos cómo podemos usar la sintaxis de
8:18:55desestructuración para objetos anidados
8:18:58vamos a crear un objeto que representa
8:19:02un usuario ese usuario vamos a llamarlo
8:19:06por ejemplo john 2 esa va a ser la
8:19:08propiedad y esa propiedad va a estar
8:19:11asociada a un objeto el objeto va a
8:19:14tener los datos de yondó que va a ser su
8:19:16edad y su correo yo ando
8:19:22fricker camps puntocom bien este es el
8:19:26objeto anidado digamos que queremos
8:19:28asignar la edad y el correo de yondó a
8:19:32variables individuales en nuestro
8:19:34programa para trabajar con ellas aquí
8:19:37puedes empezar a ver la ventaja de usar
8:19:40la sintaxis de desestructuración porque
8:19:43imagínate cómo sería acceder a los
8:19:46objetos anidados en estructuras más
8:19:48complejas una y otra vez con la sintaxis
8:19:51de de su estructura estructuración
8:19:52podemos asignar los a variables de una
8:19:55vez y trabajar con esas variables donde
8:19:58las necesitemos nuestro programa así que
8:20:00vamos a ver cómo podemos hacerlo con la
8:20:03palabra clave conste vamos a comenzar
8:20:05esta sintaxis y escribimos un par de
8:20:08llaves pero en este caso el par de
8:20:10llaves lo que va a ir dentro del par de
8:20:12llaves va a ser un poco más poco más
8:20:15elaborado el lado derecho se va a
8:20:17mantener igual es el nombre del objeto
8:20:21lo que queremos especificar dentro de
8:20:23las llaves es que propiedades vamos a
8:20:26extraer de ese objeto de usuario de la
8:20:30propiedad donde queremos extraer o
8:20:33asignar a sus variables correspondientes
8:20:36las propiedades edad y correo así es
8:20:40exactamente cómo vamos a extraer la edad
8:20:43y el correo de jong del primero
8:20:45escribimos el nombre de la propiedad que
8:20:48queremos acceder en este caso junto
8:20:51luego en llaves rodeadas por llaves
8:20:55escribimos los nombres de las
8:20:57propiedades que queremos asignar a las
8:20:59variables luego de esta línea vamos a
8:21:02poder tener estas variables disponibles
8:21:05para trabajar si mostramos sus valores
8:21:08edad y correo tenemos 27 y yondó arroz
8:21:13fríjol camps puntocom imagínate lo que
8:21:16sería acceder a edad y a correo
8:21:19el objeto anidado cada vez que lo
8:21:22necesitemos si es un valor que usamos
8:21:24muchas veces en nuestro programa podemos
8:21:26asignarlos directamente una variable y
8:21:28trabajar con esos valores también otra
8:21:32alternativa que podemos usar que es muy
8:21:34útil es que podemos asignarles a estas
8:21:37propiedades nombres distintos es como si
8:21:40los asignaremos a variables con nombres
8:21:42distintos no necesariamente tienen que
8:21:45ser edad y correo esas variables estos
8:21:48son los nombres de las propiedades y
8:21:50cómo lo hacemos luego del nombre aquí
8:21:53escribimos el nombre nuevo por ejemplo
8:21:56edad del usuario
8:21:59y en el correo escribiríamos correo de
8:22:03él
8:22:04usuario cualquier nombre que le quieras
8:22:07asignar que te parezca más descriptivo y
8:22:09así podríamos usar el nombre nuevo que
8:22:13asignamos en nuestro programa edad del
8:22:16usuario y correo del usuario
8:22:19genial si usamos los nombres originales
8:22:22de las propiedades vamos a ver que no
8:22:24están definidos como variables en
8:22:26nuestro programa esta primera línea
8:22:29resulta en un error porque edad no es
8:22:32una variable sino que este nombre que le
8:22:35aceptamos es una variable en nuestro
8:22:37programa
8:22:40veamos otro ejemplo de la sintaxis de
8:22:42texto estructuración aplicada a objetos
8:22:45anidados digamos que tenemos una
8:22:48constante una variable que la vamos a
8:22:50declarar con const ghosn que va a
8:22:54representar el pronóstico local del
8:22:56clima
8:22:57en este caso vamos a tener el pronóstico
8:23:01de ayer de hoy y de mañana
8:23:03ayer la temperatura mínima era 61 y la
8:23:09temperatura máxima era 75 en el
8:23:12pronóstico
8:23:14hoy la temperatura mínima era 64 y la
8:23:20máxima 77 veamos si se cumple y mañana
8:23:26el pronóstico es que la temperatura
8:23:27mínima sea 68 y la temperatura máxima
8:23:31sea 80 ese es nuestro pronóstico local
8:23:35del clima veamos cómo podemos usar la
8:23:38sintaxis de desestructuración para
8:23:41acceder a la temperatura mínima y máxima
8:23:44de hoy en este caso puedes ver que estoy
8:23:47usando la ñ es el nuevo carácter
8:23:50estándar en inglés así que queda de nada
8:23:53si deseas usarlo en tu programa o no en
8:23:55este caso lo estoy usando para evitar
8:23:57confusiones aunque veamos aquí una
8:24:01constante vamos a decir una constante
8:24:04para ver cómo accederíamos a esos
8:24:07valores para asignarlos a una variable
8:24:10antes de tener la sintaxis de
8:24:12desestructuración escribimos la variable
8:24:15pronóstico local
8:24:17luego el nombre de la propiedad hoy
8:24:19puedes ver que en este caso estoy
8:24:22mezclando propiedades rodeadas entre
8:24:24comillas y propiedades que no tienen
8:24:26comillas las propiedades de los objetos
8:24:28anidados no las definir con comillas
8:24:31pero ya ves que detrás de escenas los va
8:24:34a añadir así que no hay ningún problema
8:24:37porque son propiedades de una sola
8:24:39palabra bien accedemos a hoy y luego
8:24:41accedemos a la temperatura mínima y así
8:24:45las podemos asignar lo mismo con la
8:24:47máxima
8:24:48máxima hoy aquí vamos a cambiar mínimo a
8:24:51mínima para ser mínimas para ser
8:24:54consistentes temperatura mínima
8:24:57pronóstico local hoy
8:25:01máxima vamos a mostrar los valores en la
8:25:04consola para que confirmemos que los
8:25:06valores son los correctos máxima hoy le
8:25:11abramos la consola para ver los valores
8:25:1464 y 77 mínima y máxima vamos a ver aquí
8:25:2064 y 77 correcto un truco interesante
8:25:24que puedes usar con con su punto logo es
8:25:27que si separas los valores con una coma
8:25:30van a aparecer en la misma línea
8:25:32separados por un espacio aquí lo puedes
8:25:36ver 64 y 77 ahora están en la misma
8:25:39línea separados por un espacio y eso
8:25:42puede hacer que tus resultados sean más
8:25:44concisos para verlos en la consola un
8:25:47dato interesante bien ya sabemos cómo
8:25:50asignar y amos esos valores a varios
8:25:53estos valores a variables en este caso
8:25:56constantes
8:25:57pero vamos a ver cómo podemos hacer lo
8:26:00mismo con la sintaxis de
8:26:01desestructuración vamos a borrar este
8:26:04código y nuevamente escribimos cons
8:26:07porque van a ser constantes
8:26:10para la sintaxis de desestructuración
8:26:12escribimos un par de llaves en el lado
8:26:15izquierdo de la asignación escribimos el
8:26:18nombre de la propiedad hoy y luego como
8:26:22tenemos un objeto anidado escribimos
8:26:24nuevamente un par de llaves queremos
8:26:27acceder a la propiedad mínima que
8:26:29tenemos aquí pero que debemos asignarle
8:26:31otro nombre para nuestra variable mínima
8:26:35hoy eso lo hacemos con dos puntos un
8:26:38espacio y el nombre nuevo que queremos
8:26:41asignarle a la variable
8:26:44genial ya tenemos esta parte lista y en
8:26:47el lado derecho lo que falta es escribir
8:26:50el nombre del objeto de la variable
8:26:52pronóstico local usamos el nombre mínima
8:26:56hoy en nuestro código podemos acceder a
8:26:58ese valor sería 64 según el objeto
8:27:0364 es exactamente lo que tenemos aquí
8:27:06este es el único nombre que vamos a
8:27:08poder usar para ese valor en nuestro
8:27:11código si usamos el nombre de la
8:27:13propiedad vamos a tener un error aquí lo
8:27:16puedes ver si uso mínima en vez del
8:27:18nombre nuevo error de referencia mínima
8:27:21no está definida así que cuando le
8:27:25asignas un nombre nuevo a la variable y
8:27:28ese es el único nombre que puedes usar
8:27:29el nombre de la propiedad no es una
8:27:32variable ok
8:27:34vamos a intentar ahora hacer lo mismo
8:27:36para acceder al máximo a la temperatura
8:27:39máxima del pronóstico le vamos a asignar
8:27:42el nombre máxima hoy que sería 77 vamos
8:27:47a abrir la consola
8:27:4877
8:27:50exactamente lo que esperábamos
8:27:53también podemos también puedes hacer
8:27:56ambas operaciones en la misma línea
8:27:59veamos como escribes el nombre de la
8:28:03propiedad y su nombre nuevo luego el
8:28:06nombre de la otra propiedad que queremos
8:28:08asignar y su nombre para la variable y
8:28:11así podemos asignar ambas propiedades en
8:28:15la misma línea
8:28:17para comprobar que tenemos acceso a
8:28:19ambos valores vamos a mostrar los
8:28:21mínimos y máxima hoy veamos
8:28:2564 y 77 exactamente lo que esperábamos a
8:28:30partir de este objeto del pronóstico
8:28:32genial ya sabes cómo usar la sintaxis de
8:28:36desestructuración con objetos anidados
8:28:38para una o varias variables y como
8:28:42asignarles un nombre nuevo para las
8:28:44variables de tu programa buen trabajo
8:28:46esto va a ser muy útil para trabajar con
8:28:49objetos en javascript
8:28:51así que continuemos con nuestro
8:28:52siguiente tema
8:28:59y la sintaxis de desestructuración
8:29:01también funciona con arreglos y nos
8:29:04permite asignar valores a variables
8:29:07usando arreglos ya vas a ver cómo lo
8:29:10podemos usar por ejemplo si queremos
8:29:13asignar los valores 1 y 2 a la variable
8:29:17a y b a estas dos variables podemos
8:29:20hacerlo con esta sintaxis claro primero
8:29:24tenemos que declarar las variables en el
8:29:27programa y luego podemos asignarles un
8:29:30valor usando está sintaxis o en
8:29:32cualquier punto del programa en
8:29:34cualquier momento de la ejecución del
8:29:36programa que necesitamos vamos a mostrar
8:29:39el valor de las variables con con su
8:29:41punto log a y b aquí vemos los valores 1
8:29:45y 2 at en el valor 1 y b tiene el valor
8:29:492 los valores se asignan en el mismo
8:29:52orden que aparecen en el arreglo y si
8:29:55tuviéramos una tercera variable se
8:29:58asignaría el tercer valor en el orden
8:30:01aquí podemos mostrar la variable y está
8:30:04en los tres valores 1 2 y 3 también
8:30:07podemos asignar los valores a un número
8:30:10menor de variables
8:30:12si nosotros queremos
8:30:14asignar solo los dos primeros valores
8:30:17del arreglo a estas dos variables
8:30:19podemos hacerlo sin ningún problema con
8:30:22la sintaxis de desestructuración estos
8:30:25valores no van a asignarse a ninguna
8:30:28variable solo estos dos primeros aquí
8:30:31los tenemos 1 y 2 también podemos saltar
8:30:35posiciones para asignar los valores
8:30:38digamos que tenemos una tercera variable
8:30:42y a esa variable queremos asignarle el
8:30:45valor 5 tenemos que saltar dos
8:30:48posiciones en el arreglo para asignar el
8:30:50valor 5 así que lo que hacemos es
8:30:54escribir 3 comas para indicar que
8:30:56queremos saltarnos la tercera y cuarta y
8:30:59cuarta posición del arreglo para llegar
8:31:01a la quinta y allí si escribimos la
8:31:04variable
8:31:07también podríamos dejar el espacio aquí
8:31:09y llegamos a hacer vamos a comprobar que
8:31:12el valor de acs efectivamente 5 aquí lo
8:31:16tenemos 1 2 y 5 depende del número de
8:31:19comas dos comas representan un espacio
8:31:22como si aquí no hubiese nada en el medio
8:31:26y se salta esa posición la sintaxis de
8:31:29desestructuración también puede usarse
8:31:31para cambiar o intercambiar los valores
8:31:34de dos variables veamos como puedes
8:31:37hacerlo si tenemos dos variables digamos
8:31:41a
8:31:41ive con los valores 8 y 6 podemos usar
8:31:47la sintaxis de desestructuración para
8:31:50arreglos para intercambiar su valor
8:31:52queremos que ahora tenga el valor 6 y b
8:31:56tenga el valor 8
8:31:58veamos cómo podemos hacerlo simplemente
8:32:00escribimos un arreglo del lado izquierdo
8:32:03con las variables a las cuales queremos
8:32:06asignar los valores en este caso serían
8:32:09b y a ya vas a ver porque estoy
8:32:12invirtiendo el orden y en el lado
8:32:14derecho escribimos otro arreglo pero en
8:32:18este arreglo vamos a escribir los
8:32:19valores que queremos asignarle a las
8:32:22variables en el orden en el que queremos
8:32:25asignar las aves queremos asignarle el
8:32:28valor de a así que aquí escribimos a se
8:32:32va a asignar ave y luego queremos
8:32:36asignar el valor de b
8:32:39así que la escribimos del segundo
8:32:41el valor que está en este arreglo el
8:32:45arreglo del lado derecho se va a asignar
8:32:47a su variable correspondiente en el
8:32:50mismo índice del arreglo luego de
8:32:53escribir esta línea de código podemos
8:32:56verificar los valores de ahí bebé vamos
8:32:59a decimos a escribirlos aquí a ive y
8:33:01podemos verlos en la consola ahora tiene
8:33:05el valor 6 y ve tiene el valor 8
8:33:08inicialmente de al revés ha tenido el
8:33:10valor 8 y ve tenía el valor 6 así que
8:33:13podemos usar la sintaxis de
8:33:16desestructuración para intercambiar su
8:33:18valor en una sola línea genial ya sabes
8:33:22cómo usar la sintaxis de
8:33:24desestructuración para arreglos puedes
8:33:27ver que es muy versátil y muy poderosa y
8:33:29seguramente la va a usar en sus
8:33:31programas de javascript
8:33:33así que continuemos con nuestro
8:33:35siguiente tema
8:33:44veamos cómo puedes usar la sintaxis de
8:33:47desestructuración con el operador rest
8:33:50recuerda que el operador best agrupaba
8:33:54los elementos y formaba un arreglo
8:33:56cuando lo usábamos con funciones
8:33:59agrupaban los argumentos en este caso
8:34:02vamos a usar ese operador para reasignar
8:34:04un arreglo en varias variables veamos
8:34:08este ejemplo primero declaramos la
8:34:11variable luego declaramos la variable p
8:34:14y vamos a usar la sintaxis de
8:34:17desestructuración aquí tenemos dos
8:34:20variables a esas dos variables le vamos
8:34:23a asignar los valores 1 y 2 1 se va a
8:34:27asignar a y 2 se va a asignar a ver aquí
8:34:30tengo una coma porque después de esas
8:34:33dos variables vamos a asignar el resto
8:34:36de los números todos los números que
8:34:38vengan después
8:34:40a un arreglo un arreglo nuevo que vamos
8:34:43a crear con estos elementos como lo
8:34:45podemos hacer con el operador ves los
8:34:48tres puntos que tenemos aquí y luego una
8:34:52variable
8:34:54esta variable la podemos escribir
8:34:56directamente
8:34:57aquí y se va a asignar a esa variable
8:35:01todos estos elementos esta variable la
8:35:04tenemos que declarar también en nuestro
8:35:07código para que funciona vamos a mostrar
8:35:10el valor de la variable y luego el valor
8:35:13de la variable p y finalmente el valor
8:35:16de la variable al arreglo a ver qué
8:35:21valores tienen asignados vemos que la
8:35:24variable a tiene el valor uno asignado
8:35:27que era lo que predecíamos el valor dos
8:35:30también se asignó a be pero aquí todos
8:35:33los demás elementos del arreglo fueron
8:35:36asignados a un arreglo particular así
8:35:40que esta es una forma de usar el
8:35:41operador rest para racing para reasignar
8:35:44un arreglo veamos otro ejemplo en el que
8:35:47vamos a usar este principio para remover
8:35:50los tres primeros elementos de un
8:35:52arreglo
8:35:53inicialmente vamos a tener este arreglo
8:35:56con los elementos
8:35:57del 1 hasta el 8 8 números
8:36:01y vamos a definir una función que va a
8:36:03remover los tres primeros elementos el
8:36:08parámetro también podría ser abreviado
8:36:10como ar estoy escribiendo arreglo
8:36:13y qué vamos a hacer aquí vamos a primero
8:36:17a declarar una variable nuevo arreglo
8:36:20que va a
8:36:22tener el nuevo arreglo que vamos a
8:36:25generar sin los tres primeros elementos
8:36:28vamos a usar la sintaxis de
8:36:30desestructuración para arreglos y vamos
8:36:33a usar el principio que vimos en uno de
8:36:35los ejemplos anteriores donde saltábamos
8:36:38lugares antes de llegar al valor que
8:36:41queríamos con las comas las comas nos
8:36:44permiten decir no quiero asignar el
8:36:46primer valor a nada no quiero asignar el
8:36:48segundo valor a nada y como queremos
8:36:51remover los tres primeros deberíamos
8:36:53agregar otra coma y luego sí vamos a
8:36:56asignar esos valores que sobren a el
8:37:00nuevo arreglo
8:37:01en este caso como ya estamos declarando
8:37:03la variable aquí arriba
8:37:05no necesitamos escribir const pero si
8:37:08queremos declarar la en la misma línea
8:37:10podemos usar aquí por ejemplo var o
8:37:13comes dependiendo de lo que queríamos
8:37:16crear podemos hacerlo en la misma línea
8:37:18y que vamos a asignar a esta estructura
8:37:21el arreglo que tomamos como argumento
8:37:24bien
8:37:25finalmente vamos a retornar ese valor
8:37:28nuevo arreglo vamos a llamar a la
8:37:31función pasando el arreglo inicial y
8:37:34vamos a tener un arreglo final sin los
8:37:37tres elementos
8:37:39iniciales sin los tres el primeros
8:37:41elementos
8:37:42va a mostrar el arreglo final
8:37:46veamos si esta cantidad de comas es la
8:37:48adecuada para remover los tres elementos
8:37:50aquí podemos ver el resultado 4 5 6 7 y
8:37:548 estos son los elementos del arreglo
8:37:58que si queríamos conservar y eliminamos
8:38:01los primeros tres elementos simplemente
8:38:04con una sola línea
8:38:06genial ya puedes trabajar con la
8:38:09sintaxis de desestructuración para
8:38:11trabajar con arreglos y reasignarlos
8:38:14felicitaciones por llegar hasta este
8:38:16punto del curso continua y ánimo porque
8:38:19ya estás aprendiendo mucho sobre
8:38:20javascript y vas a poder aplicar tus
8:38:23conocimientos a tus propios proyectos
8:38:35la sintaxis de desestructuración también
8:38:38se puede usar para pasar un objeto como
8:38:41argumento es realmente sorprendente la
8:38:44versatilidad de esta sintaxis vamos a
8:38:46ver en este caso cómo pasar un objeto
8:38:49como argumento primero que todo para
8:38:52nuestro ejemplo necesitamos un objeto
8:38:56que va a representar el nuevo perfil de
8:38:59un cliente los datos actualizados su
8:39:02nombre game those su edad es 24 su
8:39:06nacionalidad es digamos española y su
8:39:10ubicación es españa tenemos nuestro
8:39:13objeto ahora como vamos a actualizar ese
8:39:17perfil
8:39:18vamos a hacerlo con una función
8:39:22actualizar perfil
8:39:25vamos a definir una función flecha en
8:39:29este caso esa función flecha va a tomar
8:39:32la información
8:39:33de perfil del cliente y va a actualizar
8:39:37el perfil pero en realidad no vamos a
8:39:41implementar esa actualización del perfil
8:39:43lo que vamos a hacer es ver cómo podemos
8:39:45tomar este objeto y descomponerlo cuando
8:39:49lo pasamos como un argumento si no lo
8:39:51descomponemos y simplemente escribimos
8:39:54este parámetro la información de perfil
8:39:56que va a ser un objeto podemos
8:39:59descomponerlo ya dentro de la función
8:40:02escribimos const seguido de las llaves
8:40:06la sintaxis de desestructuración que ya
8:40:09aprendiste y escribimos las propiedades
8:40:12nombre edad nacionalidad y ubicación y
8:40:16del otro lado del lado derecho
8:40:17escribimos el nombre del objeto y
8:40:20podemos mostrar el nombre la edad la
8:40:24nacionalidad y la ubicación es lo que
8:40:26vamos a hacer en esta función
8:40:29y vamos a llamar a la función pasando
8:40:32como argumento el nuevo perfil del
8:40:34cliente
8:40:35este objeto que tenemos aquí se va a
8:40:39asignar a este parámetro y luego vamos a
8:40:44desglosar lo descomponerlo en sus
8:40:47propiedades nombre edad nacionalidad y
8:40:50ubicación éstas van a ser variables que
8:40:53podemos utilizar en la función variables
8:40:55locales y en las vamos a mostrar vamos a
8:40:58mostrar su valor veamos
8:41:00efectivamente el nombre siendo su edad
8:41:0324 nacionalidad española y ubicación
8:41:07españa pero en este caso estamos tomando
8:41:10el objeto completo si nosotros mostramos
8:41:13con con su punto lo que representa
8:41:17información de perfil vamos a ver que
8:41:20obtenemos obtenemos un objeto el objeto
8:41:23completo que se pasó como argumento hay
8:41:26otra forma con la sintaxis de
8:41:28desestructuración de descomponer ese
8:41:31objeto directamente en la lista de
8:41:34parámetros para asignar las variables
8:41:37individuales es muy práctico vamos a ver
8:41:40cómo lo podemos hacer en lugar de este
8:41:42parámetro vamos a escribir un par de
8:41:45llaves dentro de la lista de parámetros
8:41:47y vamos a escribir el nombre de la
8:41:50propiedad que queremos asignar en este
8:41:53caso tenemos cuatro propiedades que
8:41:55queremos extraer nombre edad
8:41:58nacionalidad y ubicación así podemos de
8:42:02una vez directamente asignar los valores
8:42:06a variables independientes a variables
8:42:09que podemos usar en nuestra función y
8:42:13así el cuerpo de la función también es
8:42:15más conciso veamos la consola vemos el
8:42:19mismo resultado el nombre es james edad
8:42:2324 nacionalidad española y ubicación
8:42:26españa no necesariamente tenemos que
8:42:29tomar todos los valores tampoco como
8:42:32argumento por ejemplo podemos
8:42:35simplemente tomar el nombre y la edad
8:42:38aquí los tendríamos y vamos a ver la
8:42:40consola y vemos yendo y 24 así que
8:42:44también nos sirve para seleccionar
8:42:46propiedades específicas para la función
8:42:49del objeto que vamos a tomar como
8:42:52argumento aquí del nuevo perfil del
8:42:54cliente solo estamos tomando el nombre y
8:42:57la edad y los podemos usar en la función
8:43:00ahora vamos a ver otro ejercicio otro
8:43:02ejemplo de cómo puedes pasar un objeto
8:43:05usando la sintaxis de desestructuración
8:43:08vamos a definir un objeto que se llame
8:43:11estadísticas estas propiedades serían
8:43:15marx el maximo
8:43:1756.78 desviación estándar
8:43:22434
8:43:24mediana
8:43:2734.54
8:43:29moda
8:43:3223.87
8:43:34mínimos el valor mínimo de el conjunto
8:43:37de datos es menos 0.75 y el promedio
8:43:42sería
8:43:4535.85
8:43:47estas son nuestras estadísticas si están
8:43:49representadas como un objeto ese objeto
8:43:53lo podemos pasar digamos a una función
8:43:55flecha digamos que inicialmente tenemos
8:43:59esta función flecha
8:44:02que calcula el punto medio del intervalo
8:44:06entre el máximo y el mínimo podemos
8:44:08llamarlo también en mitad la mitad o el
8:44:11punto medio entre el máximo y el mínimo
8:44:13del conjunto de estadísticas tomaría un
8:44:16parámetro que se va a llamar
8:44:20estadísticas pero no tiene nada que ver
8:44:22con
8:44:24este objeto si quieres también podemos
8:44:26abreviar lo como é o
8:44:29ponerle un nombre más descriptivo
8:44:32y qué vamos a hacer con esas
8:44:33estadísticas vamos a tomar el máximo y
8:44:37el mínimo
8:44:39lo vamos a sumar y los vamos a dividir
8:44:41entre 2.0 eso es lo que va a ser la
8:44:44función flecha lo suma y luego divide
8:44:48entre 2 pero cómo podemos reescribir
8:44:51esta función para usar la sintaxis de
8:44:54desestructuración lo primero que tenemos
8:44:56que hacer es analizar qué propiedades de
8:44:59ese objeto vamos a necesitar en la
8:45:02función el máximo y el mínimo en este
8:45:04caso así que simplemente
8:45:07escribimos esas propiedades en la lista
8:45:12de parámetros rodeados por llaves
8:45:14escribimos máximo y escribimos mínimo y
8:45:18como ya son variables con las que
8:45:20podemos trabajar en nuestra función
8:45:23reemplazamos esto por máximo más mínimo
8:45:27y bueno así las tenemos esto va a
8:45:31asignar cada propiedad a su variable
8:45:33correspondiente
8:45:34vamos a ver vamos a llamar a la función
8:45:38mitad pasando el objeto estadísticas y
8:45:42veamos el resultado
8:45:44el valor resultante es 28 puntos 0 15
8:45:48que sería el resultado de sumar el
8:45:50máximo con el mínimo y dividirlo entre 2
8:45:53genial ya ha visto un ejemplo de cómo
8:45:56puedes cambiar una función para usar
8:45:59esta sintaxis de desestructuración
8:46:01tienes que identificar qué propiedades
8:46:04vas a necesitar en la función y
8:46:06simplemente las escribes aquí entre
8:46:08llaves y esas propiedades esos valores
8:46:11se van a asignar a variables con las
8:46:13cuales puedes trabajar en la función te
8:46:16veo en el siguiente tema
8:46:24hablar sobre un tipo especial de cadena
8:46:27de caracteres que nos permite crear
8:46:29cadenas con varias líneas y reemplazar
8:46:32los valores de las variables que
8:46:34necesitemos fácilmente en una cadena las
8:46:38características principales de las
8:46:40plantillas literales o las plantillas de
8:46:42cadenas son que se definen usando el
8:46:46acento invertido bactec este tipo de
8:46:50cadena especial se llaman plantillas
8:46:52literales o también plantillas de
8:46:55cadenas estas son sus características
8:46:57principales se usa el acento invertido
8:47:00en inglés se llamaba ctic este símbolo
8:47:04en lugar de comillas pueden contener
8:47:08comillas simples y comillas dobles
8:47:11recuerda que antes cuando usábamos
8:47:13comillas no podíamos usar el mismo tipo
8:47:15de comilla dentro de la cadena
8:47:18pero ahora como estamos definiendo las
8:47:20plantillas con bhakti con el acento
8:47:23invertido no vamos a tener problemas con
8:47:26eso podemos usar cualquier tipo de
8:47:28comillas dentro de la cadena las líneas
8:47:31de la plantilla se preservan como se
8:47:34escriben en el código si escribes la
8:47:37cadena en tres o cuatro líneas esas tres
8:47:39o cuatro líneas se van a preservar
8:47:41incluyendo todos sus espacios y así se
8:47:44va a mostrar y una de las cosas más
8:47:47importantes que puedes hacer en este
8:47:49tipo de cadena es que para reemplazar
8:47:52una variable se escribe esta expresión
8:47:54el nombre de la variable rodeada por
8:47:58llaves y antes de las llaves un signo de
8:48:02dólar este signo que tenemos aquí esto
8:48:04nos permite reemplazar el valor de la
8:48:07variable en la cadena y la vamos a poder
8:48:09escribir como parte de la cadena ya vas
8:48:12a ver que va a ser muy útil y dentro de
8:48:14este conjunto de símbolos también puedes
8:48:16escribir expresiones por ejemplo puedes
8:48:19multiplicar una variable por 2 o sumar
8:48:22un valor
8:48:23y escribir una expresión y el resultado
8:48:26de esta expresión se va a reemplazar en
8:48:28la cadena
8:48:30bien veamos algunos ejemplos
8:48:33si definimos una variable con un valor
8:48:36inicial 6
8:48:38y mostramos una cadena una plantilla de
8:48:42cadena primero tenemos que usar batik el
8:48:45acento invertido
8:48:47y escribimos la cadena como normalmente
8:48:50lo hacemos el valor de a es
8:48:54normalmente aquí hubiésemos concatenado
8:48:57la cadena con la variable
8:48:59cierto y hubiésemos dejado un espacio
8:49:02aquí para mejorar la presentación para
8:49:05que hubiera una separación pero con las
8:49:08plantillas de cadenas o plantillas
8:49:10literales ya es mucho más fácil
8:49:12reemplazar el valor de una variable lo
8:49:14único que hacemos es escribir esta
8:49:17secuencia de símbolos el signo de dólar
8:49:19seguido de llaves y dentro de las llaves
8:49:24escribimos el nombre de la variable
8:49:27esto le dice a javascript que queremos
8:49:29reemplazar el valor de esa variable en
8:49:32la cadena si vemos la consola puedes ver
8:49:35que el valor se reemplazó el valor 6 y
8:49:39es mucho más fácil de leer y de escribir
8:49:41las cadenas veamos otro ejemplo con una
8:49:44cadena de caracteres
8:49:46tenemos una variable digamos con una
8:49:48cadena de caracteres no ahora su edad va
8:49:52a ser 66 añitos
8:49:54si creamos una plantilla literal una
8:49:57plantilla de cadena podemos reemplazar
8:49:59el valor de cada una de estas variables
8:50:02digamos mi nombre es el valor de nombre
8:50:05y tengo tantos años esto va a ser muy
8:50:09útil para ti si te quieres adentrar
8:50:12también en desarrollo web porque puedes
8:50:14personalizar el valor de las cadenas
8:50:16fácilmente y escribirlas de forma más
8:50:19concisa para presentárselas al usuario
8:50:21también como puedes ver podemos usar
8:50:23cualquier tipo de comillas dentro de la
8:50:26cadena porque estamos definiendo la con
8:50:29acento invertido o bactec si abrimos la
8:50:32consola mi nombre es no ahora el nombre
8:50:34se reemplazo y tengo seis años aquí ves
8:50:38el valor de la edad los dos valores
8:50:40correctos que correspondían a esas
8:50:42variables
8:50:43genial también podemos reemplazar otros
8:50:46tipos de datos por ejemplo arreglos
8:50:48digamos que tenemos otro ejemplo y vamos
8:50:53a definir un arreglo 1 2 3 y 4 vamos a
8:50:57mostrar una plantilla de cadena una
8:50:59plantilla literal
8:51:02que incluya el arreglo el arreglo es
8:51:07me arreglo aquí deberíamos ver los
8:51:10elementos del arreglo y como lo
8:51:13esperábamos vemos los elementos del
8:51:15arreglo
8:51:16si queremos mostrar el arreglo de esta
8:51:18forma más presentable podemos usar este
8:51:22método jason que es un tipo de datos que
8:51:25usamos para representar trata
8:51:27normalmente en
8:51:29notación
8:51:31se llama javascript update notation es
8:51:34un formato que nos permite presentar
8:51:36objetos de forma mucho más
8:51:39legible mucho más fácil de entender
8:51:42jason tiene un método que se llama
8:51:45string ifai que convierte un valor en
8:51:48javascript a una cadena de caracteres
8:51:51que sigue el formato jason si aplicamos
8:51:55este método al arreglo podemos verlo
8:51:58aquí mucho más presentable pero aun así
8:52:01el valor de esta expresión fue
8:52:03reemplazado en la plantilla literal
8:52:06genial también podemos reemplazar el
8:52:09valor de las propiedades de un objeto
8:52:11veamos un ejemplo
8:52:13digamos que un objeto representa una
8:52:16persona o un cliente y lo casa
8:52:21y eso edad es días ahora tenemos un
8:52:24objeto lugar de variables individuales o
8:52:27variables separadas con un objeto
8:52:29también podemos crear una plantilla
8:52:31literal vamos a ver otra variación en
8:52:35lugar de escribir la plantilla literal
8:52:37directamente en con su punto lo podemos
8:52:40asignarle a una variable digamos saludo
8:52:43lo que hacemos es escribir las vãctimas
8:52:46y crear nuestra plantilla que va a ser
8:52:49asignada a esta variable que en este
8:52:51caso actúa como una constante así que
8:52:54deberíamos escribirla en mayúscula hola
8:52:58mi nombre es
8:53:01y aquí queremos reemplazar el nombre del
8:53:04objeto persona como lo hacemos con
8:53:08notación de punto el nombre de la
8:53:11variable que contiene el objeto seguido
8:53:14de la propiedad nombre hola mi nombre es
8:53:17tal y tengo
8:53:20tantos años
8:53:22de la misma forma podemos acceder a la
8:53:24edad y completamos nuestra plantilla si
8:53:28queremos mostrarla usamos con su logo y
8:53:31aquí tenemos el saludo hola mi nombre es
8:53:34chino cast este valor se reemplazo y
8:53:38tengo 10 este valor se reemplazó años
8:53:42genial también vimos la variación de que
8:53:44podemos crear la plantilla y asignar la
8:53:48a una variable o una constante en este
8:53:51caso buen trabajo ya sabes cómo trabajar
8:53:54con plantillas literales o plantillas de
8:53:57cadenas en java es que así que pasemos a
8:53:59nuestro siguiente tema ya nos quedan
8:54:01pocos temas para culminar el curso
8:54:03felicitaciones por llegar hasta este
8:54:05punto continúa así sigue con el buen
8:54:08trabajo y nos vemos en el próximo tema
8:54:17veamos una forma de crear objetos de
8:54:20forma mucho más concisa en javascript
8:54:23digamos que tenemos una función que se
8:54:26llama crear persona esa función va a ser
8:54:30una función flecha que va a tomar tres
8:54:33parámetros nombre edad e idioma luego
8:54:37escribimos la flecha y cómo va a tener
8:54:40más de una línea tenemos que rodear ese
8:54:44cuerpo de la función con llaves que va a
8:54:46retornar esta función va a retornar un
8:54:49objeto y esta es una forma de crear
8:54:52objetos en nuestro programa cuando
8:54:55llamemos a la función nos va a retornar
8:54:57un objeto cuál va a ser la estructura de
8:55:00ese objeto va a tener una propiedad para
8:55:04el nombre con el valor de este parámetro
8:55:07va a tener una propiedad edad con el
8:55:11valor de este parámetro y va a tener una
8:55:14propiedad idioma con el valor de este
8:55:17parámetro esta va a ser la estructura
8:55:19del objeto ya vamos a crear personas con
8:55:22el nombre chino es mi edad 28 idioma
8:55:28español bien veamos la consola aquí
8:55:31vemos nombres y no es mi edad 28 idioma
8:55:35español perfecto tenemos el objeto pero
8:55:38hay una forma todavía más concisa de
8:55:41poder escribir esta función flecha en
8:55:44una sola línea veamos lo que podemos
8:55:47hacer es simplemente
8:55:50luego de la flecha
8:55:52escribir el objeto rodeado por
8:55:55paréntesis de una forma más concisa
8:55:57vamos a borrar todo esto
8:55:59de este lado de la flecha del lado
8:56:01derecho
8:56:02escribimos un par de paréntesis y dentro
8:56:05de los paréntesis llaves esas llaves le
8:56:08van a decir a javascript que queremos
8:56:10retornar un objeto y cuál va a ser la
8:56:13estructura del objeto esta que tenemos
8:56:16aquí va a tener una propiedad nombre con
8:56:20el valor de este parámetro una propiedad
8:56:22edad con el valor de este parámetro y
8:56:25una propiedad idioma con el valor de
8:56:27este parámetro esto es básicamente lo
8:56:30que le estamos diciendo a javascript
8:56:32crea un objeto con esta estructura las
8:56:35propiedades van a tener los mismos
8:56:36nombres de los parámetros y sus valores
8:56:40se van a reemplazar cuando se cree el
8:56:42objeto veamos el resultado en la consola
8:56:45podemos ver que el resultado es
8:56:47exactamente el mismo nombre jim smith el
8:56:51valor de este parámetro se asigna aquí a
8:56:53esta propiedad edad 28 idioma español
8:56:58convertimos algo que nos hubiera tomado
8:57:00varias líneas a una función flecha en
8:57:03una sola línea
8:57:04genial ya sabes cómo escribir objetos de
8:57:07forma más concisa en javascript
8:57:17también puedes declarar funciones dentro
8:57:21de los objetos que crees en tu programa
8:57:24veamos cómo puedes hacerlo y cómo puedes
8:57:27usar una versión más concisa con el
8:57:29estándar s 6 en nueva estándar vamos a
8:57:33definir un objeto vamos a crearlo en el
8:57:36programa llamado persona esa persona ese
8:57:40objeto va a tener un nombre
8:57:41digamos isabel
8:57:45y ahora va a tener una función asociada
8:57:48esa es parte de la versatilidad de los
8:57:51objetos
8:57:52podemos definir propiedades con sus
8:57:54correspondientes valores y también
8:57:56propiedades que sean funciones digamos
8:57:59que queremos que isabel se pueda
8:58:01presentar
8:58:02para eso vamos a crear una propiedad que
8:58:06se llame presentar se va a ser una
8:58:08función vamos a poder llamar a esta
8:58:11función a través del objeto
8:58:14escribimos function paréntesis vacíos
8:58:18porque en este caso la función no va a
8:58:20tomar ningún parámetro y luego llaves
8:58:23dentro de las llaves
8:58:24escribimos el cuerpo de la función
8:58:27digamos que queremos retornar la
8:58:29siguiente plantilla literal o plantilla
8:58:32de cadena hola mi nombre es
8:58:36y aquí dentro de la función
8:58:39podemos usar el valor de alguna
8:58:41propiedad digamos que queremos
8:58:43reemplazar el nombre del objeto aquí
8:58:45como lo podemos hacer con la combinación
8:58:48de símbolos que aprendiste para las
8:58:50plantillas literal es el símbolo de
8:58:53dólar seguido de llaves y dentro de las
8:58:56llaves escribimos esto que ves aquí des
8:59:00punto nombre la palabra this tiene una
8:59:04función muy especial en java esker
8:59:06porque se refiere al objeto con el que
8:59:09estamos trabajando en este caso ustedes
8:59:13se refiere al objeto persona al nombre
8:59:17de esta persona al nombre de este objeto
8:59:20cuando usamos d es seguido de un punto y
8:59:23luego el nombre de la propiedad esa
8:59:26propiedad se va a buscar en el objeto
8:59:28actual en el objeto que contiene la
8:59:31palabra test en este caso sería este
8:59:33valor
8:59:34vamos a llamar a esta función como la
8:59:37podemos llamar escribimos el nombre de
8:59:40la variable que contiene ese objeto y
8:59:43curiosamente vamos a poder usar el
8:59:45nombre de esta propiedad como si fuera
8:59:47el nombre de la función escribimos el
8:59:50nombre de la propiedad presentarse
8:59:52seguido de paréntesis vacíos como no
8:59:56toma ningún parámetro esta función
8:59:58porque aquí tenemos paréntesis vacíos
9:00:01escribimos también paréntesis vacíos
9:00:03para llamar a la función
9:00:10pero como estamos retornando este valor
9:00:13tenemos que mostrarlo en la consola
9:00:17también en lugar de retornar lo
9:00:19podríamos mostrar el mensaje
9:00:20directamente vamos a ver el resultado
9:00:24hola mi nombre es y saber puedes ver que
9:00:28el valor de la propiedad nombre del
9:00:31objeto fue reemplazada aquí en la
9:00:33plantilla literal genial ya sabes cómo
9:00:36definir funciones que están asociadas a
9:00:39objetos específicos y cómo llamar a esas
9:00:42funciones y también cómo usar
9:00:44propiedades del objeto dentro de esas
9:00:48funciones acuérdate que tienes que usar
9:00:50test seguido un punto y el nombre de la
9:00:53propiedad esta es la sintaxis que
9:00:56hubiésemos usado anteriormente pero con
9:00:58el estándar nuevo es6 podemos
9:01:02simplificar nuestro código aún más para
9:01:04definir esta función lo que podemos
9:01:07hacer es simplemente quitar aquí los dos
9:01:09puntos y la palabra clave function
9:01:12paréntesis vacíos aquí la cual sería la
9:01:15lista de parámetros hubiesen parámetros
9:01:17justo inmediatamente del nombre de la
9:01:20propiedad
9:01:21como si estuviésemos definiendo una
9:01:23función con este nombre prácticamente
9:01:25así es como se ve visualmente vamos a
9:01:29ver cómo funciona luego de estos cambios
9:01:30el resultado es exactamente el mismo
9:01:33hola mi nombre es isabel no hubo ningún
9:01:36cambio y logramos escribir código más
9:01:38conciso y más fácil de leer
9:01:41recuerda quitamos los dos puntos y la
9:01:43palabra clave function y simplemente
9:01:46escribimos el nombre de la función
9:01:48seguido de la lista de parámetros bien
9:01:51ya sabes cómo definir funciones
9:01:53asociadas a objetos en javascript esto
9:01:56es muy útil para expandir la
9:01:57funcionalidad de los objetos en tu
9:01:59programa
9:02:08a ver cómo puedes declarar una clase en
9:02:10javascript una clase es simplemente algo
9:02:14parecido a un plano de un edificio o de
9:02:17un objeto que nos permite crear muchos
9:02:21objetos con la misma estructura las
9:02:23mismas propiedades y la misma
9:02:25funcionalidad es un plano general que
9:02:27nos permite escribir código una sola vez
9:02:29y re usarlo para crear tantos objetos
9:02:32como necesitemos en nuestro programa
9:02:34veamos un ejemplo class significa clase
9:02:38en español luego de la palabra clave
9:02:40class
9:02:42escribimos el nombre de la clase el
9:02:45nombre del tipo de objeto que vamos a
9:02:47crear digamos que queremos representar
9:02:50un transbordador espacial en nuestro
9:02:54código un transbordador espacial que va
9:02:57a tener ciertas propiedades este
9:03:00transbordador espacial
9:03:02va a tener un estado inicial que lo
9:03:05podemos inicializar con esta función
9:03:08asociada al objeto que vamos a definir
9:03:10que se llama constructor
9:03:12y constructor en español podríamos
9:03:15traducirlo como constructor es la
9:03:17función que se va a llamar
9:03:18automáticamente cuando creemos un objeto
9:03:21de este tipo de transbordador espacial
9:03:25esa función se va a llamar
9:03:26automáticamente y va a tomar este
9:03:30parámetro que nosotros definimos planeta
9:03:33debemos saber cuál es el planeta de
9:03:36destino para este transbordador espacial
9:03:38y lo vamos a asignar
9:03:41como una propiedad ese planeta va a ser
9:03:44una propiedad del objeto y para eso
9:03:48usamos está sintaxis el objeto
9:03:51transbordador espacial va a tener una
9:03:53propiedad llamada planeta
9:03:56cuando escribimos ustedes nos estamos
9:03:58refiriendo al objeto que estamos creando
9:04:01estamos básicamente diciendo vamos a
9:04:04asignar el valor del parámetro a la
9:04:06propiedad planeta del objeto que estamos
9:04:09creando
9:04:10eso es básicamente lo que estamos
9:04:12haciendo algo importante que debes saber
9:04:15es que el nombre de las clases que
9:04:18creamos en javascript deberían seguir
9:04:20una convención llamada o perca monkeys
9:04:23que es similar a lo que hemos usado
9:04:25hasta ahora cada palabra comienza con
9:04:28una letra mayúscula pero también la
9:04:32primera palabra comienza con una letra
9:04:34mayúscula
9:04:35esto es una convención que usamos en
9:04:37javascript que se recomienda y se
9:04:39sugiere para escribir código que siga
9:04:42los estándares del lenguaje así que ya
9:04:44sabes los nombres de las clases
9:04:46comienzan con la letra mayúscula
9:04:49algo que debes saber también es que en
9:04:51realidad cuando usamos la palabra clave
9:04:54clave aquí debes saber que ya vas que en
9:04:57realidad no está creando una clase
9:04:59completamente funcional como la que
9:05:02crearíamos en python wen jiabao en otros
9:05:04lenguajes de programación sino que
9:05:07simplemente estamos escribiendo de forma
9:05:10más concisa una forma distinta de crear
9:05:13un objeto no tiene todas todas las
9:05:15capacidades de una clase en otros
9:05:17lenguajes de programación
9:05:18pero sí nos permite crear objetos en
9:05:22nuestro programa vamos a ver un ejemplo
9:05:25si queremos crear un transbordador
9:05:27espacial que se llame zeus
9:05:30vamos a definir una variable
9:05:33zeus y vamos a crear un nuevo objeto
9:05:36creamos un objeto en javascript con la
9:05:39palabra clave new seguido del nombre de
9:05:42la clase y entre paréntesis los
9:05:45argumentos que requiera el constructor
9:05:48en este caso es el planeta de destino
9:05:52ese planeta es júpiter en este caso para
9:05:55este objeto en particular
9:05:57así que estamos creando un objeto de
9:06:00tipo transbordador espacial que va a
9:06:02tener una propiedad planeta esa
9:06:05propiedad va a tener como valor júpiter
9:06:08vamos a comprobarlo vamos a tratar de
9:06:11acceder a la propiedad planeta del
9:06:14objeto zeus y veamos en la consola
9:06:18aquí tenemos júpiter exactamente lo que
9:06:21esperábamos
9:06:22ahora vamos a crear otro objeto y vamos
9:06:24a llamarlo a polo este va a ser otro
9:06:28transbordador espacial pero su planeta
9:06:30de destino va a ser martes
9:06:33ahora vamos a usar este objeto a polo y
9:06:37acceder a su propiedad planeta
9:06:40aquí la podemos ver marte es el valor
9:06:43del planeta para polo
9:06:46genial ya sabes cómo usar la palabra
9:06:49clave class para crear una clase en
9:06:52javascript y poder crear objetos veamos
9:06:55otro ejemplo si quiero definir una clase
9:06:59que represente a mi mascota
9:07:01puedo hacerlo con el estándar nuevo
9:07:05escribimos constructor
9:07:09y va a tomar dos parámetros nombre y
9:07:11edad voy a asignar el valor de nombre a
9:07:16una propiedad llamada el nombre para el
9:07:19objeto y lo mismo voy a hacer con la
9:07:21edad
9:07:23así cuando creemos una mascota por
9:07:25ejemplo mi mascota va a ser un nuevo
9:07:29objeto va a tener por nombre en ahora su
9:07:33edad de cinco
9:07:35y ya después de esta línea podemos
9:07:37trabajar con el objeto va a tener una
9:07:39propiedad llamada nombre y una propiedad
9:07:42llamada edad a las cuales podemos
9:07:44acceder actualizar y eliminar y con las
9:07:47cuales podemos trabajar en general todas
9:07:49las operaciones que aprendiste durante
9:07:51el curso
9:07:53con su punto log mi mascota
9:07:56edad si las vemos aquí en la consola
9:07:59puedes ver que si los valores son los
9:08:01que esperábamos no hora y 5 podemos
9:08:03reutilizar este código cuántas veces
9:08:05necesitamos para crear cuantos objetos
9:08:08necesitemos por ejemplo podemos crear
9:08:11otro objeto que se llame tu mascota esa
9:08:14mascota se va a llamar chino y su edad
9:08:17va a ser 2
9:08:18puedes ver que estamos re utilizando el
9:08:21código para crear dos mascotas distintas
9:08:23y cada una va a tener sus propios
9:08:26valores para sus propiedades y van a ser
9:08:28independientes genial ya sabes cómo
9:08:31definir una clase en javascript esto es
9:08:34muy útil para evitar repetir códigos y
9:08:36para crear una plantilla general de la
9:08:39estructura de un tipo de objeto
9:08:41bien pasemos a nuestro siguiente tema ya
9:08:45estamos llegando al final del curso buen
9:08:47trabajo por llegar hasta aquí te
9:08:49felicito
9:08:50así que continuemos
9:08:57y ahora expandamos nuestro concepto de
9:08:59un objeto ya sabes que los objetos
9:09:02pueden tener funciones asociadas a esos
9:09:05objetos también podemos definir
9:09:08funciones en una clase para que cuando
9:09:10creemos un objeto ese objeto tenga todas
9:09:13esas funciones asociadas pero hay dos
9:09:17funciones específicas que se llaman kers
9:09:21y servers que nos van a permitir
9:09:23proteger la data de ese objeto ya vamos
9:09:27a ver
9:09:28vamos a declarar una clase llamada libro
9:09:31esa clase va a tener un constructor el
9:09:35libro va a tener un autor y vamos a
9:09:38crear una propiedad llamada autor pero
9:09:41así como la estamos definiendo en este
9:09:43momento podemos cambiar el valor del
9:09:47autor en cualquier momento y a cualquier
9:09:49valor eso podría ser una posible fuente
9:09:53de errores si lo cambiamos a un valor
9:09:55que no es válido por ejemplo que el
9:09:57autor sea un número o un autor que no
9:10:01corresponde a ese libro por eso en
9:10:04javascript podemos proteger esa data
9:10:07haciendo que nuestras variables sean
9:10:09privadas por convención
9:10:12agregando un guión bajo antes del nombre
9:10:16de la propiedad aquí
9:10:18esto le dice a otros desarrolladores que
9:10:20no deberían modificar este valor solo se
9:10:24debe usar internamente dentro de la
9:10:27clase sin embargo en la práctica
9:10:30técnicamente no hace que la propiedad
9:10:32sea privada no es privada porque igual
9:10:35se podría acceder si agregamos el guión
9:10:37bajo en el nombre pero por convención ya
9:10:41eso es una señal para otros
9:10:43desarrolladores de que no se debe
9:10:45acceder aún así podemos dar acceso si lo
9:10:48deseamos a esa propiedad con los
9:10:51guerreros y los servers los querer son
9:10:53métodos que nos permiten obtener el
9:10:56valor de una propiedad privada una
9:10:59propiedad que tiene un guión bajo antes
9:11:02de su nombre nos permite acceder a ese
9:11:05valor de forma indirecta así protegemos
9:11:08el valor no lo estamos cambiando
9:11:10directamente como definimos hunger get
9:11:14en español significa obtener podríamos
9:11:17traducirlo así
9:11:19método su propósito es retornar este
9:11:22valor para que podamos usarlo en nuestro
9:11:25programa de forma indirecta
9:11:26escribimos que luego el nombre de la
9:11:30propiedad autor y aquí paréntesis vacíos
9:11:34luego retornamos ese valor retornamos
9:11:38tres puntos jon bajo autor
9:11:42como puedes ver solamente estamos
9:11:44retornando este valor de la propiedad
9:11:47del objeto cuando accedamos a la
9:11:50propiedad autor vamos a obtener este
9:11:53valor pero está protegido porque tiene
9:11:56un intermediario durante el proceso esto
9:11:59nos permite obtener un valor pero
9:12:01también podemos definir un server un
9:12:04saber es una función que nos permite
9:12:06actualizar el valor de una propiedad y
9:12:10son muy útiles porque podemos verificar
9:12:13el valor nuevo antes de asignarlo si no
9:12:16usamos un ser entonces podríamos cambiar
9:12:19este valor a cualquier valor aunque no
9:12:22sea válido pero con un setter podemos
9:12:24usar condicionales para verificar si es
9:12:27válido en este ejemplo simplemente vamos
9:12:31a asignar un nuevo autor tomamos el
9:12:34valor del parámetro y lo asignamos a la
9:12:36propiedad autor
9:12:38genial tenemos nuestro querer y tenemos
9:12:40nuestro ser recuerda que aquí podría
9:12:43haber un condicional para verificar si
9:12:45este valor es válido y asignarlo o no
9:12:48dependiendo de si es válido vamos a
9:12:50probarlo creando un objeto
9:12:54nuevo de tipo libro el autor va a ser
9:12:59anónimo si mostramos el autor de este
9:13:02objeto en la consola vamos a ver lo
9:13:06siguiente anónimo exactamente lo que
9:13:09especificamos aquí este valor del autor
9:13:12puedes ver que aunque en realidad no
9:13:15tenemos una propiedad llamada autor sino
9:13:17que la propiedad se llama autor con un
9:13:20guión bajo adelante aún así podemos
9:13:23acceder a la propiedad simplemente
9:13:25escribiendo autor eso es gracias a que
9:13:28definimos aquí un game y le asignamos
9:13:31ese nombre autor nosotros cuando
9:13:34escribimos esto llamamos al quieren y
9:13:36este valor se obtiene indirectamente a
9:13:39través del guerrero
9:13:40podemos confirmarlo si también aquí
9:13:43agregamos con su punto log
9:13:46vamos a ver la consola
9:13:48exactamente aquí vemos el mensaje de
9:13:51querer porque se está llamando el
9:13:53guerrero antes de retornar el valor
9:13:54anónimo
9:13:56bien ahora vamos a probar cómo funciona
9:13:59el server si queremos actualizar el
9:14:02valor de la propiedad autor podemos
9:14:04hacerlo también
9:14:06directamente y gracias al ceder se va a
9:14:09actualizar como puedes ver actúan como
9:14:11intermediarios
9:14:13nuevamente luego de la actualización
9:14:15vamos a mostrar el valor del autor y
9:14:18aquí vamos a borrar el consumidor del
9:14:21querer vamos a agregar un consumo en el
9:14:24ser vamos a ver si en realidad se está
9:14:27llamando el server cuando cambiamos el
9:14:29valor cuando la actualizadas
9:14:31aquí lo puedes ver tenemos el autor
9:14:33anónimo que es el autor inicialmente
9:14:35luego cambiamos el valor llamando al
9:14:38share y el nuevo valor se asignó que si
9:14:41no es mes
9:14:43genial ya sabes cómo trabajar con kers y
9:14:46servers en javascript recuerda que aquí
9:14:49puedes escribir un condicional para
9:14:52determinar si el nuevo valor es válido o
9:14:54no para que no hayan cambios inesperados
9:14:56que puedan generar errores
9:15:00gracias por ver el curso espero que te
9:15:02haya gustado y que te haya sido de
9:15:04utilidad te invito a suscribirte a
9:15:06nuestro canal de freak el campeón
9:15:07español

About this transcript

This page contains the full transcript of Aprende JavaScript - Curso Completo desde Cero by freeCodeCamp Español, generated from the public captions YouTube serves with the video. The transcript has 77,530 words across 12,111 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to translate the transcript into 100+ languages.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, translation to 100+ languages, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.