जावास्क्रिप्ट में चर प्रकार ढूँढना

Question

जावा में, आप उपयोग कर सकते हैं instanceOf याgetClass() इसके प्रकार का पता लगाने के लिए एक चर पर ।

मुझे जावास्क्रिप्ट में चर का प्रकार कैसे पता चलता है जो दृढ़ता से टाइप नहीं किया जाता है?

उदाहरण के लिए, मुझे कैसे पता चलेगा कि barए Booleanया ए है Numberया ए String?

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

Comments

— इन्हें

Answer 1

उपयोग करें 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]"

इसके साथ आपको आदिम मूल्यों और वस्तुओं के बीच अंतर नहीं करना होगा।

Comments

प्रोटो .constructor.name का उपयोग करने का निम्न पक्ष क्या होगा : एक siple function होगा: function getVariableType (ऑब्जेक्ट) {return (ऑब्जेक्ट .__ proto__.constructor.name); }

— स्टु

मैं ऊपर दी गई फ़ंक्शन परिभाषा में अपडेट करता हूं: फ़ंक्शन getVariableType (ऑब्जेक्ट) {रिटर्न (ऑब्जेक्ट === अपरिभाषित; "अनिर्धारित": object.__proto__.constructor.name);

— स्टु

Answer 2

टाइपोफ़ केवल "आदिम" प्रकार जैसे संख्या, बूलियन, ऑब्जेक्ट, स्ट्रिंग और प्रतीकों को वापस करने के लिए अच्छा है। instanceofयदि कोई ऑब्जेक्ट किसी विशिष्ट प्रकार का है, तो आप परीक्षण करने के लिए भी उपयोग कर सकते हैं ।

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

var obj = new MyObj(10);

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

Answer 3

का उपयोग कर 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';

Comments

उपयोग करने में कोई समस्या नहीं है Number(1), Boolean(true)...केवल समस्याएँ हैं जब आप उपयोग करते हैं newऔर एक बॉक्सिंग ऑब्जेक्ट बनाया जाता है, उन्हें फ़ंक्शंस के रूप में उपयोग करना वास्तव में अन्य प्रकारों से उपयोगी रूपांतरित हो सकता है। Boolean(0) === false, Number(true) === 1

— जुआन मेंडेस

किस बारे में null? typeof nullis 'object'

— धीरज

Answer 4

जावास्क्रिप्ट में आप टाइपोफ फ़ंक्शन का उपयोग करके ऐसा कर सकते हैं

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

Comments

जैसा कि मैंने अपने उत्तर में बताया है, टाइपोफ केवल नंबर, बूलियन, ऑब्जेक्ट, स्ट्रिंग लौटाएगा। किसी अन्य प्रकार के निर्धारण के लिए उपयोगी नहीं है, जैसे कि ऐरे, रेगेक्स या कस्टम प्रकार।

— जुआन मेंडेस

Answer 5

अन्य उत्तरों की तुलना में थोड़ा अधिक ECMAScript-5.1-सटीक होना (कुछ पांडित्य कह सकते हैं):

जावास्क्रिप्ट में, चर (और गुण) प्रकार नहीं होते हैं: मान करते हैं। इसके अलावा, केवल 6 प्रकार के मूल्य हैं: अपरिभाषित, अशक्त, बूलियन, स्ट्रिंग, संख्या और वस्तु। (तकनीकी रूप से, 7 "विनिर्देश प्रकार" भी हैं, लेकिन आप उन प्रकारों के मूल्यों को वस्तुओं या वैरिएबल के मूल्यों के रूप में संग्रहीत नहीं कर सकते हैं - वे केवल कल्पना के भीतर ही उपयोग किए जाते हैं, यह परिभाषित करने के लिए कि भाषा कैसे काम करती है। आप स्पष्ट रूप से हेरफेर कर सकते हैं केवल 6 प्रकार जो मैंने सूचीबद्ध किए हैं।)

जब यह "एक्स के प्रकार" के बारे में बात करना चाहता है तो कल्पना "टाइप (एक्स)" का उपयोग करता है। यह केवल कल्पना के भीतर प्रयोग किया जाने वाला एक अंकन है: यह भाषा की विशेषता नहीं है।

जैसा कि अन्य उत्तर स्पष्ट करते हैं, व्यवहार में आप अच्छी तरह से एक मूल्य के प्रकार से अधिक जानना चाह सकते हैं - खासकर जब प्रकार वस्तु है। भले ही, और पूर्णता के लिए, यहां टाइप (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';
    }
}

Comments

प्रतीक

— जुआन मेंडेस

ECMAScript 5.1 में नहीं, वहाँ नहीं हैं।

— वेस

Answer 6

मुझे यह निराशा होती है typeof है यह बहुत सीमित है। यहाँ एक बेहतर संस्करण है:

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

नमूना जाँच:

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

Answer 7

अंतर्निहित JS प्रकारों के लिए, जिनका आप उपयोग कर सकते हैं:

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

यहाँ हम 'ऑब्जेक्ट क्लास' से 'toString' पद्धति का उपयोग करते हैं जो अन्य प्रकारों की समान विधि से भिन्न काम करता है।

उदाहरण:

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

यदि आपको एक वर्ग नाम की आवश्यकता है, जिसका आप उपयोग कर सकते हैं:

instance.constructor.name

उदाहरण:

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

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

लेकिन इस फीचर को ES2015 में जोड़ा गया था ।

Answer 8

यहाँ पूरा समाधान है।

आप इसे अपने प्रोजेक्ट्स में हेल्पर वर्ग के रूप में भी उपयोग कर सकते हैं।

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

एक्सपोर्टेबल कॉमनज मॉड्यूल या आवश्यकता मॉड्यूल के लिए ...।

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

वर्तमान में एक सार्वजनिक git रेपो पर उपयोग में। जीथब प्रोजेक्ट

अब आप इस Sys कोड को Sys.js फ़ाइल में आयात कर सकते हैं। फिर आप जावास्क्रिप्ट ऑब्जेक्ट्स के प्रकार का पता लगाने के लिए इस Sys ऑब्जेक्ट फ़ंक्शन का उपयोग कर सकते हैं

आप यह भी देख सकते हैं कि ऑब्जेक्ट डिफाइंड है या टाइप फंक्शन है या ऑब्जेक्ट खाली है ... आदि।

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

उदाहरण के लिए

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

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

Answer 9

जावास्क्रिप्ट में सब कुछ एक वस्तु है

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

वास्तविक प्रकार प्राप्त करने के लिए , इसका उपयोग करें

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

उम्मीद है की यह मदद करेगा