Comment vérifier si la fonction existe en JavaScript?

Mon code est

function getID( swfID ){
     if(navigator.appName.indexOf("Microsoft") != -1){
          me = window[swfID];
     }else{
          me = document[swfID];
     }
}

function js_to_as( str ){
     me.onChange(str);
}

Cependant, parfois mon onChangene se charge pas. Erreurs Firebug avec

me.onChange n'est pas une fonction

Je veux me dégrader gracieusement car ce n'est pas la caractéristique la plus importante de mon programme. typeofdonne la même erreur.

Avez-vous des suggestions sur la façon de vous assurer qu'il existe et ensuite de l'exécuter uniquement onChange?

(Aucune des méthodes ci-dessous, sauf essayez d'attraper un travail)

Essayez quelque chose comme ceci:

if (typeof me.onChange !== "undefined") { 
    // safe to use the function
}

ou mieux encore (selon le commentaire de UpTheCreek)

if (typeof me.onChange === "function") { 
    // safe to use the function
}

J'ai eu ce problème.

if (obj && typeof obj === 'function') { ... }

continuait à lancer une erreur de référence si obj n'était pas défini.

Au final, j'ai fait ce qui suit:

if (typeof obj !== 'undefined' && typeof obj === 'function') { ... }

Un collègue m'a fait remarquer que vérifier si c'est !== 'undefined'et puis === 'function'c'est redondant bien sûr.

Plus simple:

if (typeof obj === 'function') { ... }

Beaucoup plus propre et fonctionne très bien.

Si vous utilisez eval pour convertir une chaîne en fonction et que vous souhaitez vérifier si cette méthode évaluée existe, vous voudrez utiliser typeof et votre chaîne de fonction dans un eval :

var functionString = "nonexsitantFunction"
eval("typeof " + functionString) // returns "undefined" or "function"

N'inversez pas cela et essayez un typeof sur eval . Si vous faites une ReferenceError sera levée:

var functionString = "nonexsitantFunction"
typeof(eval(functionString)) // returns ReferenceError: [function] is not defined

Que diriez-vous:

if('functionName' in Obj){
    //code
}

par exemple

var color1 = new String("green");
"length" in color1 // returns true
"indexOf" in color1 // returns true
"blablabla" in color1 // returns false

ou comme pour votre cas:

if('onChange' in me){
    //code
}

Voir les documents MDN .

Essayez typeof- Cherchez 'undefined'à dire qu'elle n'existe pas, 'function'pour une fonction. JSFiddle pour ce code

function thisishere() {
    return false;
}
alert("thisishere() is a " + typeof thisishere);
alert("thisisnthere() is " + typeof thisisnthere);

Ou comme si:

if (typeof thisishere === 'function') {
    // function exists
}

Ou avec une valeur de retour, sur une seule ligne:

var exists = (typeof thisishere === 'function') ? "Value if true" : "Value if false";
var exists = (typeof thisishere === 'function') // Returns true or false

N'a pas vu cela suggéré: me.onChange && me.onChange (str);

Fondamentalement, si me.onChange n'est pas défini (ce qu'il sera s'il n'a pas été lancé), il n'exécutera pas la dernière partie. Si me.onChange est une fonction, elle exécutera me.onChange (str).

Vous pouvez même aller plus loin et faire:

me && me.onChange && me.onChange(str);

au cas où je serais asynchrone aussi.

//Simple function that will tell if the function is defined or not
function is_function(func) {
    return typeof window[func] !== 'undefined' && $.isFunction(window[func]);
}

//usage

if (is_function("myFunction") {
        alert("myFunction defined");
    } else {
        alert("myFunction not defined");
    }

Pour moi, le moyen le plus simple:

function func_exists(fname)
{
  return (typeof window[fname] === 'function');
}

Je vais aller plus loin pour m'assurer que la propriété est bien une fonction

function js_to_as( str ){
     if (me && me.onChange && typeof me.onChange === 'function') {
         me.onChange(str);
     }
}

function js_to_as( str ){
     if (me && me.onChange)
         me.onChange(str);
}

J'aime utiliser cette méthode:

function isFunction(functionToCheck) {
  var getType = {};
  return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
}

Usage:

if ( isFunction(me.onChange) ) {
    me.onChange(str); // call the function with params
}

La bibliothèque Underscore.js le définit dans la méthode isFunction comme ceci (ce que les commentaires suggèrent peut répondre à certains bogues du navigateur)

typeof obj == 'function' || false

http://underscorejs.org/docs/underscore.html#section-143

function function_exists(function_name)
{
    return eval('typeof ' + function_name) === 'function';
}
alert(function_exists('test'));
alert(function_exists('function_exists'));

OU

function function_exists(func_name) {
  //  discuss at: http://phpjs.org/functions/function_exists/
  // original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
  // improved by: Steve Clay
  // improved by: Legaev Andrey
  // improved by: Brett Zamir (http://brett-zamir.me)
  //   example 1: function_exists('isFinite');
  //   returns 1: true

  if (typeof func_name === 'string') {
    func_name = this.window[func_name];
  }
  return typeof func_name === 'function';
}

Mettez un double point d'exclamation, c'est-à-dire !! avant le nom de la fonction que vous souhaitez vérifier. S'il existe, il retournera vrai.

function abc(){
}
!!window.abc; // return true
!!window.abcd; // return false

En quelques mots: rattrapez l'exception.

Je suis vraiment surpris que personne n'ait encore répondu ou commenté Exception Catch sur ce post.

Détail: voici un exemple où j'essaie de faire correspondre une fonction qui est préfixée par mask_ et suffixée par le champ de formulaire "nom". Lorsque JavaScript ne trouve pas la fonction, il doit lancer une ReferenceError que vous pouvez gérer comme vous le souhaitez dans la section catch.

function inputMask(input) {
  try {
    let maskedInput = eval("mask_"+input.name);

    if(typeof maskedInput === "undefined")
        return input.value;
    else
        return eval("mask_"+input.name)(input);

  } catch(e) {
    if (e instanceof ReferenceError) {
      return input.value;
    }
  }
}

Sans conditions

me.onChange=function(){};

function getID( swfID ){
     if(navigator.appName.indexOf("Microsoft") != -1){
          me = window[swfID];
     }else{
          me = document[swfID];
     }
}

function js_to_as( str ){
     me.onChange(str);
}

Je soupçonne que la charge men'est pas correctement affectée.

Le déplacement de l'appel get_ID dans l'événement onclick devrait en prendre soin.

Évidemment, vous pouvez piéger davantage comme mentionné précédemment:

function js_to_as( str) {
  var me = get_ID('jsExample');
  if (me && me.onChange) {
    me.onChange(str);
  }
}

Je vérifie toujours comme ça:

if(!myFunction){return false;}

il suffit de le placer avant tout code utilisant cette fonction

J'ai eu le cas où le nom de la fonction variait selon une variable (var 'x' dans ce cas) ajoutée au nom de la fonction. Cela marche:

if ( typeof window['afunction_'+x] === 'function' ) { window['afunction_'+x](); } 

Ce simple code jQuery devrait faire l'affaire:

if (jQuery.isFunction(functionName)) {
    functionName();
}

J'ai essayé la réponse acceptée; toutefois:

console.log(typeof me.onChange);

renvoie «non défini». J'ai remarqué que la spécification indique un événement appelé «onchange» au lieu de «onChange» (notez le camelCase).

La modification de la réponse acceptée d'origine aux éléments suivants a fonctionné pour moi:

if (typeof me.onchange === "function") { 
  // safe to use the function
}

Si vous recherchez une fonction qui est un plugin jQuery, vous devez utiliser $ .fn.myfunction

if (typeof $.fn.mask === 'function') {
    $('.zip').mask('00000');
}

J'ai également recherché une solution élégante à ce problème. Après mûre réflexion, j'ai trouvé cette approche meilleure.

const func = me.onChange || (str => {}); func(str);

Javascript moderne à la rescousse!

Cela pourrait ne pas avoir de grandes chances d'être vu avec la longue liste de réponses, mais cela est maintenant résolu * au niveau de la langue avec la nouvelle syntaxe de chaînage facultative

me.onChange?.(str)

C'est aussi simple que cela - onChangen'est appelé que s'il existe .

S'il onChangen'existe pas, rien ne se passe et l'expression revient undefined- donc si elle a une valeur de retour que vous utiliseriez autrement, vous pouvez simplement vérifier cette valeur !== undefinedavant de continuer.

Mise en garde de cas limite - si onChange ne existons , mais en est pas une fonction, vous obtenez un TypeError. C'est comme vous vous en doutez, c'est la même chose que d'essayer d'appeler une non-fonction en tant que fonction, mais il convient de souligner explicitement que le chaînage facultatif ne fait aucune magie pour que cela disparaisse.

_{* Eh bien, techniquement parlant, le chaînage facultatif est toujours une proposition de l'étape 4 TC39, il n'est donc pas encore dans la spécification ECMAScript, mais l'étape 4 signifie qu'il est finalisé et que son inclusion est essentiellement garantie, il attend juste qu'une nouvelle version soit livrée. Vous pouvez utiliser la syntaxe dans sa version finale aujourd'hui via Babel avec confiance qu'elle ne changera pas. C'est même en Typographie!}

Voici une solution simple et fonctionnelle pour vérifier l' existence d'une fonction et déclencher cette fonction dynamiquement par une autre fonction;

Fonction de déclenchement

function runDynamicFunction(functionname){ 

    if (typeof window[functionname] == "function") { //check availability

        window[functionname]("this is from the function it"); // run function and pass a parameter to it
    }
}

et vous pouvez maintenant générer dynamiquement la fonction en utilisant peut-être php comme celui-ci

function runThis_func(my_Parameter){

    alert(my_Parameter +" triggerd");
}

vous pouvez maintenant appeler la fonction à l'aide d'un événement généré dynamiquement

<?php

$name_frm_somware ="runThis_func";

echo "<input type='button' value='Button' onclick='runDynamicFunction(\"".$name_frm_somware."\");'>";

?>

le code HTML exact dont vous avez besoin est

<input type="button" value="Button" onclick="runDynamicFunction('runThis_func');">

    function sum(nb1,nb2){

       return nb1+nb2;
    }

    try{

      if(sum() != undefined){/*test if the function is defined before call it*/

        sum(3,5);               /*once the function is exist you can call it */

      }

    }catch(e){

      console.log("function not defined");/*the function is not defined or does not exists*/
    }

Et puis il y a ceci ...

( document.exitPointerLock || Function )();

Essaye celui-là:

Window.function_exists=function(function_name,scope){
//Setting default scope of none is provided
If(typeof scope === 'undefined') scope=window;
//Checking if function name is defined
If (typeof function_name === 'undefined') throw new 
Error('You have to provide an valid function name!');
//The type container
var fn= (typeof scope[function_name]);
//Function type
If(fn === 'function') return true;
//Function object type
if(fn.indexOf('function')!== false) return true; 
return false;
}

Sachez que j'ai écrit ceci avec mon téléphone portable Peut contenir des problèmes en majuscules et / ou d'autres corrections nécessaires comme par exemple le nom des fonctions

Si vous voulez qu'une fonction comme PHP vérifie si la var est définie:

Window.isset=function (variable_con){
If(typeof variable_con !== 'undefined') return true;
return false;
}

Pour illustrer les réponses précédentes, voici un rapide extrait JSFiddle:

function test () {
console.log()

}

console.log(typeof test) // >> "function"

// implicit test, in javascript if an entity exist it returns implcitly true unless the element value is false as :
// var test = false
if(test){ console.log(true)}
else{console.log(false)}

// test by the typeof method
if( typeof test === "function"){ console.log(true)}
else{console.log(false)}


// confirm that the test is effective : 
// - entity with false value
var test2 = false
if(test2){ console.log(true)}
else{console.log(false)}

// confirm that the test is effective :
// - typeof entity
if( typeof test ==="foo"){ console.log(true)}
else{console.log(false)}

/* Expected :
function
true 
true 
false
false
*/

// just pass your tested function name instead of myFunctionName
if ( $.isFunction($.fn.myFunctionName) ) {
    console.log( 'write your code here.' );
}