Mejor manera de obtener el tipo de una variable Javascript?

Puede intentar usar constructor.name.

[].constructor.name
new RegExp().constructor.name

Al igual que con todo JavaScript, alguien eventualmente invariablemente señalará que esto es de alguna manera malvado, por lo que aquí hay un enlace a una respuesta que cubre esto bastante bien.

Una alternativa es usar Object.prototype.toString.call

Object.prototype.toString.call([])
Object.prototype.toString.call(/./)

Una función de captura de tipo razonablemente buena es la utilizada por YUI3 :

var TYPES = {
    'undefined'        : 'undefined',
    'number'           : 'number',
    'boolean'          : 'boolean',
    'string'           : 'string',
    '[object Function]': 'function',
    '[object RegExp]'  : 'regexp',
    '[object Array]'   : 'array',
    '[object Date]'    : 'date',
    '[object Error]'   : 'error'
},
TOSTRING = Object.prototype.toString;

function type(o) {
    return TYPES[typeof o] || TYPES[TOSTRING.call(o)] || (o ? 'object' : 'null');
};

Esto captura muchas de las primitivas proporcionadas por javascript, pero siempre puede agregar más modificando el objeto TYPES. Tenga en cuenta que typeof HTMLElementCollection en Safari informará function, pero type (HTMLElementCollection) devolverá object

Puede encontrar útil la siguiente función:

function typeOf(obj) {
  return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}

O en ES7 (comment if further improvements)

function typeOf(obj) {
  const { toString } = Object.prototype;
  const stringified = obj::toString();
  const type = stringified.split(' ')[1].slice(0, -1);

  return type.toLowerCase();
}

Resultados:

typeOf(); //undefined
typeOf(null); //null
typeOf(NaN); //number
typeOf(5); //number
typeOf({}); //object
typeOf([]); //array
typeOf(''); //string
typeOf(function () {}); //function
typeOf(/a/) //regexp
typeOf(new Date()) //date
typeOf(new Error) //error
typeOf(Promise.resolve()) //promise
typeOf(function *() {}) //generatorfunction
typeOf(new WeakMap()) //weakmap
typeOf(new Map()) //map

Gracias @johnrees por notificarme de: error, promise, generatorfunction

También podemos cambiar un pequeño ejemplo de ipr101

Object.prototype.toType = function() {
  return ({}).toString.call(this).match(/\s([a-zA-Z]+)/)[1].toLowerCase()
}

Y llamar como

"aaa".toType(); // 'string'

Función de una línea:

function type(obj) {
    return Object.prototype.toString.call(obj).replace(/^\[object (.+)\]$/,"$1").toLowerCase()
}

Esto da el mismo resultado que jQuery.type()

Puede aplicar Object.prototype.toString a cualquier objeto:

var toString = Object.prototype.toString;

console.log(toString.call([]));
//-> [object Array]

console.log(toString.call(/reg/g));
//-> [object RegExp]

console.log(toString.call({}));
//-> [object Object]

Esto funciona bien en todos los navegadores, con la excepción de IE - cuando se llama a esto en una variable obtenida de otra ventana, simplemente escupirá [object Object].

Mis 2 centavos! Realmente, parte de la razón por la que estoy lanzando esto aquí, a pesar de la larga lista de respuestas, es para proporcionar un poco más all in one escriba la solución y obtenga información en el futuro sobre cómo expandirla para incluir más real types.

Con la siguiente solución, como se mencionó anteriormente, combiné un par de soluciones que se encuentran aquí, así como incorporar un fix para devolver un valor de jQuery en jQuery objeto definido si está disponible. También añado el método al prototipo de objeto nativo. Sé que a menudo es tabú, ya que podría interferir con otras extensiones de este tipo, pero dejo que user beware. Si no le gusta esta forma de hacerlo, simplemente copie la función base en cualquier lugar que desee y reemplace todas las variables de this con un parámetro de argumento para pasar (como argumentos[0]).

;(function() {  //  Object.realType
    function realType(toLower) {
        var r = typeof this;
        try {
            if (window.hasOwnProperty('jQuery') && this.constructor && this.constructor == jQuery) r = 'jQuery';
            else r = this.constructor && this.constructor.name ? this.constructor.name : Object.prototype.toString.call(this).slice(8, -1);
        }
        catch(e) { if (this['toString']) r = this.toString().slice(8, -1); }
        return !toLower ? r : r.toLowerCase();
    }
    Object['defineProperty'] && !Object.prototype.hasOwnProperty('realType')
        ? Object.defineProperty(Object.prototype, 'realType', { value: realType }) : Object.prototype['realType'] = realType;
})();

Entonces simplemente use con facilidad, así:

obj.realType()  //  would return 'Object'
obj.realType(true)  //  would return 'object'

Nota: Hay 1 argumento pasable. Si es bool de true, entonces el retorno siempre estará en minúsculas.

Más ejemplos:

true.realType();                            //  "Boolean"
var a = 4; a.realType();                    //  "Number"
$('div:first').realType();                   // "jQuery"
document.createElement('div').realType()    //  "HTMLDivElement"

Si tiene algo que agregar que puede ser útil, como definir cuándo se creó un objeto con otra biblioteca (Moo, Proto, Yui, Dojo, etc.)...) por favor, siéntase libre de comentar o editar esto y mantenerlo va a ser más preciso y preciso. O rodar a la GitHub Hice para ello y me dejó saber. También encontrará un enlace rápido a un archivo cdn min allí.

function getType(obj) {
    if(obj && obj.constructor && obj.constructor.name) {
        return obj.constructor.name;
    }
    return Object.prototype.toString.call(obj).slice(8, -1).toLowerCase();
}

En mis pruebas preliminares, esto está funcionando bastante bien. El primer caso imprimirá el nombre de cualquier objeto creado con "nuevo", y el segundo caso debería capturar todo lo demás.

Estoy usando (8, -1) porque estoy asumiendo que el resultado siempre va a comenzar con [object y terminar con ] pero no estoy seguro de que sea cierto en todos los escenarios.