Javascript-Aufruf verschachtelte Funktion

Question

Ich habe das folgende Stück Code:

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

Gibt es eine Möglichkeit, wie ich die validate() Funktion außerhalb der initValidation() Funktion? Ich habe versucht, die Funktion validate() aber ich glaube, sie ist nur innerhalb der übergeordneten Funktion sichtbar.

Answer 1

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

        initValidation.validate = validate;
    }

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

Answer 2

Ich hoffe, dass Sie etwas in dieser Art suchen

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

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

Das wird funktionieren.

Ich hoffe, damit ist Ihr Problem gelöst.

Answer 3

Sie können anrufen validate von innen initValidation . Etwa so.

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

    return validate(someVar);
}

validate ist für niemanden außerhalb von initValidation wegen seiner Umfang .

Edita: Hier ist mein Vorschlag für eine Lösung.

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

    function initValidation()
    {
        // irrelevant code here

        return validate(someVar);
    }

    function otherFunctions() {
        // ...
    }

    // initValidation = function
}());

// initValidation = undefined

Alle Ihre Funktionen werden außerhalb des Funktions-Wrappers nicht sichtbar sein, können sich aber gegenseitig sehen.

Answer 4

Dieser Aufruf gibt eine Funktionsanweisung zurück, die eine Funktionsvalidierung darstellt. Sie können die Funktion also direkt nach dem ersten Aufruf aufrufen.

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

initValidation()();

Answer 5

Ich weiß, dass dies ein alter Beitrag ist, aber wenn Sie eine Reihe von Instanzen erstellen möchten, mit denen Sie arbeiten möchten und die den Code wiederverwenden, könnten Sie so etwas tun:

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