javascript - 检查任何类型的 typeof 的最短方法是什么？

Question

我今天发现这个来检查某些东西是否是 bool 值:

而不是:

typeof a === 'boolean' && //do sth

您可以使用:

a === !!a && //do sth

还有其他类似的方法来检查 typeof string/number/obj/arr 等吗？

我不是在寻找最佳实践，而是在寻找进行“类型检查”的巧妙方法。

Answer 1

javascript中的类型并不那么简单，而是 this对您来说是一个很好的指南!

检查 Javascript 中的类型是一团糟。

typeof operator

In the beginning, there was typeof. This handy operator gives you the "type" of a Javascript value:

typeof 3 // "number" 
typeof "abc" // "string"
 typeof {} // "object"
 typeof true // "boolean" 
typeof undefined // "undefined" 
typeof function(){} // "function" 

All is fine 'n dandy until

typeof [] // "object" 

Huh? An array's type is object? I guess it is, if you want to get technical about it, but still, what the...

typeof null // "object" 

Okay, now that's just wrong!

instanceof operator

The instanceof operator tells you whether a object is an instance of a certain type. The so-called "type" is a constructor. For example

function Animal(){}
    var a = new Animal()
    a instanceof Animal // true

Cross-window Issues of instanceof

It turns out that instanceof has another problem. It breaks down when you try to test an object coming from another window. You know? The ones that are created for each , or popup window that you create.

   var iframe = document.createElement('iframe')
    document.body.appendChild(iframe)
    var iWindow = iframe.contentWindow // get a reference to the window object of the iframe
    iWindow.document.write('<script>var arr = [1, 2, 3]</script>') // create an array var in iframe's window
    iWindow.arr // [1, 2, 3]
    iWindow.arr instanceof Array // false

Duck-Typing

Because neither typeof or instanceof are satisfactory, many resort to duck-typing. This means checking the behavior: if it looks like a duck and quacks like a duck, then it is a duck as far as I am concerned. Pretty sure I misquoted that...oh well.

So, using duck-typing, an isArray check might look like

// source: http://forums.devshed.com/javascript-development-115/javascript-test-whether-a-variable-is-array-or-not-33051.html
function isArray(obj){
    return (typeof(obj.length)=="undefined") ?
        false:true;
}

Object.prototype.toString method

It turns out that, you can get type information about an object by using the Object.prototype.toString method.

Object.prototype.toString.call(3) // "[object Number]"
Object.prototype.toString.call([1, 2, 3]) // "[object Array]"
Object.prototype.toString.call({}) // "[object Object]"

Function.prototype.toString method

Yet another way to test for type information is by using the Function.prototype.toString method.

Function.prototype.toString.call((3).constructor)
// "function Number() {
//    [native code]
// }"

DOM Elements and Host Objects

So far, I have not mentioned type checking for DOM elements and host objects. That's because it's hard. With the exception of duck-typing, none of the methods mentioned above will work for all browsers. If you drop IE7 and below, however, you can actually get some of the things to work. The output below were created using Tutti

var div = document.createElement('div')
typeof div
Safari 5.0 => object
Firefox 3.6 => object
IE 7.0 => object
IE 8.0 => object
Opera 11.01 => object
div instanceof Element
Safari 5.0 => true
Firefox 3.6 => true
IE 7.0 => Error: 'Element' is undefined
IE 8.0 => true
Opera 11.01 => true
div instanceof HTMLDivElement
Safari 5.0 => true
Firefox 3.6 => true
IE 8.0 => true
IE 7.0 => Error: 'HTMLDivElement' is undefined
Opera 11.01 => true

http://tobyho.com/2011/01/28/checking-types-in-javascript/