Come verificare se la funzione esiste in JavaScript?

Il mio codice è

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

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

Tuttavia, a volte il mio onChangenon si carica. Errori Firebug con

me.onChange non è una funzione

Voglio degradare con grazia perché questa non è la caratteristica più importante nel mio programma. typeofdà lo stesso errore.

Eventuali suggerimenti su come accertarsi che esista e quindi eseguire solo onChange ?

(Nessuno dei metodi seguenti, tranne provare a catturare un'opera)

Prova qualcosa del genere:

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

o meglio ancora (come da commento di UpTheCreek votato)

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

Ho avuto questo problema

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

continuava a generare un errore di riferimento se obj non era definito.

Alla fine ho fatto quanto segue:

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

Un collega mi ha fatto notare che controllando se è !== 'undefined'e poi=== 'function' è ridondante, ovviamente.

Più semplice:

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

Molto più pulito e funziona alla grande.

Se stai usando eval per convertire una stringa in funzione e vuoi controllare se esiste questo metodo di valutazione, ti consigliamo di usare typeof e la tua stringa di funzione all'interno di un eval :

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

Non invertire questo e cercare un typeof su eval . Se lo fai, verrà lanciato un ReferenceError:

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

Che ne dite di:

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

per esempio

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

o come nel tuo caso:

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

Vedi i documenti MDN .

Prova typeof: cerca 'undefined'di dire che non esiste, 'function'per una funzione. JSFiddle per questo codice

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

O come se:

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

O con un valore di ritorno, su una sola riga:

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

Non ho visto questo suggerito: me.onChange && me.onChange (str);

Fondamentalmente se me.onChange è indefinito (come sarà se non è stato avviato), non eseguirà quest'ultima parte. Se me.onChange è una funzione, eseguirà me.onChange (str).

Puoi anche andare oltre e fare:

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

nel caso in cui anche io sia asincrono.

//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");
    }

Per me il modo più semplice:

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

Farò un ulteriore passo per assicurarmi che la proprietà sia effettivamente una funzione

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);
}

Mi piace usare questo metodo:

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

Uso:

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

La libreria Underscore.js lo definisce nel metodo isFunction in questo modo (che i commenti suggeriscono potrebbero soddisfare alcuni bug del browser)

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'));

O

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';
}

Metti doppio punto esclamativo cioè !! prima del nome della funzione che si desidera verificare. Se esiste, tornerà vero.

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

In poche parole: cogliere l'eccezione.

Sono davvero sorpreso che nessuno abbia ancora risposto o commentato in merito a Exception Catch su questo post.

Dettaglio: Ecco un esempio in cui provo ad abbinare una funzione che è preceduta da mask_ e suffissata dal campo del modulo "name". Quando JavaScript non trova la funzione, dovrebbe generare un ReferenceError che puoi gestire come desideri nella sezione 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;
    }
  }
}

Senza condizioni

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);
}

Sospetterei che menon viene assegnato correttamente onload.

Lo spostamento della chiamata get_ID nell'evento onclick dovrebbe occuparsene.

Ovviamente puoi intrappolare ulteriormente come precedentemente menzionato:

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

Controllo sempre così:

if(!myFunction){return false;}

posizionalo prima di qualsiasi codice che utilizza questa funzione

Ho avuto il caso in cui il nome della funzione variava in base a una variabile (var 'x' in questo caso) aggiunta al nome della funzione. Questo funziona:

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

Questo semplice codice jQuery dovrebbe fare il trucco:

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

Ho provato la risposta accettata; però:

console.log(typeof me.onChange);

restituisce "non definito". Ho notato che la specifica indica un evento chiamato 'onchange' invece di 'onChange' (notare il camelCase).

La modifica della risposta originale accettata al seguente ha funzionato per me:

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

Se stai cercando una funzione che è un plugin jQuery, devi usare $ .fn.myfunction

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

Ho anche cercato una soluzione elegante a questo problema. Dopo molte riflessioni, ho trovato questo approccio migliore.

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

Javascript moderno per il salvataggio!

Questo potrebbe non avere grandi probabilità di essere visto con la lunga lista di risposte, ma questo è ora risolto * a livello di lingua con la nuova sintassi di Chaining opzionale

me.onChange?.(str)

È così semplice: onChangeviene chiamato solo se esiste .

Se onChangenon esiste, non succede nulla e l'espressione ritorna undefined, quindi se ha un valore di ritorno che altrimenti utilizzeresti, puoi semplicemente controllare questo valore !== undefinedprima di continuare.

Bordo caso avvertimento - se onChange lo fa esistere, ma è non è una funzione, si ottiene unTypeError . Questo è come ti aspetteresti, è lo stesso che provare a chiamare qualsiasi non funzione come funzione, ma vale la pena sottolineare esplicitamente che il concatenamento opzionale non fa alcuna magia per farla sparire.

_{* Beh, tecnicamente parlando, il concatenamento opzionale è ancora una proposta TC39 della fase 4, quindi non è ancora nelle specifiche ECMAScript, ma la fase 4 significa che è finalizzata e la sua inclusione è sostanzialmente garantita, sta solo aspettando che venga spedita una nuova versione. Puoi usare la sintassi nella sua versione finale oggi tramite Babel con la certezza che non cambierà. È persino in Typescript!}

Ecco una soluzione semplice e funzionante per verificare l' esistenza di una funzione e attivarla dinamicamente da un'altra funzione;

Funzione di trigger

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
    }
}

e ora puoi generare dinamicamente la funzione magari usando php in questo modo

function runThis_func(my_Parameter){

    alert(my_Parameter +" triggerd");
}

ora puoi chiamare la funzione usando un evento generato dinamicamente

<?php

$name_frm_somware ="runThis_func";

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

?>

l'esatto codice HTML di cui hai bisogno è

<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*/
    }

E poi c'è questo ...

( document.exitPointerLock || Function )();

Prova questo:

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;
}

Essere consapevoli del fatto che ho scritto questo con il mio cellulare Potrebbe contenere alcuni problemi maiuscoli e / o altre correzioni necessarie come ad esempio il nome delle funzioni

Se vuoi una funzione come PHP per verificare se var è impostato:

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

Per illustrare le risposte precedenti, qui un breve frammento di 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.' );
}