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 …
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…
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
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;)
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
.
name
de la propriété constructor
… Encore une fois, voir ci-dessus Il est assez courant que le constructor
soit complètement et complètement faux et inutile.
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) {} }); }
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.
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é.
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:
<
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"
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:
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:
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('') === 'Ssortingng' kind('bla') === 'Ssortingng' kind(Ssortingng("abc")) === 'Ssortingng' kind(new Ssortingng("abc")) === 'Ssortingng'
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'
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
Ok, les gars, je construis lentement une méthode de capture pour toutes ces années lol! L’astuce consiste à:
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(']', '');