Dans mon travail de développement, je rencontre souvent des situations où je dois déterminer si une fonction est une fonction native JavaScript. Parfois, c'est une tâche très nécessaire. Vous devez savoir si cette fonction est fournie par le navigateur lui-même, ou est encapsulé et déguisé en fonction native par un tiers. Bien sûr, la meilleure façon est d'examiner la valeur de retour de la méthode TOSTRING qui exécute cette fonction.
Le javascript
La façon d'accomplir cette tâche est très simple:
La copie de code est la suivante:
fonction isNative (fn) {
return (// {/ s * / [code natif /] / s * /} /). test ('' + fn);
}
La méthode TOSTRING renverra la forme de chaîne de cette méthode, puis utilise une expression régulière pour déterminer les caractères contenus.
Une méthode plus forte
John-David Dalton, le fondateur de Lodash, a trouvé une meilleure solution:
La copie de code est la suivante:
;(fonction() {
// utilisé pour résoudre le `[[classe]] interne de valeurs
var toString = object.prototype.tostring;
// utilisé pour résoudre la source de fonctions décompilée
var fntoString = function.prototype.toString;
// Utilisé pour détecter les constructeurs hôtes (Safari> 4; vraiment tapé sur le tableau)
var rehostctor = / ^ / [objet. +? Constructeur /] $ /;
// Compilez un regexp en utilisant une méthode native commune comme modèle.
// Nous choisissons `objet # toString` car il y a de fortes chances qu'il ne soit pas bouché.
var renative = regexp ('^' +
// coerce `objet # toString` à une chaîne
String (toString)
// échapper à tous les caractères regexp spéciaux
.replace (/ [. * +? ^ $ {} () | [/] ////] / g, '// $ &')
// Remplacez les mentions de «tostring» par `. *?` Pour garder le modèle générique.
// Remplacez une chose comme `pour ...` pour prendre en charge des environnements comme Rhino qui ajoutent des informations supplémentaires
// comme la méthode Arity.
.replace (/ toString | (fonction). *? (? = /// () | pour. +? (? = ///]) / g, '$ 1 *?') + '$'
));
fonction isNative (valeur) {
VAR TYPE = TYPEOF VALEUR;
type de retour == 'fonction'
// Utilisez `function # tostring` pour contourner la méthode` tostring` de la valeur
// et éviter d'être truqué.
? Renative.test (fntoString.Call (valeur))
// se calmer à un objet hôte à vérifier car certains environnements représenteront
// des choses comme les tableaux typés comme méthodes DOM qui peuvent ne pas être conformes au
// motif natif normal.
: (valeur && type == 'objet' && rehostctor.test (toString.call (valeur))) || FAUX;
}
// Exporter comme vous le souhaitez
module.exports = isNative;
} ());
Maintenant, vous le voyez aussi, c'est très complexe, mais plus puissant. Bien sûr, ce n'est pas pour la protection de la sécurité, il vous fournit simplement des informations pertinentes pour savoir s'il s'agit d'une fonction native.