Tipos de datos Javascript

Las variables Javascript pueden almacenar muchos tipos de datos: números, cadenas de texto, objetos…

Ejm

var length = 16;                               // Number
var lastName = "Johnson";                      // String
var x = {firstName:"John", lastName:"Doe"};    // Object

El concepto de tipos de datos

En programación los tipos de datos son un importante concepto. Para poder operar en variables, es importante saber algo sobre el tipo. Sin tipos de datos, una computadora no puede resolver esto de manera segura.

Ejm

var x = 16 + "Volvo";

¿Tiene sentido agregar “Volvo” a dieciséis? ¿Producirá un error o producirá un resultado?

JavaScript tratará el ejemplo anterior como.

var x = "16" + "Volvo";

Al agregar un número y una cadena, JavaScript tratará el número como una cadena.

Los tipos de JavaScript son dinámicos

JavaScript tiene tipos dinámicos. Esto significa que la misma variable se puede usar para contener diferentes tipos de datos.

Ejm

var x;           // Now x is undefined
x = 5;           // Now x is a Number
x = "John";      // Now x is a String

Strings Javascript

Un string (o una cadena de texto) es una serie de caracteres como “John Doe”.

Las cadenas se escriben con comillas. Puede usar comillas simples o dobles.

Ejm

var carName1 = "Volvo XC60";   // Using double quotes
var carName2 = 'Volvo XC60';   // Using single quotes

Puede usar comillas dentro de una cadena, siempre que no coincidan con las comillas que rodean la cadena.

Ejm

var answer1 = "It's alright";             // Single quote inside double quotes
var answer2 = "He is called 'Johnny'";    // Single quotes inside double quotes
var answer3 = 'He is called "Johnny"';    // Double quotes inside single quotes

Números Javascript

Javascript sólo tiene un tipo de números. Los números pueden ser escritos con o sin decimales.

Ejm

var x1 = 34.00;     // Written with decimals
var x2 = 34;        // Written without decimals

Los números extra grandes o extra pequeños se pueden escribir con notación científica (exponencial):

Ejm

var y = 123e5;      // 12300000
var z = 123e-3;     // 0.00123

Booleanos Javascript

Los booleanos solo pueden tener dos valores, true (verdadero) y false (falso).

Ejm

var x = 5;
var y = 5;
var z = 6;
(x == y)       // Returns true
(x == z)       // Returns false

Los booleanos a menudo se usan en pruebas condicionales.

Arrays Javascript

Las matrices de JavaScript se escriben entre corchetes. Los elementos de la matriz están separados por comas. El siguiente código declara (crea) una matriz llamada automóviles, que contiene tres elementos (nombres de automóviles).

Ejm

var cars = ["Saab", "Volvo", "BMW"];

Los índices de matriz están basados en cero, lo que significa que el primer elemento es [0], el segundo es [1], y así sucesivamente.

Objetos Javascript

Los objetos de JavaScript se escriben con llaves {}. Las propiedades de los objetos se escriben como nombre: pares de valores, separados por comas.

Ejm

var person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};

El objeto (persona) en el ejemplo anterior tiene 4 propiedades: nombre, apellido, edad y eyeColor.

El operador typeof

Puedes usar el operador typeof de JavaScript para encontrar el tipo de una variable de JavaScript.

El operador typeof devuelve el tipo de una variable o una expresión.

Ejm

typeof ""             // Returns "string"
typeof "John"         // Returns "string"
typeof "John Doe"     // Returns "string
typeof 0              // Returns "number"
typeof 314            // Returns "number"
typeof 3.14           // Returns "number"
typeof (3)            // Returns "number"
typeof (3 + 4)        // Returns "number"

Undefined (indefinido)

En JavaScript, una variable sin valor tiene el valor undefined (indefinido). El tipo también es undefined (indefinido).

Ejm

var car;    // Value is undefined, type is undefined

Cualquier variable se puede vaciar, estableciendo el valor en indefinido. El tipo también será indefinido.

Valores vacíos

Un valor vacío no tiene nada que ver con undefined. Una cadena vacía tiene tanto un valor legal como un tipo.

Ejm

var car = "";    // The value is "", the typeof is "string"

Null

En JavaScript null es “nada”. Se supone que es algo que no existe. Desafortunadamente, en JavaScript, el tipo de datos null es un objeto.

Puedes considerarlo un error en JavaScript que typeof null es un objeto. Debería ser nulo.

Puedes vaciar un objeto configurándolo como null.

Ejm

var person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};
person = null;    // Now value is null, but type is still an object

También puedes vaciar un objeto configurándolo como undefined.

Ejm

person = undefined;   // Now both value and type is undefined

Diferencia entre indefinido y nulo

undefined y null son iguales en valor pero diferentes en tipo.

typeof undefined           // undefined
typeof null                // object

null === undefined         // false
null == undefined          // true

Datos primitivos

typeof "John"              // Returns "string"
typeof 3.14                // Returns "number"
typeof true                // Returns "boolean"
typeof false               // Returns "boolean"
typeof x                   // Returns "undefined" (if x has no value)

Datos complejos

El operador typeof puede devolver uno de dos tipos complejos:

• function
• object

El operador typeof devuelve “object” para objetos, matrices y nulos. El operador typeof no devuelve “objeto” para funciones.

Ejm

typeof {name:'John', age:34} // Returns "object"
typeof [1,2,3,4]             // Returns "object" (not "array", see note below)
typeof null                  // Returns "object"
typeof function myFunc(){}   // Returns "function"

El operador typeof devuelve “objeto” para las matrices porque en JavaScript las matrices son objetos.