Die Anleitung zu ECMAScript Function
View more Tutorials:


In ECMAScript ist eine Funktion ein Sub-Programm. Es fasst die Commands zur Durchführung einer Aufgabe um. Und wenn Sie in irgendwo in die Applikation eine solche Aufgabe tun möchten, brauchen Sie nur diese Funktion aufrufen. Die Funktion hilft Ihnen bei der Unterhaltung der Applikation und bei der einfachen Wieder-verwendung der Kode.
function function_name() {
// function body
}
// Define a function:
function greeting() {
console.log("Hello World!");
}
// Call function.
greeting();
Hello World!
function function_name(parameter1, parameter2, .., parameterN) {
// Function body
// return ....
}
- Einen Schlüsselwort function benutzen um eine Funktion zu definieren
- Die Funktion kann 0 oder viele Parameter haben
- Die Funktion gibt immer eine Wert zurück. Wenn diese Wert nicht bestimmt wird, wird sie underfined zurückgeben. Um eine Wert zurückzugeben, benutzen wir den Schlüsselwort return.
function calculateTax(salary) {
if(salary >= 1000) {
// The function will end here
return salary * 20 / 100;
}
if(salary >= 500) {
// The function will end here
return salary * 10 / 100;
}
return 0;
}
let tax = calculateTax(2000);
console.log("Salary: 2000, tax: " + tax);
tax = calculateTax(800);
console.log("Salary: 800, tax: " + tax);
tax = calculateTax(300);
console.log("Salary: 300, tax: " + tax);
Salary: 2000, tax: 400
Salary: 800, tax: 80
Salary: 300, tax: 0
function add(a, b = 1) {
return a+b;
}
// Test
let value = add(2, 3);
console.log(value); // 5
// Test
value = add(9);
console.log(value); // 10
function calculateTax(salary = 1000, rate = 0.2) {
return salary * rate;
}
// Test
console.log (calculateTax() ) ; // 1000 * 0.2 = 200
console.log (calculateTax(2000) ) ; // 2000 * 0.2 = 400
console.log (calculateTax(3000, 0.5) ) ; // 3000 * 0.5 = 1500
console.log (calculateTax(undefined, 0.5) ) ; // 1000 * 0.5 = 500
Die Eigenschaften des Parameter Varargs:
- Wenn eine Funktion den Parameter Varargs hat, muss dieser Parameter den letzen Parameter der Funktion sein.
- Eine Funktion hat einen Parameter Varargs am meisten.
function myFunction(param1, param2, ... paramVarargs) {
}
function showInfo(name, ... points) {
console.log("------------ ");
console.log("Name: " + name);
console.log("Array length: "+ points.length);
for(let i=0; i< points.length; i++) {
console.log( points[i] );
}
}
showInfo("Tom", 52, 82, 93);
showInfo("Jerry", 10, 50);
showInfo("Donald");
------------
Name: Tom
Array length: 3
52
82
93
------------
Name: Jerry
Array length: 2
10
50
------------
Name: Donald
Array length: 0
var myVar = function( parameters ) {
// ....
}
// Function expression
var f = function(name){
return "Hello " + name;
}
// Call it.
var value = f("Tom");
console.log( value ); // Hello Tom.
// Create anonymous function and call immediately
(function() {
var now = new Date();
console.log("Now is " + now);
}) () ;
// Create anonymous function and call immediately
(function(name) {
console.log("Hello " + name);
}) ("Tom") ;
Now is Mon Nov 05 2018 00:44:47 GMT+0700 (SE Asia Standard Time)
Hello Tom
var variableName = new Function(paramName1, paramName2, ..., paramNameN, "Function Body");
var myMultiple = new Function( "x", "y", "return x * y");
console.log( myMultiple (3, 4) ); // 12
function showTotal() {
let quantity = 4;
let price = 5;
console.log("Total: " + myMultiple(quantity, price) );
}
showTotal();
12
Total: 20

// Anonymous Function
var func = function(a, b) {
return a * b;
}
// Arrow function
var func = (a, b) => {
return a * b;
}
console.log( func( 5, 6 ) ); // 30
Wenn die Funktion keinen Parameter hat :
// Function without parameter.
var func = () => {
console.log("Hello World");
}
console.log( func( ) ); // Hello World
// Function with one parameter.
var func = name => {
console.log("Hello " + name);
}
console.log( func( "Tom" ) ); // Hello Tom
Wenn der Körper der Funktion einen einzigen Ausdruck hat, können Sie die eckigen Klammern (brackets) { } nicht schreiben und den Schlüsselwort return (wenn ja) entfernen:
// Body has only one expression.
var func = (name) => {
console.log("Hello " + name)
}
// Body has only one expression.
var func = (name) => console.log("Hello " + name);
// Body has only one expression.
var func = (a, b) => {
return a * b;
}
// Body has only one expression.
var func = (a, b) => a * b;
var func = (name) => {
console.log("Hello " + name);
}
// Shortest:
var func = name => console.log("Hello " + name);
Generator Function ist eine neue Funktion, die in ECMAScript 6 (ES6) gegeben wird. Um eine Generator Function anzumelden, benutzen wir den Schlüsselwort function*.
function* functionName( param1, param2, ..., paramN) {
// Statements
}

function* season() {
yield "Spring";
yield "Summer";
yield "Autumn";
yield "Winter";
}
// This method return an Iterator.
var seasonIterator = season();
let value1 = seasonIterator.next().value;
console.log(value1); // Spring
let value2 = seasonIterator.next().value;
console.log(value2); // Summer
let value3 = seasonIterator.next().value;
console.log(value3); // Autumn
let value4 = seasonIterator.next().value;
console.log(value4); // Winter
function* season() {
yield "Spring";
yield "Summer";
yield "Autumn";
yield "Winter";
}
// This method return an Iterator.
var seasonIterator = season();
let e;
while( !(e = seasonIterator.next()).done ) {
console.log(e.value);
}
function* season() {
console.log("Do something in Spring");
yield "Spring";// Spring Stop here!
console.log("Do something in Summer");
yield "Summer";// Summer Stop here!
console.log("Do something in Autumn");
yield "Autumn";// Autumn Stop here!
console.log("Do something in Winter");
yield "Winter";// Winter Stop here!
}
// This method returns an Iterator.
var seasonIterator = season();
let e;
while( !(e = seasonIterator.next()).done ) {
console.log(e.value);
if(e.value === "Autumn") {
console.log("OK Stop after Autumn");
break;
}
}
Do something in Spring
Spring
Do something in Summer
Summer
Do something in Autumn
Autumn
OK Stop after Autumn