JavaScript-Funktionen unterscheiden sich von anderen Sprachen. Jede Funktion wird als Objekt verwaltet und ausgeführt. Über die Eigenschaften von Funktionsobjekten können Sie ganz einfach einer Variablen eine Funktion zuweisen oder die Funktion als Parameter übergeben. Bevor wir fortfahren, werfen wir einen Blick auf die Syntax der Verwendung von Funktionen:
Hier ein Zitat:
Funktion func1(…){…}
var func2=function(…){…};
var func3=function func4(…){…};
var func5=new Function();
Kopieren Sie den Codecode wie folgt:
<script type="text/javascript">
// 1, Methodenaufrufmodus
// Wenn eine Funktion als Eigenschaft eines Objekts gespeichert wird, nennen wir sie eine Methode des Objekts, dann wird diese an das Objekt gebunden
var myObject={
Name: „meinObjekt“,
Wert: 0,
inkrementieren: function(num){
this.value += typeof(num) === 'number' : 0;
gib dies zurück;
} ,
toString: function(){
return '[Object:' + this.name + ' {value:' + this.value + '}]';
}
}
Alert(myObject.increment(10).increment(20).toString()); // [Object:myObject {value:30}]
// 2, Funktionsaufrufmodus
// Wenn eine Funktion keine Funktion eines Objekts ist, wird sie als Funktion aufgerufen und an das globale Objekt gebunden. Dies ist ein Fehler im Sprachdesign. Wenn das Sprachdesign korrekt ist, sollte die innere Funktion beim Aufruf immer noch an die Variable this der äußeren Funktion gebunden sein.
var myObject={
Name: „meinObjekt“,
Wert: 0,
inkrementieren: function(num){
this.value += typeof(num) === 'number' : 0;
gib dies zurück;
} ,
toString: function(){
return '[Object:' + this.name + ' {value:' + this.value + '}]';
},
getInfo: function(){
var self=this;
return (function(){
//return this.toString(); // Dies zeigt in der internen anonymen Funktion auf das globale Objektfenster und gibt [Objektfenster] aus
return self.toString(); // Definieren Sie eine Variable selft und weisen Sie ihr den Wert this zu, dann kann die interne Funktion über diese Variable auf das Objekt zugreifen
})();
}
}
Alert(myObject.increment(10).increment(20).toString()); // [Object:myObject {value:30}]
// 3, Konstruktor-Aufrufmodus
// JavaScript ist eine Sprache, die auf prototypischer Vererbung basiert, was bedeutet, dass Objekte Eigenschaften direkt von anderen Objekten erben können und die Sprache klassenlos ist.
// Wenn eine Funktion mit new am Anfang aufgerufen wird, wird ein neues Objekt erstellt, das den mit der Funktion verbundenen Prototyp-Member verbirgt, und dieser wird an die Instanz des Konstruktors gebunden.
Funktion MyObject(name){
this.name = name ||. 'MyObject';
this.value=0;
this.increment = function(num){
this.value += typeof(num) === 'number' : 0;
};
this.toString = function(){
return '[Object:' + this.name + ' {value:' + this.value + '}]';
}
this.target = this;
}
MyObject.prototype.getInfo = function(){
return this.toString();
}
// Erstelle gleichzeitig ein MyObject.prototype-Objekt, das alle Eigenschaften von MyObject.prototype erbt.
var myObject = new MyObject();
myObject.increment(10);
alarm(myObject.value); //10
var otherObject = new MyObject();
otherObject.increment(20);
alarm(otherObject.value); //20
Alert(myObject.target===myObject); // true
Alert(myObject.target.getInfo()); // [Object:MyObject {value:10}]
// 4, Aufrufmodus anwenden
// JavaScript ist eine funktionale objektorientierte Programmiersprache, daher können Funktionen Methoden haben. Die Apply-Methode der Funktion ist so, als ob das Objekt diese Methode hätte, und diese zeigt auf das Objekt.
// apply empfängt zwei Parameter, der erste ist das zu bindende Objekt (das Objekt, auf das dies zeigt) und der zweite ist das Parameterarray.
Funktion MyObject(name){
this.name = name ||. 'MyObject';
this.value = 0;
this.increment = function(num){
this.value += typeof(num) === 'number' : 0;
};
this.toString=function(){
return '[Object:'+this.name+' {value:'+this.value+'}]';
}
this.target=this;
}
Funktion getInfo(){
return this.toString();
}
var myObj = new MyObject();
Alert(getInfo.apply(myObj)); //[Object:MyObject {value:0}], dies zeigt auf myObj
warning(getInfo.apply(window)); //[object Window], dies zeigt auf window
// für und während
Funktion func(a,b){
alarm(a); // 1
alarm(b); // 2
for(var i=0;i<arguments.length;i++){
alarm(arguments[i]); // 1, 2, 1, 2, 3
}
var i=0;
while(i<arguments.length){
alarm(arguments[i]); // 1, 2, 1, 2, 3
i=i+1;
}
}
func(1,2,3);
var i=0
für (i=0;i<=10;i++) {
document.write("Die Zahl ist " + i + "<br/>")
}
</script>