Obtener el tipo de dato

Habrá ocasiones en las que nos interese obtener el tipo de dato de una variable. Por ejemplo en una función o método para realizar alguna actividad dependiendo del tipo de dato del parámetro.

Javascript nos permite utilizar dos operadores – typeof, instanceof – y una propiedad – constructor – para conocer el tipo de dato de un valor. Dependiendo del operador o propiedad utilizado y del tipo de dato que se está evaluando los resultados pueden variar.

/*
Variables de las cuales queremos
conocer el tipo de dato.
*/
var my_int = 3;
var my_float = 3.5;
var my_string = "texto";
var my_bool = true;
var my_undefined = undefined;
var my_function = function() {};
var my_null = null;
var my_array = ["uno", "dos", "tres"];
var my_date = new Date();
var my_obj = {};

typeof

Devuelve el tipo de dato de la variable. Algunos tipos de datos – como null, date, array – los devuelve como objetos.

/*
  typeof 
*/

typeof my_int;
typeof my_float;
typeof my_string;
typeof my_bool;
typeof my_undefined;
typeof my_function;
typeof my_obj;

typeof my_null;
typeof my_array;
typeof my_date;

constructor

Con constructor obtenemos el constructor del valor del tipo de dato. Hay que tener cuidado al momento de utilizarlo con null y undefined porque se genera un error.

/*
  constructor
*/
my_int.constructor;
my_float.constructor;
my_string.constructor;
my_bool.constructor;
my_array.constructor;
my_function.constructor;
my_date.constructor;
my_obj.constructor;

my_undefined.constructor;
my_null.constructor;


my_int.constructor === Number;
my_float.constructor === Number;
my_string.constructor === String;
my_bool.constructor === Boolean;
my_function.constructor === Function;
my_array.constructor === Array;
my_date.constructor === Date;
my_obj.constructor === Object;

instanceof

instanceof nos permite comparar si el tipo de dato de una variable es una instancia de un tipo de dato.
Hay que poner atención con los números, cadenas de texto y valores de verdad – boolean. Para que el valor sea cierto en esos casos, se tienen que definir los valores creando una instancia del objeto. Si se utilizan las primitivas de JavaScript el valor va a ser falso.

Al igual que con la propiedad constructor, null y undefined también van a arrojar error al utilizar instanceof.

/*
  instanceof
*/

my_function instanceof(Function);
my_array instanceof(Array);
my_date instanceof(Date);
my_obj instanceof(Object);

my_int instanceof(Number);
my_float instanceof(Number);
my_string instanceof(String);
my_bool instanceof(Boolean);
my_undefined instanceof(undefined);
my_null instanceof(null);

/*
Para poder utilizar instance of con números, texto 
y valores de verdad,  al momento de crear 
los valores hay que utilizar los objetos
y no las primitivas de javascript.
*/

var another_int = new Number(10);
var another_float = new Number(10.5);
var another_string = new String("Otra cadena");
var another_bool = new Boolean(true);

another_int.constructor === Number;
another_float.constructor === Number;
another_string.constructor  === String;
another_bool.constructor === Boolean;

another_int instanceof(Number);
another_float instanceof(Number);
another_string instanceof(String);
another_bool instanceof(Boolean);

Objetos personalizados

Si queremos comparar que el tipo de dato pertenezca a un objeto que definimos nosotros podemos utilizar cualquiera de los tres métodos con resultados consistentes.

var Custom = function () {
  this.propiedad = 1;
  this.metodo = metodo;
  
  function metodo() {
    console.log("Me llamo:" )
  }
}

var custom_obj = new Custom();


typeof custom_obj;

custom_obj.constructor;
custom_obj.constructor === Custom;

custom_obj instanceof(Custom);

Como conocemos el tipo de dato que necesita el código – que estamos desarrollando – para trabajar es conveniente elegir la opción que vaya más de acuerdo a esa funcionalidad.