Récupère le nom du type d’object

Existe-t-il un équivalent JavaScript de Java class.getName() ?

Existe-t-il un équivalent JavaScript de Java class.getName() ?

Non

ES2015 Update : le nom de la class Foo {} est Foo.name . Le nom de la classe de la thing , quel que soit le type de la thing , est thing.constructor.name . Les constructeurs intégrés dans un environnement ES2015 ont la propriété de name correcte; par exemple (2).constructor.name est "Number" .


Mais voici différents types de piratage qui tombent d’une manière ou d’une autre:

Voici un hack qui fera ce dont vous avez besoin – sachez que cela modifie le prototype de l’object, quelque chose que les gens désapprouvent (généralement pour une bonne raison)

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

Maintenant, tous vos objects auront la fonction, getName() , qui retournera le nom du constructeur sous forme de chaîne. Je l’ai testé dans FF3 et IE7 , je ne peux pas parler pour d’autres implémentations.

Si vous ne voulez pas faire cela, voici une discussion sur les différentes manières de déterminer les types en JavaScript …


Je l’ai récemment mis à jour pour qu’il soit un peu plus exhaustif, même si c’est loin d’être le cas. Corrections bienvenue …

Utiliser la propriété constructor

Chaque object a une valeur pour sa propriété constructor , mais en fonction de la manière dont cet object été construit et de ce que vous voulez faire avec cette valeur, il peut être utile ou non.

En règle générale, vous pouvez utiliser la propriété constructor pour tester le type de l’object comme suit:

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

Donc, cela fonctionne assez bien pour la plupart des besoins. Cela dit…

Mises en garde

Ne fonctionnera pas du tout dans de nombreux cas

Ce modèle, bien que cassé, est assez courant:

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

Objects construits via new Thingy auront une propriété constructor qui pointe vers Object , pas Thingy . Nous tombons donc dès le départ; vous ne pouvez tout simplement pas faire confiance à un constructor dans une base de code que vous ne contrôlez pas.

Héritage multiple

Un exemple où ce n’est pas aussi évident consiste à utiliser l’inheritance multiple:

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

Les choses ne fonctionnent plus comme vous vous en doutez:

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

Ainsi, vous pourriez obtenir des résultats inattendus si l’ object vous testez possède un ensemble d’ object différent comme prototype . Il y a des moyens de contourner cette question.

Il y a d’autres utilisations de la propriété constructor , certaines intéressantes, d’autres moins; pour l’instant, nous ne nous pencherons pas sur ces utilisations car elles ne sont pas pertinentes pour cette discussion.

Ne fonctionnera pas en croix et en fenêtre croisée

L’utilisation de .constructor pour la vérification de type se brisera lorsque vous souhaitez vérifier le type d’objects provenant d’objects de window différents, par exemple celui d’une iframe ou d’une fenêtre contextuelle. C’est parce qu’il existe une version différente de chaque constructor type de base dans chaque fenêtre, c’est-à-dire

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

En utilisant l’opérateur instanceof

L’opérateur instanceof est un moyen propre de tester également le type d’ object , mais a ses propres problèmes potentiels, tout comme la propriété constructor .

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

Mais instanceof ne fonctionne pas pour les valeurs littérales (car les littéraux ne sont pas des Objects )

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

Les littéraux doivent être encapsulés dans un Object pour que instanceof fonctionne, par exemple

 new Number(3) instanceof Number // true 

La vérification de .constructor fonctionne .constructor pour les littéraux car le . invocation de méthode enveloppe implicitement les littéraux dans leur type d’object respectif

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

Pourquoi deux points pour le 3? Parce que Javascript interprète le premier point comme un point décimal;)

Ne fonctionnera pas en croix et en fenêtre croisée

instanceof ne fonctionnera pas non plus sur différentes fenêtres, pour la même raison que la vérification des propriétés du constructor .


En utilisant la propriété name de la propriété constructor

Ne fonctionne pas du tout dans de nombreux cas

Encore une fois, voir ci-dessus Il est assez courant que le constructor soit complètement et complètement faux et inutile.

Ne fonctionne pas dans

Utiliser myObjectInstance.constructor.name vous donnera une chaîne contenant le nom de la fonction constructor utilisée, mais est sujette aux avertissements concernant la propriété constructor mentionnée précédemment.

Pour IE9 et les versions ultérieures, vous pouvez utiliser monkey-patch dans le support :

 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).toSsortingng()); return (results && results.length > 1) ? results[1] : ""; }, set: function(value) {} }); } 

Version mise à jour de l’article en question. Cela a été ajouté 3 mois après la publication de l’article, il s’agit de la version recommandée par l’auteur Matthew Scharley. Ce changement a été inspiré par les commentaires soulignant les pièges potentiels du code précédent.

 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).toSsortingng()); return (results && results.length > 1) ? results[1].sortingm() : ""; }, set: function(value) {} }); } 

Utiliser Object.prototype.toSsortingng

Il s’avère que, comme ce post détails , vous pouvez utiliser Object.prototype.toSsortingng – l’implémentation bas niveau et générique de toSsortingng – pour obtenir le type de tous les types intégrés

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

On pourrait écrire une fonction d’assistance courte telle que

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

pour enlever le cru et obtenir juste le nom du type

 type('abc') // Ssortingng 

Cependant, il retournera Object pour tous les types définis par l’utilisateur.


Mises en garde pour tous …

Tout cela est sujet à un problème potentiel, et c’est la question de savoir comment l’object en question a été construit. Voici différentes manières de construire des objects et les valeurs que les différentes méthodes de vérification de type renverront:

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

Bien que toutes les permutations ne soient pas présentes dans cet ensemble d’exemples, nous espérons qu’il y en aura assez pour vous donner une idée de la façon dont les choses peuvent être désordonnées en fonction de vos besoins. Ne présumez rien, si vous ne comprenez pas exactement ce que vous recherchez, vous risquez de vous retrouver avec du code qui ne vous attend pas à cause du manque de perspicacité.

REMARQUE:

La discussion de l’opérateur typeof peut sembler être une omission flagrante, mais ce n’est vraiment pas utile pour identifier si un object est un type donné, car il est très simpliste. Comprendre où typeof est utile est important, mais je ne pense pas que cela soit très pertinent pour cette discussion. Mon esprit est ouvert au changement cependant. 🙂

La réponse de Jason Bunting m’a donné assez d’indice pour trouver ce dont j’avais besoin:

 <>.constructor.name 

Donc, par exemple, dans le morceau de code suivant:

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

myInstance.constructor.name renverrait "MyObject" .

Un petit truc que j’utilise:

 function Square(){ this.className = "Square"; this.corners = 4; } var MySquare = new Square(); console.log(MySquare.className); // "Square" 

Mettre à jour

Pour être précis, je pense que OP a demandé une fonction qui récupère le nom du constructeur pour un object particulier. En terme de Javascript, object n’a pas de type mais est un type de et en soi . Cependant, différents objects peuvent avoir différents constructeurs .

 Object.prototype.getConstructorName = function () { var str = (this.prototype ? this.prototype.constructor : this.constructor).toSsortingng(); 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" 


Remarque: l’exemple ci-dessous est obsolète.

Un article de blog lié par Christian Sciberras contient un bon exemple de la manière de le faire. À savoir, en étendant le prototype Object:

 if (!Object.prototype.getClassName) { Object.prototype.getClassName = function () { return Object.prototype.toSsortingng.call(this).match(/^\[object\s(.*)\]$/)[1]; } } var test = [1,2,3,4,5]; alert(test.getClassName()); // returns Array 

Utiliser Object.prototype.toSsortingng

Il s’avère que, comme ce post détails, vous pouvez utiliser Object.prototype.toSsortingng – l’implémentation bas niveau et générique de toSsortingng – pour obtenir le type de tous les types intégrés

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

On pourrait écrire une fonction d’assistance courte telle que

 function type(obj){ return Object.prototype.toSsortingng.call(obj]).match(/\s\w+/)[0].sortingm() } return [object Ssortingng] as Ssortingng return [object Number] as Number return [object Object] as Object return [object Undefined] as Undefined return [object Function] as Function 

Voici une solution qui résout les lacunes de l’instance. Il peut vérifier les types d’un object à partir de fenêtres croisées et croisées et n’a pas de problèmes avec les types primitifs.

 function getType(o) { return Object.prototype.toSsortingng.call(o).match(/^\[object\s(.*)\]$/)[1]; } function isInstance(obj, type) { var ret = false, isTypeASsortingng = getType(type) == "Ssortingng", functionConstructor, i, l, typeArray, context; if (!isTypeASsortingng && getType(type) != "Function") { throw new TypeError("type argument must be a ssortingng 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 (isTypeASsortingng) { //type is a ssortingng 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 nécessite deux parameters: un object et un type. Le vrai truc dans son fonctionnement est qu’il vérifie si l’object provient de la même fenêtre et si ce n’est pas la fenêtre de l’object.

Exemples:

 isInstance([], "Array"); //true isInstance("some ssortingng", "Ssortingng"); //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 

L'argument type peut également être une fonction de rappel qui renvoie un constructeur. La fonction de rappel recevra un paramètre qui est la fenêtre de l'object fourni.

Exemples:

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

Une chose à garder à l'esprit est que IE <9 ne fournit pas le constructeur sur tous les objets, donc le test ci-dessus pour NodeList renverrait false et un isInstance (alerte, "Fonction") renverrait false.

Utilisez constructor.name quand vous le pouvez, et regex fonctionne quand je ne peux pas.

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

La fonction kind () de Agave.JS renverra:

  • le prototype le plus proche de l’arbre d’inheritance
  • pour les types toujours primitifs comme “null” et “undefined”, le nom primitif.

Il fonctionne sur tous les objects et primitives JS, quelle que soit la manière dont ils ont été créés , et n’a aucune surprise. Exemples:

Nombres

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

NaN

 kind(NaN) === 'NaN' 

Cordes

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

Booléens

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

Tableaux

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

Objets

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

Rendez-vous

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

Les fonctions

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

indéfini

 kind(undefined) === 'undefined' 

nul

 kind(null) === 'null' 

Vous pouvez utiliser l’opérateur instanceof pour voir si un object est une instance d’un autre, mais comme il n’y a pas de classe, vous ne pouvez pas obtenir un nom de classe.

Je cherchais en fait une chose similaire et je suis tombé sur cette question. Voici comment j’obtiens les types: jsfiddle

 var TypeOf = function ( thing ) { var typeOfThing = typeof thing; if ( 'object' === typeOfThing ) { typeOfThing = Object.prototype.toSsortingng.call( thing ); if ( '[object Object]' === typeOfThing ) { if ( thing.constructor.name ) { return thing.constructor.name; } else if ( '[' === thing.constructor.toSsortingng().charAt(0) ) { typeOfThing = typeOfThing.subssortingng( 8,typeOfThing.length - 1 ); } else { typeOfThing = thing.constructor.toSsortingng().match( /function\s*(\w+)/ ); if ( typeOfThing ) { return typeOfThing[1]; } else { return 'Function'; } } } else { typeOfThing = typeOfThing.subssortingng( 8,typeOfThing.length - 1 ); } } return typeOfThing.charAt(0).toUpperCase() + typeOfThing.slice(1); } 

Vous pouvez utiliser l’opérateur “instanceof” pour déterminer si un object est une instance d’une certaine classe ou non. Si vous ne connaissez pas le nom d’un type d’object, vous pouvez utiliser sa propriété constructeur. La propriété constructeur des objects est une référence à la fonction utilisée pour les initialiser. Exemple:

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

Maintenant, c1.constructor est une référence à la fonction Circle() . Vous pouvez également utiliser l’opérateur typeof , mais l’opérateur typeof affiche des informations limitées. Une solution consiste à utiliser la toSsortingng() de l’object global Object. Par exemple, si vous avez un object, disons myObject, vous pouvez utiliser la toSsortingng() de l’object global pour déterminer le type de la classe de myObject. Utilisez ceci:

 Object.prototype.toSsortingng.apply(myObject); 

Le plus proche possible est typeof , mais il ne renvoie que “object” pour tout type de type personnalisé. Pour ceux-là, voir Jason Bunting .

Edit, Jason a supprimé son message pour une raison quelconque, utilisez simplement la propriété constructor de Object.

Voici une implémentation basée sur la réponse acceptée :

 /** * 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 ssortingng, returns "Ssortingng". * 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 {Ssortingng} the name of the object's class * @see https://stackoverflow.com/a/332429/14731 * @see getFunctionName * @see getObjectClass */ function getTypeName(object) { const objectToSsortingng = Object.prototype.toSsortingng.call(object).slice(8, -1); if (objectToSsortingng === "Function") { const instanceToSsortingng = object.toSsortingng(); if (instanceToSsortingng.indexOf(" => ") != -1) return "ArrowFunction"; const getFunctionName = /^function ([^(]+)\(/; const match = instanceToSsortingng.match(getFunctionName); if (match === null) return "AnonymousFunction"; return "Function"; } // Built-in types (eg Ssortingng) or class instances return objectToSsortingng; }; /** * 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 {Ssortingng} the name of the function * @throws {TypeError} if {@code fn} is not a function * @see getTypeName */ function getFunctionName(fn) { try { const instanceToSsortingng = fn.toSsortingng(); if (instanceToSsortingng.indexOf(" => ") != -1) return "=>"; const getFunctionName = /^function ([^(]+)\(/; const match = instanceToSsortingng.match(getFunctionName); if (match === null) { const objectToSsortingng = Object.prototype.toSsortingng.call(fn).slice(8, -1); if (objectToSsortingng === "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 {Ssortingng} 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.toSsortingng().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)); 

Vous devriez utiliser somevar.constructor.name comme:

 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' 

Si quelqu’un cherchait une solution fonctionnant avec jQuery, voici le code wiki ajusté (l’original casse jQuery).

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

Lodash a beaucoup de méthodes, donc si vous utilisez Lodash, un mixin comme celui-ci peut être utile:

  // 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', 'isSsortingng', 'isTypedArray', 'isUndefined', 'isEmpty', 'isObject'] this.each(isMethods, function (method) { if (this[method](object)) { output = method; return false; } }.bind(this)); return output; } }); 

Il ajoute une méthode à lodash appelée “identifier” qui fonctionne comme suit:

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

Plunker: http://plnkr.co/edit/Zdr0KDtQt76Ul3KTEDSN

Ok, les gars, je construis lentement une méthode de capture pour toutes ces années lol! L’astuce consiste à:

  1. Avoir un mécanisme pour créer des classes.
  2. Avoir un mécanisme pour vérifier toutes les classes créées par l’utilisateur, les primitives et les valeurs créées / générées par les constructeurs natifs.
  3. Avoir un mécanisme pour étendre les classes créées par l’utilisateur en nouvelles afin que la fonctionnalité ci-dessus imprègne votre code / application / bibliothèque / etc.

Pour un exemple (ou pour voir comment j’ai traité le problème), regardez le code suivant sur github: https://github.com/elycruz/sjljs/blob/master/src/sjl/sjl.js et recherchez:

classOfIs = classOf = , classOfIs = , et ou defineSubClass = (sans les backticks (`)).

Comme vous pouvez le constater, certains mécanismes permettent à classOf de toujours me donner le nom du type classes / constructeurs, qu’il s’agisse d’une primitive, d’une classe définie par l’utilisateur, d’une valeur créée avec un constructeur natif, Null, NaN, etc. Pour chaque valeur javascript, je vais obtenir son nom de type unique à partir de la fonction classOf . De plus, je peux passer des constructeurs réels dans sjl.classOfIs pour vérifier le type d’une valeur en plus de pouvoir transmettre également son nom de type! Donc par exemple:

“ `S’il vous plaît pardonnez les espaces de noms longs! Je n’avais aucune idée de l’impact avant de les utiliser pendant un moment (ils sucent haha)

 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 someSsortingng = 'helloworld'; sjl.classOfIs(someSsortingng, Ssortingng) === 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`! 

“ `

Si vous êtes intéressé à en savoir plus sur la façon dont j’utilise la configuration mentionnée ci-dessus, jetez un coup d’œil au repository: https://github.com/elycruz/sjljs

Aussi des livres avec du contenu sur le sujet: – “JavaScript Patterns” de Stoyan Stefanov. – “Javascript – Le guide définitif” par David Flanagan. – et beaucoup d’autres .. (search le` web).

Vous pouvez également tester rapidement les fonctionnalités dont je parle ici: – http://sjljs.elycruz.com/0.5.18/tests/for-browser/ (également le chemin 0.5.18 dans l’URL des sources de github là-bas moins les node_modules et autres).

Heureux codage!

Disons que vous avez var obj;

Si vous voulez juste le nom du type d’obj, comme “Object”, “Array” ou “Ssortingng”, vous pouvez utiliser ceci:

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