වස්තුවක වර්ගයේ නම ලබා ගන්න

යම් කෙනෙක් JavaScript ගැසීම ජාවා හි class.getName()?

ජාවාට සමාන ජාවාස්ක්‍රිප්ට් එකක් class.getName()තිබේද?

නැත .

ES2015 යාවත්කාලීන : නම class Foo {}කියන්නේFoo.name . වර්ගය thingකුමක් වුවත් පන්තියේ නම thingවේ thing.constructor.name. ES2015 පරිසරයක බිල්ටින් ඉදිකිරීම්කරුවන්ට නිවැරදි nameදේපළ තිබේ; උදාහරණයක් (2).constructor.nameලෙස "Number".

නමුත් සියල්ලම එක් ආකාරයකින් හෝ වෙනත් ආකාරයකින් පහත වැටෙන විවිධ හක්ක මෙන්න:

මෙන්න ඔබට අවශ්‍ය දේ කරන හැක් එකක් - එය වස්තුවේ මූලාකෘතිය වෙනස් කරන බව මතක තබා ගන්න, මිනිසුන් කෝපයට පත් දෙයක් (සාමාන්‍යයෙන් හොඳ හේතුවක් නිසා)

Object.prototype.getName = function() { 
   var funcNameRegex = /function (.{1,})\(/;
   var results = (funcNameRegex).exec((this).constructor.toString());
   return (results && results.length > 1) ? results[1] : "";
};

දැන්, ඔබේ සියලු වස්තූන් හට ශ්‍රිතය ඇත, getName()එමඟින් ඉදිකිරීම්කරුගේ නම නූලක් ලෙස ලැබෙනු ඇත. මම මෙය පරීක්ෂා කර ඇති FF3අතර IE7, වෙනත් ක්‍රියාත්මක කිරීම් සඳහා මට කථා කළ නොහැක.

ඔබට එය කිරීමට අවශ්‍ය නැතිනම්, ජාවාස්ක්‍රිප්ට් හි වර්ග තීරණය කිරීමේ විවිධ ක්‍රම පිළිබඳ සාකච්ඡාවක් මෙන්න ...

මම මෙය මෑතකදී යාවත්කාලීන කළේ එය තරමක් දුරට පරිපූර්ණ ලෙස ය. නිවැරදි කිරීම් සාදරයෙන් පිළිගනිමු ...

constructorදේපල භාවිතා කිරීම ...

සෑම කෙනෙකුම objectඑහි constructorදේපල සඳහා වටිනාකමක් ඇත , නමුත් objectඑය ඉදිකරන ලද ආකාරය මෙන්ම එම වටිනාකම සමඟ ඔබට කිරීමට අවශ්‍ය දේ මත පදනම්ව , එය ප්‍රයෝජනවත් විය හැකිය හෝ නොවිය හැකිය.

පොදුවේ ගත් කල, ඔබට constructorවස්තුවේ වර්ගය පරීක්ෂා කිරීමට දේපල භාවිතා කළ හැකිය :

var myArray = [1,2,3];
(myArray.constructor == Array); // true

එබැවින්, එය බොහෝ අවශ්‍යතා සඳහා ප්‍රමාණවත් ලෙස ක්‍රියා කරයි. ඒක කිව්වේ ...

ගුහා

වැඩ නොකරන සියල්ල බොහෝ අවස්ථාවල දී

මෙම රටාව කැඩී ගියද එය පොදු ය:

function Thingy() {
}
Thingy.prototype = {
    method1: function() {
    },
    method2: function() {
    }
};

Objectsහරහා ඉදිකරන new Thingyලද constructorදේපලක් ඇත Object, නොව යොමු Thingyකරයි. ඒ නිසා අපි ආරම්භයේදීම වැටෙනවා; ඔබට පාලනය කළ නොහැකි constructorකේත පදනමක් කෙරෙහි විශ්වාස කළ නොහැක .

බහු උරුමය

එය පැහැදිලිව නොපෙනෙන උදාහරණයක් නම් බහු උරුමය භාවිතා කිරීමයි:

function a() { this.foo = 1;}
function b() { this.bar = 2; }
b.prototype = new a(); // b inherits from a

ඔබ බලාපොරොත්තු වන පරිදි දැන් දේවල් ක්‍රියාත්මක නොවේ:

var f = new b(); // instantiate a new object with the b constructor
(f.constructor == b); // false
(f.constructor == a); // true

එබැවින්, objectඔබේ පරීක්ෂණයට වෙනස් objectකට්ටලයක් තිබේ නම් ඔබට අනපේක්ෂිත ප්‍රති results ල ලැබෙනු prototypeඇත. මෙම සාකච්ඡාවේ විෂය පථයෙන් පිටත මේ වටා ක්‍රම තිබේ.

constructorදේපල සඳහා වෙනත් භාවිතයන් ඇත , ඒවායින් සමහරක් සිත්ගන්නා සුළුය, අනෙක් ඒවා එතරම් නොවේ; මෙම සාකච්ඡාවට අදාළ නොවන බැවින් දැන් අපි එම භාවිතයන් පිළිබඳව සොයා බලන්නේ නැත.

හරස් රාමු සහ හරස් කවුළුව ක්‍රියා නොකරනු ඇත

.constructorවිවිධ windowවස්තූන්ගෙන් එන වස්තු වර්ගය පරීක්ෂා කිරීමට ඔබට අවශ්‍ය විට, වර්ග පරීක්ෂාව සඳහා භාවිතා කිරීම කැඩී යනු ඇත, iframe හෝ උත්පතන කවුළුවක් යැයි කියන්න. මෙයට හේතුව constructorඑක් එක් 'කවුළුව' තුළ එක් එක් මූලික වර්ගයේ වෙනස් අනුවාදයක් තිබීමයි, එනම්

iframe.contentWindow.Array === Array // false

instanceofක්රියාකරු භාවිතා කරමින් ...

මෙම instanceofක්රියාකරු පරීක්ෂා කිරීමේ පිරිසිදු ක්රමයක් objectමෙන්ම වර්ගය, නමුත් එහි ම විය හැකි ගැටලු, කළාක් මෙනි ඇත constructorදේපල.

var myArray = [1,2,3];
(myArray instanceof Array); // true
(myArray instanceof Object); // true

නමුත් instanceofවචනයේ පරිසමාප්ත අර්ථයෙන්ම වැඩ කිරීමට අපොහොසත් වේ (සාහිත්‍යකරුවන් නොවන නිසා Objects)

3 instanceof Number // false
'abc' instanceof String // false
true instanceof Boolean // false

නිදසුනක් වශයෙන්, වැඩ Objectකිරීම සඳහා සාක්ෂරතාවන් ඔතා තිබිය යුතුයinstanceof

new Number(3) instanceof Number // true

මෙම .constructorචෙක්පත literals කදිම සේවය කරන නිසා .ක්රමය පිහිට පැතීමක් ගම්ය අදාළ වස්තුව වර්ගය දී literals හකුළා

3..constructor === Number // true
'abc'.constructor === String // true
true.constructor === Boolean // true

3 සඳහා තිත් දෙකක් ඇයි? ජාවාස්ක්‍රිප්ට් පළමු තිත දශම ලක්ෂ්‍යයක් ලෙස අර්ථකථනය කරන නිසා;)

හරස් රාමු සහ හරස් කවුළුව ක්‍රියා නොකරනු ඇත

instanceofconstructorදේපල පරීක්‍ෂණයට සමාන හේතුවක් නිසා විවිධ කවුළු හරහා ක්‍රියා නොකරනු ඇත .

nameදේපලෙහි දේපල භාවිතා කිරීම constructor...

වැඩ කරන්නේ නැහැ කොහෙත්ම බොහෝ අවස්ථාවල දී

නැවතත්, ඉහත බලන්න; constructorසම්පූර්ණයෙන්ම හා සම්පූර්ණයෙන්ම වැරදි සහ නිෂ් less ල වීම සාමාන්‍ය දෙයකි .

<IE9 හි ක්‍රියා නොකරයි

භාවිතා කිරීමෙන් myObjectInstance.constructor.nameඔබට භාවිතා කරන constructorශ්‍රිතයේ නම අඩංගු නූලක් ලැබෙනු ඇත , නමුත් constructorකලින් සඳහන් කළ දේපල පිළිබඳ අවවාදයන්ට යටත් වේ .

IE9 සහ ඊට ඉහළින්, ඔබට වඳුරු පැච් ආධාරයෙන් කළ හැකිය :

if (Function.prototype.name === undefined && Object.defineProperty !== undefined) {
    Object.defineProperty(Function.prototype, 'name', {
        get: function() {
            var funcNameRegex = /function\s+([^\s(]+)\s*\(/;
            var results = (funcNameRegex).exec((this).toString());
            return (results && results.length > 1) ? results[1] : "";
        },
        set: function(value) {}
    });
}

සැක සහිත ලිපියෙන් යාවත්කාලීන කළ අනුවාදය . ලිපිය ප්‍රකාශයට පත් කර මාස 3 කට පසුව මෙය එකතු කරන ලදි, මෙය ලිපියේ කර්තෘ මැතිව් ෂාර්ලි විසින් භාවිතා කිරීමට නිර්දේශිත අනුවාදය වේ. පෙර කේතයේ ඇති විය හැකි අන්තරායන් පෙන්වා දෙන අදහස් මගින් මෙම වෙනස ඇති විය .

if (Function.prototype.name === undefined && Object.defineProperty !== undefined) {
    Object.defineProperty(Function.prototype, 'name', {
        get: function() {
            var funcNameRegex = /function\s([^(]{1,})\(/;
            var results = (funcNameRegex).exec((this).toString());
            return (results && results.length > 1) ? results[1].trim() : "";
        },
        set: function(value) {}
    });
}

Object.prototype.toString භාවිතා කිරීම

එය, දුටුවේ මෙම පශ්චාත් විස්තර , ඔබ භාවිතා කළ හැකිය Object.prototype.toString- අඩු මට්ටමේ හා Generic බලපත්රය යටතේ අවසර ලබා ඇත ක්රියාත්මක කිරීම toString- සියලු සඳහා වර්ගය බිල්ට් ගැනීමට වර්ග

Object.prototype.toString.call('abc') // [object String]
Object.prototype.toString.call(/abc/) // [object RegExp]
Object.prototype.toString.call([1,2,3]) // [object Array]

යමෙකුට කෙටි උපකාරක ශ්‍රිතයක් ලිවිය හැකිය

function type(obj){
    return Object.prototype.toString.call(obj).slice(8, -1);
}

කබොල්ල ඉවත් කර වර්ගයේ නම ලබා ගැනීමට

type('abc') // String

කෙසේ වෙතත්, එය Objectසියලු පරිශීලක අර්ථ දක්වන ලද වර්ග සඳහා නැවත පැමිණේ .

සැමට ගුහා ...

මේ සියල්ලම එක් විභව ගැටලුවකට යටත් වන අතර, එම වස්තුව ඉදිකරන ලද ආකාරය පිළිබඳ ප්‍රශ්නය එයයි. වස්තූන් තැනීමේ විවිධ ක්‍රම සහ වර්ග පරීක්ෂා කිරීමේ විවිධ ක්‍රම නැවත ලබා දෙන අගයන් මෙන්න:

// using a named function:
function Foo() { this.a = 1; }
var obj = new Foo();
(obj instanceof Object);          // true
(obj instanceof Foo);             // true
(obj.constructor == Foo);         // true
(obj.constructor.name == "Foo");  // true

// let's add some prototypical inheritance
function Bar() { this.b = 2; }
Foo.prototype = new Bar();
obj = new Foo();
(obj instanceof Object);          // true
(obj instanceof Foo);             // true
(obj.constructor == Foo);         // false
(obj.constructor.name == "Foo");  // false


// using an anonymous function:
obj = new (function() { this.a = 1; })();
(obj instanceof Object);              // true
(obj.constructor == obj.constructor); // true
(obj.constructor.name == "");         // true


// using an anonymous function assigned to a variable
var Foo = function() { this.a = 1; };
obj = new Foo();
(obj instanceof Object);      // true
(obj instanceof Foo);         // true
(obj.constructor == Foo);     // true
(obj.constructor.name == ""); // true


// using object literal syntax
obj = { foo : 1 };
(obj instanceof Object);            // true
(obj.constructor == Object);        // true
(obj.constructor.name == "Object"); // true

මෙම නිදසුන් සමූහය තුළ සියලු ප්‍රේරණයන් නොතිබුණද, ඔබේ අවශ්‍යතා අනුව අවුල් සහගත දේවල් ලැබෙන්නේ කෙසේද යන්න පිළිබඳ අදහසක් ඔබට ලබා දීමට ප්‍රමාණවත් වනු ඇතැයි අපේක්ෂා කරමු. කිසිවක් උපකල්පනය නොකරන්න, ඔබ පසු වන්නේ කුමක් දැයි ඔබට හරියටම වැටහෙන්නේ නැත්නම්, ඔබ සූක්ෂමතාවයන් නොසලකා හැරීමේ අඩුපාඩුවක් නිසා ඔබ අපේක්ෂා නොකරන කේත බිඳීමකින් අවසන් විය හැකිය.

සටහන:

typeofක්‍රියාකරුගේ සාකච්ඡාව පැහැදිලිවම මඟ හැරීමක් ලෙස පෙනෙන්නට තිබුණද object, එය ඉතා සරල බැවින්, දී ඇති වර්ගයක් දැයි හඳුනා ගැනීමට උදව් කිරීම ඇත්තෙන්ම ප්‍රයෝජනවත් නොවේ . typeofප්‍රයෝජනවත් වන්නේ කොතැනද යන්න වටහා ගැනීම වැදගත්ය, නමුත් මෙම සාකච්ඡාවට එය අතිශයින්ම අදාළ යැයි මට දැනට හැඟෙන්නේ නැත. මගේ මනස වෙනස් වීමට විවෘතය. :)

ජේසන් බන්ටිංගේ පිළිතුර මට අවශ්‍ය දේ සොයා ගැනීමට ප්‍රමාණවත් හෝඩුවාවක් ලබා දුන්නේය:

<<Object instance>>.constructor.name

උදාහරණයක් ලෙස, පහත කේත කොටසේ:

function MyObject() {}
var myInstance = new MyObject();

myInstance.constructor.nameනැවත පැමිණේවි "MyObject".

මම භාවිතා කරන කුඩා උපක්‍රමයක්:

function Square(){
    this.className = "Square";
    this.corners = 4;
}

var MySquare = new Square();
console.log(MySquare.className); // "Square"

යාවත්කාලීන කරන්න

හරියටම කිවහොත්, OP විසින් යම් වස්තුවක් සඳහා ඉදිකිරීම්කරුගේ නම ලබා ගන්නා ශ්‍රිතයක් ඉල්ලා සිටියේය. ජාවාස්ක්‍රිප්ට් objectසම්බන්ධයෙන් ගත් කල, වර්ගයක් නොමැති නමුත් එය තමාටම ආවේණික වූවකි . කෙසේ වෙතත්, විවිධ වස්තූන් සඳහා විවිධ ඉදිකිරීම්කරුවන් සිටිය හැකිය .

Object.prototype.getConstructorName = function () {
   var str = (this.prototype ? this.prototype.constructor : this.constructor).toString();
   var cname = str.match(/function\s(\w*)/)[1];
   var aliases = ["", "anonymous", "Anonymous"];
   return aliases.indexOf(cname) > -1 ? "Function" : cname;
}

new Array().getConstructorName();  // returns "Array"
(function () {})().getConstructorName(); // returns "Function"

සටහන: පහත උදාහරණය ඉවත් කර ඇත.

ඒ බ්ලොග් මගින් එකිනෙක හා සම්බන්ධ ක්රිස්තියානි Sciberras එය කිරීමට ආකාරය පිළිබඳ හොඳ උදාහරණයක් අඩංගු වේ. එනම්, වස්තු මූලාකෘතිය දිගු කිරීමෙන්:

if (!Object.prototype.getClassName) {
    Object.prototype.getClassName = function () {
        return Object.prototype.toString.call(this).match(/^\[object\s(.*)\]$/)[1];
    }
}

var test = [1,2,3,4,5];

alert(test.getClassName()); // returns Array

Object.prototype.toString භාවිතා කිරීම

මෙම පෝස්ට් විස්තරය ලෙස, ඔබට සියලු බිල්ට් වර්ග සඳහා වර්ගය ලබා ගැනීම සඳහා ඔබට Object.prototype.toString - toString හි පහත් මට්ටම සහ සාමාන්‍ය ක්‍රියාත්මක කිරීම භාවිතා කළ හැකිය.

Object.prototype.toString.call('abc') // [object String]
Object.prototype.toString.call(/abc/) // [object RegExp]
Object.prototype.toString.call([1,2,3]) // [object Array]

යමෙකුට කෙටි උපකාරක ශ්‍රිතයක් ලිවිය හැකිය

function type(obj){
    return Object.prototype.toString.call(obj]).match(/\s\w+/)[0].trim()
}

return [object String] as String
return [object Number] as Number
return [object Object] as Object
return [object Undefined] as Undefined
return [object Function] as Function

මෙන්න මම ඉදිරිපත් කළ විසඳුමකි, එය නිදර්ශනවල අඩුපාඩු විසඳයි. එයට හරස් කවුළු සහ හරස් රාමු වලින් වස්තුවක වර්ග පරීක්ෂා කළ හැකි අතර ප්‍රාථමික වර්ග සමඟ ගැටලු නොමැත.

function getType(o) {
    return Object.prototype.toString.call(o).match(/^\[object\s(.*)\]$/)[1];
}
function isInstance(obj, type) {
    var ret = false,
    isTypeAString = getType(type) == "String",
    functionConstructor, i, l, typeArray, context;
    if (!isTypeAString && getType(type) != "Function") {
        throw new TypeError("type argument must be a string or function");
    }
    if (obj !== undefined && obj !== null && obj.constructor) {
        //get the Function constructor
        functionConstructor = obj.constructor;
        while (functionConstructor != functionConstructor.constructor) {
            functionConstructor = functionConstructor.constructor;
        }
        //get the object's window
        context = functionConstructor == Function ? self : functionConstructor("return window")();
        //get the constructor for the type
        if (isTypeAString) {
            //type is a string so we'll build the context (window.Array or window.some.Type)
            for (typeArray = type.split("."), i = 0, l = typeArray.length; i < l && context; i++) {
                context = context[typeArray[i]];
            }
        } else {
            //type is a function so execute the function passing in the object's window
            //the return should be a constructor
            context = type(context);
        }
        //check if the object is an instance of the constructor
        if (context) {
            ret = obj instanceof context;
            if (!ret && (type == "Number" || type == "String" || type == "Boolean")) {
                ret = obj.constructor == context
            }
        }
    }
    return ret;
}

isInstance සඳහා පරාමිති දෙකක් අවශ්‍ය වේ: වස්තුවක් සහ වර්ගයක්. එය ක්‍රියා කරන ආකාරය පිළිබඳ සැබෑ උපක්‍රමය නම්, එය වස්තුව එකම කවුළුවෙන්ද යන්න සහ වස්තුවේ කවුළුව නොලැබුනේද යන්න පරීක්ෂා කිරීමයි.

උදාහරණ:

isInstance([], "Array"); //true
isInstance("some string", "String"); //true
isInstance(new Object(), "Object"); //true

function Animal() {}
function Dog() {}
Dog.prototype = new Animal();

isInstance(new Dog(), "Dog"); //true
isInstance(new Dog(), "Animal"); //true
isInstance(new Dog(), "Object"); //true
isInstance(new Animal(), "Dog"); //false

වර්ගය පරාමිතිය ඉදිකිරීම්කරුවෙකු ආපසු ලබා දෙන ඇමතුම් ආපසු ගැනීමේ ශ්‍රිතයක් ද විය හැකිය. ඇමතුම් ලබා ගැනීමේ ශ්‍රිතයට එක් පරාමිතියක් ලැබෙනු ඇත, එය සපයන ලද වස්තුවේ කවුළුව වේ.

උදාහරණ:

//"Arguments" type check
var args = (function() {
    return arguments;
}());

isInstance(args, function(w) {
    return w.Function("return arguments.constructor")();
}); //true

//"NodeList" type check
var nl = document.getElementsByTagName("*");

isInstance(nl, function(w) {
    return w.document.getElementsByTagName("bs").constructor;
}); //true

මතක තබා ගත යුතු එක් කරුණක් නම්, IE <9 මගින් සියලු වස්තූන් සඳහා ඉදිකිරීම්කරු ලබා නොදෙන බැවින් නෝඩ්ලිස්ට් සඳහා ඉහත පරීක්ෂණය අසත්‍ය බවට පත්වන අතර isInstance (අනතුරු ඇඟවීම, "ක්‍රියාකාරිත්වය") අසත්‍ය වේ.

මම ඇත්ත වශයෙන්ම ඒ හා සමාන දෙයක් සොයමින් සිටි අතර මෙම ප්‍රශ්නය හමු විය. මෙන්න මම වර්ග ලබා ගන්නා ආකාරය: jsfiddle

var TypeOf = function ( thing ) {

    var typeOfThing = typeof thing;

    if ( 'object' === typeOfThing ) {

        typeOfThing = Object.prototype.toString.call( thing );

        if ( '[object Object]' === typeOfThing ) {

            if ( thing.constructor.name ) {
                return thing.constructor.name;
            } 

            else if ( '[' === thing.constructor.toString().charAt(0) ) {
                typeOfThing = typeOfThing.substring( 8,typeOfThing.length - 1 );
            } 

            else {

                typeOfThing = thing.constructor.toString().match( /function\s*(\w+)/ );

                if ( typeOfThing ) { 
                    return typeOfThing[1];
                } 

                else {
                    return 'Function';
                }
            }
        } 

        else {
            typeOfThing = typeOfThing.substring( 8,typeOfThing.length - 1 );
        }
    }

    return typeOfThing.charAt(0).toUpperCase() + typeOfThing.slice(1);
}

ඔබ පහත පරිදි භාවිතා කළ යුතුය somevar.constructor.name:

    
    const getVariableType = a => a.constructor.name.toLowerCase();

    const d = new Date();
    const res1 = getVariableType(d); // 'date'
    const num = 5;
    const res2 = getVariableType(num); // 'number'
    const fn = () => {};
    const res3 = getVariableType(fn); // 'function'

    console.log(res1); // 'date'
    console.log(res2); // 'number'
    console.log(res3); // 'function'

constructor.nameඔබට හැකි විට භාවිතා කරන්න , සහ මට නොහැකි විට රීජෙක්ස් ක්‍රියා කරන්න.

Function.prototype.getName = function(){
  if (typeof this.name != 'undefined')
    return this.name;
  else
    return /function (.+)\(/.exec(this.toString())[1];
};

මෙම ආකාරයේ () සිට උත්සවය Agave.JS නැවත වනු ඇත:

• උරුම ගසෙහි ආසන්නතම මූලාකෘතිය
• 'ශුන්‍ය' සහ 'නිර්වචනය නොකළ' වැනි සෑම විටම ප්‍රාථමික වර්ග සඳහා, ප්‍රාථමික නාමය.

එය සියලු JS වස්තූන් හා ප්‍රාථමිකයන් මත ක්‍රියා කරයි, ඒවා නිර්මාණය කරන ආකාරය නොසලකා, කිසිදු විස්මයක් නොමැත. උදාහරණ:

අංක

kind(37) === 'Number'
kind(3.14) === 'Number'
kind(Math.LN2) === 'Number'
kind(Infinity) === 'Number'
kind(Number(1)) === 'Number'
kind(new Number(1)) === 'Number'

නා

kind(NaN) === 'NaN'

නූල්

kind('') === 'String'
kind('bla') === 'String'
kind(String("abc")) === 'String'
kind(new String("abc")) === 'String'

බූලියන්

kind(true) === 'Boolean'
kind(false) === 'Boolean'
kind(new Boolean(true)) === 'Boolean'

අරා

kind([1, 2, 4]) === 'Array'
kind(new Array(1, 2, 3)) === 'Array'

වස්තු

kind({a:1}) === 'Object'
kind(new Object()) === 'Object'

දිනයන්

kind(new Date()) === 'Date'

කාර්යයන්

kind(function(){}) === 'Function'
kind(new Function("console.log(arguments)")) === 'Function'
kind(Math.sin) === 'Function'

නිර්වචනය නොකළ

kind(undefined) === 'undefined'

ශුන්‍යයි

kind(null) === 'null'

instanceofවස්තුවක් තවත් අවස්ථාවකි දැයි බැලීමට ඔබට ක්‍රියාකරු භාවිතා කළ හැකිය , නමුත් පන්ති නොමැති බැවින් ඔබට පන්ති නාමයක් ලබා ගත නොහැක.

පිළිගත් පිළිතුර මත පදනම් වූ ක්‍රියාත්මක කිරීමක් මෙන්න :

/**
 * Returns the name of an object's type.
 *
 * If the input is undefined, returns "Undefined".
 * If the input is null, returns "Null".
 * If the input is a boolean, returns "Boolean".
 * If the input is a number, returns "Number".
 * If the input is a string, returns "String".
 * If the input is a named function or a class constructor, returns "Function".
 * If the input is an anonymous function, returns "AnonymousFunction".
 * If the input is an arrow function, returns "ArrowFunction".
 * If the input is a class instance, returns "Object".
 *
 * @param {Object} object an object
 * @return {String} the name of the object's class
 * @see <a href="https://stackoverflow.com/a/332429/14731">https://stackoverflow.com/a/332429/14731</a>
 * @see getFunctionName
 * @see getObjectClass 
 */
function getTypeName(object)
{
  const objectToString = Object.prototype.toString.call(object).slice(8, -1);
  if (objectToString === "Function")
  {
    const instanceToString = object.toString();
    if (instanceToString.indexOf(" => ") != -1)
      return "ArrowFunction";
    const getFunctionName = /^function ([^(]+)\(/;
    const match = instanceToString.match(getFunctionName);
    if (match === null)
      return "AnonymousFunction";
    return "Function";
  }
  // Built-in types (e.g. String) or class instances
  return objectToString;
};

/**
 * Returns the name of a function.
 *
 * If the input is an anonymous function, returns "".
 * If the input is an arrow function, returns "=>".
 *
 * @param {Function} fn a function
 * @return {String} the name of the function
 * @throws {TypeError} if {@code fn} is not a function
 * @see getTypeName
 */
function getFunctionName(fn)
{
  try
  {
    const instanceToString = fn.toString();
    if (instanceToString.indexOf(" => ") != -1)
      return "=>";
    const getFunctionName = /^function ([^(]+)\(/;
    const match = instanceToString.match(getFunctionName);
    if (match === null)
    {
      const objectToString = Object.prototype.toString.call(fn).slice(8, -1);
      if (objectToString === "Function")
        return "";
      throw TypeError("object must be a Function.\n" +
        "Actual: " + getTypeName(fn));
    }
    return match[1];
  }
  catch (e)
  {
    throw TypeError("object must be a Function.\n" +
      "Actual: " + getTypeName(fn));
  }
};

/**
 * @param {Object} object an object
 * @return {String} the name of the object's class
 * @throws {TypeError} if {@code object} is not an Object
 * @see getTypeName
 */
function getObjectClass(object)
{
  const getFunctionName = /^function ([^(]+)\(/;
  const result = object.constructor.toString().match(getFunctionName)[1];
  if (result === "Function")
  {
    throw TypeError("object must be an Object.\n" +
      "Actual: " + getTypeName(object));
  }
  return result;
};


function UserFunction()
{
}

function UserClass()
{
}

let anonymousFunction = function()
{
};

let arrowFunction = i => i + 1;

console.log("getTypeName(undefined): " + getTypeName(undefined));
console.log("getTypeName(null): " + getTypeName(null));
console.log("getTypeName(true): " + getTypeName(true));
console.log("getTypeName(5): " + getTypeName(5));
console.log("getTypeName(\"text\"): " + getTypeName("text"));
console.log("getTypeName(userFunction): " + getTypeName(UserFunction));
console.log("getFunctionName(userFunction): " + getFunctionName(UserFunction));
console.log("getTypeName(anonymousFunction): " + getTypeName(anonymousFunction));
console.log("getFunctionName(anonymousFunction): " + getFunctionName(anonymousFunction));
console.log("getTypeName(arrowFunction): " + getTypeName(arrowFunction));
console.log("getFunctionName(arrowFunction): " + getFunctionName(arrowFunction));
//console.log("getFunctionName(userClass): " + getFunctionName(new UserClass()));
console.log("getTypeName(userClass): " + getTypeName(new UserClass()));
console.log("getObjectClass(userClass): " + getObjectClass(new UserClass()));
//console.log("getObjectClass(userFunction): " + getObjectClass(UserFunction));
//console.log("getObjectClass(userFunction): " + getObjectClass(anonymousFunction));
//console.log("getObjectClass(arrowFunction): " + getObjectClass(arrowFunction));
console.log("getTypeName(nativeObject): " + getTypeName(navigator.mediaDevices.getUserMedia));
console.log("getFunctionName(nativeObject): " + getFunctionName(navigator.mediaDevices.getUserMedia));

අපි ඉදිකිරීම්කරුගේ දේපල භාවිතා කරන්නේ අපට වෙනත් විකල්පයක් නොමැති විට පමණි.

වස්තුවක් කිසියම් පන්තියක නිදසුනක් ද නැද්ද යන්න තීරණය කිරීමට ඔබට "instanceof" ක්‍රියාකරු භාවිතා කළ හැකිය. ඔබ වස්තුවක වර්ගයේ නම නොදන්නේ නම්, ඔබට එහි ඉදිකිරීම්කරු දේපල භාවිතා කළ හැකිය. වස්තූන්ගේ ඉදිකිරීම්කරු දේපල, ඒවා ආරම්භ කිරීම සඳහා භාවිතා කරන ශ්‍රිතයට යොමු දැක්වීමකි. උදාහරණයක්:

function Circle (x,y,radius) {
    this._x = x;
    this._y = y;
    this._radius = raduius;
}
var c1 = new Circle(10,20,5);

දැන් c1.constructor යනු ශ්‍රිතයට යොමු දැක්වීමකි Circle(). ඔබට typeofක්‍රියාකරු භාවිතා කළ හැකිය , නමුත් typeofක්‍රියාකරු සීමිත තොරතුරු පෙන්වයි. එක් විසඳුමක් වන්නේ toString()වස්තුව ගෝලීය වස්තුවෙහි ක්‍රමය භාවිතා කිරීමයි . උදාහරණයක් ලෙස ඔබට වස්තුවක් තිබේ නම්, myObject යැයි කියන්න, ඔබට toString()MyObject පන්තියේ වර්ගය තීරණය කිරීමට ගෝලීය වස්තුවේ ක්‍රමය භාවිතා කළ හැකිය . මෙය භාවිතා කරන්න:

Object.prototype.toString.apply(myObject);

ඔබට ඇති බව පවසන්න var obj;

ඔබට "වස්තුව", "අරාව" හෝ "නූල්" වැනි වස්තු වර්ගයේ නම අවශ්‍ය නම්, ඔබට මෙය භාවිතා කළ හැකිය:

Object.prototype.toString.call(obj).split(' ')[1].replace(']', '');

ඔබට ලබා ගත හැකි ආසන්නතම දෙය නම් typeof, නමුත් එය ලබා දෙන්නේ ඕනෑම ආකාරයක අභිරුචි වර්ගයකට පමණි. ඒ සඳහා, ජේසන් බන්ටිං බලන්න .

සංස්කරණය කරන්න, ජේසන් කිසියම් හේතුවක් නිසා ඔහුගේ තනතුර මකා දැමුවේය, එබැවින් වස්තුවේ constructorදේපල පමණක් භාවිතා කරන්න .

තරමක් සරලයි!

• JS හි ඕනෑම දෙයක් ලබා ගැනීමට මගේ ප්‍රියතම ක්‍රමය

function getType(entity){
    var x = Object.prototype.toString.call(entity)
    return x.split(" ")[1].split(']')[0].toLowerCase()
}

• JS හි ඇති ඕනෑම දෙයක් පරීක්ෂා කිරීමට මගේ ප්‍රියතම ක්‍රමය

function checkType(entity, type){
    return getType(entity) === type
}

යමෙක් jQuery සමඟ වැඩ කරන විසඳුමක් සොයන්නේ නම්, මෙන්න සකස් කළ විකී කේතය (මුල් බිඳීම් jQuery).

Object.defineProperty(Object.prototype, "getClassName", {
    value: function() {
        var funcNameRegex = /function (.{1,})\(/;
        var results = (funcNameRegex).exec((this).constructor.toString());
        return (results && results.length > 1) ? results[1] : "";
    }
});

ලොඩාෂ් සතුව බොහෝ ක්‍රම තිබේ, එබැවින් ඔබ ලොඩාෂ් භාවිතා කරන්නේ නම් මෙවැනි මික්සින් එකක් ප්‍රයෝජනවත් විය හැකිය:

  // Mixin for identifying a Javascript Object

  _.mixin({
      'identify' : function(object) {
        var output;
          var isMethods = ['isArguments', 'isArray', 'isArguments', 'isBoolean', 'isDate', 'isArguments', 
              'isElement', 'isError', 'isFunction', 'isNaN', 'isNull', 'isNumber', 
              'isPlainObject', 'isRegExp', 'isString', 'isTypedArray', 'isUndefined', 'isEmpty', 'isObject']

          this.each(isMethods, function (method) {
              if (this[method](object)) {
                output = method;
                return false;
              }
          }.bind(this));
      return output;
      }
  });

එය පහත පරිදි ක්‍රියා කරන "හදුනා ගැනීම" නමින් ලොඩාෂ් සඳහා ක්‍රමයක් එක් කරයි:

console.log(_.identify('hello friend'));       // isString

ප්ලන්කර්: http://plnkr.co/edit/Zdr0KDtQt76Ul3KTEDSN

හරි, කට්ටිය, මම අවුරුදු කීපයක් තිස්සේ සෙමෙන් අල්ලා ගැනීමේ සියලු ක්‍රමවේදයන් ගොඩනගා ගත්තා lol! උපක්‍රමය නම්:

1. පන්ති නිර්මාණය කිරීම සඳහා යාන්ත්‍රණයක් තබා ගන්න.
2. ස්වදේශීය ඉදිකිරීම්කරුවන් විසින් නිර්මාණය කරන ලද / ජනනය කරන ලද සියලුම පරිශීලක පන්ති, ප්‍රාථමික සහ අගයන් පරීක්ෂා කිරීමේ යාන්ත්‍රණයක් තබා ගන්න.
3. ඔබගේ කේතය / යෙදුම / පුස්තකාලය / යනාදිය හරහා ඉහත ක්‍රියාකාරිත්වය ව්‍යාප්ත වන පරිදි පරිශීලක විසින් සාදන ලද පන්ති නව ඒවාට ව්‍යාප්ත කිරීමේ යාන්ත්‍රණයක් තබා ගන්න.

උදාහරණයක් සඳහා (හෝ මම ගැටලුව සමඟ කටයුතු කළ ආකාරය බැලීමට) github හි පහත කේතය දෙස බලන්න: https://github.com/elycruz/sjljs/blob/master/src/sjl/sjl.js සහ සෙවීම:

classOf =,, classOfIs =සහ defineSubClass =(පසුපෙළ නොමැතිව (`)).

ඔබට පෙනෙන classOfපරිදි, පන්ති / ඉදිකිරීම්කරුවන්ගේ වර්ගයේ නම ප්‍රාථමික, පරිශීලක අර්ථ දක්වන ලද පංතියක්, ස්වදේශීය ඉදිකිරීම්කරුවෙකු භාවිතා කරමින් නිර්මාණය කරන ලද අගයක්, ශුන්‍ය, නාන්, ආදිය නොසලකා සෑම විටම මට පන්ති / ඉදිකිරීම්කරුවන්ගේ නම ලබා දීමට බල කිරීමට මට යම් යාන්ත්‍රණයක් තිබේ . සෑම ජාවාස්ක්‍රිප්ට් අගයක් සඳහාම එහි සුවිශේෂී වර්ගයේ නම ශ්‍රිතයෙන් ලැබෙනු ඇත classOf. ඊට අමතරව sjl.classOfIs, වටිනාකමේ වර්ගයක් පරීක්ෂා කිරීමට මට සැබෑ ඉදිකිරීම්කරුවන් තුළට ඇතුළු විය හැකිය. උදාහරණයක් ලෙස:

`` `// කරුණාකර දිගු නාම අවකාශයන්ට සමාව දෙන්න! ටික වේලාවක් ඒවා භාවිතා කිරීමෙන් පසුව (ඔවුන් හහා උරා බොන තුරු) එහි බලපෑම ගැන මට කිසිම අදහසක් නොතිබුණි.

var SomeCustomClass = sjl.package.stdlib.Extendable.extend({
    constructor: function SomeCustomClass () {},
    // ...
}),

HelloIterator = sjl.ns.stdlib.Iterator.extend( 
    function HelloIterator () {}, 
    { /* ... methods here ... */ },
    { /* ... static props/methods here ... */ }
),

helloIt = new HelloIterator();

sjl.classOfIs(new SomeCustomClass(), SomeCustomClass) === true; // `true`
sjl.classOfIs(helloIt, HelloIterator) === true; // `true`

var someString = 'helloworld';

sjl.classOfIs(someString, String) === true; // `true`

sjl.classOfIs(99, Number) === true; // true

sjl.classOf(NaN) === 'NaN'; // true

sjl.classOf(new Map()) === 'Map';
sjl.classOf(new Set()) === 'Set';
sjl.classOfIs([1, 2, 4], Array) === true; // `true`

// etc..

// Also optionally the type you want to check against could be the type's name
sjl.classOfIs(['a', 'b', 'c'], 'Array') === true; // `true`!
sjl.classOfIs(helloIt, 'HelloIterator') === true; // `true`!

`` `

ඉහත සඳහන් කළ සැකසුම මා භාවිතා කරන්නේ කෙසේද යන්න පිළිබඳ වැඩිදුර කියවීමට ඔබ කැමති නම්, repo බලන්න: https://github.com/elycruz/sjljs

මෙම විෂය පිළිබඳ අන්තර්ගතයන් සහිත පොත් ද: - ස්ටොයාන් ස්ටෙෆනොව් විසින් "ජාවාස්ක්‍රිප්ට් රටා". - "ජාවාස්ක්‍රිප්ට් - නියත මාර්ගෝපදේශය." ඩේවිඩ් ෆ්ලැනගන් විසිනි. - සහ තවත් බොහෝ අය .. (සෙවුම් ලෙ වෙබ්).

මා මෙහි කතා කරන විශේෂාංග ඔබට ඉක්මණින් පරීක්ෂා කළ හැකිය: - http://sjljs.elycruz.com/0.5.18/tests/for-browser/ (එසේම url හි 0.5.18 මාර්ගයෙහි ගිතුබ් වෙතින් ප්‍රභවයන් ඇත එහි node_modules අවම සහ එවැනි).

සුබ කේතීකරණයක්!

භාවිතා කරන්න class.name. මෙයද ක්‍රියාත්මක වේ function.name.

class TestA {}
console.log(TestA.name); // "TestA"

function TestB() {}
console.log(TestB.name); // "TestB"