Cuando programamos lo que hacemos es manipular datos, pero ¿qué son los datos? : Los datos son cualquier tipo de información que podemos almacenar en nuestros programas, por ejemplo, tu nombre, edad o altura, toda esta información son datos que se pueden almacenar en un programa de algún lenguaje de programación. En este apartado veremos los tipos de datos en JavaScript y sus características.

JavaScript cuenta con seis tipos de datos primitivos : String, Number, Boolean, Symbol, Undefined y Null

y un tipo de dato mas complejo llamado Object (Estos incluyen los Arrays, funciones y objetos literales)

Los tipos en programación se utilizan para clasificar datos particulares, por ejemplo: los string y los números son diferentes y serán tratados de formas diferentes.

Cuando utilizamos un tipo de dato en especifico determinamos que valores podemos asignarle, es decir, para poder realizar operaciones con variables en JavaScript o cualquier lenguaje de programación es importante tener en cuenta el tipo de dato asignado.

Javascript y su tipado dinámico

JavaScript es un lenguaje dinámicamente  tipado o de tipado débil, esto significa que no es necesario declarar el tipo de variable antes de usarla pues será determinado automáticamente cuando el programa comience a ser procesado. Por lo tanto una variable no se asocia con ningún tipo, sin embargo su valor sí lo hace.

En otras palabras, la misma variable puede contener valores de diferentes tipos y que estos cambien en cualquier momento. Veamos un ejemplo:

let myVariable;
    myVariable = 'Hola mundo'; // string
    myVariable = 2000;         // number
    myVariable = true;         // boolean
    myVariable = undefined;    // undefined

Como podemos notar en el ejemplo anterior a la variables en JavaScript se le pueden asignar diferentes tipos de datos a lo largo del programa, estos no necesitan ser declarados explicitamente con algún tipo en especifico.

Podemos utilizar el operador especial typeof para obtener el tipo actual de una variable.
let myVariable = 'Hola mundo';
console.log(typeof myVariable);
// "string"

Tipo de dato: String (Cadena de caracteres)

En JavaScript un string no es mas que una secuencia de cero o más caracteres (letras, números, símbolos, espacios e incluso emojis) en formato UTF-16 y contenidas dentro de un par de comillas simples '..', comillas dobles ".." o invertidas `..`

let variable = "Comillas dobles";
let variable = 'Comillas simples';
let variable = `String con bacticks`;

Podemos optar por utilizar cualquier tipo de comillas para definir un string en JavaScript, pero cualquiera que sea la decisión debe permanecer coherente dentro del programa, es decir un string que comienza con comillas simple debe terminar con una comillas simple.


Los string en JavaScript son inmutables, esto significa que no puede modificar una cadena una vez que se crea. Sin embargo, podemos crear nuevos strings basados en operaciones con el string original. Como lo hacemos en el siguiente ejemplo:

let str = 'fundamentos de';
str = str + ' JavaScript';

console.log(str);
// "fundamentos de JavaScript"

En el ejemplo anterior utilizamos el operador + para concatenar los strings. el motor de JavaScript crea un nuevo string que contiene el nuevo string 'fundamentos de JavaScript' y destruyendo los string originales originales 'fundamentos de' y ' JavaScript'.


Usando la función constructora

También podemos crear un objeto string utilizando la siguiente función constructora:

new String('Hola mundo');

Esto creará una nuevo string que es igual al string literal 'hola mundo', aunque se clasificará como un objeto en lugar de un tipo de dato primitivo. Por esta razón es preferible utilizar la notación literal del string, por no mencionar que requiere menos escritura.

Verifiquemos el tipo de dato generado por la función constructora de los string:

console.log( typeof new String('Hola mundo') );
// "object"

Tipo de dato: Numero

JavaScript usa el formato IEEE-754 para representar los números y estos pueden ser enteros o números de punto flotante (a menudo denominados ‘decimales’ o ‘flotantes’).

let numero_1 = 250;   // Numero entero
let numero_2 = 2.500; // decimales o flotantes
JavaScript tiene un solo tipo de número, no hay una designación separada para los números enteros y de punto flotante. Debido a esto los números se pueden escribir con o sin decimales

JavaScript no distingue entre enteros y decimales de punto flotante, a ambos se les da el tipo de “número”, algo particular en JavaScript. Este comportamiento se establece en la especificación ECMAScript, pero desde ES6 se proporciona un método práctico llamado Number.isInteger() que se puede usar para verificar si un número es un número entero.

console.log( Number.isInteger(250) );
console.log( Number.isInteger(2.500) );
// true
// false


Números octales y hexadecimales

Si un número comienza con 0x se considera que está en notación hexadecimal (base 16), estos se usan casualmente por ejemplo para definir los códigos de color en la Web.

console.log( 0xAF );
// 175

En el ejemplo anterior A representa 10 y F representa 15.

ES6 ahora admite literales octales: si un número comienza con un cero, seguido de la letra o, se considera que está en notación octal (base 8): 0o47

Notación exponencial

Los números también se pueden representar en notación exponencial, que es una abreviatura de “multiplicar por 10 a la potencia de…” (es posible que haya escuchado esto como “notación científica” o “forma estándar”)

console.log( 1e6 ); // 1 multiplicado por 10 a la potencia 6 (un millón)
console.log( 2E3 ); // 2 multiplicado por 10 ^ 3 (dos mil)
// 1000000
// 2000


También es importante tener en cuenta que los números en JavaScript se consideran precisos hasta 15 dígitos. Eso significa que los números se redondearán después de alcanzar el dígito 16:

console.log( 999999999999999 );
console.log( 9999999999999999 );
// 999999999999999
// 10000000000000000


Además de representar números, el tipo de number en JavaScript también tiene tres valores simbólicos disponibles:

  • Infinity : Valor numérico que representa un número positivo que se acerca al infinito
  • -Infinity : Valor numérico que representa un número negativo que se acerca al infinito
  • NaN : Valor numérico que representa un no-número, NAN (Not A Number)

Infinity o -Infinity será devuelto si calcula un número fuera del mayor número posible disponible en JavaScript. Esto también ocurrirá para los valores que no están definidos, como cuando se divide por cero:

console.log( 5 / 0 );
console.log( -5 / 0 );
// Infinity
// -Infinity

Como comentamos anteriormente NaN significa No es un número. De hecho, significa Número inválido. Este tiene dos características especiales:

  1. Cualquier operación con NaN devuelve NaN.
  2. NaN no es igual a ningún valor, incluyéndose a sí mismo.
console.log( "texto" * 20 );
console.log( NaN / 2 );
console.log( NaN == NaN );
// NaN
// NaN
// false


Usando la función constructora

Al igual que los strings, los números también tienen una función constructora: new Number(3) y al igual que los strings el tipo generado es de tipo object.

console.log(  typeof new Number(3) );
// "object"

Tipo de dato: Booleano

El tipo de datos booleano puede ser uno de dos valores: true o false (verdadero/falso). Estos se utilizan para representar valores asociados con la rama lógica de las matemáticas.

console.log( typeof true );
console.log( typeof false );
// "boolean"
// "boolean"

Cada valor en JavaScript tiene un valor booleano y la mayoría de ellos son true (estos son conocidos como truthy values ). Para encontrar el valor booleano de algo podemos usar la función Boolean de la siguiente forma:

console.log( Boolean('hello') );
console.log( Boolean(42) );
console.log( Boolean(0) );
// true
// true
// false

Solo 9 valores son siempre false y estos son conocidos como falsy values dentro de JavaScript:

  • "" // String vacío de doble comillas
  • '' // String vació de comillas simples
  • `` // template literal vacío
  • 0
  • -0 // considerado diferente a 0 por JavaScript
  • NaN
  • false
  • null
  • undefined

El hecho de que las cadenas vacías y el cero se consideren falsas a veces puede ser problemático, especialmente porque la mayoría de los otros lenguajes de programación no se comportan de la misma manera. Esta es otra particularidad de JavaScript.

Muchas operaciones nos dan respuestas que se evalúan como verdaderas o falsas. Al final ese tipo de lógica es la que implementamos en nuestros script y como tal en el día a día como desarrolladores.

console.log( 500 > 100 );
console.log( 500 < 100 );
console.log( 500 == '50' );
// true
// false
// false

Este tipo de datos recibe su nombre de George Boole, un matemático inglés que trabajó en el campo de la lógica algebraica. Los valores booleanos son fundamentales en las declaraciones lógicas que conforman un programa basado en código.

Tipo de dato: Symbol

Los símbolos se introdujeron como un nuevo valor primitivo en ES6, estos se pueden utilizar como identificador de propiedades de objeto puesto que crea valores únicos en el programa lo que ayudará a evitar colisiones de nombres pues estos son inmutable.

Los símbolos son los únicos primitivos que no tienen una forma literal. La única forma para crearlos es usar la función Symbol()

const simbolo_1 = Symbol();
Debemos de tener en cuenta que la función Symbol no un constructor de objetos, por lo tanto no podemos utilizar el operador new. Si lo intentamos obtendremos un TypeError.
const simbolo_1 =  new Symbol();
console.log( simbolo_1 );
// TypeError: Symbol is not a constructor


También se recomienda pasar una descripción al símbolo como argumento, este es opcional y actúa como una representación del símbolo y se utiliza para propósitos de registro y depuración.

const simbolo_1 = Symbol('Este es un simbolo único');

Como se mencionó anteriormente, un símbolo siempre es único y dos símbolos nunca pueden ser iguales. Si intentamos crear múltiples símbolos con la misma etiqueta los símbolos devueltos siempre serían únicos.

const sym_1 = Symbol("hello"); 
const sym_2 = Symbol("hello");

console.log( sym_1 === sym_2 );
// false

Casos de uso de los símbolos en JavaScript

Los símbolos se usan principalmente como claves de propiedades únicas de objetos, lo que puede ser muy útil pues estos pueden anular las propiedades nativas del mismo.

Los símbolos también se usan comúnmente para crear propiedades anónimas (o privadas en algún sentido) para el uso interno de una clase o un tipo de objeto.

Tipo de dato: Undefined

undefined o “indefinido” es un tipo de dato primitivo que tiene un valor especial. De forma predeterminada cuando una variable es declarada pero no se ha inicializado aún, el valor de esta es undefined. Veamos el siguiente ejemplo:

let myVar;

console.log( myVar );
console.log( typeof myVar );
// undefined
// "undefined"

Como podemos notar en el ejemplo anterior la variable myVar es undefined tanto por su tipo como por su valor.

Este valor undefined también puede ocurrir si la propiedad de un objeto no existe, si a una función le falta un parámetro o no devuelve algún valor. Es básicamente la forma en que JavaScript dice “No puedo encontrar un valor para esto” o “No has definido un valor para esto”.

Tipo de dato: Null

null significa “sin valor”, este tipo de dato Se puede considerar como un marcador de posición que javascript usa para decir “debería haber un valor aquí, pero no existe en este momento”.

let myVar = null; // null

Este valor te puede recordar mucho a undefined y es porque ambos son valores “sin valor”, lo que significa que son similares, pero se comportan de manera ligeramente diferente. Por ejemplo, si intentas hacer sumas con ellos pasará lo siguiente:

console.log( 10 + null );
console.log( 10 + undefined );
// 10
// NaN

En el ejemplo anterior vemos que null está obligado a ser 0, haciendo posible la suma mientras que undefined es NaN “Not a Number” haciendo que la suma sea imposible de realizar.

Básicamente en JavaScript los valores tienden a establecerse en undefined por defecto, mientras que los null generalmente son inducidos.


Algo curioso es que cuando se usa typeof para probar el tipo de dato null, este devuelve object. Veamos:

let myVar = null;
console.log( typeof myVar );
// "object"

Este fenómeno se ha considera un error no controlado causado en la implementación original de lenguaje.

Tipo de dato: Object

En JavaScript un objeto es una colección de propiedades donde cada propiedad se define como un par clave/valor. El siguiente ejemplo define un objeto vacío usando la forma literal del objeto:

const usuario = {};

El tipo de datos object en JavaScript puede contener muchos valores, estos pares proporcionan una manera útil de relacionar, almacenar y acceder a los datos cuando lo requiramos.

El siguiente ejemplo definimos el objeto con dos propiedades. La sintaxis literal del objeto compone de los pares separados por dos puntos con llaves en ambos lados { }:

const usuario = {
  nombre: 'John',
  edad  : 26
};
El nombre de una propiedad en un objeto puede ser cualquier string y se deben utilizar comillas alrededor de este si no es un identificador válido de JavaScript. Adicionalmente, Si el objeto tiene más de una propiedad utilizamos comas , para separar los pares.

Anidamiento de objetos

JavaScript permite anidar objetos dentro de otros objetos como lo vemos en el siguiente ejemplo:

const usuario = {
  nombre: 'John',
  edad  : 26,
  membresia : {
    tipoUsuario : 'platino',
    esActivo : true
  }
};

Ahora tenemos un objeto con tres propiedades y a su vez una de ella es un objeto que contiene dos propiedades más.

Accediendo a las propiedades de un objetos

Podemos acceder a las propiedades de un objeto utilizando dos notaciones: la notación de puntos . Y la notación tipo matriz [] o corchetes cuadrados.

En el siguiente ejemplo utilizamos la notación de puntos . Para acceder a las propiedades de primer nivel del objeto usuario.

console.log( usuario.nombre );
console.log( usuario.edad );
// "John"
// 26

Para obtener una propiedad de un objeto anidado simplemente seguimos la secuencia o cadena de anidamiento por medio las clave del objeto. por ejemplo:

console.log( usuario.membresia.tipoUsuario );
// "platino"

Si intentamos acceder a una propiedad no existente en el objeto el resultado será un undefined

La otra forma de acceder a las propiedades de un objeto es utilizando la notación de corchete, simplemente colocamos la propiedad a la queremos acceder entre los corchetes anteponiendo el nombre del objeto o nivel de anidamiento si es requerido:

console.log( usuario['nombre'] );
console.log( usuario['membresia']['tipoUsuario'] );
// "John"
// "platino"


Además de la forma literal del objeto que hemos visto, podemos usar la palabra clave new para crear un nuevo objeto:

const cliente = new Object();

Y para asignar un valor a la propiedad del objeto creado con new podemos hacer lo siguiente:

cliente.nombre = 'Deportivo FC';
En JavaScript todos los objetos se derivan del tipo Object. Este ya es un tema más profundo y avanzado que veremos mucho mas adelante..
avatar