Testowanie, czy wartość jest funkcją

Try

if (this.onsubmit instanceof Function) {
    // do stuff;
}

Można po prostu użyć operatora typeof wraz z operatorem trójdzielnym w skrócie:

onsubmit="return typeof valid =='function' ? valid() : true;"

Jeśli jest to funkcja wywołujemy ją i zwracamy jej wartość, w przeciwnym razie po prostu zwracamy true

Edit:

Kiedy zadeklarujesz swój kod onsubmit w swoim html, zostanie on zamieniony w funkcję, a tym samym jego wywołanie z "świata" JavaScript. To znaczy że te dwie metody są równoważne:

HTML: <form onsubmit="return valid();" />
JavaScript: myForm.onsubmit = function() { return valid(); };

Te dwie funkcje będą obiema funkcjami i obie będą wywoływalne. Możesz przetestować dowolne z nich używając operatora typeof, który powinien dać taki sam wynik: "function".

Teraz, jeśli przypiszesz łańcuch do właściwości "onsubmit" za pomocą JavaScript, pozostanie on ciągiem znaków, dlatego nie można go wywołać. Zauważ, że jeśli zastosujesz wobec niego operator typeof, otrzymasz "string" zamiast "function".

Mam nadzieję, że to może wyjaśnić kilka rzeczy. Z drugiej strony, jeśli chcesz wiedzieć, czy taka właściwość (lub dowolny identyfikator w danej sprawie) jest funkcją i można ją wywołać, operator typeof powinien załatwić sprawę. Chociaż nie jestem pewien, czy działa poprawnie w wielu klatkach.

Cheers

Jakiej przeglądarki używasz?

alert(typeof document.getElementById('myform').onsubmit);

To daje mi "function " w IE7 i Firefoksie.

Upewnij się, że wywołujesz typeof w rzeczywistej funkcji, a nie literalny łańcuch znaków:

function x() { 
    console.log("hi"); 
}

typeof "x"; // returns "string"

typeof x; // returns "function"

Używanie zmiennej opartej na łańcuchu jako przykładu i używanie instanceof Function Rejestrujesz funkcję..Przypisz zmienną...sprawdź, czy zmienna jest nazwą function...do proces wstępny... przypisanie funkcji do nowego var...następnie wywołaj funkcję.

function callMe(){
   alert('You rang?');
}

var value = 'callMe';

if (window[value] instanceof Function) { 
    // do pre-process stuff
    // FYI the function has not actually been called yet
    console.log('callable function');
    //now call function
   var fn = window[value];
   fn();
}

Możesz spróbować zmodyfikować tę technikę do własnych potrzeb:

 function isFunction() {
   var functionName = window.prompt('Function name: ');
   var isDefined = eval('(typeof ' + functionName + '==\'function\');');
   if (isDefined)
     eval(functionName + '();');
   else
     alert('Function ' + functionName + ' does not exist');
 }
 function anotherFunction() {
   alert('message from another function.');
 }

Formularz.onsubmit zawsze będzie funkcją, gdy zostanie zdefiniowany jako atrybut HTML elementu formularza. Jest to rodzaj anonimowej funkcji dołączonej do elementu HTML, który ma ten wskaźnik związany z tym elementem formularza, a także ma parametr o nazwie event, który będzie zawierał dane o zdarzeniu submit.

W tych okolicznościach nie rozumiem, skąd masz ciąg znaków w wyniku operacji typeof. Powinieneś podać więcej szczegółów, lepiej trochę kod.

Edit (w odpowiedzi na drugą edycję):

Wierzę, że handler dołączony do atrybutu HTML będzie działał niezależnie od powyższego kodu. Co więcej, możesz spróbować to jakoś zatrzymać, ale wygląda na to, że FF 3, IE 8, Chrome 2 i Opera 9 wykonują atrybut HTML handler w pierwszej kolejności, a następnie ten dołączony (nie testowałem z jQuery, ale z addEventListener i attachEvent). Więc... co próbujesz osiągnąć dokładnie?

Przy okazji, twój kod nie działa, ponieważ twoje Wyrażenie regularne wyodrębni łańcuch " valid ();", który zdecydowanie nie jest funkcją.

Jeśli jest to ciąg znaków, możesz założyć / mieć nadzieję, że zawsze ma postać

return SomeFunction(arguments);

Parse for the function name, and then see if that function is defined using

if (window[functionName]) { 
    // do stuff
}

Dobrze, "return valid();" jest ciągiem znaków, więc to prawda.

Jeśli chcesz sprawdzić, czy ma dołączoną funkcję, możesz spróbować tego:

formId.onsubmit = function (){ /* */ }

if(typeof formId.onsubmit == "function"){
  alert("it's a function!");
}

Myślę, że źródłem nieporozumień jest rozróżnienie pomiędzy atrybutem węzła a odpowiadającą mu właściwością .

Używasz:

$("a.button").parents("form").attr("onsubmit")

Czytasz bezpośrednio onsubmit wartość atrybutu (która musi być ciągiem znaków). Zamiast tego powinieneś uzyskać dostęp do onsubmit własność węzła:

$("a.button").parents("form").prop("onsubmit")

Oto szybki test:

<form id="form1" action="foo1.htm" onsubmit="return valid()"></form>
<script>
window.onload = function () {
    var form1 = document.getElementById("form1");

    function log(s) {
        document.write("<div>" + s + "</div>");
    }

    function info(v) {
        return "(" + typeof v + ") " + v;
    }

    log("form1 onsubmit property: " + info(form1.onsubmit));
    log("form1 onsubmit attribute: " + info(form1.getAttribute("onsubmit")));
};
</script> 

Daje to:

form1 onsubmit property: (function) function onsubmit(event) { return valid(); }
form1 onsubmit attribute: (string) return valid()

  if ( window.onsubmit ) {
     //
  } else {
     alert("Function does not exist.");
  }

Zawsze możesz użyć jednej z funkcji typeOf na blogach JavaScript, takich jak Chrisa Westa . Użycie definicji takiej jak poniżej dla funkcji typeOf() będzie działać:

function typeOf(o){return {}.toString.call(o).slice(8,-1)}

Ta funkcja (która jest zadeklarowana w globalnej przestrzeni nazw, może być używana w następujący sposób:

alert("onsubmit is a " + typeOf(elem.onsubmit));

Jeśli jest to funkcja, zostanie zwrócona "Function". Jeśli jest to łańcuch, zostanie zwrócony "String". Inne możliwe wartości są pokazane tutaj .

// This should be a function, because in certain JavaScript engines (V8, for
// example, try block kills many optimizations).
function isFunction(func) {
    // For some reason, function constructor doesn't accept anonymous functions.
    // Also, this check finds callable objects that aren't function (such as,
    // regular expressions in old WebKit versions), as according to EcmaScript
    // specification, any callable object should have typeof set to function.
    if (typeof func === 'function')
        return true

    // If the function isn't a string, it's probably good idea to return false,
    // as eval cannot process values that aren't strings.
    if (typeof func !== 'string')
        return false

    // So, the value is a string. Try creating a function, in order to detect
    // syntax error.
    try {
        // Create a function with string func, in order to detect whatever it's
        // an actual function. Unlike examples with eval, it should be actually
        // safe to use with any string (provided you don't call returned value).
        Function(func)
        return true
    }
    catch (e) {
        // While usually only SyntaxError could be thrown (unless somebody
        // modified definition of something used in this function, like
        // SyntaxError or Function, it's better to prepare for unexpected.
        if (!(e instanceof SyntaxError)) {
            throw e
        }

        return false
    }
}

Takie proste sprawdzenie da Ci znać, czy istnieje / jest zdefiniowane:

if (this.onsubmit)
{
  // do stuff;
}