subir/Curso de Fundamentos de JavaScript/01-Introducción a JavaScript/05-Tipos de Datos en JavaScript Primitivos y Complejos.vtt

WEBVTT

00:00.000 --> 00:04.680
En JavaScript tenemos 10 tipos de datos y
ellos se agrupan en

00:04.680 --> 00:07.560
dos, los primitivos y los complejos.

00:07.560 --> 00:11.720
Entre ellos tenemos, para los primitivos,
string, number,

00:11.720 --> 00:15.840
boolean, null, indefinido, symbol y begin.

00:15.840 --> 00:19.720
Y entre los complejos tenemos los objetos,
los arrays y

00:19.720 --> 00:20.920
también las
funciones.

00:20.920 --> 00:23.760
Vamos al código para revisar cómo
escribimos cada uno de

00:23.760 --> 00:24.600
ellos.

00:24.600 --> 00:28.000
Vamos a comenzar escribiendo los tipos de
datos que son

00:28.000 --> 00:29.360
primitivos.

00:29.360 --> 00:33.640
Y con ellos, por supuesto, vamos a
comenzar con los strings.

00:33.640 --> 00:37.080
Estos son, en esencia, cadenas de caracteres.

00:37.080 --> 00:40.880
Los escribimos normalmente, colocándole
ese nombre de

00:40.880 --> 00:44.680
variable que queremos y seguido vamos a
colocar o comillas

00:44.680 --> 00:46.680
simples o comillas
dobles.

00:46.680 --> 00:50.280
A mí me encantan las comillas simples y
podemos colocar,

00:50.280 --> 00:51.320
por ejemplo,
tere.

00:51.320 --> 00:54.600
Aquí puedes colocar punto y coma o también
puedes ignorar el

00:54.600 --> 00:56.560
punto y coma porque ya JavaScript lo hace
por

00:56.560 --> 00:57.760
nosotros.

00:57.760 --> 01:00.600
Por otro lado, tenemos los tipos de datos
que son

01:00.600 --> 01:03.840
numéricos o number, que en esencia también
nos va a

01:03.840 --> 01:05.760
indicar un
número.

01:05.760 --> 01:08.480
Y ello también lo vamos a escribir con un
nombre de

01:08.480 --> 01:10.200
variable, en este caso, por ejemplo,

01:10.200 --> 01:15.240
para indicar la edad de tere y le podemos
colocar 25.

01:15.240 --> 01:17.720
Otro tipo de datos serían los booleanos.

01:17.720 --> 01:19.760
Vamos a colocar acá
boolean.

01:19.760 --> 01:22.640
Nuevamente vamos a escribir un nombre de
variable.

01:22.640 --> 01:27.120
Por ejemplo, vamos a decir si es mayor de
edad o no es mayor de

01:27.120 --> 01:29.960
edad, que para esto nos sirven los
booleanos para indicar si

01:29.960 --> 01:32.160
eso es verdadero o si es
falso.

01:32.160 --> 01:36.320
Y aquí le colocamos es mayor de edad.

01:36.320 --> 01:40.680
Le estamos como preguntando y él nos va a
decir si es verdad o

01:40.680 --> 01:41.080
si
no.

01:41.080 --> 01:44.080
Entonces, si es verdad, le colocamos true
o si no,

01:44.080 --> 01:45.880
le podemos colocar
false.

01:45.880 --> 01:49.120
Entonces, en este caso, claro, ella es
mayor de edad.

01:49.120 --> 01:53.520
Seguido, vamos a colocar el tipo de dato nulo.

01:53.520 --> 01:56.040
Estos tipos de datos nulos nos indican,

01:56.040 --> 01:58.120
así como su nombre le indica, un vacío,

01:58.120 --> 02:00.920
como si no existiera absolutamente nada.

02:00.920 --> 02:04.400
Pero también nos ayuda muchísimo
justamente para saber si hay

02:04.400 --> 02:05.600
algo o si
no.

02:05.600 --> 02:09.880
Entonces, podríamos decir, no hay valor,

02:09.880 --> 02:11.440
como si fuera una
pregunta.

02:11.440 --> 02:14.880
Y acá le vamos a decir, en efecto, está vacío.

02:14.880 --> 02:19.560
Entonces, este nul nos va a indicar o nos
va a asegurar que

02:19.560 --> 02:20.920
no hay nada
allí.

02:20.920 --> 02:24.120
Por otro lado, también hay otro muy
similar que se llama

02:24.120 --> 02:25.000
undefined.

02:25.000 --> 02:28.120
Entonces,
undefined.

02:28.120 --> 02:30.040
Y vamos a colocar un
nombre.

02:30.040 --> 02:32.120
Aquí se me borró este
nul.

02:32.120 --> 02:34.040
Y colocamos nuevamente un
nombre.

02:34.040 --> 02:36.640
Puede ser no
definido.

02:36.640 --> 02:38.880
Y acá le decimos
undefined.

02:38.880 --> 02:43.000
Entonces, este tipo de dato también nos
sirve para indicar

02:43.000 --> 02:45.680
que, en efecto, tampoco hay
nada.

02:45.680 --> 02:49.640
Este valor normalmente no lo colocamos
nosotros como

02:49.640 --> 02:50.980
programadores.

02:50.980 --> 02:53.720
Esto, en esencia, no lo da JavaScript.

02:53.720 --> 02:58.120
Es decir, si no hay nada o no hay un valor
definido,

02:58.120 --> 03:01.240
como su nombre lo indica, JavaScript nos
va a decir,

03:01.240 --> 03:04.240
en esencia, no está definido o no hay nada.

03:04.240 --> 03:06.640
Este nul, nosotros como programadores,

03:06.640 --> 03:10.600
sí lo utilizamos para indicar que no hay
algo como tal.

03:10.600 --> 03:13.840
Entonces, acá, lo único que hay que tener
en cuenta es que

03:13.840 --> 03:16.600
esto normalmente no lo da JavaScript para
indicarnos

03:16.600 --> 03:17.360
algo.

03:17.360 --> 03:21.080
Y nosotros, como programadores, podemos
utilizar este para

03:21.080 --> 03:23.080
indicar que, en efecto, hay algo vacío.

03:23.080 --> 03:26.440
Aunque JavaScript también nos puede
arrojar esto en algún

03:26.440 --> 03:30.080
momento de la existencia en nuestro código.

03:30.080 --> 03:34.040
Ahora, vamos a seguir con otros dos que no
son tan utilizados,

03:34.040 --> 03:37.280
pero que también es importante tenerlos en
cuenta por si los

03:37.280 --> 03:39.240
necesitamos en algún
momento.

03:39.240 --> 03:40.320
Ellos son
quiénes?

03:40.320 --> 03:43.880
El símbolo que nos va a indicar un valor
único.

03:43.880 --> 03:46.320
Entonces, si queremos que algo sea único,

03:46.320 --> 03:49.660
como un ID de un usuario, podemos utilizar,
por ejemplo,

03:49.660 --> 03:50.760
este
símbolo.

03:50.760 --> 03:51.840
¿Cómo lo
colocamos?

03:51.840 --> 03:56.480
De nuevo, escribimos nuestra variable
símbolo único.

03:56.480 --> 04:00.120
Y allí le vamos a colocar su
correspondiente valor.

04:00.120 --> 04:02.480
¿Cómo vamos a escribir un
símbolo?

04:02.480 --> 04:07.040
Le decimos símbol y le colocamos entre
paréntesis el

04:07.040 --> 04:11.240
valor que nosotros queremos colocar o
asignar como valor

04:11.240 --> 04:12.200
único.

04:12.200 --> 04:14.080
Y también lo colocamos entre comillas,

04:14.080 --> 04:16.320
puede ser comillas simples en este caso.

04:16.320 --> 04:18.320
Y le decimos, por ejemplo,
único.

04:18.320 --> 04:20.760
Entonces, lo único que hay que tener en
cuenta es que lo

04:20.760 --> 04:25.120
tenemos que añadir a esa forma de
escritura para que ya le

04:25.120 --> 04:28.360
entienda que es un valor completamente único.

04:28.360 --> 04:31.440
Y el último sería datos muy grandes.

04:31.440 --> 04:34.040
En cuanto a números, ¿qué pasaría si
queremos tener el

04:34.040 --> 04:36.040
número pi, pero
gigantesco?

04:36.040 --> 04:39.960
Entonces, él nos va a permitir almacenar
este tipo de valores.

04:39.960 --> 04:40.960
Vamos a
escribirlo.

04:40.960 --> 04:43.080
Sería big
int.

04:43.080 --> 04:47.560
Y aquí, en este big int, colocamos de
nuevo un nombre de

04:47.560 --> 04:50.840
variable, puede ser número
grande.

04:50.840 --> 04:53.880
Y allí le podemos colocar
2n.

04:53.880 --> 04:56.600
Este sería uno de los números más grandes
que tenemos en

04:56.600 --> 04:57.640
JavaScript.

04:57.640 --> 05:01.680
Así ya quedarían nuestros tipos de datos
que son primitivos.

05:01.680 --> 05:06.600
Por otro lado, tenemos los tipos de datos
que son complejos.

05:06.600 --> 05:10.680
Voy a cerrar aquí nuestra terminal y vamos
a colocar

05:10.680 --> 05:14.280
unos comentarios para ya empezar con los
complejos.

05:14.280 --> 05:19.680
Y estos complejos son, en esencia, objeto,
object.

05:19.680 --> 05:21.280
¿Y cómo lo vamos a
escribir?

05:21.280 --> 05:23.520
Vamos a escribir un nombre de variable,

05:23.520 --> 05:25.480
que en este caso puede ser
carro.

05:25.480 --> 05:29.000
Y ese carro yo quiero que tenga varias
características.

05:29.000 --> 05:34.520
Por ejemplo, que tenga una marca, el modelo,
el color.

05:34.520 --> 05:37.640
Y cada vez que nosotros queremos añadirle
como varias

05:37.640 --> 05:40.480
características a algo en particular,

05:40.480 --> 05:42.840
así es que escribimos nosotros como ese
objeto.

05:42.840 --> 05:45.320
Entonces, vamos a abrir
llaves.

05:45.320 --> 05:49.680
Vamos a decirle en este caso que ese carro
tiene una marca,

05:49.680 --> 05:51.680
Tesla, por
ejemplo.

05:51.680 --> 05:52.640
Tesla.

05:52.640 --> 05:55.440
Y que también tiene, por ejemplo, un modelo,

05:55.440 --> 05:59.320
modelo, que es Model
S.

05:59.320 --> 06:02.440
Entonces, aquí ya estamos haciendo un objeto,

06:02.440 --> 06:05.000
porque en esencia vamos a escribir carro,

06:05.000 --> 06:08.080
que es el que nosotros queremos, y le
estamos definiendo unas

06:08.080 --> 06:10.080
características
propias.

06:10.080 --> 06:13.080
¿Como cuál? ¿Como la marca o como el
modelo?

06:13.080 --> 06:16.440
Por otro lado, tenemos lo que son los arrays,

06:16.440 --> 06:20.440
que también en otros lenguajes les puedes
conocer como listas.

06:20.440 --> 06:21.720
¿Cómo las
escribimos?

06:21.720 --> 06:24.600
Le decimos let
frutas.

06:24.600 --> 06:28.040
En este caso, vamos a escribir como un
conjunto de esas

06:28.040 --> 06:28.600
frutas.

06:28.600 --> 06:32.320
Entonces, cada vez que queremos escribir
un conjunto de algo,

06:32.320 --> 06:36.360
un grupo de algo, justamente utilizamos
los arrays.

06:36.360 --> 06:39.760
Estos los escribimos con estos corchetes.

06:39.760 --> 06:43.920
Y por dentro vamos a empezar a escribir
como manzana,

06:43.920 --> 06:45.040
banano, lo que
sea.

06:45.040 --> 06:47.880
Entonces, acá podemos poner, por ejemplo,
manzana.

06:47.880 --> 06:50.560
Luego, podemos poner
banano.

06:50.560 --> 06:53.600
Podemos colocar
uvas.

06:53.600 --> 06:57.800
Y ya aquí tendríamos nuestro grupo de frutas.

06:57.800 --> 06:58.680
¿Dentro de
qué?

06:58.680 --> 07:00.600
Dentro de un
array.

07:00.600 --> 07:04.080
Las funciones, vamos a escribir aquí
nuestro título,

07:04.080 --> 07:06.160
las vamos a escribir de la siguiente manera.

07:06.160 --> 07:09.360
Primero, hay una palabra clave que es
function.

07:09.360 --> 07:12.320
Entonces, la empezamos a escribir de esa
manera.

07:12.320 --> 07:14.480
Y luego le debemos colocar un nombre,

07:14.480 --> 07:16.520
como por ejemplo,
saludar.

07:16.520 --> 07:19.800
Y adicional, tiene dos cosas muy importantes.

07:19.800 --> 07:24.680
La primera es algo como que está esperando
un contenido,

07:24.680 --> 07:26.640
como bueno, ¿a quién quiero
saludar?

07:26.640 --> 07:28.400
Por ejemplo, entonces, yo le puedo decir,

07:28.400 --> 07:30.480
ah, yo quiero saludar a
Pepito.

07:30.480 --> 07:33.960
Entonces, acá voy a colocar toda esta
información que quiero

07:33.960 --> 07:37.480
que llegue a esa función y que la voy a
necesitar para el

07:37.480 --> 07:38.960
contenido de esa
función.

07:38.960 --> 07:43.720
Y por otro lado, vamos a colocar unas
llaves y ahí va el cuerpo

07:43.720 --> 07:45.400
de toda nuestra
función.

07:45.400 --> 07:48.480
Esto tiene muchas formas de escribirse.

07:48.480 --> 07:51.240
También nosotros utilizamos otro tipo de
funciones,

07:51.240 --> 07:53.680
pero en esencia, lo más importante acá es
que

07:53.680 --> 07:57.080
conozcamos que las funciones también hacen
parte de los

07:57.080 --> 08:09.640
tipos de datos que son complejos en
JavaScript.