הצהרות חזרתיות ב-TypeScript
מאמר זה מסביר את ההצהרות החזרתיות ב-TypeScript.
YouTube Video
הצהרת for ב-TypeScript
הצהרת for ב-TypeScript היא מבנה לולאה בסיסי לביצוע פעולות חוזרות. בלולאת for, ניתן לבצע קטע קוד חוזר שוב ושוב בהתבסס על מספר פעמים או תנאים שצוינו.
תחביר בסיסי
1for (initialization; condition; update) {
2 // Code to execute repeatedly while the condition is true
3}- initialization: זהו החלק שהוצא להורג רק פעם לפני תחילת הלולאה. שינויים ראשוניים כגון לולאה נגד.
- ** "תנאי" ** לקבוע אם הלולאה ממשיכה. אם זה נכון, המשיכו לחדור, ואם שקר, יציאה.
- **עדכון (עודכן) ** לרוץ בסוף כל לולאה ולעדכן את הדלפק.
דוגמה 1: לולאת for בסיסית
בדוגמה למטה, היא מדפיסה את המספרים מ-0 עד 4 בסדר.
1for (let i = 0; i < 5; i++) {
2 console.log("The value of i is: " + i);
3}
4// Outputs:
5// The value of i is: 0
6// The value of i is: 1
7// The value of i is: 2
8// The value of i is: 3
9// The value of i is: 4
דוגמה 2: לולאת for עם מערך
אתם יכולים גם להשתמש בלולאת for כדי לעבד את האלמנטים של מערך בסדר מסוים.
1let fruits: string[] = ["apple", "banana", "cherry"];
2
3for (let i = 0; i < fruits.length; i++) {
4 console.log("Fruit: " + fruits[i]);
5}
6// Outputs:
7// Fruit: apple
8// Fruit: banana
9// Fruit: cherry
דוגמה 3: לולאת for-in
לולאת for-in משמשת לעבור על התכונות של אובייקט או על האינדקסים של מערך בסדר מסוים.
1let car = { brand: "Toyota", model: "Corolla", year: 2020 };
2
3for (let key in car) {
4 console.log(key + ": " + car[key]);
5}
6// Outputs:
7// brand: Toyota
8// model: Corolla
9// year: 2020
דוגמה 4: לולאת for-of
לולאת for-of משמשת לקבל את הערכים של כל אלמנט לפי הסדר מאובייקטים שניתן לעבור עליהם, כמו מערכים או מחרוזות.
1let colors: string[] = ["red", "green", "blue"];
2
3for (let color of colors) {
4 console.log("Color: " + color);
5}
6// Outputs:
7// Color: red
8// Color: green
9// Color: blue
דוגמה 5: לולאת for מקוננת
זה גם אפשרי להשתמש בלולאת for בתוך לולאת for נוספת, מה שקרוי לולאה מקוננת (nested loop). זה מאפשר לכם ליצור לולאות כפולות, בין היתר.
1for (let i = 0; i < 3; i++) {
2 console.log("Outer loop i: " + i);
3 for (let j = 0; j < 2; j++) {
4 console.log(" Inner loop j: " + j);
5 }
6}
7// Outputs:
8// Outer loop i: 0
9// Inner loop j: 0
10// Inner loop j: 1
11// Outer loop i: 1
12// Inner loop j: 0
13// Inner loop j: 1
14// Outer loop i: 2
15// Inner loop j: 0
16// Inner loop j: 1
סיכום
- הצהרת
forמבצעת עיבוד חוזר בהתבסס על ספירות או תנאים שצוינו. for-inמשמשת לשלוף תכונות של אובייקט או את האינדקסים של מערך.for-ofשולפת את הערכים של אלמנטים מתוך אובייקטים שניתן לעבור עליהם, כמו מערכים.- עיבוד חוזר מורכב אפשרי גם באמצעות לולאות
forמקוננות.
פקודת for ב-TypeScript מספקת עיבוד חוזר חזק וגמיש, בדומה ללולאות אחרות.
פקודות while ב-TypeScript
ב-TypeScript, פקודת while היא מבנה לולאה שמבצעת תהליך חוזר כל עוד התנאי שצוין הוא true. בדומה ללולאת for, לולאת while מתאימה למקרים שבהם מספר החזרות אינו ידוע מראש, או כאשר רוצים לשלוט בחזרות על בסיס תנאי.
תחביר בסיסי
1while (condition) {
2 // Code to execute repeatedly while the condition is true
3}- תנאי: התנאי שבמסגרתו הלולאה פועלת. הלולאה נמשכת כל עוד התנאי הזה הוא
true, ונפסקת כאשר הוא נהפך ל-false.
דוגמה 1: לולאת while בסיסית
בדוגמה למטה, הלולאה ממשיכה להציג את הערך של i כל עוד i קטן מ-5.
1let i: number = 0;
2
3while (i < 5) {
4 console.log("The value of i is: " + i);
5 i++;
6}
7// Outputs:
8// The value of i is: 0
9// The value of i is: 1
10// The value of i is: 2
11// The value of i is: 3
12// The value of i is: 4
בדוגמה זו, הלולאה נפסקת כאשר i הופך ל-5 או גדול מכך מכיוון שהתנאי הופך להיות false.
דוגמה 2: דוגמה ללולאה אינסופית
אם התנאי בלולאת while הוא תמיד true, היא יכולה להפוך ללולאה אינסופית. בדרך כלל זה גורם לתוכנית לא להיפסק כמתוכנן, ולכן יש לנקוט בזהירות.
1let x: number = 0;
2
3while (true) {
4 console.log("The value of x is: " + x);
5 x++;
6 if (x >= 5) {
7 break; // Exit the loop when the condition is met
8 }
9}
10// Outputs:
11// The value of x is: 0
12// The value of x is: 1
13// The value of x is: 2
14// The value of x is: 3
15// The value of x is: 4
אפשר להשתמש בפקודת break כדי לצאת בכוח מהלולאה כאשר התנאי מתקיים.
דוגמה 3: לולאת do-while
לולאת do-while היא מבנה שבו תהליך הלולאה מתבצע לפחות פעם אחת. מכיוון שהתנאי מוערך לאחר התהליך, התהליך מתבצע לפחות פעם אחת גם אם התנאי הוא false.
1let j: number = 5;
2
3do {
4 console.log("The value of j is: " + j);
5 j++;
6} while (j < 5);
7// Outputs: The value of j is: 5
בדוגמה זו, j הוא 5 מההתחלה, ו- j < 5 הוא false, אך בלולאת do-while, הלולאה מתבצעת לפחות פעם אחת ללא קשר לתנאי.
סיכום
- לולאת
whileחוזרת על עיבוד כל עוד התנאי הואtrue. - אם תנאי הסיום של הלולאה אינו ברור, יש להיזהר מלולאות אינסופיות.
- לולאת
do-whileשונה מלולאתwhileרגילה בכך שהעיבוד מתבצע לפחות פעם אחת.
הצהרת while ב-TypeScript שימושית לעיבוד לולאה עם מספר איטרציות לא ידוע או כאשר נדרש לבדוק תנאי באופן דינמי.
break ו-continue
ניתן להשתמש ב-break ו-continue בתוך לולאות.
breakמשמש להפסקת לולאה מוקדם מהצפוי.continueמשמש לדלג על האיטרציה הנוכחית ולעבור לאיטרציה הבאה.
דוגמה לשימוש ב-break
1for (let i = 0; i < 10; i++) {
2 if (i === 5) {
3 break; // Exits the loop when i is 5
4 }
5 console.log(i);
6}
7// Outputs 0, 1, 2, 3, 4
8
9let i = 0;
10
11while (i < 10) {
12 if (i === 5) {
13 break; // Ends the loop when i is 5
14 }
15 console.log(i++);
16}
17// Outputs 0, 1, 2, 3, 4
במקרה זה, break מופעל כאשר i מגיע ל-5. כתוצאה מכך, המספרים מ-0 עד 4 מוצגים.
דוגמה לשימוש ב-continue
1for (let i = 0; i < 5; i++) {
2 if (i === 2) {
3 continue; // Skips when i is 2
4 }
5 console.log(i);
6}
7// Outputs 0, 1, 3, 4
8
9let i = 0;
10
11while (i < 5) {
12 i++;
13 if (i === 3) {
14 continue; // Skips when i is 3
15 }
16 console.log(i);
17}
18// Outputs 1, 2, 4, 5
במקרה זה, continue מופעל כאשר i הוא 2. כתוצאה מכך, המספרים למעט 2 מוצגים.
לולאות מקוננות ב-TypeScript
לולאה מקוננת היא מבנה שבו לולאה אחת נמצאת בתוך לולאה אחרת. ב-TypeScript נתמכים מבני לולאה כמו for, while ו-do-while. באמצעות לולאות מקוננות, ניתן לעבד מערכים דו-ממדיים (מטריצות) ולייעל עיבוד המבוסס על מספר תנאים.
תחביר בסיסי
תחביר בסיסי של לולאה מקוננת הוא כדלקמן.
1for (let i: number = 0; i < n; i++) {
2 for (let j: number = 0; j < m; j++) {
3 // Processing for the inner loop
4 }
5}בכל ביצוע של הלולאה החיצונית, הלולאה הפנימית משלימה את כל האיטרציות שלה. מבנה זה שימושי מאוד בעת ההתמודדות עם לולאות מרובות או מבני נתונים.
דוגמה ללולאה מקוננת ב-TypeScript
מעבר על מערך דו-ממדי
לולאות מקוננות משמשות לעיתים קרובות בעת עבודה עם מבני נתונים רב-ממדיים כמו מערכים דו-ממדיים. בדוגמה הבאה, עוברים על איברים במערך דו-ממדי, וערכיהם מוצגים במסוף.
1const matrix: number[][] = [
2 [1, 2, 3],
3 [4, 5, 6],
4 [7, 8, 9]
5];
6
7for (let row: number = 0; row < matrix.length; row++) {
8 for (let col: number = 0; col < matrix[row].length; col++) {
9 console.log(`matrix[${row}][${col}] = ${matrix[row][col]}`);
10 }
11}
12// Output
13// matrix[0][0] = 1
14// matrix[0][1] = 2
15// matrix[0][2] = 3
16// matrix[1][0] = 4
17// matrix[1][1] = 5
18// matrix[1][2] = 6
19// matrix[2][0] = 7
20// matrix[2][1] = 8
21// matrix[2][2] = 9
בדוגמה זו, אנו עוברים על המערך הדו-ממדי בשם matrix. הלולאה החיצונית מטפלת בשורות, והלולאה הפנימית מטפלת בעמודות, ומציגה כל אלמנט לפי הסדר.
שילוב של שני מערכים
בהמשך, אנו מציגים דוגמה לחישוב כל השילובים של שני מערכים. לדוגמה, תוכלו לקחת אלמנט אחד מכל אחד משני המערכים ולהוציא את כל הזוגות האפשריים.
1const array1: string[] = ['A', 'B', 'C'];
2const array2: number[] = [1, 2, 3];
3
4for (let i: number = 0; i < array1.length; i++) {
5 for (let j: number = 0; j < array2.length; j++) {
6 console.log(`Pair: (${array1[i]}, ${array2[j]})`);
7 }
8}
9// Output
10// Pair: (A, 1)
11// Pair: (A, 2)
12// Pair: (A, 3)
13// Pair: (B, 1)
14// Pair: (B, 2)
15// Pair: (B, 3)
16// Pair: (C, 1)
17// Pair: (C, 2)
18// Pair: (C, 3)
בדוגמה זו, כל הזוגות בין מערך המחרוזות array1 ומערך המספרים array2 נוצרו. הלולאה החיצונית מוציאה אלמנטים מתוך array1, והלולאה הפנימית מוציאה אלמנטים מתוך array2, ומציגה כל זוג.
יצירת קואורדינטות עם לולאה משולשת
על ידי שימוש בלולאות משולבות ברמה שלוש, ניתן ליצור קואורדינטות במרחב תלת-ממדי, לדוגמה.
1for (let x: number = 0; x < 3; x++) {
2 for (let y: number = 0; y < 3; y++) {
3 for (let z: number = 0; z < 3; z++) {
4 console.log(`Coordinate: (${x}, ${y}, ${z})`);
5 }
6 }
7}
8// Output
9// Coordinate: (0, 0, 0)
10// Coordinate: (0, 0, 1)
11// Coordinate: (0, 0, 2)
12// ...
13// Coordinate: (2, 2, 1)
14// Coordinate: (2, 2, 2)
בדרך זו, שימוש בלולאות משולבות ברמה שלוש מאפשר ליצור בקלות קואורדינטות במרחב תלת-ממדי.
ביצועים של לולאות משולבות
לולאות משולבות הן נוחות, אך העלות החישובית עולה במהירות כאשר העומק של הלולאות גדל. לדוגמה, אם קיימות n חזרות של הלולאה החיצונית ו-m חזרות של הלולאה הפנימית, מספר החזרות הכולל יהיה n * m. כאשר זה נכנס לשכבות נוספות, המורכבות החישובית גדלה באופן אקספוננציאלי, וייתכן שהיא תשפיע על ביצועי התוכנית.
להלן המורכבויות החישוביות בעת מעבר על פני שלושה מערכים.
1const array1: number[] = [1, 2, 3];
2const array2: number[] = [4, 5, 6];
3const array3: number[] = [7, 8, 9];
4
5for (let i: number = 0; i < array1.length; i++) {
6 for (let j: number = 0; j < array2.length; j++) {
7 for (let k: number = 0; k < array3.length; k++) {
8 console.log(`Combination: (${array1[i]}, ${array2[j]}, ${array3[k]})`);
9 }
10 }
11}במקרה זה, עליך לחשב array1.length * array2.length * array3.length, והתוצאה תהיה 3 * 3 * 3 = 27 חזרות לעיבוד כל השילובים.
אופטימיזציה של לולאות משולבות
בעת שימוש בלולאות משולבות, תוכל לשפר את הביצועים על ידי שקילת האופטימיזציות הבאות.
- הכנסו יציאה מוקדמת: צאו מהלולאה מוקדם כאשר המטרה מושגת כדי להימנע מחזרות בלתי נחוצות.
- אחסנו מראש ערכי משתנים של הלולאה: שמרו מראש את הערכים של משתנים בשימוש בתוך הלולאה (במיוחד אורכים וטווחים) כדי להפחית את עלות החישוב בכל פעם.
- שנו את מבנה הנתונים: תיקון מבנה המערכים והאובייקטים יכול להיות יעיל בהאצת תהליכים חוזרים מסוימים.
סיום
לולאות משולבות הן כלי חזק בתהליכי עיבוד נתונים מורכבים ובאלגוריתמים. עם זאת, כאשר עומק הלולאות ומספר החזרות גדלים, עשויות להתעורר בעיות ביצועים. עם אופטימיזציות מתאימות ועיצוב מדויק, ניתן לנצל באופן יעיל את הלולאות המשולבות ב-TypeScript.
תוכלו לעקוב אחר המאמר שלמעלה באמצעות Visual Studio Code בערוץ היוטיוב שלנו. נא לבדוק גם את ערוץ היוטיוב.