Conseils pour détecter si une fonction est native de JavaScript function_javascript tips

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 la fonction est fournie par le navigateur lui-même ou par un. tiers. Encapsulation à trois et déguisement en fonctions natives. Bien entendu, le meilleur moyen est d’examiner la valeur de retour de la méthode toString qui exécute cette fonction.

Le JavaScript

La manière d'accomplir cette tâche est très simple :

Copier le code Le code est le suivant :

la fonction estNative(fn) {
return (/{s*[code natif]s*}/).test(''fn);
>

La méthode toString renverra la forme de chaîne de cette méthode, puis utilisera des expressions régulières pour déterminer les caractères qu'elle contient.

Une méthode plus puissante

Le fondateur de Lodash, John-David Dalton, a trouvé une meilleure solution :

Copier le code Le code est le suivant :

;(fonction() {

// Utilisé pour résoudre la `[[Class]]` interne des valeurs
var toString = Object.prototype.toString;

// Utilisé pour résoudre la source décompilée des fonctions
var fnToString = Function.prototype.toString;

// Utilisé pour détecter les constructeurs d'hôtes (Safari > 4; spécifique au tableau vraiment typé)
var reHostCtor = /^[objet ?Constructeur]$/;

// Compilez une expression rationnelle en utilisant une méthode native commune comme modèle.
// Nous avons choisi `Object#toString` car il y a de fortes chances qu'il ne soit pas détruit.
var reNative = RegExp('^'
// Contraindre `Object#toString` en une chaîne
Chaîne(versChaîne)
// Échapper à tous les caractères d'expression rationnelle spéciaux
.replace(/[.* ?^${}()|[]/\]/g, '\$&')
// Remplacez les mentions de `toString` par `.*?` pour garder le modèle générique.
// Remplacez quelque chose comme `for ...` pour prendre en charge des environnements comme Rhino qui ajoutent des informations supplémentaires
// comme l'arité de la méthode.
.replace(/toString|(function).*?(?=\()| for . ?(?=\])/g, '$1.*?') '$'
);

la fonction estNative(valeur) {
var type = type de valeur ;
Type de retour == 'fonction'
// Utilisez `Function#toString` pour contourner la propre méthode `toString` de la valeur
// et évitez de vous faire tromper.
​ ? reNative.test(fnToString.call(value))
// Repli sur une vérification d'objet hôte car certains environnements représenteront
// des choses comme des tableaux typés en tant que méthodes DOM qui peuvent ne pas être conformes au
// modèle natif normal.
: (value && type == 'object' && reHostCtor.test(toString.call(value))) || false;
>

// exportez comme vous le souhaitez
module.exports = isNative;
}());

Maintenant vous le voyez, c'est complexe, mais plus puissant. Bien entendu, ce n’est pas à des fins de sécurité, cela vous indique simplement s’il s’agit d’une fonction native.