פונקציות, רקורסיה, סקופינג

שימוש בפונקציות בג'אווה סקריפט

פונקציה היא קטע קוד בעל שם מסויים, שמוגדר פעם אחת ושניתן להפעילו באמצעות "קריאה". הגדרת הפונקציה נעשית באמצעות המילה השמורה function.

פונקציה יכולה לקבל פרמטרים (אך לא חייבת), שהם ערכים כלשהם שישמשו פנימית בריצת הפונקציה. הערכים המוזנים כפרמטרים, מכונים ארגומנטים.

פונקציה יכולה להחזיר ערך (אך לא חייבת), שניתן (אך אין חובה) להשתמש בו בקוד. החזרת הערך נעשית באמצעות המילה השמורה return.

נהוג לתת לפונקציות בג'אווה סקריפט שמות בקונבנציה דומה לשמות משתנים: התחלה באות קטנה, ובכל מילה שניה ואילך אות גדולה.

דוגמה לשימוש בפונקציה:

<script>
function minTriple(a, b, c) {
	return a < b ? ((a < c) ? a : c) : ((b < c) ? b : c);
}

var m1 = minTriple(56, 62, 17); // 17
var m2 = minTriple(13, 72, 85); // 13
</script>

הגדרנו את הפונקציה minTriple שיש לה 3 פרמטרים: a, b, c. שם הפונקציה מותאם לקונבנציות של ג'אווה סקריפט: המילה הראשונה min מתחילה באות קטנה והמילה השניה Triple מתחילה באות גדולה.

הפונקציה מחזירה את ערך המינימום בין 3 הפרמטרים שהיא מקבלת.

תחילה, אנו קוראים לפונקציה minTriple עם הארגומנטים 56, 62, 17 ועושים השמה של ערך החזרה 17 לתוך המשתנה m1.

לאחר מכן, אנו שוב קוראים לפונקציה minTriple, הפעם עם הארגומנטים 13, 72, 85 ועושים השמה של ערך החזרה 13 לתוך המשתנה m2.

נראה דוגמה נוספת לפונקציה:

<script>
function dumpValues(a) {
	if (!Array.isArray(a)) {
		return false;
	}

	for (var i=0; i<a.length; i++) {
		document.write(a[i] + "<br />");
	}

	return true;
}

var cities = ["Haifa", "Tel Aviv", "Beer Sheva", "Jerusalem", "Afula"];
dumpValues(cities);
</script>

הפונקציה dumpValues מקבלת פרמטר a. אם הוא אינו מערך, היא תחזיר false ותסיים. אם הוא מערך, היא תדפיס את ערכיו על המסך ותחזיר true.

נפעיל את הפונקציה עם הארגומנט cities. נשים לב כי למרות שהפונקציה מחזירה ערך true / false, הפעם לא עשינו שימוש בערך החוזר.

מדוע להשתמש בפונקציות?

השימוש בפונקציות עושה לנו סדר בקוד. הוא מחלק את הקוד לחלקים ברורים שכל אחד מהם מטפל במשהו מסויים.

קל יותר לתחזק קוד שמחולק נכון לפונקציות, מכמה סיבות:

1. הקוד קריא הרבה יותר כשהוא מחולק לפונקציה ולא כתוב ברצף

2. הקוד קצר יותר, כי קטעי קוד שחוזרים על עצמם "נוציא החוצה" ונגדיר פונקציה שמבצעת אותם ובכך נימנע שיכפולי קוד

3. אם יש לנו באג שלא ברור המקור שלו, קל יהיה לאתר אותו ע"י בדיקה כל פעם של פונקציות קטנות מאשר של קוד רציף אחד ארוך

פונקציה רקורסיבית

כל פונקציה יכולה לקרוא לפונקציה אחרת. בפרט, כל פונקציה יכולה גם לקרוא לעצמה.

פונקציה תיקרא רקורסיבית אם מתקיימים 2 תנאים: הפונקציה קוראת לעצמה וקיים תנאי עצירה שמסיים את הקריאות.

דוגמה לפונקציה רקורסיבית:

<script>
function fibonacci(a) {
	if (a == 1 || a == 2) {
		return a;
	}
	return fibonacci(a-2) + fibonacci(a-1);
}

function dumpFibonacci() {
	for (var i=1; i<=20; i++) {
		document.write(fibonacci(i) + "<br />");
	}
}

dumpFibonacci();
</script>

הפונקציה fibonacci היא פונקציה רקורסיבית המחזירה את הערך במקום ה-a של סידרת פיבונאצ'י (פיבונאצ'י היא סידרה שבה כל מספר שווה לסכום 2 המספרים לפניו).

אם a=1 היא תחזיר 1, אם a=2 היא תחזיר 2, ובכל מקרה אחר, היא תחזיר את הסכום של 2 המספרים הקודמים בסידרה.

זוהי פונקציה רקורסיבית כיוון שהיא קוראת לעצמה וכיוון שיש לה תנאי עצירה: אם a=1 או a=2 הפונקציה מסיימת (כלומר מחזירה ערך ללא קריאה נוספת לעצמה).

הפונקציה dumpFibonacci אינה רקורסיבית. זוהי פונקציה שאינה מקבלת פרמטרים ואינה מחזירה כל ערך. הפונקציה הזו מדפיסה את 20 הערכים הראשונים בסידרת פיבונאצ'י. כדי לחשב את הערכים, היא קוראת לפונקציה fibonacci.

סקופינג Scoping

סקופ Scope הוא האזור בקוד שבו משתנה או קבוע שהוגדרו תקפים.

משתנים וקבועים שמוגדרים בפונקציה, משוייכים רק לפונקציה עצמה. בשפה המקצועית נאמר כי "הסקופ של משתנים וקבועים שמוגדרים בפונקציה, הוא הפונקציה".

למעשה, פונקציה היא סוג של קטע קוד חיצוני עצמאי שאינו משפיע ואיזו "מזהם" את הסביבה.

דוגמה להמחשה של סקופינג:

<script>
const a = 1;
var b = 2;
var c = 3;

function foo() {
	const a = 8;
	var b = 9;
	console.log("a=" + a); // a=8
	console.log("b=" + b); // b=9
	console.log("c=" + c); // c=3
}

// before calling the function foo()
console.log("a=" + a); // a=1
console.log("b=" + b); // b=2
console.log("c=" + c); // c=3

// calling the function foo()
foo();

// after calling the function foo()
console.log("a=" + a); // a=1
console.log("b=" + b); // b=2
console.log("c=" + c); // c=3
</script>

דוגמה זו ממחישה כי הקבוע a והמשתנה b שמוגדרים מחוץ לפונקציה (אשר מכונים משתנים גלובאליים) הם אינם הקבוע a והמשתנה b שמוגדרים בתוך הפונקציה (אשר מכונים משתנים לוקאליים).

הסקופ של הקבוע a והמשתנה b שמוגדרים בתוך הפונקציה foo הוא הפונקציה foo, בעוד הסקופ של הקבוע a והמשתנה b הגלובאליים הוא כל הקוד.

המשתנה c הוא משתנה גלובאלי שהסקופ שלו הוא כל הקוד. נשים לב, כי ניתן לעשות בו שימוש בפונקציה foo בלי שום בעיה.

באופן כללי, המלצתנו היא להגדיר כמה שפחות משתנים וקבועים גלובאליים, כיוון שאלו "מזהמים" את הסביבה (הם תקפים בכל הקוד וגם בתוך פונקציות), דבר שעלול להוביל לטעויות בכתיבת הקוד וליצירת באגים.

ככל שניתן, מומלץ להגדיר רק משתנים וקבועים לוקאליים בתוך פונקציות.