Tìm loại biến trong JavaScript

Trong Java, bạn có thể sử dụng instanceOfhoặc getClass()trên một biến để tìm ra loại của nó.

Làm cách nào để tìm ra loại biến trong JavaScript không được gõ mạnh?

Ví dụ, làm thế nào để tôi biết nếu barlà a Booleanhoặc a Number, hay a String?

function foo(bar) {
    // what do I do here?
}

Sử dụng typeof:

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

Vì vậy, bạn có thể làm:

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

Mặc dù vậy, hãy cẩn thận nếu bạn xác định các nguyên hàm này bằng các trình bao bọc đối tượng của chúng (điều mà bạn không bao giờ nên làm, hãy sử dụng các chữ theo bất cứ khi nào có thể):

> typeof new Boolean(false)
"object"
> typeof new String("foo")
"object"
> typeof new Number(42)
"object"

Loại của một mảng vẫn còn object. Ở đây bạn thực sự cần các instanceofnhà điều hành.

Cập nhật:

Một cách thú vị khác là kiểm tra đầu ra của 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]"

Với điều đó, bạn sẽ không phải phân biệt giữa các giá trị nguyên thủy và các đối tượng.

typeof chỉ tốt khi trả về các kiểu "nguyên thủy" như số, boolean, đối tượng, chuỗi và ký hiệu. Bạn cũng có thể sử dụng instanceofđể kiểm tra nếu một đối tượng thuộc loại cụ thể.

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

var obj = new MyObj(10);

console.log(obj instanceof MyObj && obj instanceof Object); // outputs true

Sử dụng 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';

Trong Javascript, bạn có thể làm điều đó bằng cách sử dụng hàm typeof

function foo(bar){
  alert(typeof(bar));
}

Để chính xác hơn một chút ECMAScript-5.1 so với các câu trả lời khác (một số có thể nói là phạm vi):

Trong JavaScript, các biến (và thuộc tính) không có kiểu: giá trị nào. Hơn nữa, chỉ có 6 loại giá trị: Không xác định, Null, Boolean, String, Number và Object. (Về mặt kỹ thuật, cũng có 7 "loại đặc tả", nhưng bạn không thể lưu trữ giá trị của các loại đó làm thuộc tính của đối tượng hoặc giá trị của biến - chúng chỉ được sử dụng trong chính thông số kỹ thuật, để xác định cách thức hoạt động của ngôn ngữ. bạn có thể thao tác rõ ràng chỉ có 6 loại tôi liệt kê.)

Thông số kỹ thuật sử dụng ký hiệu "Loại (x)" khi muốn nói về "loại x". Đây chỉ là một ký hiệu được sử dụng trong thông số kỹ thuật: nó không phải là một tính năng của ngôn ngữ.

Như các câu trả lời khác đã rõ ràng, trong thực tế, bạn có thể muốn biết nhiều hơn loại giá trị - đặc biệt khi loại là Đối tượng. Bất kể và để hoàn thiện, đây là một triển khai JavaScript đơn giản của Loại (x) vì nó được sử dụng trong thông số:

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';
    }
}

Tôi thấy bực bội typeoflà rất hạn chế. Đây là phiên bản cải tiến:

var realtypeof = function (obj) {
    switch (typeof(obj)) {
        // object prototypes
        case 'object':
            if (obj instanceof Array)
                return '[object Array]';
            if (obj instanceof Date)
                return '[object Date]';
            if (obj instanceof RegExp)
                return '[object regexp]';
            if (obj instanceof String)
                return '[object String]';
            if (obj instanceof Number)
                return '[object Number]';

            return 'object';
        // object literals
        default:
            return typeof(obj);
    }   
};

mẫu thử:

realtypeof( '' ) // "string"
realtypeof( new String('') ) // "[object String]"
Object.prototype.toString.call("foo bar") //"[object String]" 

Đối với các loại JS dựng sẵn, bạn có thể sử dụng:

function getTypeName(val) {
    return {}.toString.call(val).slice(8, -1);
}

Ở đây, chúng tôi sử dụng phương thức 'toString' từ lớp 'Object' hoạt động khác với cùng một phương thức của các loại khác.

Ví dụ:

// Primitives
getTypeName(42);        // "Number"
getTypeName("hi");      // "String"
getTypeName(true);      // "Boolean"
getTypeName(Symbol('s'))// "Symbol"
getTypeName(null);      // "Null"
getTypeName(undefined); // "Undefined"

// Non-primitives
getTypeName({});            // "Object"
getTypeName([]);            // "Array"
getTypeName(new Date);      // "Date"
getTypeName(function() {}); // "Function"
getTypeName(/a/);           // "RegExp"
getTypeName(new Error);     // "Error"

Nếu bạn cần một tên lớp, bạn có thể sử dụng:

instance.constructor.name

Ví dụ:

({}).constructor.name       // "Object"
[].constructor.name         // "Array"
(new Date).constructor.name // "Date"

function MyClass() {}
let my = new MyClass();
my.constructor.name         // "MyClass"

Nhưng tính năng này đã được thêm vào ES2015 .

Đây là giải pháp hoàn chỉnh.

Bạn cũng có thể sử dụng nó như một lớp Trình trợ giúp trong các Dự án của mình.

"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>

Đối với Mô-đun CommonJs có thể xuất hoặc Mô-đun RequireJS ....

"use strict";

/*** Helper Utils ***/

/**
 * @description Util file :: From Vault
 * @author Tarandeep Singh
 * @created 2016-08-09
 */

var 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 isn't Required but just makes WebStorm color Code Better :D
 * */
Sys.isObject
    = Sys.isArguments
    = Sys.isFunction
    = Sys.isString
    = Sys.isArray
    = Sys.isUndefined
    = Sys.isDate
    = Sys.isNumber
    = Sys.isRegExp
    = "";

/** 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 + ']';
            };
        }
    );


module.exports = Sys;

Hiện đang được sử dụng trên một repo git công cộng. Dự án Github

Bây giờ bạn có thể nhập mã Sys này trong tệp Sys.js. sau đó bạn có thể sử dụng các hàm đối tượng Sys này để tìm ra loại Đối tượng JavaScript

bạn cũng có thể kiểm tra xem Object là Defined hay type is Function hay Object is Empty ... vv

• Sys.isObject
• Sys.isArgument
• Sys.isFloyment
• Sys.isString
• Sys.isArray
• Sys.isUnd xác định
• Sys.isDate
• Sys.isNumber
• Sys.isRegExp

Ví dụ

var m = function(){};
Sys.isObject({});
Sys.isFunction(m);
Sys.isString(m);

console.log(Sys.isDefined(jQuery));

Trong JavaScript mọi thứ đều là một đối tượng

console.log(type of({}))  //Object
console.log(type of([]))  //Object

Để có được kiểu Real , hãy sử dụng kiểu này

console.log(Object.prototype.toString.call({}))   //[object Object]
console.log(Object.prototype.toString.call([]))   //[object Array]

Hi vọng điêu nay co ich