Lorsque vous traitez des codes complexes en JavaScript, il existe souvent une ambiguïté dans la détermination de la différence entre une fonction en ligne et une fonction normale. Par exemple, vérifier une variable créée au moment de l'exécution et affectée à une fonction. Dans de tels cas, vérifier si une variable est de type fonction à l'aide de JavaScript aide à déterminer et à trier les données de manière appropriée.
Ce blog démontrera les approches pour vérifier si une variable est de type fonction en JavaScript.
Comment vérifier si une variable est de type Function en JavaScript ?
Pour vérifier/vérifier si une variable est de type fonction en JavaScript, les approches suivantes peuvent être utilisées :
- Opérateur 'typeOf'.
- opérateur 'instanceof'.
- Méthode 'object.prototype.tostring.call()'.
Suivons chacune des approches une par une !
Approche 1 : vérifier si la variable est de type de fonction en JavaScript à l'aide de l'opérateur typeOf
La ' Type de ” L'opérateur récupère le type de données d'une variable. Cet opérateur peut être utilisé en combinaison avec l'opérateur d'égalité stricte (===) pour appliquer une vérification sur une variable particulière pour son type.
Exemple
Voyons l'exemple suivant :
< type de scénario = 'texte/javascript' >fonction multiplier ( un , b ) {
revenir un * b ;
}
si ( Type de multiplier === 'fonction' ) {
console. Journal ( 'La variable est de type fonction' ) ;
}
autre {
console. Journal ( 'La variable n'est pas de type fonction' ) ;
}
scénario >
Passons par les étapes suivantes comme indiqué dans le code ci-dessus:
- Déclarez une fonction nommée ' multiplier() ” ayant les paramètres indiqués pour multiplier deux nombres.
- Dans sa définition, multipliez les nombres spécifiés passés en paramètres de la fonction.
- Après cela, appliquez le ' Type de ” à l'aide d'un opérateur égal strict pour vérifier si le type de la variable indiquée est “ fonction ”.
- En conséquence, le message correspondant s'affichera selon la condition satisfaite ou non satisfaite, respectivement.
Production
Dans la sortie ci-dessus, on peut observer que la variable ' multiplier ” est du type fonction.
Approche 2 : vérifier si la variable est de type de fonction en JavaScript à l'aide de l'opérateur instanceof
La ' exemple de L'opérateur ” est utilisé pour vérifier le type d'une fonction particulière, d'une variable, etc., au moment de l'exécution. Cet opérateur peut être utilisé pour vérifier le paramètre passé pour son type en spécifiant son type correspondant et en lui appliquant une vérification.
Syntaxe
Nom exemple de TaperDans la syntaxe ci-dessus :
- ' Nom ” fait référence au nom d'une variable/fonction.
- ' Taper ” correspond au type d'une variable/fonction, c'est-à-dire chaîne, etc.
Exemple
L'exemple ci-dessous illustre le concept énoncé :
< type de scénario = 'texte/javascript' >laissez sampleFunc = fonction ( ) {
}
fonction vérifierFonction ( X ) {
si ( X exemple de Fonction ) {
alerte ( 'La variable est de type fonction' ) ;
}
autre {
alerte ( 'La variable n'est pas de type fonction' ) ;
} }
vérifierFonction ( sampleFunc ) ;
scénario >
Dans l'extrait de code ci-dessus :
- Tout d'abord, définissez une fonction inline nommée ' sampleFunc() ”.
- Après cela, déclarez une autre fonction nommée ' vérifierFonction() ” ayant le paramètre indiqué. Dans sa définition, appliquer le « exemple de ' opérateur dans le ' sinon ' condition. Ici, ' X ” représente le nom du paramètre passé, et “ Fonction ” indique son type, respectivement.
- Enfin, accédez à la fonction indiquée en passant la fonction inline comme paramètre. Cela affichera le message correspondant par rapport au type spécifié dans l'opérateur.
Production
À partir de la sortie ci-dessus, on peut observer que la fonction en ligne indiquée est du ' fonction ' taper.
Approche 3 : vérifier/vérifier si la variable est de la fonction de type en JavaScript à l'aide de la méthode object.prototype.tostring.call()
La ' Objet.prototype.toString() ” est utilisée pour renvoyer une chaîne qui peut représenter un objet. Cette méthode peut être appliquée à l'aide d'une méthode d'objet telle que le type de l'objet est renvoyé.
Exemple
Passons en revue l'exemple suivant :
< type de scénario = 'texte/javascript' >laissez sampleFunc = fonction ( ) { }
fonction vérifierFonction ( X ) {
si ( Objet . prototype . toString . appel ( X ) == '[Fonction d'objet]' ) {
console. Journal ( 'La variable est de type fonction' ) ;
}
autre {
console. Journal ( 'La variable n'est pas de type fonction' ) ;
} }
vérifierFonction ( sampleFunc ) ;
scénario >
Effectuez les étapes suivantes comme indiqué dans les lignes de code ci-dessus :
- De même, déclarez une fonction inline nommée ' sampleFunc() ”.
- Dans l'étape suivante, définissez une fonction nommée ' vérifierFonction() ” ayant le paramètre indiqué.
- Dans sa définition, appliquer le « Objet.prototype.toString.call() ” méthode en se référant au paramètre de la fonction. La ' Fonction ” représente ici le type de la fonction particulière à vérifier.
- Le ' si ' La condition s'exécute si le paramètre passé est une fonction.
- Dans l'autre scénario, le ' autre ” la condition sera exécutée.
Production
La sortie ci-dessus indique que la fonctionnalité requise est atteinte.
Conclusion
La ' Type de ' opérateur, le ' exemple de ' ou l'opérateur ' objet.prototype.tostring.call() ” La méthode peut vérifier/vérifier si une variable est de type fonction en JavaScript. L'opérateur typeOf peut être combiné avec l'opérateur d'égalité stricte pour vérifier le type d'une variable. L'instance de l'opérateur vérifie la variable transmise en spécifiant son type correspondant et en lui appliquant une vérification. La méthode object.prototype.tostring.call() renvoie le type de l'objet. Cet article a fourni les méthodes pour vérifier si une variable est de type fonction en utilisant JavaScript.