web-dev-qa-db-fra.com

Fonction imbriquée d'appel Javascript

J'ai le code suivant:

function initValidation()
{
    // irrelevant code here
    function validate(_block){
        // code here
    }
}

Puis-je appeler la fonction validate() en dehors de la fonction initValidation()? J'ai essayé d'appeler validate() mais je pense que ce n'est visible que dans la fonction parent.

javascriptnested-function
25
Eduard Luca

    function initValidation()
    {
        // irrelevant code here
        function validate(_block){
            console.log( "test", _block );
        }
    
        initValidation.validate = validate;
    }

    initValidation();
    initValidation.validate( "hello" );
    //test hello

84
Esailija

J'espère que vous cherchez quelque chose comme ça

function initValidation()
{
    // irrelevant code here
    this.validate = function(_block){
        // code here
    }
}

var fCall = new initValidation()
fCall.validate(param);

Cela fonctionnera.

J'espère que cela répond à votre problème.

14
AmGates

Vous pouvez appeler validate à partir de initValidation. Comme ça.

function initValidation()
{
    // irrelevant code here
    function validate(_block){
        // code here
    }

    return validate(someVar);
}

validate n'est pas visible en dehors de initValidation en raison de son scope .

Edit: Voici ma suggestion de solution.

(function() {
    function validate(_block){
        // code here
    }

    function initValidation()
    {
        // irrelevant code here

        return validate(someVar);
    }

    function otherFunctions() {
        // ...
    }

    // initValidation = function
}());

// initValidation = undefined

Toutes vos fonctions seront masquées par tout ce qui se trouve en dehors de l’encapsuleur de fonctions mais peuvent toutes se voir.

6
Olical

Cette invocation retournera une instruction de fonction, qui est function validate . Vous pouvez donc appeler directement après la première invocation.

function initValidation() {
  // irrelevant code here
  return function validate(_block) {
    // code here
  }
}

initValidation()();
1
Jonathan Wang

Je sais que ceci est un ancien message, mais si vous souhaitez créer un ensemble d'instances avec lesquelles vous souhaitez travailler, vous pouvez utiliser le code suivant:

"use strict";
// this is derived from several posts here on SO and ultimately John Resig
function makeClassStrict() {
  var isInternal, instance;
  var constructor = function(args) {
    if (this instanceof constructor) {
      if (typeof this.init == "function") {
        this.init.apply(this, isInternal ? args : arguments);
      }
    } else {
      isInternal = true;
      instance = new constructor(arguments);
      isInternal = false;
      return instance;
    }
  };
  return constructor;
}
var MyClass = makeClassStrict();// create "class"
MyClass.prototype.init = function(employeeName, isWorking) {
  var defaultName = 'notbob';
  this.name = employeeName ? employeeName : defaultName;
  this.working = !!isWorking;
  this.internalValidate = function() {
    return {
      "check": this.working,
      "who": this.name
    };
  };
};
MyClass.prototype.getName = function() {
  return this.name
};
MyClass.prototype.protoValidate = function() {
return {
      "check": this.working,
      "who": this.name
    };
};
var instanceBob = MyClass("Bob", true);// create instance
var instanceFred = MyClass("Fred", false);// create instance
var mything = instanceFred.internalValidate();// call instance function
console.log(mything.check + ":" + mything.who);
var myBobthing = instanceBob.protoValidate();
console.log(myBobthing.check + ":" + myBobthing.who);
0
Mark Schultheiss