JavaScript'te Değişken Türünü Bulmak

Question 1

Java'da, türünü öğrenmek için bir değişken üzerinde instanceOfveya kullanabilirsiniz getClass().

JavaScript'te türü kesin olmayan bir değişkenin türünü nasıl bulabilirim?

Örneğin, nasıl anlarım barbir olduğu Booleanya da Number, ya da String?

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

Question 2

Kullanım typeof:

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

Böylece şunları yapabilirsiniz:

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

Bu ilkelleri nesne sarmalayıcılarıyla tanımlarsanız dikkatli olun (ki bunu asla yapmamalısınız, mümkün olduğunca değişmez değerleri kullanın):

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

Bir dizinin türü hala object. Burada instanceofoperatöre gerçekten ihtiyacınız var .

Güncelleme:

Bir başka ilginç yol da şu çıktıyı incelemektir 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]"

Bununla, ilkel değerler ve nesneler arasında ayrım yapmak zorunda kalmazsınız.

Question 3

typeof yalnızca sayı, boole, nesne, dizge ve semboller gibi "ilkel" türleri döndürmek için iyidir. instanceofBir nesnenin belirli bir tür olup olmadığını test etmek için de kullanabilirsiniz .

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

var obj = new MyObj(10);

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

Question 4

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

Question 5

Javascript'te bunu typeof işlevini kullanarak yapabilirsiniz

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

Question 6

Diğer cevaplardan biraz daha fazla ECMAScript-5.1-kesin olmak gerekirse (bazıları bilgiçlik tasvir edebilir):

JavaScript'te, değişkenlerin (ve özelliklerin) türleri yoktur: değerler vardır. Ayrıca, yalnızca 6 tür değer vardır: Tanımsız, Boş, Boolean, Dize, Sayı ve Nesne. (Teknik olarak, ayrıca 7 "belirtim türü" vardır, ancak bu türlerin değerlerini nesnelerin özellikleri veya değişkenlerin değerleri olarak saklayamazsınız - bunlar yalnızca belirtimin kendi içinde dilin nasıl çalıştığını tanımlamak için kullanılır. sadece listelediğim 6 tipte açıkça işleyebilirsiniz.)

Spesifikasyon, "x türü" hakkında konuşmak istediğinde "Tür (x)" gösterimini kullanır. Bu, yalnızca şartnamede kullanılan bir gösterimdir: dilin bir özelliği değildir.

Diğer yanıtların da netleştirdiği gibi, pratikte bir değerin türünden daha fazlasını bilmek isteyebilirsiniz - özellikle de tür Nesne olduğunda. Ne olursa olsun ve eksiksizlik açısından, spesifikasyonda kullanıldığı şekliyle Type (x) 'in basit bir JavaScript uygulaması aşağıda verilmiştir:

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

Question 7

Bu typeofkadar sınırlı olmasını sinir bozucu buluyorum . İşte geliştirilmiş bir sürüm:

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

örnek test:

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

Question 8

Yerleşik JS türleri için şunları kullanabilirsiniz:

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

Burada başka türlerin aynı yönteminden farklı çalışan 'Object' sınıfından 'toString' yöntemini kullanıyoruz.

Örnekler:

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

Bir sınıf adına ihtiyacınız varsa şunları kullanabilirsiniz:

instance.constructor.name

Örnekler:

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

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

Ancak bu özellik ES2015'te eklendi .

Question 9

JavaScript'te her şey bir nesnedir

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

Gerçek tip almak için bunu kullanın

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

Bu yardımcı olur umarım

Question 10

İşte tam çözüm.

Bunu Projelerinizde Yardımcı sınıf olarak da kullanabilirsiniz.

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

Snippet'i genişlet

Dışa Aktarılabilir CommonJs Modülü veya RequireJS Modülü için ....

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

Şu anda genel bir git deposunda kullanılıyor. Github Projesi

Artık bu Sys kodunu bir Sys.js dosyasına aktarabilirsiniz. JavaScript Nesnelerinin türünü öğrenmek için bu Sys nesnesi işlevlerini kullanabilirsiniz.

Ayrıca, Nesnenin Tanımlı olup olmadığını veya türün İşlev veya Nesne Boş olduğunu kontrol edebilirsiniz ... vb.

Sys.isObject
Sys.isArguments
Sys.isFunction
Sys.isString
Sys.isArray
Sys.isUndefined
Sys.isDate
Sys.isNumber
Sys.isRegExp

Örneğin

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

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