Tipos de datos en JavaScript

Este artículo explica los tipos de datos en JavaScript.

YouTube Video

Tipos de datos en JavaScript

JavaScript tiene tipos de datos para clasificar valores, que pueden dividirse ampliamente en tipos primitivos y tipos de objetos. Los tipos de datos determinan qué tipo de datos se almacenan en una variable e influyen en cómo se pueden manipular.

Tipos Primitivos

Los tipos primitivos son tipos de datos simples que representan un solo valor. JavaScript tiene los siguientes 7 tipos primitivos.

number

1let num = 42;
2let pi = 3.14;
3
4console.log("Value of num:", num);
5console.log("Value of pi:", pi);

• number es un tipo utilizado para manejar valores numéricos, incluidos enteros y números de punto flotante (decimales). Manejar valores que exceden ciertos límites resulta en Infinity o NaN (Not-a-Number, no es un número).

1// Decimal calculations
2console.log(0.1 + 0.2 === 0.3); // false
3console.log(0.1 + 0.2); // 0.30000000000000004
4
5// Calculations with large numbers
6console.log(9007199254740991 + 1); // correct value
7console.log(9007199254740991 + 2); // incorrect value

• En JavaScript, los números se representan como números de punto flotante. Como resultado, ciertos decimales (especialmente aquellos que no pueden representarse con precisión en binario) pueden no expresarse de manera exacta.
• Cuando se requieren cálculos precisos, como en el caso de valores monetarios, es necesario evitar tales errores de redondeo. Por ejemplo, puedes usar BigInt o ajustar el número de decimales con toFixed().

string

1let greeting = "Hello, world!";
2let char = 'A';
3const message = `"${greeting}" in JavaScript`;
4
5console.log("Value of greeting:", greeting);
6console.log("Value of char:", char);
7console.log("Value of message:", message);

• string es un tipo de datos utilizado para manejar texto, representando una secuencia de caracteres. Se representa encerrando el texto entre comillas simples (') o comillas dobles ("). A partir de ES6, los literales de plantilla permiten una fácil incrustación de variables utilizando comillas invertidas (). Para incrustar una variable, utiliza la sintaxis ${}.

boolean

1let isAvailable = true;
2let hasError = false;
3
4console.log("Value of isAvailable:", isAvailable);
5console.log("Value of hasError:", hasError);

• boolean representa un valor lógico y solo puede tener dos valores: true o false. Se utiliza como resultado de expresiones condicionales o como una bandera.

null

1let result = null;
2
3console.log("Value of result:", result);

• null es un tipo de dato que indica explícitamente 'sin valor'. null es asignado por los desarrolladores para indicar un vacío intencional.

undefined

1let score;
2let subject = undefined;
3
4console.log("Value of score:", score);     // undefined
5console.log("Value of subject:", subject);

• undefined es un tipo de dato que significa 'indefinido'. undefined se asigna automáticamente cuando se declara una variable pero no se le asigna un valor.

bigint

1let bigIntValue = 9007199254740991n;
2let anotherBigInt = 123456789012345678901234567890n;
3
4console.log("Value of bigIntValue:", bigIntValue);
5console.log("Value of anotherBigInt:", anotherBigInt);

• bigint es un tipo de datos para manejar números enteros grandes. bigint permite la representación precisa de números enteros grandes que no pueden ser representados por el tipo number. Los literales de bigint se representan añadiendo n al final de un número.
• bigint es un tipo para manejar números enteros de tamaño arbitrario, sin limitaciones de rango. Sin embargo, bigint y number no pueden operar directamente juntos, por lo que se requiere precaución.

Symbol

1let sym1 = Symbol('id');
2let sym2 = Symbol('id');
3
4console.log("sym1 === sym2:", sym1 === sym2); // false

• Symbol es un tipo de dato utilizado para crear identificadores únicos. Se crea usando Symbol() y se puede usar como una propiedad de un objeto. A diferencia de otros tipos primitivos, Symbol tiene valores únicos, por lo que incluso con el mismo contenido, se trata como un Symbol diferente.

Tipos de Objetos

Los tipos de objetos son estructuras de datos que pueden almacenar múltiples valores. Un objeto es una colección de pares clave-valor y puede tener propiedades y métodos.

Object

1let person = {
2    name: "John",
3    age: 30,
4    isEmployee: true
5};
6console.log(person.name); // John

• Object es una colección de propiedades (pares clave-valor) que pueden almacenar varios tipos de datos. Los objetos se representan con llaves {}, y cada propiedad está conectada por : entre la clave y el valor.

Array

1let numbers = [10, 20, 30];
2console.log(numbers[0]); // 10
3console.log(numbers[1]); // 20
4console.log(numbers[2]); // 30
5console.log(numbers[3]); // undefined

• Array es una lista que contiene varios valores de manera ordenada. Los arreglos se representan con corchetes [], y los valores están separados por comas ,. Cada elemento se accede utilizando un índice que comienza en 0.

Function

1function greet(name) {
2    return "Hello, " + name;
3}
4console.log(greet("Alice")); // Hello, Alice

• Las funciones son un tipo de objeto y bloques de código reutilizables. Las funciones se pueden definir usando la palabra clave function.

Otros Tipos de Objetos

• JavaScript también tiene tipos de objetos incorporados, como Date, RegExp, Map y Set. Estos manejan datos según casos de uso específicos.

Conversión de Tipos

En JavaScript, se realizan con frecuencia conversiones de tipos implícitas y explícitas.

Conversión de Tipo Implícita

• JavaScript puede convertir automáticamente los tipos al realizar operaciones entre diferentes tipos.

1let result = 5 + "5"; // "55" (the number is converted to a string)
2
3console.log(result);

• En este ejemplo, el número 5 se convierte implícitamente en una cadena, resultando en la cadena "55".

Conversión de Tipo Explícita

• Los desarrolladores también pueden realizar conversiones de tipo explícitamente.

1let num = "123";
2let convertedNum = Number(num); // Converts "123" to the number 123
3
4console.log(typeof num);
5console.log(typeof convertedNum);

• En este ejemplo, la función Number() se utiliza para convertir explícitamente la cadena "123" en el número 123.

Verificación de Tipos

En JavaScript, puedes usar el operador typeof para verificar el tipo de dato de una variable.

 1// Output: The type of 42 is: number
 2console.log('The type of 42             is:', typeof 42);
 3
 4// Output: The type of 42 is: bigint
 5console.log('The type of 42n            is:', typeof 42n);
 6
 7// Output: The type of "hello" is: string
 8console.log('The type of "hello"        is:', typeof "hello");
 9
10// Output: The type of true is: boolean
11console.log('The type of true           is:', typeof true);
12
13// Output: The type of undefined is: undefined
14console.log('The type of undefined      is:', typeof undefined);
15
16// Output: The type of null is: object
17console.log('The type of null           is:', typeof null);
18
19// Output: The type of Symbol() is: symbol
20console.log('The type of Symbol()       is:', typeof Symbol());
21
22// Output: The type of {} is: object
23console.log('The type of {}             is:', typeof {});
24
25// Output: The type of function () {} is: function
26console.log('The type of function () {} is:', typeof function () {});

Conclusión

• Los tipos primitivos incluyen number, string, boolean, null, undefined y symbol.
• Los tipos de objetos incluyen Object, Array, Function, entre otros.
• Dado que ocurren tanto conversiones automáticas como explícitas de tipos, es importante entender el uso adecuado de los tipos de datos.

Puedes seguir el artículo anterior utilizando Visual Studio Code en nuestro canal de YouTube. Por favor, también revisa nuestro canal de YouTube.

YouTube Video