29 
<script type="text/javascript">   
function saveName (firstName) {
    function capitalizeName () {
        return firstName.toUpperCase();
    }
    var capitalized = capitalizeName();console.log(capitalized instanceof String);
    return capitalized; 
}
console.log(saveName("Robert")); // Returns "ROBERT"
</script>

问题：

我想检查大写的类型，所以我使用capitalized instanceof String? 但它显示：false在控制台中，我不想尝试capitalized instanceof Function，Object...这将花费太多时间，那么检测变量类型的最佳方法是什么？

4

7 回答 7

41

最好的方法是使用typeof关键字。

typeof "hello" // "string"

运算符将操作数typeof映射到以下六个值之一："string"、"number"、"object"、"function"和。该方法测试提供的函数的原型是否在对象的原型链中。"undefined""boolean"instanceof

这篇 Wikibooks 文章和MDN 文章很好地总结了 JavaScript 的类型。

于 2013-07-03T05:45:03.617 回答
7

采用typeof();

例子： 

> typeof "foo"
"string"
> typeof true
"boolean"
> typeof 42
"number"

所以你可以这样做：

if(typeof bar === 'string') {
   //whatever
}

请记住，typeof 仅适用于返回“原始”类型、数字、布尔值、对象、字符串。您还可以使用 instanceof 来测试对象是否属于特定类型。

function MyObj(prop) {
  this.prop = prop;
}

var obj = new MyObj(10);

console.log(obj instanceof MyObj && obj instanceof Object); // outputs true
于 2013-07-03T05:46:08.787 回答
3

最好的方法是使用typeof

typeof "blahha"

我借助 jQuery 库代码、 jQuery 库类型方法 github 链接制作了一个函数。

var getType = (function() {

    var objToString = ({}).toString ,
        typeMap     = {},
        types = [ 
          "Boolean", 
          "Number", 
          "String",                
          "Function", 
          "Array", 
          "Date",
          "RegExp", 
          "Object", 
          "Error"
        ];

    for ( var i = 0; i < types.length ; i++ ){
        typeMap[ "[object " + types[i] + "]" ] = types[i].toLowerCase();
    };    

    return function( obj ){
        if ( obj == null ) {
            return String( obj );
        }
        // Support: Safari <= 5.1 (functionish RegExp)
        return typeof obj === "object" || typeof obj === "function" ?
            typeMap[ objToString.call(obj) ] || "object" :
            typeof obj;
    }
}());

你可以把它称为getType("Hello")

于 2013-07-03T05:51:41.043 回答
2

typeof 大写 == 'string'

于 2013-07-03T05:49:21.867 回答
1

getVarType方法（如下）适用于几乎所有变量。看看这个小提琴。对于结果可靠的情况，它首先使用非常快速的typeof 。然后它在其他情况下使用更昂贵的toString方法。最后，如果它正在处理一个命名对象（由 Firefox 为像 document.location 这样的对象返回），它会检查类似数组的对象并将它们报告为数组。

相比之下，typeof 就差的很尴尬了。typeof([]) 返回“对象”，typeof(new Number()) 返回对象。它还为许多其他不是（出于实际目的）对象的变量返回“对象”。请参阅小提琴结果进行比较。

  // Begin public utility /getVarType/
  // Returns 'Function', 'Object', 'Array',
  // 'String', 'Number', 'Null', 'Boolean', or 'Undefined'
  //
  getVarType = (function () {
    var typeof_map = {
      'undefined' : 'Undefined',
      'boolean'   : 'Boolean',
      'number'    : 'Number',
      'string'    : 'String',
      'function'  : 'Function',

      'Undefined' : 'Undefined',
      'Null'      : 'Null',
      'Boolean'   : 'Boolean',
      'Number'    : 'Number',
      'String'    : 'String',
      'Function'  : 'Function',
      'Array'     : 'Array',
      'StyleSheetList' : 'Array'
    };

    return function( data ) {
      var type, type_str;

      if ( data === null      ) { return 'Null'; }
      if ( data === undefined ) { return 'Undefined'; }

      type     = typeof( data );
      type_str = typeof_map[ type ];

      if ( type_str ) { return type_str; }

      type = {}.toString.call( data ).slice( 8, -1 );
      return typeof_map[ type ]
        || ( data instanceof Array ? 'Array' :
        ( data.propertyIsEnumerable(0) && data.length !== undefined
          ? 'Array' : 'Object' )
        );
    };
  }());
  // End public utility /getVarType/

如果您正在测试一个空的命名数组（例如除了 StyleSheetList 之外的一个空的可枚举 DOM 对象），则唯一可能的失败模式会发生。但是 on 可以根据需要将它们添加到 type_of_map 中。

我希望这会有所帮助！

于 2013-07-11T01:27:41.493 回答
0

ES-Next 版本支持BigInt&Symbol


"use strict";

/**
 *
 * @author xgqfrms
 * @license MIT
 * @copyright xgqfrms
 * @created 2020-06-09
 * @modified
 *
 * @description js data type checker
 * @augments
 * @example
 * @link
 *
 */


const dataTypeChecker = (data, debug = false) => {
  const log = console.log;
  let result = ``;
  const typeString = Object.prototype.toString.call(data);
  result = typeString.replace(/\[object /gi, ``).replace(/\]/gi, ``);
  if(debug) {
    log(`true type`, result)
  }
  return result;
};



export default dataTypeChecker;

export {
  dataTypeChecker,
};

测试

const dataTypeChecker = (data, debug = false) => {
  const log = console.log;
  let result = ``;
  const typeString = Object.prototype.toString.call(data);
  // const typeString = Object.prototype.toString.apply(data);
  result = typeString.replace(/\[object /gi, ``).replace(/\]/gi, ``);
  if(!debug) {
    log(`true type`, result)
  }
  return result;
};



const obj = {};
const func = () => {};


dataTypeChecker(NaN)
//"[object Number]"
dataTypeChecker(undefined)
//"[object Undefined]"
dataTypeChecker(true)
//"[object Boolean]"
dataTypeChecker({})
//"[object Object]"
dataTypeChecker(func)
//"[object Function]"
dataTypeChecker(obj)
//"[object Object]"
dataTypeChecker(Symbol())
//"[object Symbol]"
dataTypeChecker(null)
//"[object Null]"
dataTypeChecker(123)
//"[object Number]"
dataTypeChecker(BigInt(1n))
//"[object BigInt]"


// true type Number
// true type Undefined
// true type Boolean
// true type Object
// true type Function
// true type Object
// true type Symbol
// true type Null
// true type Number
// true type BigInt

于 2020-06-09T13:47:17.027 回答
0

2021+ 一个班轮答案。

我最喜欢的方式是不使用typeof

为什么？ 因为除了布尔、字符串、数字和函数之外，它没有给出真正的类型。

然后呢？ 这是使用 Object.prototype 的小型实用程序函数

var trueTypeOf = (obj) => Object.prototype.toString.call(obj).slice(8, -1).toLowerCase()

结果：

trueTypeOf([]); // array
trueTypeOf({}); // object
trueTypeOf(''); // string
trueTypeOf(new Date()); // date
trueTypeOf(1); // number
trueTypeOf(function () {}); // function
trueTypeOf(/test/i); // regexp
trueTypeOf(true); // boolean
trueTypeOf(null); // null
trueTypeOf(); // undefined
于 2021-12-28T18:51:20.720 回答