From 4b1a9203c547c019fc5398082ae19a3f3d4c3efe Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 14:41:15 -0500 Subject: initial commit --- .../global_objects/function/apply/index.html | 226 ++++++++++++++++ .../global_objects/function/arguments/index.html | 92 +++++++ .../global_objects/function/arity/index.html | 32 +++ .../global_objects/function/bind/index.html | 286 +++++++++++++++++++++ .../global_objects/function/call/index.html | 163 ++++++++++++ .../global_objects/function/caller/index.html | 84 ++++++ .../global_objects/function/displayname/index.html | 81 ++++++ .../reference/global_objects/function/index.html | 188 ++++++++++++++ .../global_objects/function/isgenerator/index.html | 56 ++++ .../global_objects/function/length/index.html | 92 +++++++ .../global_objects/function/name/index.html | 229 +++++++++++++++++ .../global_objects/function/prototype/index.html | 99 +++++++ .../global_objects/function/tosource/index.html | 72 ++++++ .../global_objects/function/tostring/index.html | 236 +++++++++++++++++ 14 files changed, 1936 insertions(+) create mode 100644 files/de/web/javascript/reference/global_objects/function/apply/index.html create mode 100644 files/de/web/javascript/reference/global_objects/function/arguments/index.html create mode 100644 files/de/web/javascript/reference/global_objects/function/arity/index.html create mode 100644 files/de/web/javascript/reference/global_objects/function/bind/index.html create mode 100644 files/de/web/javascript/reference/global_objects/function/call/index.html create mode 100644 files/de/web/javascript/reference/global_objects/function/caller/index.html create mode 100644 files/de/web/javascript/reference/global_objects/function/displayname/index.html create mode 100644 files/de/web/javascript/reference/global_objects/function/index.html create mode 100644 files/de/web/javascript/reference/global_objects/function/isgenerator/index.html create mode 100644 files/de/web/javascript/reference/global_objects/function/length/index.html create mode 100644 files/de/web/javascript/reference/global_objects/function/name/index.html create mode 100644 files/de/web/javascript/reference/global_objects/function/prototype/index.html create mode 100644 files/de/web/javascript/reference/global_objects/function/tosource/index.html create mode 100644 files/de/web/javascript/reference/global_objects/function/tostring/index.html (limited to 'files/de/web/javascript/reference/global_objects/function') diff --git a/files/de/web/javascript/reference/global_objects/function/apply/index.html b/files/de/web/javascript/reference/global_objects/function/apply/index.html new file mode 100644 index 0000000000..784843e276 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/apply/index.html @@ -0,0 +1,226 @@ +--- +title: Function.prototype.apply() +slug: Web/JavaScript/Reference/Global_Objects/Function/apply +tags: + - Function + - JavaScript + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Function/apply +--- +
{{JSRef}}
+ +

Die apply() Methode ruft eine Funktion mit gegebenem this Wert und arguments als Array (oder einem Array ähnlichem Objekt).

+ +
+

Hinweis: Die Syntax dieser Funktion ist größtenteils identisch zu der Funktion {{jsxref("Function.call", "call()")}}. Der fundamentale Unterschied ist, dass call() eine Liste von Argumenten und apply() ein Array mit Argumenten übergeben bekommt.

+
+ +
{{EmbedInteractiveExample("pages/js/function-apply.html")}}
+ + + +

Syntax

+ +
function.apply(thisArg, [argsArray])
+ +

Parameter

+ +
+
thisArg
+
Optional. Der Wert von this, der für den Aufruf der Funktion func genutzt wird. Zu beachten ist, dass this möglicherweise nicht der Wert ist, den die Methode sieht: Wenn die Methode eine Funktion im {{jsxref("Functions_and_function_scope/Strict_mode", "non-strict mode", "", 1)}} ist, werden {{jsxref("Global_Objects/null", "null")}} und {{jsxref("Global_Objects/undefined", "undefined")}} mit dem globalen Objekt ersetzt und primitive Werte werden in ein Hüllobjekt umgewandelt.
+
argsArray
+
Optional. Ein Array ähnliches Objekt, welches die Argumente spezifiziert, welche beim Aufruf von func benutzt werden, oder {{jsxref("null")}} oder {{jsxref("undefined")}}, wenn keine Argumente übergeben werden. Mit Einführung von ECMAScript 5 können diese Argumente mit einem generische Array ähnliches Objekt statt einem Array übergeben werden. Für mehr Informationen sollte die {{anch("Browserkompatibilität", "Browserkompatibilität")}} geprüft werden.
+
+ +

Rückgabewert

+ +

Das Ergebnis der aufgerufenen Funktion mit dem spezifischen this Wert und Parametern.

+ +

Beschreibung

+ +

Man kann ein anderes this Objekt für den Aufruf einer existierenden Funktion zuweisen. this referenziert zum aktuellen Objekte, dem aufrufenden Objekt. Mit apply kann eine Methode geschrieben und in einem anderen Objekt vererbt werden, ohne die Methode für das neue Objekte neu zu schreiben.

+ +

apply ist sehr ähnlich zu {{jsxref("Function.call", "call()")}}, mit der Ausnahme des Typen der übergebenen Argumente. Man kann ein Array von Argumenten statt einer Menge von benannten Parametern benutzen. Mit apply kann man ein Arrayliteral benutzen, wie zum Beispiel fun.apply(this, ['eat', 'bananas']) oder ein {{jsxref("Array")}} Objekt, wie zum Beispiel fun.apply(this, new Array('eat', 'bananas')).

+ +

Für den argsArray Parameter kann auch {{jsxref("Functions/arguments", "arguments")}} eingesetzt werden. arguments ist eine lokale Variable einer Funktion. Sie kann für alle nicht spezifizieren Argumente bei einem Aufruf benutzt werde. Dadurch muss man die Argumente eines Aufrufers nicht kennen, wenn die apply Methode genutzt wird. Man kann arguments nutzen, um alle Argumente eines Aufrufers zu übergeben. Das aufgerufene Objekt ist dann verantwortlich für das Verarbeiten der Argument.

+ +

Seit ECMAScript in der 5. Ausgabe kann jedes Objekt übergeben werden, welches Array ähnlich ist, was in der Praxis bedeutet, dass es eine length Eigenschaft hat und Ganzzahlige Eigenschaften im Bereich von 0 bis length-1 besitzt. Zum Beispiel kann man {{domxref("NodeList")}} oder benutzerdefinierte Objekte wie { 'length': 2, '0': 'eat', '1': 'bananas' } benutzen.

+ +
Viele Browser, auch Chrome 14 und Internet Explorer 9, unterstützen keine Array ähnlichen Objekte, was zu einem Fehler führt.
+ +

Beispiele

+ +

Einsatz von apply um ein Array an ein anderes zu hängen

+ +

Man kann push benutzen, um ein Element an ein Array anzufügen. Weil push eine variable Anzahl von Argumenten enthält, kann man auch mehrere Element mit einem Aufruf hinzufügen. Übergibt man jedoch ein Array an die push Methode, so wird das Array als ein Element hinzugefügt anstatt jedes Element des Arrays hinzuzufügen, was zu einem Array im Array führt. Was tun, wenn das nicht das ist, was gewollt ist? concat hat das gewünschte verhalten, jedoch erstellt es ein neues Array und fügt die Elemente nicht an das existierende Array. Was wenn man die Elemente unbedingt an das existierende Array hängen möchte? Eine Schleife schreiben? Sicher nicht!

+ +

apply ist die Funktion der Wahl!

+ +
var array = ['a', 'b'];
+var elements = [0, 1, 2];
+array.push.apply(array, elements);
+console.info(array);  // ["a", "b", 0, 1, 2]
+
+ +

Einsatz von apply und eingebauten Standardfunktionen

+ +

Der clevere Einsatz von apply erlaubt es standard Functionen für Aufgaben zu benutzen, für die man sonst schleifen Schreiben müsste, um über alle Elemente eines Arrays zu iterieren. Im folgenden Beispiel wurde Math.max/Math.min benutzt, um das maximalen/minimalen Wert in einem Array zu finden.

+ +
// min/max number in an array
+var numbers = [5, 6, 2, 3, 7];
+
+// using Math.min/Math.max apply
+var max = Math.max.apply(null, numbers);
+// This about equal to Math.max(numbers[0], ...)
+// or Math.max(5, 6, ...)
+
+var min = Math.min.apply(null, numbers);
+
+// vs. simple loop based algorithm
+max = -Infinity, min = +Infinity;
+
+for (var i = 0; i < numbers.length; i++) {
+  if (numbers[i] > max) {
+    max = numbers[i];
+  }
+  if (numbers[i] < min) {
+    min = numbers[i];
+  }
+}
+
+ +

Jedoch muss man bei einem solchen Einsatz von apply vorsichtig sein, weil das Risiko da ist, dass man in das Limit der maximalen Argumente der JavaScriptumgebung überschreitet. Die Konsequenz aus dem ausführen von Funktionen mit zu vielen Argumenten (mehr als Zehntausend Argumente) ist, dass dieses Limit stark variiert (JavaScriptCore hat ein hart Codiertes Argumentlimit von 65536), weil es in JavaScript nicht spezifiziert ist (tatsächlich sogar die Art eines übermäßig großen Stack-Verhaltens). Einige Umgebungen erzeugen einen Fehler. Andere übergeben nicht alle Argumente der Funktion, um das Limit nicht zu überschreiten. Um diesen Fall man zu schildern: Wenn eine Umgebung ein Limit von 4 Argumenten hätte (aktuelle Limits sind natürlich signifikant höher), würde es so sein, als ob nur die Argumente 5, 6, 2, 3 über apply im oberen Beispiel übergeben werden, statt dem ganzen Array.

+ +

Wenn das Array in einigen Fällen so groß wird, dass es zehntausend Element erreicht, sollte eine hybride Strategie genutzt werden: Man teilt das Array auf und übergibt diese Teile der Funktion:

+ +
function minOfArray(arr) {
+  var min = Infinity;
+  var QUANTUM = 32768;
+
+  for (var i = 0, len = arr.length; i < len; i += QUANTUM) {
+    var submin = Math.min.apply(null,
+                                arr.slice(i, Math.min(i+QUANTUM, len)));
+    min = Math.min(submin, min);
+  }
+
+  return min;
+}
+
+var min = minOfArray([5, 6, 2, 3, 7]);
+
+ +

apply für das Verketten von Konstruktoren verwenden

+ +

Man kann apply einsetzen, um {{jsxref("Operators/new", "Konstruktoren", "", 1)}} für ein Objekt zu verketten, ähnlich wie in Java. Im folgenden Beispiel wird eine globale {{jsxref("Function")}} Methode namens construct erstellt, welche es ermöglicht ein Array ähnliches Objekt mit einem Konstruktor anstatt eines Argumentliste zu benutzen.

+ +
Function.prototype.construct = function (aArgs) {
+  var oNew = Object.create(this.prototype);
+  this.apply(oNew, aArgs);
+  return oNew;
+};
+
+ +
+

Hinweis: Die oben eingesetzte Object.create() Methode ist relativ neu. Alternativ kann eine der folgenden Ansätze verwendet werden:

+ +

Einsatz von {{jsxref("Object/__proto__", "Object.__proto__")}}:

+ +
Function.prototype.construct = function (aArgs) {
+  var oNew = {};
+  oNew.__proto__ = this.prototype;
+  this.apply(oNew, aArgs);
+  return oNew;
+};
+
+ +

Einsatz von Closures:

+ +
Function.prototype.construct = function(aArgs) {
+  var fConstructor = this, fNewConstr = function() {
+    fConstructor.apply(this, aArgs);
+  };
+  fNewConstr.prototype = fConstructor.prototype;
+  return new fNewConstr();
+};
+ +

Einsatz von {{jsxref("Function")}} Konstruktoren:

+ +
Function.prototype.construct = function (aArgs) {
+  var fNewConstr = new Function("");
+  fNewConstr.prototype = this.prototype;
+  var oNew = new fNewConstr();
+  this.apply(oNew, aArgs);
+  return oNew;
+};
+
+
+ +

Beispiel für den Einsatz:

+ +
function MyConstructor() {
+  for (var nProp = 0; nProp < arguments.length; nProp++) {
+    this['property' + nProp] = arguments[nProp];
+  }
+}
+
+var myArray = [4, 'Hello world!', false];
+var myInstance = MyConstructor.construct(myArray);
+
+console.log(myInstance.property1);                // logs 'Hello world!'
+console.log(myInstance instanceof MyConstructor); // logs 'true'
+console.log(myInstance.constructor);              // logs 'MyConstructor'
+
+ +
+

Hinweis: Diese nicht native Function.construct Methode funktioniert nicht mit einigen nativen Konstruktoren (mit {{jsxref("Date")}} zum Beispiel). In diesem Fall muss man die {{jsxref("Function.prototype.bind")}} Methode (hat man zum Beispiel ein Array ähnliches Objekt wie folgt, um mit dem {{jsxref("Global_Objects/Date", "Date")}} Konstruktor [2012, 11, 4] einzusetzen; in diesem Fall muss folgendes geschrieben werden: new (Function.prototype.bind.apply(Date, [null].concat([2012, 11, 4])))() — Jedoch ist das nicht die beste Art und Weise Probleme zu Lösen, weshalb diese Lösung nicht Praxistauglich ist).

+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES3')}}{{Spec2('ES3')}}Initiale Definition. Implementiert in JavaScript 1.3.
{{SpecName('ES5.1', '#sec-15.3.4.3', 'Function.prototype.apply')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-function.prototype.apply', 'Function.prototype.apply')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-function.prototype.apply', 'Function.prototype.apply')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.Function.apply")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/function/arguments/index.html b/files/de/web/javascript/reference/global_objects/function/arguments/index.html new file mode 100644 index 0000000000..271120bd9d --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/arguments/index.html @@ -0,0 +1,92 @@ +--- +title: Function.arguments +slug: Web/JavaScript/Reference/Global_Objects/Function/arguments +tags: + - Deprecated + - Function + - JavaScript + - Property + - arguments +translation_of: Web/JavaScript/Reference/Global_Objects/Function/arguments +--- +
{{JSRef}} {{deprecated_header}}
+ +

Die function.arguments Eigenschaft referenziert ein Array ähnliches Objekt, welches die übergebenen Parameter einer Funktion enthält. Stattdessen kann die Variable {{jsxref("Functions/arguments", "arguments")}} benutzt werden. Diese Eigenschaft ist im Strict Mode aufgrund von taill Aufrufoptimierung verboten.

+ +

Beschreibung

+ +

Die Syntax function.arguments ist veraltet. Der empfolene Weg, um das {{jsxref("Functions/arguments", "arguments")}} Objekt zu erreichen, ist in einer Funktion die Variable {{jsxref("Functions/arguments", "arguments")}} zu benutzen.

+ +

Im Fall von Rekursion, z. B. wenn die Funktion f mehrere Male auf dem Aufruf-Stack ist, repräsentiert f.arguments die Argumente des letzten Aufrufes der Funktion.

+ +

Der Wert der arguments Eigenschaft ist normalerweise null, wenn keine Durchführung der Funktion vorhanden ist (Durchführung bedeutet, dass die Funktion aufgerufen wurde, aber noch nichts zurückgegeben hat).

+ +

Beispiele

+ +
function f(n) { g(n - 1); }
+
+function g(n) {
+  console.log('before: ' + g.arguments[0]);
+  if (n > 0) { f(n); }
+  console.log('after: ' + g.arguments[0]);
+}
+
+f(2);
+
+console.log('returned: ' + g.arguments);
+
+// Output
+
+// before: 1
+// before: 0
+// after: 0
+// after: 1
+// returned: null
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0. Deprecated zugunsten von  {{jsxref("Functions/arguments", "arguments")}} in ES3.
{{SpecName('ES5.1', '#sec-10.6', 'arguments object')}}{{Spec2('ES5.1')}}{{jsxref("Functions/arguments", "arguments")}} Objekt
{{SpecName('ES6', '#sec-arguments-object', 'arguments object')}}{{Spec2('ES6')}}{{jsxref("Functions/arguments", "arguments")}} Objekt
{{SpecName('ESDraft', '#sec-arguments-object', 'arguments object')}}{{Spec2('ESDraft')}}{{jsxref("Functions/arguments", "arguments")}} Objekt
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.Function.arguments")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/function/arity/index.html b/files/de/web/javascript/reference/global_objects/function/arity/index.html new file mode 100644 index 0000000000..f5ff00bd27 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/arity/index.html @@ -0,0 +1,32 @@ +--- +title: Function.arity +slug: Web/JavaScript/Reference/Global_Objects/Function/arity +tags: + - Function + - JavaScript + - Obsolete + - Property + - Unimplemented +translation_of: Archive/Web/JavaScript/Function.arity +--- +
{{JSRef}} {{obsolete_header}}
+ +

Die arity Eigenschaft wurde benutzt, um die Anzahl der erwarteten Argumente einer Funktion zurückzugeben, jedoch existiert diese Eigenschaft nicht mehr und wurde durch die Eigenschaft {{jsxref("Function.prototype.length")}} ersetzt.

+ +

Spezifikationen

+ +

Implementiert in JavaScript 1.2. Veraltet seit JavaScript 1.4.

+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.Function.arity")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/function/bind/index.html b/files/de/web/javascript/reference/global_objects/function/bind/index.html new file mode 100644 index 0000000000..9427e62299 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/bind/index.html @@ -0,0 +1,286 @@ +--- +title: Function.prototype.bind() +slug: Web/JavaScript/Reference/Global_Objects/Function/bind +tags: + - Class + - ECMAScript 2015 + - ECMAScript 5 + - Function + - JavaScript + - Method + - bind + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Function/bind +--- +
{{JSRef}}
+ +

Die bind() Methode erzeugt eine neue Funktion die beim Aufruf ihr this Schlüsselwort auf den ersten übergebenen Wert setzt. Alle weiteren Argumente werden den beim Funktionsaufruf übergebenen Werten vorangestellt.

+ +
{{EmbedInteractiveExample("pages/js/function-bind.html", "taller")}}
+ + + +

Syntax

+ +
function.bind(thisArg[, arg1[, arg2[, ...]]])
+ +

Parameter

+ +
+
thisArg
+
Der für this zu übergebende Wert an die Zielfunktion sobald die gebundene Funktion aufgerufen wird. Der Wert wird ignoriert, wenn die gebundene Funktion mit dem {{jsxref("Operators/new", "new")}} Schlüsselwort initiiert wurde.
+
arg1, arg2, ...
+
An die bind Funktion übergebene Werte. Diese Werte werden an die gebundene Funktion überreicht.
+
+ +

Rückgabewert

+ +

Eine Kopie der gegebenen Funktion mit dem spezifizierten this Wert und initialen Parametern.

+ +

Beschreibung

+ +

Die bind() Funktion erstellt eine neue gebundene Funktion (BF). Eine BF ist ein exotisches Funktionsobjekte (ein Teil von ECMAScript 2015) welches die eigentliche Funktion umhüllt. Das Aufrufen einer BF führt zum ausführen der umhüllten Funktion. Eine BF hat die folgenden internen Eigenschaften:

+ + + +

Wenn die gebundene Funktion aufgerufen wird, ruft diese die interne Methode [[Call]] auf [[BoundTargetFunction]] mit den Argumenten Call(boundThis, args) auf. Dabei ist boundThis gleich [[BoundThis]] und args gleich [[BoundArguments]] gefolgt von den übergebenen Parametern des Funktionsaufrufes.

+ +

Eine gebundene Funktion kann zudem mit einen new Operator erstellt werden: Das sieht so aus, als ob die Zielfunktion stattdessen konstruiert worden wäre. Dar übergebene this Wert wird ignoriert, während die voranstehenden Argumente für die Emulierte Funktion zur Verfügung stehen.

+ +

Beispiele

+ +

Erstellen einer gebunden Funktion

+ +

Die einfachste Verwendung von bind() besteht darin, eine Funktion zu erstellen, die, egal wie sie aufgerufen wird, mit einem this Wert aufgerufen wird. Ein häufiger Fehler für neue JavaScript-Programmierer besteht darin, eine Methode aus einem Objekt zu extrahieren, diese Funktion später aufzurufen und zu erwarten, dass sie das ursprüngliche Objekt als this verwendet (z. B. durch Verwendung dieser Methode in Callback-basiertem Code). Ohne besondere Sorgfalt ist das ursprüngliche Objekt jedoch in der Regel verloren. Das Erstellen einer gebundenen Funktion aus der Funktion, die das ursprüngliche Objekt verwendet, löst dieses Problem sauber:

+ +
this.x = 9;    // this refers to global "window" object here in the browser
+var module = {
+  x: 81,
+  getX: function() { return this.x; }
+};
+
+module.getX(); // 81
+
+var retrieveX = module.getX;
+retrieveX();
+// returns 9 - The function gets invoked at the global scope
+
+// Create a new function with 'this' bound to module
+// New programmers might confuse the
+// global var x with module's property x
+var boundGetX = retrieveX.bind(module);
+boundGetX(); // 81
+
+ +

Partiell gebunden Funktionen

+ +

Der nächste einfache Einsatz von bind() ist das Vordefinieren von Initialparameter einer Funktion. Diese Argumente (wenn welche vorhanden) folgen auf den übergebenen this Wert und Werten am Anfang der Zielfunktion den Parametern hinzugefügt, gefolgt von den Parametern, die der gebunden Funktion übergeben werden, immer wenn die gebunden Funktion aufgerufen wird.

+ +
function list() {
+  return Array.prototype.slice.call(arguments);
+}
+
+var list1 = list(1, 2, 3); // [1, 2, 3]
+
+// Create a function with a preset leading argument
+var leadingThirtysevenList = list.bind(null, 37);
+
+var list2 = leadingThirtysevenList();
+// [37]
+
+var list3 = leadingThirtysevenList(1, 2, 3);
+// [37, 1, 2, 3]
+
+ +

Mit setTimeout

+ +

Bei {{domxref("window.setTimeout()")}} wird im Standardfall das this Schlüsselwort mit dem {{ domxref("window") }} (oder global) Objekt versehen. Wenn mit Klassenmethoden gearbeitet wird, die es vorgesehen, dass this zu der Klasseninstanz verweist, muss this explizit an die Callback-Funktion gebunden werden, damit die Instanz vorhanden ist.

+ +
function LateBloomer() {
+  this.petalCount = Math.floor(Math.random() * 12) + 1;
+}
+
+// Declare bloom after a delay of 1 second
+LateBloomer.prototype.bloom = function() {
+  window.setTimeout(this.declare.bind(this), 1000);
+};
+
+LateBloomer.prototype.declare = function() {
+  console.log('I am a beautiful flower with ' +
+    this.petalCount + ' petals!');
+};
+
+var flower = new LateBloomer();
+flower.bloom();
+// after 1 second, triggers the 'declare' method
+ +

Gebunden Funktion mit einem Konstruktor

+ +
+

Warnung: Dieses Kapitel demonstriert JavaScript-möglichkeiten und dokumentiert Randfälle der bind() Methode. Die Methoden, die unten gezeigt werden, sind nicht die Besten, um Dinge zu lösen, weshalb sie nicht in einem Produktivsystem eingesetzt werden sollten.

+
+ +

Gebundene Funktion sind automatisch verfügbar für den Einsatz mit dem {{jsxref("Operators/new", "new")}} Operator, um eine neue Instanz von einer Zielfunktion zu erstellen. Wenn eine gebundene Funktion eingesetzt wird, um einen Wert zu erstellen, wird das unterstützte this Argument ignoriert. Dahingegen werden unterstützte Argumente vor den Konstruktoraufrufe vorgehängt:

+ +
function Point(x, y) {
+  this.x = x;
+  this.y = y;
+}
+
+Point.prototype.toString = function() {
+  return this.x + ',' + this.y;
+};
+
+var p = new Point(1, 2);
+p.toString(); // '1,2'
+
+// not supported in the polyfill below,
+
+// works fine with native bind:
+
+var YAxisPoint = Point.bind(null, 0/*x*/);
+
+
+var emptyObj = {};
+var YAxisPoint = Point.bind(emptyObj, 0/*x*/);
+
+var axisPoint = new YAxisPoint(5);
+axisPoint.toString(); // '0,5'
+
+axisPoint instanceof Point; // true
+axisPoint instanceof YAxisPoint; // true
+new Point(17, 42) instanceof YAxisPoint; // true
+
+ +

Zu beachten ist, dass nichts spezielles getan werden muss, um eine gebundene Funktion mit {{jsxref("Operators/new", "new")}} zu erstellen. Die Folge ist, dass man nichts Besonderes tun muss, um eine gebundene Funktion zu erzeugen, die einfach aufgerufen werden kann, selbst wenn es gewollt ist, dass die gebundene Funktion nur mit {{jsxref("Operators/new", "new")}} aufgerufen wird:

+ +
// Example can be run directly in your JavaScript console
+// ...continuing from above
+
+// Can still be called as a normal function
+// (although usually this is undesired)
+YAxisPoint(13);
+
+emptyObj.x + ',' + emptyObj.y;
+// >  '0,13'
+
+ +

Wenn es gewünscht ist, dass der Einsatz von gebundenen Funktion nur mit {{jsxref("Operators/new", "new")}} oder einem einfachen Aufruf sein soll, so muss die Zielfunktion diese Einschränkung erzwingen.

+ +

Kurzformen erstellen

+ +

bind() ist nützlich in fällen, in denen man kurzformen erstellen will, bei denen ein spezifischer this vorhanden sein soll.

+ +

Nimmt man zum Beispiel {{jsxref("Array.prototype.slice")}}, welche man zum Konvertieren von Array ähnlichen Objekte zu einem richtigen Array einsetzen mögliche, dann kann man eine Kurzform wie diese erstellen:

+ +
var slice = Array.prototype.slice;
+
+// ...
+
+slice.apply(arguments);
+
+ +

Mit bind(), kann dieses vereinfacht werden. Im folgenden Codestück ist slice eine gebunden Funktion zu der {{jsxref("Function.prototype.apply()", "apply()")}} Funktion von {{jsxref("Function.prototype")}} mit dem this Wert auf der {{jsxref("Array.prototype.slice()", "slice()")}} Funktion von {{jsxref("Array.prototype")}}. Das bedeutet, dass der zusätzliche Aufruf von apply() nicht nötig ist:

+ +
// same as "slice" in the previous example
+var unboundSlice = Array.prototype.slice;
+var slice = Function.prototype.apply.bind(unboundSlice);
+
+// ...
+
+slice(arguments);
+
+ +

Polyfill

+ +

Wenn die bind() Funktion nicht vorhanden ist, kann ein Großteil der Funktionalität mit trotzdem hinzugefügt werden, indem der folgende Quelltext am Anfang des Skriptes hinzugefügt wird.

+ +
if (!Function.prototype.bind) {
+  Function.prototype.bind = function(oThis) {
+    if (typeof this !== 'function') {
+      // closest thing possible to the ECMAScript 5
+      // internal IsCallable function
+      throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable');
+    }
+
+    var aArgs   = Array.prototype.slice.call(arguments, 1),
+        fToBind = this,
+        fNOP    = function() {},
+        fBound  = function() {
+          return fToBind.apply(this instanceof fNOP
+                 ? this
+                 : oThis,
+                 aArgs.concat(Array.prototype.slice.call(arguments)));
+        };
+
+    if (this.prototype) {
+      // Function.prototype doesn't have a prototype property
+      fNOP.prototype = this.prototype;
+    }
+    fBound.prototype = new fNOP();
+
+    return fBound;
+  };
+}
+
+ +

Einige der vielen Unterschiede (es kann durchaus andere geben, weil bei dieser Liste nicht auf Vollständig geachtet wurde) zwischen diesem Algorithmus und dem angegebenen Algorithmus sind:

+ + + +

Wenn diese partielle Implementierung eingesetzt wird, muss man davon ausgehen, dass dessen Verhalten von dem in ECMA-262 in der 5. Auflage unterscheidet! Mit etwas Vorsicht (und vielleicht kleinen Modifizierungen für spezielle Anforderungen) kann diese partielle Implementierung eine gute Übergangslösung für die Zeit sein, in der bind() noch nicht in allen Umgebungen unterstützt wird.

+ +

Auf https://github.com/Raynos/function-bind könnte es eine gründlichere Lösung geben!

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES5.1', '#sec-15.3.4.5', 'Function.prototype.bind')}}{{Spec2('ES5.1')}}Initiale Definition. Implementiert in JavaScript 1.8.5.
{{SpecName('ES2015', '#sec-function.prototype.bind', 'Function.prototype.bind')}}{{Spec2('ES2015')}}
{{SpecName('ESDraft', '#sec-function.prototype.bind', 'Function.prototype.bind')}}{{Spec2('ESDraft')}}
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.Function.bind")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/function/call/index.html b/files/de/web/javascript/reference/global_objects/function/call/index.html new file mode 100644 index 0000000000..46bdb07442 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/call/index.html @@ -0,0 +1,163 @@ +--- +title: Function.prototype.call() +slug: Web/JavaScript/Reference/Global_Objects/Function/call +tags: + - Function + - JavaScript + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Function/call +--- +
{{JSRef}}
+ +

Die call() Methode ruft eine Funktion mit dem Argument this und den individuellen Parametern auf.

+ +
+

Hinweis: Die Syntax dieser Funktion ist nahezu identisch zu {{jsxref("Function.prototype.apply", "apply()")}}. Der Unterschied ist, dass call() eine Liste von Argumenten und apply() einen einzelnen Array von Argumenten akzeptiert.

+
+ +
{{EmbedInteractiveExample("pages/js/function-call.html")}}
+ + + +

Syntax

+ +
function.call(thisArg, arg1, arg2, ...)
+ +

Parameter

+ +
+
thisArg
+
Optional. Der Wert von this, der für den Aufruf der Funktion function genutzt wird. Zu beachten ist, dass this möglicherweise nicht der Wert ist, den die Methode sieht: Wenn die Methode eine Funktion in {{jsxref("Functions_and_function_scope/Strict_mode", "non-strict mode", "", 1)}} ist, werden {{jsxref("Global_Objects/null", "null")}} und {{jsxref("Global_Objects/undefined", "undefined")}} mit dem globalen Objekt ersetzt und primitive Werte werden in ein Hüllobjekt umgewandelt.
+
arg1, arg2, ...
+
Argumente für das Objekt.
+
+ +

Rückgabewert

+ +

Das Ergebnis der aufgerufenen Funktion mit dem spezifischen this Wert und Parametern.

+ +

Beschreibung

+ +

Beim Aufruf einer existierenden Funktion können Sie für this ein neues Objekt zuweisen. this verweist auf das aktuelle Objekt, also das aufrufende Objekt. Mit call können Sie eine Methode schreiben und an ein anderes Objekt vererben, ohne die Methode für das neue Objekt neuzuschreiben.

+ +

Beispiele

+ +

Nutzung von call, um Konstruktoren für ein Objekt zu verketten

+ +

Man kann call nutzen, um Konstruktoren für ein Objekt, ähnlich wie in Java, zu verketten. Im folgenden Beispiel wird der Konstruktor für das Product Objekt mit zwei Parametern, name und price, definiert. Zwei andere Funktionen Food und Toy rufen Product auf und übergeben this, name und price. Product initialisiert die Eigenschaften name und price und beide speziellen Funktionen definieren category.

+ +
function Product(name, price) {
+  this.name = name;
+  this.price = price;
+}
+
+function Food(name, price) {
+  Product.call(this, name, price);
+  this.category = 'food';
+}
+
+function Toy(name, price) {
+  Product.call(this, name, price);
+  this.category = 'toy';
+}
+
+var cheese = new Food('feta', 5);
+var fun = new Toy('robot', 40);
+
+ +

Nutzung von call zum Aufruf einer anonymen Funktion

+ +

In diesem komplett konstruierten Beispiel erstellen wir eine anonyme Funktion und nutzen call, um diese für jedes Objekt in einem Array aufzurufen. Der Hauptnutzen für die Nutzung anonymer Funktionen hier, ist das hinzufügen einer Print-Funktion für jedes Objekt, welche den rechten Index des Objekts in dem eingegebenen Array ausgeben kann. Die Übergabe des Objektes als this-Wert ist hier nicht zwingend erforderlich, wurde aber zur Veranschaulichung genutzt.

+ +
var animals = [
+  { species: 'Lion', name: 'King' },
+  { species: 'Whale', name: 'Fail' }
+];
+
+for (var i = 0; i < animals.length; i++) {
+  (function(x) {
+    this.print = function() {
+      console.log('#' + x + ' ' + this.species
+                  + ': ' + this.name);
+    }
+    this.print();
+  }).call(animals[i], i);
+}
+
+ +

Einsatz von call zum aufrufen einer Funktion mit spezifiziertem Kontext für 'this'

+ +

Im unten stehenden Beispiel wird das thisObjekt der greet Funktion beim Aufruf auf obj gesetzt.

+ +
function greet() {
+  var reply = [this.animal, 'typically sleep betreen', this.sleepDuration].join(' ');
+  console.log(reply);
+}
+
+var obj = {
+  animal: 'cats', sleepDuration: '12 and 16 hours'
+};
+
+greet.call(obj); // cats typically sleep between 12 and 16 hours
+
+ +

Eine Funktion mit call ausführen ohne den ersten Parameter zu setzen.

+ +

Im unten stehenden Beispiel wird die display Funktion aufgerufen ohne den ersten Parameter zu übergeben. Wenn der erste Parameter nicht übergeben wird, ist this das globale Objekt.

+ +
var sData = 'Wisen';
+
+function display(){
+  console.log('sData value is %s', this.sData);
+}
+
+display.call(); // sData value is Wisen
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.3.
{{SpecName('ES5.1', '#sec-15.3.4.4', 'Function.prototype.call')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-function.prototype.call', 'Function.prototype.call')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-function.prototype.call', 'Function.prototype.call')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.Function.call")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/function/caller/index.html b/files/de/web/javascript/reference/global_objects/function/caller/index.html new file mode 100644 index 0000000000..1b0b3f6c03 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/caller/index.html @@ -0,0 +1,84 @@ +--- +title: Function.caller +slug: Web/JavaScript/Reference/Global_Objects/Function/caller +tags: + - Function + - JavaScript + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Function/caller +--- +
{{JSRef}} {{non-standard_header}}
+ +

Die function.caller Eigenschaft gibt die Funktion zurück, die eine spezifizierte Funktion aufgerufen hat. Diese Eigenschaft ist im Strict-Modus wegen tail call Optimierungen verboten.

+ +

Beschreibung

+ +

Wenn die Funktion f durch einen Quelltext auf höchster Ebene aufgerufen wird, ist der Wert von f.caller {{jsxref("null")}}, anderfalls die Funktion, die f aufgerufen hat.

+ +

Diese Eigenschaft ersetzt die veraltete Eigenschaft {{jsxref("Functions/arguments/caller", "arguments.caller")}} des {{jsxref("Functions/arguments", "arguments")}} Objektes.

+ +

Die spezielle Eigenschaft __caller__, welches das Objekt des Aufrufers zurück gab, erlaubt es den Stack zu rekonstruieren und wurde aus Sicherheitsgründen entfernt.

+ +

Hinweise

+ +

Im Fall von Rekursion, kann der Stack nicht mit dieser Eigenschaft reproduziert werden. Gegeben:

+ +
function f(n) { g(n - 1); }
+function g(n) { if (n > 0) { f(n); } else { stop(); } }
+f(2);
+
+ +

Im Moment, indem stop() aufgerufen wird, ist der Aufruferstack:

+ +
f(2) -> g(1) -> f(1) -> g(0) -> stop()
+
+ +

Das folgende ergibt true:

+ +
stop.caller === g && f.caller === g && g.caller === f
+
+ +

Wenn man versucht den Stacktrace in der stop() Funktion zu bekommen, wie hier:

+ +
var f = stop;
+var stack = 'Stack trace:';
+while (f) {
+  stack += '\n' + f.name;
+  f = f.caller;
+}
+
+ +

wird die Schleife nie beendet.

+ +

Beispiele

+ +

Prüfen des Wertes der Funktionseigenschaft caller

+ +

Der folgende Quelltext prüft den Wert der Funktionseigenschaft caller.

+ +
function myFunc() {
+  if (myFunc.caller == null) {
+    return 'The function was called from the top!';
+  } else {
+    return 'This function\'s caller was ' + myFunc.caller;
+  }
+}
+
+ +

Spezifikationen

+ +

In keiner Spezifikation enthalten. Implementiert in JavaScript 1.5.

+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.Function.caller")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/function/displayname/index.html b/files/de/web/javascript/reference/global_objects/function/displayname/index.html new file mode 100644 index 0000000000..9e22b16fca --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/displayname/index.html @@ -0,0 +1,81 @@ +--- +title: Function.displayName +slug: Web/JavaScript/Reference/Global_Objects/Function/displayName +tags: + - Function + - JavaScript + - Non Standard + - Non-standard + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Function/displayName +--- +
{{JSRef}} {{non-standard_header}}
+ +

Die function.displayName Eigenschaft gibt den sichtbaren Namen der Funktion zurück.

+ +

Beschreibung

+ +

Wenn definiert, gibt dit displayName Eigenschaft den sichtbaren Namen der Funktion zurück:

+ +
function doSomething() {}
+
+console.log(doSomething.displayName); // "undefined"
+
+var popup = function(content) { console.log(content); };
+
+popup.displayName = 'Show Popup';
+
+console.log(popup.displayName); // "Show Popup"
+
+ +

Man kann eine Funktion mit sichtbaren Namen mit einem {{jsxref("Functions", "Funktionsausdruck", "", 1)}} definieren:

+ +
var object = {
+  someMethod: function() {}
+};
+
+object.someMethod.displayName = 'someMethod';
+
+console.log(object.someMethod.displayName); // logs "someMethod"
+
+try { someMethod } catch(e) { console.log(e); }
+// ReferenceError: someMethod is not defined
+
+ +

Man kann den displayName einer Funktion dynamisch ändern:

+ +
var object = {
+  // anonymous
+  someMethod: function(value) {
+    arguments.callee.displayName = 'someMethod (' + value + ')';
+  }
+};
+
+console.log(object.someMethod.displayName); // "undefined"
+
+object.someMethod('123')
+console.log(object.someMethod.displayName); // "someMethod (123)"
+
+ +

Beispiele

+ +

Konsolen und Profiler präferieren die {{jsxref("Function.name", "func.name")}} zum anzeigen des Namens einer Funktion.

+ +

Beim eingeben des Folgenden Quelltextes in der Konsole, wird etwas wie "function My Function()" ausgegeben:

+ +
var a = function() {};
+a.displayName = 'My Function';
+
+a; // "function My Function()"
+ +

Spezifikationen

+ +

In keiner Spezifikation enthalten.

+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.Function.displayName")}}

+
diff --git a/files/de/web/javascript/reference/global_objects/function/index.html b/files/de/web/javascript/reference/global_objects/function/index.html new file mode 100644 index 0000000000..dd2a7d5583 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/index.html @@ -0,0 +1,188 @@ +--- +title: Function +slug: Web/JavaScript/Reference/Global_Objects/Function +tags: + - Constructor + - Function + - JavaScript +translation_of: Web/JavaScript/Reference/Global_Objects/Function +--- +
{{JSRef}}
+ +

Der Function Konstruktor erstellt ein neues Funktion Objekt. Das direkte Aufrufen kann Funktionen dynamisch erstellen, hat aber Sicherheits- und Performanceprobleme genau wie der Einsatz von {{jsxref("eval")}}. Im Gegensatz zu eval ermöglicht der Function-Konstruktor die Ausführung von Code im globalen Gültigkeitsbereich, was zu besseren Programmiergewohnheiten führt und eine effizientere Code-Minimierung ermöglicht.

+ +
{{EmbedInteractiveExample("pages/js/function-constructor.html")}}
+ + + +

Jede JavaScript Funktion ist aktuell ein Function Objekt. Das kann mit dem Code (function(){}).constructor === Function gezeigt werden, der true zurückgibt.

+ +

Syntax

+ +
new Function ([arg1[, arg2[, ...argN]],] functionBody)
+ +

Parameter

+ +
+
arg1, arg2, ... argN
+
Namen die von der Funktion als formelle Argumentname genutzt werden. Jeder davon muss ein String sein, welcher ein gültiger JavaScript Bezeichner ist oder einer Liste von solchen Strings, getrennt mit Kommata ist. Zum Beispiel: "x", "derWert", oder "a,b".
+
functionBody
+
Ein String, welcher den JavaScript Ausdruck als Funktions-Definition beinhaltet.
+
+ +

Beschreibung

+ +

Mit dem Function Konstruktor erstellte Function-Objekte werden übersetzt, sobald die Funktion erstellt wurde. Das ist weniger effizient, als wenn man eine Funktion als Funktionsausdruck oder Funktionsstatement deklariert und diese innerhalb des Codes abruft, weil diese mit dem Rest des Codes übersetzt werden.

+ +

Alle der Funktion übergegebenen Argumente werden als Namen der Bezeichner der Parameter in der zu erstellenden Funktion in der angegebenen Reihenfolge behandelt.

+ +

Das Aufrufen des Function Konstruktors als Funktion (ohne den new Operator) hat dieselbe Wirkung, wie als Konstrukteuraufruf. Jedoch kann das Weglassen des new Operators eine kleinere minimierten Codegröße (4 Byte kleiner) erreichen, so dass es besser ist Function ohne new zu benutzen.

+ +

Eigenschaften und Methoden von Function

+ +

Das globale Function Objekt hat eigene Methoden und Eigenschaften, doch, da es eine Funktion selbst ist, erbt es einige Methoden und Eigenschaften durch die Prototypkette aus {{jsxref("Function.prototype")}}.

+ +

Function Prototyp Objekt

+ +

Eigenschaften

+ +
{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Function/prototype', 'Eigenschaften')}}
+ +

Methoden

+ +
{{page('/de/docs/Web/JavaScript/Reference/Global_Objects/Function/prototype', 'Methoden')}}
+ +

Function Instanzen

+ +

Funktions-Instanzen erben Methoden und Eigenschaften vom {{jsxref("Function.prototype")}}. Wie bei allen Konstruktoren kann das Prototypen Objekt verändern werden, um Änderungen an allen Funktions-Instanzen durchzuführen.

+ +

Beispiele

+ +

Spezifizieren von Argumente mit dem Function Konstruktor

+ +

Der folgende Code erstellt ein Funktions-Objekt, mit zwei Argumenten.

+ +
// Das Beispiel kann direkt in der JavaScript Console ausgeführt werden.
+
+// Erstellt eine Funktion mit zwei Argumenten und gibt die Summe dieser Argumente zurück
+var adder = new Function('a', 'b', 'return a + b');
+
+// Aufruf der Funktion
+adder(2, 6);
+// > 8
+
+ +

Die Argumente "a" und "b" sind formale Argument-Namen, welche im Funktionskörper genutzt werden, "return a + b".

+ +

Unterschiede zwischen dem Function Konstruktor und Funktionsdeklarationen

+ +

Funktionen, die mit dem Function Konstruktor erstellt werden, erstellen keine Closures in ihrem Erstellungskontext; Sie werden immer im globalen Scope erstellt. Wenn diese ausgeführt wird, kann sie nur auf eigene lokale oder globale Variablen zugreifen, jedoch nicht auf die aus dem Erstellungskontext des Function Konstruktor aufzufes. Dieses ist der Unterschied zum Einsatz von {{jsxref("eval")}} mit Quelltext für einen Funktionsausdruck.

+ +
var x = 10;
+
+function createFunction1() {
+    var x = 20;
+    return new Function('return x;'); // this |x| refers global |x|
+}
+
+function createFunction2() {
+    var x = 20;
+    function f() {
+        return x; // this |x| refers local |x| above
+    }
+    return f;
+}
+
+var f1 = createFunction1();
+console.log(f1());          // 10
+var f2 = createFunction2();
+console.log(f2());          // 20
+
+ +

Der "richtige" Weg für das Ausführen von externen Code mit Function (Für maximale Minimierung).

+ +
function makeFunction(code){
+    return Funktion('"use strict";return ' + code)();
+}
+var add = makeFunktion(
+  "" + function(a, b, c){ return a + b + c } // dieser Code ist in einer seperaten Datei irgendwo im Produktivprogramm
+)
+console.log( add(1, 2, 3) );  // gibt sechs aus
+
+ +

Zu beachten ist, dass der obere Code komplett unpraktikabel ist. Man sollte Function niemals so missbrauchen. Stattdessen ist der obere Code nur als vereinfachtes Beispiel für eine Art Modulloader zu sehen, wobei es ein Basisskript gibt, welches dann hunderte von großen optionalen Modulen lädt. Dadurch muss ein Benutzer nicht lange warten, bis alle Module heruntergeladen sind, sondern der Clientcomputer lädt nur die benötigten Module und eine Seite lädt schneller. Dabei wird es beim auswerten von vielen Funktionen empfohlen, sie gebündelt zu übersetzen anstatt jede einzeln.

+ +
function bulkMakeFunctions(){
+    var str = "", i = 1, Len = arguments.length;
+    if(Len) {
+        str = arguments[0];
+        while (i !== Len) str += "," + arguments[i], ++i;
+    }
+    return Funktion('"use strict";return[' + str + ']')();
+}
+const [
+    add,
+    sub,
+    mul,
+    div
+] = bulkMakeFunctions(
+    "function(a,b){return a+b}",
+    "function(a,b){return a-b}",
+    "function(a,b){return a*b}",
+    "function(a,b){return a/b}"
+);
+console.log(sub(add(mul(4, 3), div(225, 5)), 7));
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.3', 'Function')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-function-objects', 'Function')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-function-objects', 'Function')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.Function")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/function/isgenerator/index.html b/files/de/web/javascript/reference/global_objects/function/isgenerator/index.html new file mode 100644 index 0000000000..5897905e92 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/isgenerator/index.html @@ -0,0 +1,56 @@ +--- +title: Function.prototype.isGenerator() +slug: Web/JavaScript/Reference/Global_Objects/Function/isGenerator +tags: + - Function + - JavaScript + - Method + - Non-standard + - Obsolete +translation_of: Archive/Web/JavaScript/Function.isGenerator +--- +
{{JSRef}} {{non-standard_header}}
+ +

Die nicht standardisierte isGenerator() Methode wird benutzt, um festzustellen, ob eine Funktion ein Generator ist. In Firefox Version 58 wurde diese Methode entfernt.

+ +

Syntax

+ +
fun.isGenerator()
+ +

Rückgabewert

+ +

Ein {{jsxref("Boolean")}} Welcher angibt, ob eine Funktion ein Generator ist.

+ +

Beschreibung

+ +

Die isGenerator() Methode stellt fest, ob eine Funktion fun ein Generator ist. Diese war in einem frühen Vorschlag, wurde jedoch nicht in der ECMAScript 2015 Spezifikation eingefügt.

+ +

Beispiele

+ +
function f() {}
+
+function* g() {
+  yield 42;
+}
+
+console.log('f.isGenerator() = ' + f.isGenerator()); // f.isGenerator() = false
+console.log('g.isGenerator() = ' + g.isGenerator()); // g.isGenerator() = true
+
+ +

Spezifikationen

+ +

Ist in keiner Spezifikation vorhanden. Implementiert in JavaScript 1.8.6.

+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.Function.isGenerator")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/function/length/index.html b/files/de/web/javascript/reference/global_objects/function/length/index.html new file mode 100644 index 0000000000..3eca57b92a --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/length/index.html @@ -0,0 +1,92 @@ +--- +title: Function.length +slug: Web/JavaScript/Reference/Global_Objects/Function/length +tags: + - Function + - JavaScript + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Function/length +--- +
{{JSRef}}
+ +

Die length Eigenschaft gibt die Anzahl der von der Funktion erwarteten Parameter an.

+ +
{{EmbedInteractiveExample("pages/js/function-length.html")}}
+ + + +
{{js_property_attributes(0,0,1)}}
+ +

Beschreibung

+ +

length ist eine Eigenschaft eines Funktionsobjekts und zeigt an, wie viele Argumente die Funktion erwartet, d.h. die Anzahl der formalen Parameter. Diese Anzahl beinhaltet jedoch nicht den {{jsxref("rest_parameters", "rest Parameter", "", 1)}} und bezieht außerdem auch nur die Parameter ein, die in der Reihenfolge vor dem ersten Parameter mit einem Default-Wert sind. Im Gegensatz dazu ist {{jsxref("Functions/arguments/length", "arguments.length")}} eine in jeder Funktion verfügbare lokale Variable, die die tatsächliche Anzahl der übergebenen Argumente angibt.

+ +

Dateneigenschaft des Function Konstruktors

+ +

Der {{jsxref("Global_Objects/Function", "Function")}} Konstruktor ist selbst ein {{jsxref("Global_Objects/Function", "Function")}} Objekt. Seine Eigenschaft length hat den Wert 1. Dessen Attribute lauten: Writable: false, Enumerable: false, Configurable: true.

+ +

Eigenschaft des Function prototype Objekt

+ +

Die length-Eigenschaft des {{jsxref("Global_Objects/Function", "Function")}} prototype Objekts hat den Wert 0.

+ +

Beispiele

+ +
console.log(Function.length); /* 1 */
+
+console.log((function()        {}).length); /* 0 */
+console.log((function(a)       {}).length); /* 1 */
+console.log((function(a, b)    {}).length); /* 2 etc. */
+
+console.log((function(...args) {}).length);
+// 0, rest parameter wird nicht gezählt
+
+console.log((function(a, b = 1, c) {}).length);
+// 1, nur Parameter vor dem ersten Parameter mit
+// einem Default-Wert werden gezählt
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.3.5.1', 'Function.length')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-function-instances-length', 'Function.length')}}{{Spec2('ES6')}}Das configurable Attribut dieser Eigenschaft ist nun true.
{{SpecName('ESDraft', '#sec-function-instances-length', 'Function.length')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.Function.length")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/function/name/index.html b/files/de/web/javascript/reference/global_objects/function/name/index.html new file mode 100644 index 0000000000..29a3903d56 --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/name/index.html @@ -0,0 +1,229 @@ +--- +title: Function.name +slug: Web/JavaScript/Reference/Global_Objects/Function/name +tags: + - ECMAScript 2015 + - Function + - JavaScript + - Property +translation_of: Web/JavaScript/Reference/Global_Objects/Function/name +--- +
{{JSRef}}
+ +

Die nur lesende Eigenschaft name eines {{jsxref("Function")}} Objektes welche den Namen, der beim erstellen angegeben wurde enthält oder "anonymous" für anonyme Funktionen.

+ +
{{EmbedInteractiveExample("pages/js/function-name.html")}}
+ + + +
{{js_property_attributes(0,0,1)}}
+ +
 
+ +
+

Zu beachten ist, dass in nicht standardisierten implementierungen vor ES2015 das configurable Attribute ebenfalls false ist.

+
+ +

Beispiele

+ +

Name bei Funktionsanweisungen

+ +

Die name Eigenschaft gibt den Namen einer Funktionsanweisung:

+ +
function doSomething() {}
+doSomething.name; // logs "doSomething"
+
+ +

Name bei Function Konstruktoren

+ +

Funktionen, die mit der Syntax new Function(...) oder nur Function(...) erstellt werden, erstellen {{jsxref("Function")}}  mit dem Namen "anonymous".

+ +
(new Function).name; // "anonymous"
+
+ +

Gefolgerte Funktionsnamen

+ +

Bei Variablen und Methoden kann der Name von anonymen Funktionen von ihrer syntaktischen Position gefolgert werden (neu in ECMAScript 2015).

+ +
var f = function() {};
+var object = {
+  someMethod: function() {}
+};
+
+console.log(f.name); // "f"
+console.log(object.someMethod.name); // "someMethod"
+
+ +

Funktionen mit einem Namen lassen sich mittels {{jsxref("Operators/Function", "Funktionanweisung", "", 1)}} definieren:

+ +
var object = {
+  someMethod: function object_someMethod() {}
+};
+console.log(object.someMethod.name); // logs "object_someMethod"
+
+try { object_someMethod } catch(e) { console.log(e); }
+// ReferenceError: object_someMethod is not defined
+
+ +

Man kann den Namen einer Funktion nicht ändern, weil diese Eigenschaft schreibgeschützt ist:

+ + + +
var object = {
+  // anonyme Funktionsdefinition
+  someMethod: function() {}
+};
+
+object.someMethod.name = 'someMethod';
+console.log(object.someMethod.name); // leerer String, someMethod ist anonym
+
+ +

Um sie zu ändern, kann {{jsxref("Object.defineProperty()")}} eingesetzt werden.

+ +

Kurzform von Methodennamen

+ +
var o = {
+  foo(){}
+};
+o.foo.name; // "foo";
+
+ +

Gebundene Funktionsnamen

+ +

{{jsxref("Function.bind()")}} erzeugt eine Funktion mit dem Namen, der sich aus "bound " und dem Namen der Funktion zusammensetzt.

+ +
function foo() {};
+foo.bind({}).name; // "bound foo"
+ +

Funktionsnamen für Getter und Setter

+ +

Beim Einsatz von get und set Zugriffseigenschaften wird "get" oder "set" im Funktionsnamen auftauchen.

+ +
var o = {
+  get foo(){},
+  set foo(x){}
+};
+
+var descriptor = Object.getOwnPropertyDescriptor(o, "foo");
+descriptor.get.name; // "get foo"
+descriptor.set.name; // "set foo"
+
+ +

Funktionsnamen in Klassen

+ +

Über obj.constructor.name lässt sich die "Klasse" eines Objekts überprüfen (jedoch sollten die unten stehende Warnung berücksichtigt werden):

+ +
function Foo() {}  // ES2015 Syntax: class Foo {}
+
+var fooInstance = new Foo();
+console.log(fooInstance.constructor.name); // logs "Foo"
+
+ +
+

Warnung: Der Skriptinterpreter wird die eingebaute Function.name Eigenschaft nur setzen, wenn eine Funktion keine eigene Eigenschaft mit dem Namen name hat (siehe Kapitel 9.2.11 der ECMAScript2015 Sprachdefinition). Jedoch spezifiziert ES2015 das static Schlüsselwort so, dass statische Methoden als eigene Eigenschaft des Klassenkonstruktorfunktion gesetzt wird (ECMAScript2015, 14.5.14.21.b + 12.2.6.9).

+
+ +

Aus diesem Grund kann der Klassenname für jede Klasse mit einer statischen Methodeneigenschaft name() nicht bestimmt werden:

+ +
class Foo {
+  constructor() {}
+  static name() {}
+}
+
+ +

Mit einer static name() Methode hält Foo.name nicht mehr den aktuellen Klassennamen bereit, sondern eine Referenz zu dem name() Funktionsobjekt. Die oben stehende Klassendefinition in ES2015 Syntax kann in ES5 Syntax für Chrome oder Firefox wie folgt übersetzt werden:

+ +
function Foo() {}
+Object.defineProperty(Foo, 'name', { writable: true});
+Foo.name = function() {};
+
+ +

Beim Versuch die Klasse von fooInstance mithilfe von fooInstance.constructor.name herauszufinden, bekommt man nicht den Klassennamen, sondern eine Referenz auf die statische Methode. Beispiel:

+ +
var fooInstance = new Foo();
+console.log(fooInstance.constructor.name); // logs function name()
+
+ +

Man sieht zudem in der Beispiel  der ES5 Syntax für Chrome und Firefox, dass die Definition der statischen Foo.name Methode überschreibbar (writable) wird. Wird nicht angegeben, ist der Standard für solche Definition nur lesend (read-only).

+ +
Foo.name = 'Hello'
+console.log(Foo.name); // logs "Hello" if class Foo has a static name() property but "Foo" if not.
+
+ +

Aus diesem Grund darf man sich nicht darauf verlassen, dass Function.name immer den Klassennamen zurück gibt.

+ +

Symbols als Funktionsnamen

+ +

Wenn ein {{jsxref("Symbol")}} als Funktionsnamen genutzt wird und das Symbol eine Beschreibung (description) hat, ist der Methodennamen gleich der Beschreibung in eckigen Klammern.

+ +
var sym1 = Symbol("foo");
+var sym2 = Symbol();
+bar o = {
+  [sym1]: function(){},
+  [sym2]: function(){}
+};
+
+o[sym1].name; // "[foo]"
+o[sym2].name; // ""
+
+ +

JavaScript-Kompressoren und -Minimierer

+ +
+

Warnung: Beim der Benutzung von Function.name ist Vorsicht geboten, wenn Codetransformtionen, wie JavaScript Kompressoren (Minimierer) oder Obfuscators, zum Einsatz kommen. Diese Werkzeuge werden häufig im Zuge von Werkzeugketten zum Bauen von JavaScript-Programmen eingesetzt um die Größe eines Programms zu für den Produktivbetrieb zu minimieren. Solche Werkzeuge ändern die Funktionsnamen häufig beim Erstellen.

+
+ +

Quelltext wie dieser:

+ +
function Foo() {};
+var foo = new Foo();
+
+if (foo.constructor.name === 'Foo') {
+  console.log("'foo' is an instance of 'Foo'");
+} else {
+  console.log('Oops!');
+}
+
+ +

wird manchmal zu folgendem Quelltext komprimiert:

+ +
function a() {};
+var b = new a();
+if (b.constructor.name === 'Foo') {
+  console.log("'foo' is an instance of 'Foo'");
+} else {
+  console.log('Oops!');
+}
+
+ +

In der nicht komprimierten Version läuft das Programm in den true-Zweig und gibt 'foo' is an instance of 'Foo' aus. Die komprimierte Version verhält sich anders und läuft in den else-Zweig. Wenn man sich Function.name zurückerinnert, wie in obigen Beispielen, muss beachtet werden, dass Kompressoren die Methodennamen nicht ändert oder nicht annimmt, dass eine Funktion nur in diesem Quelltext benutzt.

+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES2015', '#sec-name', 'name')}}{{Spec2('ES2015')}}Initiale Definition.
{{SpecName('ESDraft', '#sec-function-instances-name', 'name')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +
+ +{{Compat("javascript.builtins.Function.name")}}
diff --git a/files/de/web/javascript/reference/global_objects/function/prototype/index.html b/files/de/web/javascript/reference/global_objects/function/prototype/index.html new file mode 100644 index 0000000000..afb602971c --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/prototype/index.html @@ -0,0 +1,99 @@ +--- +title: Function.prototype +slug: Web/JavaScript/Reference/Global_Objects/Function/prototype +tags: + - Function + - JavaScript + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Function +--- +
{{JSRef}}
+ +

Die Function.prototype Eigenschaft repräsentiert das {{jsxref("Function")}} Prototyp Objekt.

+ +

Beschreibung

+ +

{{jsxref("Function")}} Objekte erben von Function.prototype.  Function.prototype kann nicht modifiziert werden.

+ +

Eigenschaften

+ +
+
{{jsxref("Function.arguments")}} {{deprecated_inline}}
+
Ein Array, welches die der Funktion übergebenen Parameter enthält. Dieses ist veraltet als Eigenschaft von {{jsxref("Function")}}. Stattdessen sollte das {{jsxref("Functions/arguments", "arguments")}} Objekt in einer Funktion benutzt werden
+
{{jsxref("Function.arity")}} {{obsolete_inline}}
+
Wurde benutzt, um die Anzahl der erwarteten Argumente einer Funktion einzustellen, ist jedoch entfernt. Stattdessen kann die {{jsxref("Function.length", "length")}} Eigenschaft genutzt werden.
+
{{jsxref("Function.caller")}} {{non-standard_inline}}
+
Spezifizert die Funktion, die die aktuelle Funktion aufgerufen hat.
+
{{jsxref("Function.length")}}
+
Spezifizert die Anzahl der Parameter, die eine Funktion erwartet.
+
{{jsxref("Function.name")}}
+
Der Name einer Funktion.
+
{{jsxref("Function.displayName")}} {{non-standard_inline}}
+
Der angezeigte Name einer Funktion.
+
Function.prototype.constructor
+
Spezifiziert die Funktion, die ein Objekt Prototyp erstellt. Mehr Informationen bei {{jsxref("Object.prototype.constructor")}}.
+
+ +

Methoden

+ +
+
{{jsxref("Function.prototype.apply()")}}
+
Führt eine Funktion aus und setzt das this Objekt mit einem übergebenen wert. Parameter können in einem {{jsxref("Array")}} Objekt übergeben werden.
+
{{jsxref("Function.prototype.bind()")}}
+
Erstellt eine neue Funktion, die beim Aufruf einen angegebenen Wert für this hat, wobei die Argumentfolge vor dem Aufruf der neuen Funktion fest steht.
+
{{jsxref("Function.prototype.call()")}}
+
Führt eine Funktion aus und setzt this auf einen übergebenen Wert. Parameter können übergeben werden.
+
{{jsxref("Function.prototype.isGenerator()")}} {{non-standard_inline}}
+
Gibt true zurück, wenn die Funktion ein Generator ist, anderfalls false.
+
{{jsxref("Function.prototype.toSource()")}} {{non-standard_inline}}
+
Gibt eine Stringrepräsentation des Quelltextes einer Funktion zurück. Sie überschreibt die {{jsxref("Object.prototype.toSource")}} Methode.
+
{{jsxref("Function.prototype.toString()")}}
+
Gibt eine Stringrepräsentation des Quelltextes einer Funktion zurück. Sie überschreibt die {{jsxref("Object.prototype.toString")}} Methode.
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.1
{{SpecName('ES5.1', '#sec-15.3.5.2', 'Function.prototype')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-function-instances-prototype', 'Function.prototype')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-function-instances-prototype', 'Function.prototype')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.Function.prototype")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/function/tosource/index.html b/files/de/web/javascript/reference/global_objects/function/tosource/index.html new file mode 100644 index 0000000000..75552bdc8c --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/tosource/index.html @@ -0,0 +1,72 @@ +--- +title: Function.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Function/toSource +tags: + - Function + - JavaScript + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Function/toSource +--- +
{{JSRef}} {{non-standard_header}}
+ +

Die toSource() Methode gibt eine Stringrepräsentation des Quelltextes des Objektes zurück.

+ +

Syntax

+ +
function.toSource();
+Function.toSource();
+
+ +

Rückgabewert

+ +

Eine Stringrepräsentation des Quelltextes des Objektes.

+ +

Beschreibung

+ +

Die toSource Methode gibt die folgenden Werte zurück:

+ + + +

Die Methode wird normalerweise von JavaScript selbst aufgerufen und nicht explizit im Quelltext. Man kann toSource während des Debuggens aufrufen, um zu ermitteln, was ein Objekt enthält.

+ +

Spezifikationen

+ +

Ist in keinem Standard. Implementiert in JavaScript 1.3.

+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.Function.toSource")}}

+
+ +

Siehe auch

+ + diff --git a/files/de/web/javascript/reference/global_objects/function/tostring/index.html b/files/de/web/javascript/reference/global_objects/function/tostring/index.html new file mode 100644 index 0000000000..5b3978809e --- /dev/null +++ b/files/de/web/javascript/reference/global_objects/function/tostring/index.html @@ -0,0 +1,236 @@ +--- +title: Function.prototype.toString() +slug: Web/JavaScript/Reference/Global_Objects/Function/toString +tags: + - Function + - JavaScript + - Method + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Function/toString +--- +
{{JSRef}}
+ +

Die toString() Methode gibt eine Stringrepräsentation des Quelltextes einer Funktion zurück.

+ +
{{EmbedInteractiveExample("pages/js/function-tostring.html")}}
+ + + +

Syntax

+ +
function.toString()
+ +

Rückgabewert

+ +

Eine Stringrepräsentation des Quelltextes der Funktion.

+ +

Beschreibung

+ +

Das {{jsxref("Function")}} Objekt überschreibt die von {{jsxref("Object")}} geerbte Methode {{jsxref("Object.prototype.toString", "toString")}}; sie erbt nicht von {{jsxref("Object.prototype.toString")}}. Für benutzerdefinierte {{jsxref("Function")}} Objekte gibt die toString Methode einen String zurück, welcher den Quelltext, der die Funktion definiert, enthält.

+ +

JavaScript ruft die toString Methode automatisch auf, wenn einen {{jsxref("Function")}} als Text repräsentiert werden muss, z. B. wenn eine Funktion mit einem String konkateniert wird.

+ +

Die toString() Methode erzeugt eine {{jsxref("TypeError")}} Fehler("Function.prototype.toString called on incompatible object"), wenn das Objekt von this Objekt kein Function Objekt ist. Dieser wird auch bei einem {{jsxref("Proxy")}} Objekte erzeugt, zum Beispiel:

+ +
Function.prototype.toString.call('foo'); // TypeError
+
+var proxy = new Proxy(function() {}, {});
+Function.prototype.toString.call(proxy); // TypeError
+
+ +

Wenn die toString() Methode auf eingebauten Objekten oder einer von Function.prototype.bind erstellten Methode aufgerufen wird, gibt toString() native function string zurück, was wie folgt aussiet:

+ +
"function () {\n    [native code]\n}"
+
+ +

Wenn die toString() Methode auf einer Funktion aufgerufen wird, die mit dem Function Konstruktor erstellt wurde, gibt diese den Quelltext der syntetischen Funktionsdeklerations mit dem Namen "anonymous" zurück, welche die Parameter und den Funktionrumpf enthält.

+ +

Beispiele

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FunktionErgebnis von Function.prototype.toString
+ 
+function f(){}
+ 		+ 
+"function f(){}"
+
+ 
+class A { a(){} }
+ 		+ 
+"class A { a(){} }"
+
+ 
+function* g(){}
+ 		+ 
+"function* g(){}"
+
+ 
+a => a
+ 		+ 
+"a => a"
+
+ 
+({ a(){} }.a)
+ 		+ 
+"a(){}"
+
+ 
+({ *a(){} }.a)
+ 		+ 
+"*a(){}"
+
+ 
+({ [0](){} }[0])
+ 		+ 
+"[0](){}"
+
+ 
+Object.getOwnPropertyDescriptor({
+    get a(){}
+}, "a").get
+ 		+ 
+"get a(){}"
+
+ 
+Object.getOwnPropertyDescriptor({
+    set a(x){}
+}, "a").set
+ 		+ 
+"set a(x){}"
+
+ 
+Function.prototype.toString
+ 		+ 
+"function toString() { [native code] }"
+
+ 
+(function f(){}.bind(0))
+ 		+ 
+"function () { [native code] }"
+
+ 
+Function("a", "b")
+ 		+ 
+"function anonymous(a\n) {\nb\n}"
+
+ +

Spezifikationen

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpezifikationStatusKommentar
{{SpecName('ES1')}}{{Spec2('ES1')}}Initiale Definition. Implementiert in JavaScript 1.1.
{{SpecName('ES6', '#sec-function.prototype.tostring', 'Function.prototype.toString')}}{{Spec2('ES6')}}Spezifischere Anforderungen wurden an die Stringrepräsentation hinzugefügt.
Function.prototype.toString revisionDraftStandardisierung nativer Funktionsstrings am Zeilenende.
{{SpecName('ESDraft', '#sec-function.prototype.tostring', 'Function.prototype.toString')}}{{Spec2('ESDraft')}} 
+ +

Browserkompatibilität

+ +
+ + +

{{Compat("javascript.builtins.Function.toString")}}

+
+ +

Firefox spezifische Hinweise

+ + + +

Siehe auch

+ + -- cgit v1.2.3-54-g00ecf