В Java вы можете использовать instanceOf или getClass() для переменной, чтобы узнать ее тип.
Как узнать тип переменной в JavaScript, который не сильно типизирован?
Например, как узнать, является ли bar Boolean или Number, или String?
function foo(bar) {
// what do I do here?
}
Использовать typeof:
> typeof "foo"
"string"
> typeof true
"boolean"
> typeof 42
"number"
Таким образом, вы можете:
if(typeof bar === 'number') {
//whatever
}
Будьте осторожны, хотя если вы определите эти примитивы своими обертками объектов (которые вы никогда не должны делать, используйте литералы там, где это возможно):
> typeof new Boolean(false)
"object"
> typeof new String("foo")
"object"
> typeof new Number(42)
"object"
Тип массива все еще является object. Здесь вам действительно нужен оператор instanceof.
Обновить:
Еще один интересный способ - проверить вывод Object.prototype.toString:
> Object.prototype.toString.call([1,2,3])
"[object Array]"
> Object.prototype.toString.call("foo bar")
"[object String]"
> Object.prototype.toString.call(45)
"[object Number]"
> Object.prototype.toString.call(false)
"[object Boolean]"
> Object.prototype.toString.call(new String("foo bar"))
"[object String]"
> Object.prototype.toString.call(null)
"[object Null]"
> Object.prototype.toString.call(/123/)
"[object RegExp]"
> Object.prototype.toString.call(undefined)
"[object Undefined]"
При этом вам не нужно было бы различать примитивные значения и объекты.
typeof хорош только для возвращения "примитивных" типов, числа, булева, объекта, строки и символов. Вы также можете использовать instanceof, чтобы проверить, имеет ли объект определенный тип.
function MyObj(prop) {
this.prop = prop;
}
var obj = new MyObj(10);
console.log(obj instanceof MyObj && obj instanceof Object); // outputs true
Использование type:
// Numbers
typeof 37 === 'number';
typeof 3.14 === 'number';
typeof Math.LN2 === 'number';
typeof Infinity === 'number';
typeof NaN === 'number'; // Despite being "Not-A-Number"
typeof Number(1) === 'number'; // but never use this form!
// Strings
typeof "" === 'string';
typeof "bla" === 'string';
typeof (typeof 1) === 'string'; // typeof always return a string
typeof String("abc") === 'string'; // but never use this form!
// Booleans
typeof true === 'boolean';
typeof false === 'boolean';
typeof Boolean(true) === 'boolean'; // but never use this form!
// Undefined
typeof undefined === 'undefined';
typeof blabla === 'undefined'; // an undefined variable
// Objects
typeof {a:1} === 'object';
typeof [1, 2, 4] === 'object'; // use Array.isArray or Object.prototype.toString.call to differentiate regular objects from arrays
typeof new Date() === 'object';
typeof new Boolean(true) === 'object'; // this is confusing. Don't use!
typeof new Number(1) === 'object'; // this is confusing. Don't use!
typeof new String("abc") === 'object'; // this is confusing. Don't use!
// Functions
typeof function(){} === 'function';
typeof Math.sin === 'function';
В Javascript вы можете сделать это с помощью функции typeof
function foo(bar){
alert(typeof(bar));
}
Чтобы быть немного более ECMAScript-5.1 точным, чем другие ответы (некоторые могут сказать, педантичный):
В JavaScript переменные (и свойства) не имеют типов: значения делают. Кроме того, существует только 6 типов значений: Undefined, Null, Boolean, String, Number и Object. (Технически существует также 7 "спецификационных типов", но вы не можете хранить значения этих типов в качестве свойств объектов или значений переменных - они используются только в самой спецификации, чтобы определить, как работает язык. Значения вы можете явно манипулировать, имеют только 6 типов, которые я перечисл.)
В спецификации используется обозначение "Тип (x)", когда она хочет говорить о "типе x". Это только обозначение, используемое в спецификации: это не особенность языка.
Как показывают другие ответы, на практике вам может потребоваться узнать больше, чем тип значения - особенно, когда тип является Object. Независимо от того, и для полноты, вот простая реализация JavaScript типа (x), которая используется в спецификации:
function Type(x) {
if (x === null) {
return 'Null';
}
switch (typeof x) {
case 'undefined': return 'Undefined';
case 'boolean' : return 'Boolean';
case 'number' : return 'Number';
case 'string' : return 'String';
default : return 'Object';
}
}
Я расстраиваюсь, что typeof настолько ограничен. Имеет улучшенную версию:
var realtypeof = function (obj) {
switch (typeof(obj)) {
// object prototypes
case 'object':
if (obj instanceof Array)
return '[object Array]';
else if (obj instanceof Date)
return '[object Date]';
else if (obj instanceof RegExp)
return '[object regexp]';
else if (obj instanceof String)
return '[object String]';
else if (obj instanceof Number)
return '[object Number]';
else
return 'object';
// object literals
default:
return typeof(obj);
}
};
образец теста:
realtypeof( '' ) // "string"
realtypeof( new String('') ) // "[object String]"
Object.prototype.toString.call("foo bar") //"[object String]"
Вы также можете использовать его как класс помощника в своих проектах.
"use strict";
/**
* @description Util file
* @author Tarandeep Singh
* @created 2016-08-09
*/
window.Sys = {};
Sys = {
isEmptyObject: function(val) {
return this.isObject(val) && Object.keys(val).length;
},
/** This Returns Object Type */
getType: function(val) {
return Object.prototype.toString.call(val);
},
/** This Checks and Return if Object is Defined */
isDefined: function(val) {
return val !== void 0 || typeof val !== 'undefined';
},
/** Run a Map on an Array **/
map: function(arr, fn) {
var res = [],
i = 0;
for (; i < arr.length; ++i) {
res.push(fn(arr[i], i));
}
arr = null;
return res;
},
/** Checks and Return if the prop is Objects own Property */
hasOwnProp: function(obj, val) {
return Object.prototype.hasOwnProperty.call(obj, val);
},
/** Extend properties from extending Object to initial Object */
extend: function(newObj, oldObj) {
if (this.isDefined(newObj) && this.isDefined(oldObj)) {
for (var prop in oldObj) {
if (this.hasOwnProp(oldObj, prop)) {
newObj[prop] = oldObj[prop];
}
}
return newObj;
} else {
return newObj || oldObj || {};
}
}
};
// This Method will create Multiple functions in the Sys object that can be used to test type of
['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Object', 'Array', 'Undefined']
.forEach(
function(name) {
Sys['is' + name] = function(obj) {
return toString.call(obj) == '[object ' + name + ']';
};
}
);<h1>Use the Helper JavaScript Methods..</h1>
<code>use: if(Sys.isDefined(jQuery){console.log("O Yeah... !!");}</code>В JavaScript все является объектом
console.log(type of({})) //Object
console.log(type of([])) //Object
Чтобы получить тип Real, используйте
console.log(Object.prototype.toString.call({})) //[object Object]
console.log(Object.prototype.toString.call([])) //[object Array]
Надеюсь это поможет