JavaScript

לולאות

לולאות מאפשרות לחזור על פעולות מספר פעמים ללא שכפול קוד.

for - לולאה קלאסית

הלולאה הכי נפוצה, כשיודעים כמה פעמים לחזור.

for (let i = 0; i < 5; i++) {
    console.log(i);
}
// פלט: 0, 1, 2, 3, 4

מבנה התחביר

for (initialization; condition; update) {
    // קוד שחוזר
}

// initialization - מתבצע פעם אחת בהתחלה
// condition - נבדק לפני כל איטרציה
// update - מתבצע אחרי כל איטרציה

דוגמאות

// ספירה לאחור
for (let i = 5; i >= 1; i--) {
    console.log(i);
}
// 5, 4, 3, 2, 1

// קפיצות של 2
for (let i = 0; i <= 10; i += 2) {
    console.log(i);
}
// 0, 2, 4, 6, 8, 10

// מעבר על מערך
let fruits = ["תפוח", "בננה", "תפוז"];
for (let i = 0; i < fruits.length; i++) {
    console.log(fruits[i]);
}

while - לולאה עם תנאי

ממשיכה כל עוד התנאי אמת.

let count = 0;

while (count < 5) {
    console.log(count);
    count++;
}
// פלט: 0, 1, 2, 3, 4

מתי להשתמש?

// כשלא יודעים מראש כמה פעמים
let input = "";
while (input !== "יציאה") {
    // קבל קלט מהמשתמש
    // input = prompt("הכנס טקסט:");
    console.log(input);
}

// חיפוש ערך
let numbers = [3, 7, 2, 9, 5];
let i = 0;
while (numbers[i] !== 9) {
    i++;
}
console.log(`מצאתי 9 במיקום ${i}`);

⚠️ זהירות: וודאו שהתנאי יהפוך ל-false מתישהו, אחרת תקבלו לולאה אינסופית!

do...while

כמו while, אבל מבצעת לפחות פעם אחת.

let count = 0;

do {
    console.log(count);
    count++;
} while (count < 5);
// פלט: 0, 1, 2, 3, 4

// ההבדל מ-while:
let x = 10;

while (x < 5) {
    console.log("while:", x);  // לא ירוץ!
}

do {
    console.log("do-while:", x);  // ירוץ פעם אחת!
} while (x < 5);

for...of - מעבר על איברים

לולאה מודרנית למעבר על מערכים ומחרוזות.

let fruits = ["תפוח", "בננה", "תפוז"];

for (let fruit of fruits) {
    console.log(fruit);
}
// תפוח, בננה, תפוז

// מעבר על מחרוזת
let word = "שלום";
for (let char of word) {
    console.log(char);
}
// ש, ל, ו, ם

יתרונות

• קריא יותר
• לא צריך לנהל אינדקס
• עובד על כל iterable

for...in - מעבר על מפתחות

למעבר על מפתחות (keys) של אובייקטים.

let person = {
    name: "דן",
    age: 25,
    city: "תל אביב"
};

for (let key in person) {
    console.log(`${key}: ${person[key]}`);
}
// name: דן
// age: 25
// city: תל אביב

// גם עובד על מערכים (מחזיר אינדקסים)
let arr = ["a", "b", "c"];
for (let index in arr) {
    console.log(index);  // "0", "1", "2" (מחרוזות!)
}

💡 המלצה: השתמשו ב-for...of למערכים ו-for...in לאובייקטים.

break - יציאה מלולאה

עוצר את הלולאה לחלוטין:

for (let i = 0; i < 10; i++) {
    if (i === 5) {
        break;  // יציאה מהלולאה
    }
    console.log(i);
}
// פלט: 0, 1, 2, 3, 4

// חיפוש איבר
let numbers = [3, 7, 2, 9, 5];
let found = false;

for (let num of numbers) {
    if (num === 9) {
        found = true;
        break;
    }
}
console.log(found ? "נמצא!" : "לא נמצא");

continue - מעבר לאיטרציה הבאה

מדלג על שאר הקוד באיטרציה הנוכחית:

for (let i = 0; i < 5; i++) {
    if (i === 2) {
        continue;  // מדלג על 2
    }
    console.log(i);
}
// פלט: 0, 1, 3, 4

// הדפסת מספרים זוגיים בלבד
for (let i = 0; i <= 10; i++) {
    if (i % 2 !== 0) {
        continue;  // מדלג על אי-זוגיים
    }
    console.log(i);
}
// 0, 2, 4, 6, 8, 10

לולאות מקוננות (Nested)

לולאה בתוך לולאה:

// טבלת כפל
for (let i = 1; i <= 3; i++) {
    for (let j = 1; j <= 3; j++) {
        console.log(`${i} x ${j} = ${i * j}`);
    }
}
// 1x1=1, 1x2=2, 1x3=3, 2x1=2, 2x2=4...

// מעבר על מטריצה
let matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
];

for (let row of matrix) {
    for (let cell of row) {
        console.log(cell);
    }
}

break/continue בלולאות מקוננות

// break יוצא רק מהלולאה הפנימית
outer: for (let i = 0; i < 3; i++) {
    for (let j = 0; j < 3; j++) {
        if (i === 1 && j === 1) {
            break outer;  // יציאה מהלולאה החיצונית
        }
        console.log(i, j);
    }
}

מתודות של מערכים ללולאות

forEach

let fruits = ["תפוח", "בננה", "תפוז"];

fruits.forEach(function(fruit, index) {
    console.log(`${index}: ${fruit}`);
});
// 0: תפוח, 1: בננה, 2: תפוז

// עם arrow function
fruits.forEach((fruit) => console.log(fruit));

map

let numbers = [1, 2, 3, 4, 5];
let doubled = numbers.map(num => num * 2);
console.log(doubled);  // [2, 4, 6, 8, 10]

filter

let numbers = [1, 2, 3, 4, 5, 6];
let evens = numbers.filter(num => num % 2 === 0);
console.log(evens);  // [2, 4, 6]

reduce

let numbers = [1, 2, 3, 4, 5];
let sum = numbers.reduce((acc, num) => acc + num, 0);
console.log(sum);  // 15

דוגמאות מעשיות

מציאת ערך מקסימלי

let numbers = [23, 55, 12, 89, 34];
let max = numbers[0];

for (let num of numbers) {
    if (num > max) {
        max = num;
    }
}
console.log(max);  // 89

ספירת תווים

let text = "שלום עולם";
let count = 0;

for (let char of text) {
    if (char !== " ") {
        count++;
    }
}
console.log(`מספר תווים: ${count}`);  // 8

הפיכת מערך

let arr = [1, 2, 3, 4, 5];
let reversed = [];

for (let i = arr.length - 1; i >= 0; i--) {
    reversed.push(arr[i]);
}
console.log(reversed);  // [5, 4, 3, 2, 1]

סכום מספרים זוגיים

let sum = 0;
for (let i = 2; i <= 100; i += 2) {
    sum += i;
}
console.log(sum);  // 2550

השוואת סוגי לולאות

סיכום

כללי אצבע: - השתמשו ב-for...of למערכים - השתמשו ב-for...in לאובייקטים - השתמשו ב-for קלאסי כשצריך אינדקס - השתמשו ב-while כשלא יודעים כמה איטרציות - זכרו לעדכן את התנאי למניעת לולאה אינסופית