A JavaScript függvény egy kódblokk, amely a adott feladat.
A JavaScript függvény akkor fut le, amikor "valami" hívja (nevezi).
// Function to compute the product of p1 and p2
function myFunction(p1, p2) {
return p1 * p2;
}Próbálja ki Ön is →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Functions</h1>
<p>Call a function which performs a calculation and returns the result:</p>
<p id="demo"></p>
<script>
function myFunction(p1, p2) {
return p1 * p2;
}
let result = myFunction(4, 3);
document.getElementById("demo").innerHTML = result;
</script>
</body>
</html>
A JavaScript függvényt a function kulcsszó határozza meg, ezt követi a név, majd a zárójelek ().
A függvénynevek tartalmazhatnak betűket, számjegyeket, aláhúzásjeleket és dollárjeleket (ugyanazok a szabályok, mint a változókra).
A zárójelek paraméterneveket tartalmazhatnak vesszővel elválasztva:
(paraméter1, paraméter2, ...)
A függvény által végrehajtandó kód zárójelek között van: {}
function
name(parameter1, parameter2, parameter3) {
// code to be executed
}A függvény paraméterei zárójelben() találhatók a függvény meghatározása.
Az argumentumok az értékek a függvény fogadja, amikor meghívásra kerül.
A függvényen belül az argumentumok (a paraméterek) helyi változóként viselkednek.
A függvényen belüli kód akkor fut le, amikor "valami" meghívja (meghívja) a funkció:
Amikor egy esemény bekövetkezik (amikor a felhasználó rákattint egy gombra)
Amikor meghívják (meghívják) JavaScript kódból
Automatikusan (önhívó)
A későbbiekben még sok mindent megtudhat a függvényhívásokról oktatóanyag.
Amikor a JavaScript elér egy return utasítást, a függvény végrehajtása leáll.
Ha a függvényt utasításból hívták meg, a JavaScript megteszi "return" a kód végrehajtásához a meghívó utasítás után.
A függvények gyakran visszatérési értéket számítanak ki. A visszatérési érték a "visszatért". a hívó":
Számítsa ki két szám szorzatát, és adja vissza az eredményt:
// Function is called, the return value will end up in x
let x = myFunction(4, 3);
function myFunction(a, b) {
// Function returns the product of a and b
return a * b;
}Próbálja ki Ön is →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Functions</h1>
<p>Call a function which performs a calculation and returns the result:</p>
<p id="demo"></p>
<script>
let x = myFunction(4, 3);
document.getElementById("demo").innerHTML = x;
function myFunction(a, b) {
return a * b;
}
</script>
</body>
</html>
A funkciókkal újra felhasználhatja a kódot
Sokszor használható kódot írhat.
Ugyanazt a kódot különböző argumentumokkal használhatja különböző eredmények eléréséhez.
A() operátor meghívja (meghívja) a függvényt:
Fahrenheit átváltása Celsius fokra:
function toCelsius(fahrenheit) {
return (5/9) * (fahrenheit-32);
}
let value = toCelsius(77);Próbálja ki Ön is →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Functions</h1>
<p>Invoke (call) a function that converts from Fahrenheit to Celsius:</p>
<p id="demo"></p>
<script>
function toCelsius(f) {
return (5/9) * (f-32);
}
let value = toCelsius(77);
document.getElementById("demo").innerHTML = value;
</script>
</body>
</html>
A hibás paraméterekkel rendelkező függvény elérése helytelen választ adhat vissza:
function toCelsius(fahrenheit) {
return (5/9) * (fahrenheit-32);
}
let value = toCelsius();Próbálja ki Ön is →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Functions</h1>
<p>Invoke (call) a function to convert from Fahrenheit to Celsius:</p>
<p id="demo"></p>
<script>
function toCelsius(f) {
return (5/9) * (f-32);
}
let value = toCelsius();
document.getElementById("demo").innerHTML = value;
</script>
</body>
</html>
Egy függvény elérése() nélkül a függvényt adja vissza, és nem a függvény eredményét:
function toCelsius(fahrenheit) {
return (5/9) * (fahrenheit-32);
}
let value = toCelsius;Próbálja ki Ön is →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Functions</h1>
<p>Accessing a function without () returns the function and not the function result:</p>
<p id="demo"></p>
<script>
function toCelsius(f) {
return (5/9) * (f-32);
}
let value = toCelsius;
document.getElementById("demo").innerHTML = value;
</script>
</body>
</html>
Amint a fenti példákból látható, a toCelsius a függvényobjektumra utal, és A toCelsius() a függvény eredményére utal.
A függvények ugyanúgy használhatók, mint a változók, minden típusú képletben, hozzárendelésben és számításokat.
Ahelyett, hogy változót használna egy függvény visszatérési értékének tárolására:
let x = toCelsius(77);
let text = "The temperature is " + x + " Celsius";A függvényt közvetlenül használhatja változó értékként:
let text = "The temperature is " + toCelsius(77) + " Celsius";Próbálja ki Ön is →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Functions</h1>
<p>Using a function as a variable:</p>
<p id="demo"></p>
<script>
let text = "The temperature is " + toCelsius(77) + " Celsius.";
document.getElementById("demo").innerHTML = text;
function toCelsius(fahrenheit) {
return (5/9) * (fahrenheit-32);
}
</script>
</body>
</html>
Az oktatóanyag későbbi részében még sok mindent megtudhat a funkciókról.
A JavaScript-függvényen belül deklarált változók lesz HELYIre a funkció.
Csak a helyi változók érhetők el a funkción belülről.
// code here can NOT use carName
function myFunction() {
let carName = "Volvo";
// code here CAN use carName
}
// code here can NOT use carNamePróbálja ki Ön is →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Functions</h1>
<p>Outside myFunction() carName is undefined.</p>
<p id="demo1"></p>
<p id="demo2"></p>
<script>
let text = "Outside: " + typeof carName;
document.getElementById("demo1").innerHTML = text;
function myFunction() {
let carName = "Volvo";
let text = "Inside: " + typeof carName + " " + carName;
document.getElementById("demo2").innerHTML = text;
}
myFunction();
</script>
</body>
</html>
Mivel a lokális változókat csak a függvényeiken belül ismeri fel a rendszer, az azonos nevű változók különböző függvényekben használhatók.
A helyi változók a függvény indításakor jönnek létre, és a függvény befejezésekor törlődnek.