Wie überprüfe ich, ob eine Funktion in JavaScript vorhanden ist?

Mein Code ist

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

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

Manchmal wird mein onChangejedoch nicht geladen. Firebug-Fehler mit

me.onChange ist keine Funktion

Ich möchte mich elegant verschlechtern, da dies nicht das wichtigste Merkmal in meinem Programm ist. typeofgibt den gleichen Fehler.

Irgendwelche Vorschläge, wie Sie sicherstellen können, dass es existiert und dann nur ausgeführt werden onChange?

(Keine der folgenden Methoden außer versuchen, eine Arbeit zu fangen)

Versuchen Sie so etwas:

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

oder noch besser (gemäß UpTheCreek-Kommentar)

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

Ich hatte dieses Problem.

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

hat immer wieder einen Referenzfehler ausgegeben, wenn obj undefiniert war.

Am Ende habe ich folgendes gemacht:

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

Ein Kollege hat mich darauf hingewiesen, dass es natürlich überflüssig ist , zu prüfen, ob dies der !== 'undefined'Fall === 'function'ist.

Einfacher:

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

Viel sauberer und funktioniert super.

Wenn Sie eval verwenden, um eine Zeichenfolge in eine Funktion zu konvertieren, und überprüfen möchten, ob diese eval'd-Methode vorhanden ist, sollten Sie typeof und Ihre Funktionszeichenfolge in einer Bewertung verwenden :

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

Nicht diese umkehren und versuchen typeof auf eval . Wenn Sie dies tun, wird ein ReferenceError ausgelöst:

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

Wie wäre es mit:

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

z.B

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

oder wie für Ihren Fall:

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

Siehe MDN-Dokumente .

Versuchen Sie typeof- 'undefined'Sagen Sie, dass es 'function'für eine Funktion nicht existiert . JSFiddle für diesen Code

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

Oder als ob:

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

Oder mit einem Rückgabewert in einer einzelnen Zeile:

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

Ich habe dies nicht vorgeschlagen gesehen: me.onChange && me.onChange (str);

Wenn me.onChange undefiniert ist (was der Fall ist, wenn es nicht initiiert wurde), wird der letzte Teil grundsätzlich nicht ausgeführt. Wenn me.onChange eine Funktion ist, wird me.onChange (str) ausgeführt.

Sie können sogar noch weiter gehen und Folgendes tun:

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

falls ich auch asynchron bin.

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

Für mich der einfachste Weg:

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

Ich werde noch einen Schritt weiter gehen, um sicherzustellen, dass die Eigenschaft tatsächlich eine Funktion ist

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

Ich benutze diese Methode gerne:

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

Verwendungszweck:

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

Die Underscore.js-Bibliothek definiert es in der isFunction-Methode wie folgt (die Kommentare deuten darauf hin, dass einige Browserfehler behoben werden können).

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

ODER

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

Setzen Sie ein doppeltes Ausrufezeichen, dh !! vor dem Funktionsnamen, den Sie überprüfen möchten. Wenn es existiert, wird es true zurückgeben.

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

In wenigen Worten: Fangen Sie die Ausnahme.

Ich bin wirklich überrascht, dass noch niemand auf Exception Catch in diesem Beitrag geantwortet oder kommentiert hat.

Detail: Hier ist ein Beispiel, in dem ich versuche, eine Funktion zu finden, der mask_ vorangestellt und das Formularfeld "name" angehängt ist. Wenn JavaScript die Funktion nicht findet, sollte es einen ReferenceError auslösen, den Sie im catch-Abschnitt nach Belieben behandeln können.

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

Ohne Bedingungen

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

Ich würde vermuten, dass medie Onload nicht richtig zugewiesen wird.

Das Verschieben des get_ID-Aufrufs in das onclick-Ereignis sollte sich darum kümmern.

Natürlich können Sie wie bereits erwähnt weiter fangen:

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

Ich überprüfe immer so:

if(!myFunction){return false;}

Platzieren Sie es einfach vor einem Code, der diese Funktion verwendet

Ich hatte den Fall, dass der Name der Funktion gemäß einer Variablen (in diesem Fall var 'x') variierte, die dem Funktionsnamen hinzugefügt wurde. Das funktioniert:

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

Dieser einfache jQuery-Code sollte den Trick machen:

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

Ich habe die akzeptierte Antwort versucht; jedoch:

console.log(typeof me.onChange);

gibt 'undefined' zurück. Ich habe festgestellt, dass in der Spezifikation ein Ereignis namens "onchange" anstelle von "onChange" angegeben ist (beachten Sie den camelCase).

Das Ändern der ursprünglich akzeptierten Antwort auf Folgendes hat bei mir funktioniert:

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

Wenn Sie nach einer Funktion suchen, die ein jQuery-Plugin ist, müssen Sie $ .fn.myfunction verwenden

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

Ich habe auch nach einer eleganten Lösung für dieses Problem gesucht. Nach langem Nachdenken fand ich diesen Ansatz am besten.

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

Modernes Javascript zur Rettung!

Dies könnte nicht eine große Chance hat , mit der langen Liste der Antworten gesehen zu werden, aber das ist jetzt * auf der Sprachebene mit der neuen gelöst Optional Chaining Syntax

me.onChange?.(str)

So einfach ist das - wird onChangenur aufgerufen, wenn es existiert .

Wenn onChangedies nicht vorhanden ist, geschieht nichts und der Ausdruck wird zurückgegeben. undefinedWenn er also einen Rückgabewert hat, den Sie sonst verwenden würden, können Sie diesen Wert einfach überprüfen, !== undefinedbevor Sie fortfahren.

Edge - Fall Nachteil - wenn onChange tut exist aber ist nicht eine Funktion geben Sie eine bekommen TypeError. Dies ist wie zu erwarten, es ist dasselbe wie der Versuch, eine Nichtfunktion als Funktion aufzurufen, aber es sollte ausdrücklich darauf hingewiesen werden, dass die optionale Verkettung keine Magie ausübt, um dies zu beseitigen.

_{* Nun, technisch gesehen ist die optionale Verkettung immer noch ein TC39-Vorschlag der Stufe 4, daher noch nicht in der ECMAScript-Spezifikation enthalten, aber Stufe 4 bedeutet, dass sie abgeschlossen ist und ihre Aufnahme im Wesentlichen garantiert ist. Sie wartet nur auf den Versand einer neuen Version. Sie können die Syntax in der endgültigen Version heute über Babel mit der Gewissheit verwenden, dass sie sich nicht ändert. Es ist sogar in Typoskript!}

Hier ist eine funktionierende und einfache Lösung, um das Vorhandensein einer Funktion zu überprüfen und diese Funktion dynamisch durch eine andere Funktion auszulösen .

Auslöserfunktion

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

und Sie können die Funktion jetzt dynamisch generieren, möglicherweise mit PHP wie diesem

function runThis_func(my_Parameter){

    alert(my_Parameter +" triggerd");
}

Jetzt können Sie die Funktion mit einem dynamisch generierten Ereignis aufrufen

<?php

$name_frm_somware ="runThis_func";

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

?>

Der genaue HTML-Code, den Sie benötigen, ist

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

Und dann ist da noch das ...

( document.exitPointerLock || Function )();

Probier diese:

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

Beachten Sie, dass ich dies mit meinem Handy geschrieben habe. Möglicherweise enthält es einige Probleme in Großbuchstaben und / oder andere Korrekturen, die erforderlich sind, z. B. der Name der Funktion

Wenn Sie möchten, dass eine Funktion wie PHP überprüft, ob die Variable gesetzt ist:

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

Um die vorhergehenden Antworten zu veranschaulichen, hier ein kurzer JSFiddle-Ausschnitt:

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