Tester si la valeur est une fonction

Question

J'ai besoin de tester si la valeur d'un formulaire onsubmit est une fonction.Le format est généralement onsubmit="return valid();".Est-il un moyen de savoir si c'est une fonction, et si c'est appelable?À l'aide typeof renvoie simplement que c'est une chaîne, ce qui ne m'aide pas beaucoup.

MODIFIER:Bien sûr, je comprends que "la de retour valide();" est une chaîne de caractères.J'ai replaced vers le bas pour "valide();", et même "en cours de validité()".Je veux savoir si l'une de celles-ci est une fonction.

MODIFIER:Voici un code, qui peut aider à expliquer mon problème:

$("a.button").parents("form").submit(function() {
    var submit_function = $("a.button").parents("form").attr("onsubmit");
    if ( submit_function && typeof( submit_function.replace(/return /,"") ) == 'function' ) {
        return eval(submit_function.replace(/return /,""));
    } else {
        alert("onSubmit is not a function.\n\nIs the script included?"); return false;
    }
} );

EDIT 2:Voici le nouveau code.Il semble que j'ai encore à l'utilisation d'un eval, parce que l'appel de la forme.submit() n'a pas d'incendie existant onsubmits.

var formObj = $("a.button").parents("form");
formObj.submit(function() {
    if ( formObj[0].onsubmit && typeof( formObj.onsubmit ) == 'function' ) {
        return eval(formObj.attr("onsubmit").replace(/return /,""));
    } else {
        alert("onSubmit is not a function.\n\nIs the script included?");
        return false;
    }
} );

Des Suggestions sur les probablement la façon de faire mieux?

Answer 1

  

Je remplace un bouton soumettre à une   lien ancre. depuis l'appel   form.submit () ne se met pas   onsubmit de, je trouve, et   eval () uant moi-même. Mais je voudrais   vérifier si la fonction existe avant   juste eval () uant ce qui est là. - gms8994

<script type="text/javascript">
function onsubmitHandler() {
    alert('running onsubmit handler');
    return true;
}
function testOnsubmitAndSubmit(f) {
    if (typeof f.onsubmit === 'function') {
        // onsubmit is executable, test the return value
        if (f.onsubmit()) {
            // onsubmit returns true, submit the form
            f.submit();
        }
    }
}
</script>

<form name="theForm" onsubmit="return onsubmitHandler();">
<a href="#" onclick="
    testOnsubmitAndSubmit(document.forms['theForm']);
    return false;
"></a>
</form>

EDIT: manquant paramètre f en fonction testOnsubmitAndSubmit

Le travail devrait ci-dessus, que vous attribuez l'attribut onsubmit HTML ou l'assigner en JavaScript:

document.forms['theForm'].onsubmit = onsubmitHandler;

Answer 2

Essayez

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

Answer 3

Vous pouvez simplement utiliser l'opérateur typeof avec un opérateur ternaire pour faire court:

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

S'il est une fonction que nous appelons et le retourner sa valeur retour, sinon juste retour true

Modifier

Je ne suis pas tout à fait sûr de ce que vous voulez vraiment faire, mais je vais essayer d'expliquer ce qui pourrait se produire.

Lorsque vous déclarez votre code onsubmit au sein de votre html, il se transforme en une fonction et donc son appelable du JavaScript « monde ». Cela signifie que ces deux méthodes sont équivalentes:

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

Ces deux seront les deux fonctions et les deux seront appelable. Vous pouvez tester tout de ceux qui utilisent l'opérateur typeof qui devrait YELD le même résultat. "function"

Maintenant, si vous attribuez une chaîne à la propriété « onsubmit » via JavaScript, il reste une chaîne, donc pas appelable. Notez que si vous appliquez l'opérateur typeof contre, vous aurez "string" au lieu de "function".

J'espère que cela pourrait apporter quelques précisions. Là encore, si vous voulez savoir si ces biens (ou un identifiant pour la question) est une fonction et appelable, l'opérateur typeof devrait faire l'affaire. Bien que je ne suis pas sûr que cela fonctionne correctement sur plusieurs images.

Vive

Answer 4

Quel navigateur utilisez-vous?

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

Cela me donne "function" dans IE7 et FireFox.

Answer 5

Assurez-vous que vous appelez typeof sur la fonction réelle, pas une chaîne de caractères:

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

typeof "x"; // returns "string"

typeof x; // returns "function"

Answer 6

en utilisant une variable en fonction de chaîne comme exemple et utiliser instanceof Function Vous enregistrez la function..assign la variable ... vérifier la variable est le nom de la fonction ... faire pré-traitement ... affecter la fonction à nouveau var ... puis appeler la fonction.

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

Answer 7

Vous pouvez modifier cette technique en fonction de vos besoins:

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

Answer 8

forme.onsubmit sera toujours une fonction lorsqu'il est défini comme un attribut HTML de l'élément de formulaire.C'est une sorte de fonction anonyme attaché à un élément HTML, qui a la cette pointeur lié à cet élément de FORMULAIRE et dispose également d'un paramètre nommé event qui contiennent des données sur l'événement submit.

Dans ces conditions, je ne comprends pas comment vous avez obtenu une chaîne de caractères comme un résultat d'une typeof opération.Vous devriez donner plus de détails, mieux un peu de code.

Modifier (comme réponse à votre deuxième édition):

Je crois que le gestionnaire attaché à l'attribut HTML exécutera quel que soit le code ci-dessus.De plus, vous pourriez essayer de l'arrêter en quelque sorte, mais, il semble que 3 FF, IE 8, Chrome 2 et Opera 9 sont en cours d'exécution l'attribut HTML gestionnaire en premier lieu, et ensuite celui attaché (je n'ai pas testé avec jQuery, mais avec la méthode addEventListener et attachEvent).Alors...ce que vous essayez d'accomplir exactement?

Par ailleurs, votre code ne fonctionne pas parce que votre expression régulière extrait de la chaîne "valide();", qui n'est certainement pas une fonction.

Answer 9

Si c'est une chaîne, vous pouvez supposer / espérer qu'il est toujours de la forme

return SomeFunction(arguments);

pour analyser le nom de la fonction, puis voir si cette fonction est définie en utilisant

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

Answer 10

Eh bien, "return valid();" une chaîne, de sorte que c'est exact.

Si vous voulez vérifier si elle a une fonction attachée à la place, vous pouvez essayer ceci:

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

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

Answer 11

Je pense que la source de confusion est la distinction entre attribut d'un noeud et correspondant propriété .

Vous utilisez:

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

Vous lisez directement la onsubmit attribut la valeur de (qui doit être une chaîne). , Vous devriez plutôt accéder au onsubmit propriété du nœud:

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

Voici un test rapide:

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

On obtient ainsi:

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

Answer 12

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

Answer 13

Vous pouvez toujours utiliser l'une des fonctions typeof sur les blogs JavaScript comme de Chris West. En utilisant une définition telle que la suivante pour la fonction typeOf() fonctionnerait:

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

Cette fonction (qui est déclarée dans l'espace de noms global, peut être utilisé comme ceci:

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

Si elle est une fonction, « Fonction » sera retourné. Si elle est une chaîne, « String » sera retourné. Les autres valeurs possibles sont présentés .

Answer 14

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

Answer 15

Une simple vérification comme celui-ci vous permettra de savoir si elle existe / défini:

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