einführen
In diesem Artikel wird hauptsächlich einige in der Funktion verwendete Techniken vorgestellt (Teil 1). Mit Funktionsfunktionen können Sie viele sehr interessante Code schreiben. Dieser Artikel enthält hauptsächlich: Rückrufmodus, Konfigurationsobjekt, Rückgabefunktion, Verteilungsprogramm und Currying.
Rückruffunktion
In JavaScript wird eine Funktion A einer der Parameter einer anderen Funktion B ist, Funktion A wird als Rückruffunktion bezeichnet, dh A kann innerhalb der Funktionszeit des Funktion B (sowohl Start, Zwischenprodukt und Ende) ausgeführt werden.
Zum Beispiel gibt es eine Funktion, die Knoten erzeugt
Die Codekopie lautet wie folgt:
var complexComputation = function () { /* intern handeln und einen Knoten zurückgeben* /};
Es gibt eine Findnodes -Funktionserklärung, um alle Knoten zu finden und den Code dann über den Rückruf von Callback auszuführen.
Die Codekopie lautet wie folgt:
var findNodes = Funktion (Rückruf) {
var nodes = [];
var node = komplexComputation ();
// Wenn die Rückruffunktion verfügbar ist, führen Sie sie aus
if (typeof callback === "Funktion") {
Rückruf (Knoten);
}
Knoten.push (Knoten);
Returnknoten;
};
In Bezug auf die Definition des Rückrufs können wir es im Voraus definieren, um zu verwenden:
Die Codekopie lautet wie folgt:
// Rückruf definieren
var hide = function (node) {
node.style.display = "Keine";
};
// Suchen Sie Knoten und verbergen Sie alle Knoten
var hiddennodes = findnodes (ausblenden);
Sie können auch anonyme Definitionen direkt verwenden, wenn Sie aufrufen, wie folgt:
Die Codekopie lautet wie folgt:
// Verwenden Sie anonyme Funktionen, um den Rückruf zu definieren
var blocknodes = findNodes (Funktion (Knoten) {
node.style.display = 'block';
});
Die am häufigsten verwendeten sind wahrscheinlich die Aufrufe der AJAX -Methode von JQuery. Durch das Definieren von Rückrufen zu Fertig/Faild können wir weiter verarbeiten, wenn der Ajax -Anruf erfolgreich ist oder fehlschlägt. Der Code ist wie folgt (dieser Code basiert auf JQuery Version 1.8):
Die Codekopie lautet wie folgt:
var mseuId = $ ("ul.nav"). First (). attr ("id");
var request = $ .ajax ({{
URL: "script.php",
Typ: "Post",
Daten: {ID: Menüid},
Datentyp: "HTML"
});
// Rückrufverarbeitung, wenn der Anruf erfolgreich ist
Request.Done (Funktion (msg) {
$ ("#log"). HTML (MSG);
});
// Rückrufverarbeitung, wenn der Anruf fehlschlägt
Request.Fail (Funktion (jqxhr, textstatus) {
alert ("Anfrage fehlgeschlagen:" + textStatus);
});
Konfigurationsobjekte
Wenn der Parameter einer Funktion (oder Methode) nur einen Parameter hat und der Parameter ein Objektliteral ist, nennen wir dieses Muster das Konfigurationsobjektmuster. Zum Beispiel der folgende Code:
Die Codekopie lautet wie folgt:
var conf = {
Benutzername: "Shichuan",
Erstens: "Chuan",
Zuletzt: "Shi"
};
Addperson (conf);
In Addperson können Sie den Wert von Conf nach Belieben verwenden, der im Allgemeinen für die Initialisierungsarbeiten verwendet wird. Zum Beispiel wird AjaxSetup in JQuery auf diese Weise implementiert:
Die Codekopie lautet wie folgt:
// Stellen Sie den Anfangswert im Voraus fest
$ .ajaxSetup ({{
URL: "/xmlhttp/",
global: falsch,
Typ: "Post"
});
// dann noch einmal anrufen
$ .ajax ({Daten: mydata});
Darüber hinaus haben viele JQuery-Plug-Ins diese Form der Parameterübertragung, können aber auch nicht übertragen werden. Wenn sie nicht bestehen, wird der Standardwert verwendet.
Rückgabefunktion
Die Rückgabe einer Funktion bezieht sich auf eine neue Funktion, die basierend auf bestimmten Bedingungen flexibel erstellt wird, wenn der Rückgabewert einer Funktion eine andere Funktion ist oder eine neue Funktion gemäß bestimmten Bedingungen flexibel erstellt wird. Der Beispielcode lautet wie folgt:
Die Codekopie lautet wie folgt:
var setup = function () {
Konsole.log (1);
return function () {
console.log (2);
};
};
// Rufen Sie die Setup -Funktion auf
var my = setup (); // Ausgabe 1
Mein(); // Ausgabe 2
// oder Sie können es auch direkt anrufen
aufstellen()()();
Oder Sie können die Verschlussfunktion verwenden, um eine private Zählernummer in der Setup -Funktion aufzuzeichnen und den Zähler durch jeden Anruf zu erhöhen. Der Code ist wie folgt:
Die Codekopie lautet wie folgt:
var setup = function () {
var count = 0;
return function () {
return ++ count;
};
};
// Verwendung
var next = setup ();
nächste(); // Rückkehr 1
nächste(); // Rückkehr 2
nächste(); // Rückkehr 3
Anwendbar
Die teilweise Anwendung hier besteht tatsächlich darin, die eingehenden Parameter zu trennen. Manchmal hat eine Reihe von Operationen möglicherweise ein oder mehrere Parameter immer gleich. Dann können wir zuerst eine Teilfunktion definieren und dann diese Funktion ausführen (die verbleibenden unterschiedlichen Parameter werden während der Ausführung übergeben).
Zum Beispiel lautet der Code wie folgt:
Die Codekopie lautet wie folgt:
var partialany = (function (aps) {
// Diese Funktion ist das Ergebnis Ihrer eigenen Ausführung des Funktionsausdrucks und wird der Partialy -Variablen zugeordnet
Funktion func (fn) {
var argSorig = aps.call (Argumente, 1);
return function () {
var args = [],
argSpartial = aps.call (Argumente),
i = 0;
// Alle ursprünglichen Parametersätze von Variablen,
// Wenn der Parameter ein partialy._ -Platzhalter ist, verwenden Sie den Wert, der dem nächsten Funktionsparameter entspricht
// Verwenden Sie ansonsten den Wert im ursprünglichen Parameter
für (; i <argsorig.length; i ++) {
args [i] = argsorig [i] === func._
? argspartial.shift ()
: argsorig [i];
}
// Wenn zusätzliche Parameter vorhanden sind, fügen Sie das Ende hinzu
return fn.apply (this, args.concat (argSpartial));
};
}
// für Platzhaltereinstellungen
func._ = {};
Func zurückgeben;
}) (Array.prototype.slice);
Wie man es benutzt, ist wie folgt:
Die Codekopie lautet wie folgt:
// Verarbeitungsfunktionen definieren
Funktion hex (r, g, b) {
Return '#' + r + g + b;
}
// Definieren Sie die Teilfunktion, nehmen Sie den ersten Parameter R von Hex als unveränderter Parameterwert FF
var redmax = partialy (hex, 'ff', partialany._, partialany._);
// Die Anrufmethode der neuen Funktion Redmax lautet wie folgt, und nur 2 Parameter sind erforderlich:
console.log (redmax ('11 ',' 22 ')); // "#ff1122"
Wenn Sie denken, dass partialany._ zu lang ist, können Sie stattdessen __ verwenden.
Die Codekopie lautet wie folgt:
var __ = partialany._;
var greenmax = partialy (hex, __, 'ff');
console.log (greenmax ('33 ',' 44 '));
var bluemax = partialy (hex, __, __, 'ff');
console.log (bluemax ('55 ',' 66 ');
var magentamax = partialy (hex, 'ff', __, 'ff');
console.log (magentamax ('77 '));
Auf diese Weise wird es viel einfacher sein.
Currying
Das Currying ist ein Merkmal der funktionalen Programmierung und konvertiert die Verarbeitung mehrerer Parameter in die Verarbeitung einzelner Parameter, ähnlich wie Kettenaufrufe.
Geben wir ein einfaches Beispiel für die Hinzufügen von Funktionen:
Die Codekopie lautet wie folgt:
Funktion add (x, y) {
var oldx = x, oldy = y;
if (typeof oldy === "undefined") {// partiell
Rückgabefunktion (newy) {
kehren Sie Oldx + Newy zurück;
}
}
Rückgabe x + y;
}
Auf diese Weise gibt es viele Möglichkeiten, anrufen zu können, z. B.:
Die Codekopie lautet wie folgt:
// prüfen
typeof add (5); // "Funktion"
hinzufügen (3) (4); // 7
// Dies ist auch möglich
var add2000 = add (2000);
add2000 (10); // 2010
Lassen Sie uns als nächstes eine allgemeinere Currying -Funktion definieren:
Die Codekopie lautet wie folgt:
// Der erste Parameter ist die zu angewendete Funktion, und der zweite Parameter ist die minimale Anzahl von Parametern, die in übergeben werden sollen
Funktion Curry (Func, Minargs) {
if (minargs == undefiniert) {
minargs = 1;
}
Funktion funcwithargsfrozen (Frezenargs) {
return function () {
// Optimierungsverarbeitung, wenn beim Aufrufen keine Parameter vorhanden sind, geben Sie die Funktion selbst zurück
var args = array.prototype.slice.call (Argumente);
var newargs = frozenargs.concat (args);
if (newargs.length> = minargs) {
return func.apply (this, Newargs);
} anders {
return funcwithargsfrozen (newargs);
}
};
}
return funcwithargsfrozen ([]);
}
Auf diese Weise können wir unser Geschäftsverhalten nach Belieben definieren, z. B. die Definition von Addition:
Die Codekopie lautet wie folgt:
var plus = curry (function () {
var result = 0;
für (var i = 0; i <argumente.length; ++ i) {
Ergebnis += Argumente [i];
}
Rückgabeergebnis;
}, 2);
Wie man es benutzt, ist real und abwechslungsreich.
Die Codekopie lautet wie folgt:
Plus (3, 2) // Normaler Anruf
plus (3) // anwenden, eine Funktion zurückgeben (Rückgabewert ist 3+ Parameterwert)
Plus (3) (2) // Anwendung ausfüllen (Rückkehr zu 5)
plus () () (3) () () (2) // return 5
Plus (3, 2, 4, 5) // können mehrere Parameter empfangen
Plus (3) (2, 3, 5) // ähnlich
Das Folgende ist ein Beispiel für die Subtraktion
Die Codekopie lautet wie folgt:
var minus = curry (Funktion (x) {
var result = x;
für (var i = 1; i <argumente.length; ++ i) {
Ergebnis -= Argumente [i];
}
Rückgabeergebnis;
}, 2);
Oder wenn Sie die Reihenfolge der Parameter austauschen möchten, können Sie sie so definieren
Die Codekopie lautet wie folgt:
var flip = curry (Funktion (func) {
return curry (Funktion (a, b) {
return func (b, a);
}, 2);
});
Zusammenfassen
Funktionen in JavaScript haben viele spezielle Funktionen und können die Parametereigenschaften von Schließungen und Argumenten verwenden, um viele verschiedene Techniken zu implementieren. Im nächsten Artikel werden wir weiterhin die Techniken der Verwendung der Funktion zur Initialisierung einführen.