דלג לתוכן
נושאים
  • 1 התחלה
    1.1

    התוכנית הראשונה שלך

    תוכנית היא רשימת הוראות למחשב. ב-JavaScript, כל הוראה היא פסקה, והמחשב מפעיל את הפסקאות מלמעלה למטה.

    console.log(...) מדפיק ערך בקונסולה, השטח הטקסטואלי מתחת לקוד:

    console.log("Hello, world!");
    console.log(7 * 6);   // 42
    
    • טקסט נכנס בתוך סימני ציטוט: "Hello" או 'Hello'. מספרים אינם כן.
    • סיים כל פסקה עם נקודה-פסיק ;. JavaScript יכול לעיתים קרובות לחזות היכן חסרה אחת, אך כתיבתה ברורה יותר.
    • JavaScript רגישה לגודל אותיות: console.log עובד, Console.Log אינו עובד.

    console.log יכול להדפיק מספר ערכים בו-זמנית. הוא מציב רווח אחד ביניהם:

    console.log("Total:", 3 + 4);   // Total: 7
    console.log(1, 2, 3);           // 1 2 3
    
    1.2

    הערות וסגנון כתיבה

    תגובה היא הערה לאנשים. JavaScript מתעלם ממנה כאשר התוכנית פועלת.

    // A one-line comment starts with two slashes.
    console.log("This line runs");   // a comment can follow code
    
    /* A block comment
       can cover several lines. */
    console.log("So does this one");
    

    סגנון טוב הופך את הקוד לקריא:

    • הזז את הקווים בתוך { } בשתי או ארבע רווחים, ועשה זאת באותו אופן בכל פעם.
    • תן למשתנים שמות שמבטאים מה שהם מחזיקים: total, לא t.
    • שמות ב-JavaScript משתמשים ב-camelCase: firstName, scoreTotal.
    // Work out the area of a rectangle
    const width = 4;
    const height = 3;
    console.log(width * height);   // 12
    

    שגיאות נפוצות

    • הטקסט זקוק לציטוט מתאים: "Hi' הוא שגיאה.
    • console.log הוא כולו באותיות קטנות: Console.log ו-console.Log הם שגיאות.
    • כל מה שאחרי // בשורה נעלם, ולכן // console.log(x) מדפס ריק.
  • 2 ערכים, משתנים וסוגים
    2.1

    let ו-const

    משתנה הוא תיבה המכילה ערך. צרו אחד עם let או const, ולאחר מכן השתמשו בשמו:

    let score = 10;
    score = score + 5;      // let: the value can change
    console.log(score);     // 15
    
    const name = "Mei";     // const: the name cannot be reassigned
    console.log(name);      // Mei
    
    • = פירושו הגדרה: חשבו את אגף ימין, ואז אחסנו אותו בתיבה בצד שמאל.
    • השתמשו ב-const ברירת מחדל. השתמשו ב-let רק כאשר הערך צריך להשתנות מאוחר יותר.
    • הגדרה מחדש של const היא שגיאה: name = "Tom" אינו מותר. אובייקט או מערך מסוג const עדיין יכולים לשנות את התוכן שלהם.
    2.2

    מספרים ומתמטיקה

    דוגמאות אלו משתמשות בסוג המספר לערכים שלמים ועשרוניים. BigInt הוא סוג שלם נפרד. פעולות האריתמטיקה הן:

    פעולה משמעות דוגמה תוצאה
    + - חיבור, חיסור 7 - 2 5
    * / כפל, חילוק 7 / 2 3.5
    % שארית 7 % 2 1
    ** מעלה 2 ** 3 8
    console.log(7 / 2);              // 3.5
    console.log(Math.floor(7 / 2));  // 3   (whole-number division)
    console.log(7 % 2);              // 1   (odd numbers leave 1)
    console.log(2 + 3 * 4);          // 14  (* before +)
    console.log((2 + 3) * 4);        // 20
    

    Math מכיל פונקציות שימושיות:

    console.log(Math.round(2.5));    // 3
    console.log(Math.max(4, 9, 2));  // 9
    console.log(Math.sqrt(49));      // 7
    
    • Math.random() מחזיר מספר אקראי החל מ-0 ועד (ללא) 1. Math.floor(Math.random() * 6) + 1 הוא גלגלת קובייה מ-1 עד 6.
    • עשרונות מאוחסנים בצורת בינארית, ולכן 0.1 + 0.2 מדפיס 0.30000000000000004. עגלו תוצאה לפני ההצגה: (0.1 + 0.2).toFixed(2) הוא "0.30".
    2.3

    סוגים והמרה

    לכל ערך יש סוג. typeof מגלה איזה סוג:

    console.log(typeof 42);         // number
    console.log(typeof "42");       // string
    console.log(typeof true);       // boolean
    console.log(typeof undefined);  // undefined
    
    • משתנה שנוצר עם let x; וללא ערך הוא undefined.
    • null פירושו "אין ערך", מוגדר במתכוון.

    + עם מחרוזת מחבר במקום לחבר, לכן יש להפוך טקסט למספר תחילה:

    console.log("5" + 1);           // 51  (joined)
    console.log(Number("5") + 1);   // 6   (added)
    console.log(parseInt("12px"));  // 12  (reads the number at the start)
    console.log(String(9) + "!");   // 9!
    
    • טקסט שאינו מספר מחזיר NaN ("לא מספר"): Number("abc") הוא NaN.
    • -, * ו-/ ממירים טקסט למספר באופן אוטומטי ("6" * 2 הוא 12), אך אין לסמוך על כך: יש לבצע המרה במטרה ברורה.

    שגיאות נפוצות

    • = מבצע השוואה; אינו משווה. השוואה נעשית באמצעות === (נושא 4).
    • "5" + 1 הוא "51". יש להפוך קלט ב-Number(...) לפני ביצוע פעולות מתמטיות עליו.
    • Math.round(2.5) הוא 3, אך Math.round(-2.5) הוא -2: הוא מעגל חצאים כלפי מעלה, לעבר המספר הגדול יותר.
  • 3 מחרוזות
    3.1

    תווים ואורך

    מחרוזת היא טקסט בתוך סימני ציטוט. עם אותות פשוטות, לכל תוויה יש מיקום אחד, האינדקס שלה; האינדקס הראשון הוא 0. JavaScript סופר יחידות קוד UTF-16: אימוג'י עשוי לתפוס שני מיקומים.

    const word = "Script";
    console.log(word.length);     // 6
    console.log(word[0]);         // S
    console.log(word[2]);         // r
    console.log(word.at(-1));     // t  (counts back from the end)
    console.log(word[word.length - 1]);   // t
    
    • האינדקס האחרון הוא length - 1. word[6] הוא undefined, ולא שגיאה.
    • מחרוזות הן בלתי ניתנות לשינוי: word[0] = "s" לא יכול לשנות את המחרוזת ומזרק TypeError במצב מחמיר. יש לבנות מחרוזת חדשה במקום זאת.

    יש לחבר מחרוזות באמצעות +, שמכונה הרצפה:

    const first = "Ada";
    const last = "Lovelace";
    console.log(first + " " + last);   // Ada Lovelace
    
    3.2

    שיטות String

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

    const city = "  Hong Kong ";
    console.log(city.trim());                 // Hong Kong
    console.log(city.trim().toUpperCase());   // HONG KONG
    console.log(city.length);                 // 12  (the spaces are still there)
    
    שיטה משמעות דוגמה תוצאה
    .toUpperCase() / .toLowerCase() שינוי קטליות "Hi".toLowerCase() "hi"
    .trim() הסרת רווחים בשני הקצוות " hi ".trim() "hi"
    .includes(t) האם מכיל את t? "cat".includes("a") true
    .indexOf(t) המיקום הראשון של t, או -1 "cat".indexOf("t") 2
    .slice(a, b) תווים מ-a ועד (לא כולל) b "Script".slice(0, 3) "Scr"
    .split(sep) פיצול למערך "a,b,c".split(",") ["a","b","c"]
    .replace(a, b) החלפת ה-a הראשונים ב-b "cat".replace("c", "b") "bat"
    const email = "[email protected]";
    const at = email.indexOf("@");
    console.log(email.slice(0, at));          // mei
    console.log(email.slice(at + 1));         // school.org
    console.log(email.split("@"));            // ["mei","school.org"]
    
    3.3

    ליטרליים של תבנית

    טמפלייט ליטרל הוא מחרוזת שנכתבת בין מקרבות (ברוב המקלדות, המקשי שמאל ל-1). ניתן להכניס כל ביטוי בתוך ${ } וערכו יוצב בטקסט:

    const name = "Mei";
    const age = 17;
    console.log(`${name} is ${age} years old.`);   // Mei is 17 years old.
    console.log(`Next year: ${age + 1}`);          // Next year: 18
    
    • סוגריי קוויים יכולים להכיל גם מספר שורות טקסט.
    • זה קל יותר לקרוא מאשר סימנים רבים +: השווו "Hi " + name + "!" ל-`Hi ${name}!`.
    const price = 4.5;
    console.log(`Two cost $${(price * 2).toFixed(2)}`);   // Two cost $9.00
    

    שגיאות נפוצות

    • ${ } פועל רק בתוך סוגריי קוויים. ב-"Hi ${name}" הטקסט מודפם בדיוק כפי שנכתב.
    • שיטות אינן משנות את המחרוזת: city.trim() בשורה לבד אינו עושה דבר. שמרו את התוצאה: const clean = city.trim();.
    • slice(a, b) עצור לפני b, בדיוק כמו שהאינדקס האחרון הוא length - 1.
  • 4 החלטות
    4.1

    בוליאנים והשוואות

    ערך בוליאני הוא או true או false. השוואה מחזירה ערך בוליאני:

    פעולה משמעות דוגמה תוצאה
    === שווה (אותו ערך ואותו סוג) 5 === 5 true
    !== לא שווה 5 !== 3 true
    < > פחות מ-, גדול מ- 2 > 7 false
    <= >= עד או יותר/פחות מ- 7 >= 7 true
    console.log(5 === 5);     // true
    console.log(5 === "5");   // false  (a number is not a string)
    console.log(5 == "5");    // true   (== converts first: avoid it)
    
    • תמיד השתמשו ב-=== וב-!==. ה-== הישן מבצע המרה של סוגים קודם ומחזיר תוצאות מפתיעות.

    לתנאים בוליאניים, השתמשו בפועלים הלוגיים למטה. עם ערכים אחרים, && ו-|| מחזירים אחד מפעולניהם; הם אינם תמיד מחזירים בוליאני:

    • && (וגם): אמיתי רק אם שתי הצדדים אמיתיים.
    • || (או): אמיתי אם לפחות אחד מצדדים אמיתי.
    • ! (לא): הופך true ל-false ולהפך.
    const age = 15;
    console.log(age >= 13 && age <= 19);   // true   (a teenager)
    console.log(age < 5 || age > 65);      // false
    console.log(!(age > 18));              // true
    
    4.2

    if / else if / else

    ביטוי if מפעיל בלוק קוד כאשר התנאי שלו הוא truthy (מטופל כאמיתי). עם תנאי בוליאניים, המשמעות היא הערך true. else if בודק תנאי נוסף; else לוכד הכל שנותר:

    const mark = 72;
    if (mark >= 80) {
      console.log("A");
    } else if (mark >= 60) {
      console.log("B");
    } else {
      console.log("C");
    }
    // prints B
    
    • JavaScript בודקת את התנאים מלמעלה ומפעילה רק את הנתיב האמיתי הראשון.
    • התנאי נמצא בסוגריים עגולים; הקוד לפעולה נמצא בסוגריים מעוקפים { }.

    לכן הסדר חשוב. הניחו את הבדיקה המחמירה ביותר קודם:

    const temp = 35;
    if (temp > 30) {
      console.log("hot");
    } else if (temp > 20) {
      console.log("warm");   // skipped: the first branch already ran
    }
    // prints hot
    
    4.3

    מתג

    ביטוי switch משווה ערך אחד למספר מקרים קבועים. הוא מסודר יותר משרשרת ארוכה של else if כאשר כל בדיקה היא "האם שווה ל…?":

    const day = "Sat";
    switch (day) {
      case "Sat":
      case "Sun":
        console.log("weekend");
        break;
      case "Fri":
        console.log("nearly there");
        break;
      default:
        console.log("school day");
    }
    // prints weekend
    
    • switch מבצע השוואה עם ===, ולכן case 1: אינו תואם את המחרוזת "1".
    • break מסיים את ה-switch. ללאו, הקוד ימשיך למקרה הבא (fall through).
    • default מופעל כאשר אין התאמה למקרה כלשהו, כמו else סופי.
    • לשני מקרים ללא קוד ביניהם יש אותו קוד, כפי ש"Sat" ו-"Sun" עושים כאן.

    שגיאות נפוצות

    • if (x = 5) מבצע הצצה במקום השוואה, והבדיקה נשארת תמיד נכונה. כתוב if (x === 5).
    • if (age > 13 && < 19) היא שגיאה: חזרה על המשתנה, age > 13 && age < 19.
    • חוסר break ב-switch גורם גם למקרה הבא להירץ.
  • 5 לולאות
    5.1

    לולאות for

    שלושה חלקיו של לולאת for, והסדר בהם מופעלים

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

    for (let i = 1; i <= 3; i++) {
      console.log(i);
    }
    // 1
    // 2
    // 3
    
    1. התחלה: let i = 1 מופעל פעם אחת, לפני הלולאה.
    2. תנאי: i <= 3 נבדק לפני כל מעבר; הלולאה עצורה כאשר התנאי אינו נכון.
    3. שלב: i++ (הוספת 1 ל-i) מתבצע לאחר כל מעבר.

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

    let line = "";
    for (let i = 10; i > 0; i -= 3) {
      line += i + " ";
    }
    console.log(line);   // 10 7 4 1
    

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

    let total = 0;
    for (let n = 1; n <= 5; n++) {
      total += n;          // the same as total = total + n
    }
    console.log(total);    // 15
    
    5.2

    לולאות while

    לולאת while חוזרת כל עוד התנאי שלה נכון. השתמש בה כאשר אינך יודע מראש כמה מעברים נדרשים:

    let money = 100;
    let years = 0;
    while (money < 200) {
      money = money * 1.1;   // 10% interest each year
      years++;
    }
    console.log(years);      // 8
    
    • התנאי נבדק לפני כל מעבר, כך שהגוף עשוי להירץ אפס פעמים.
    • אם התנאי נשאר נכון ולא מופעל break או יציאה אחרת, תקבל לולאה אינסופית. (לחץ עצור אם זה קורה.)
    5.3

    for...of, break & continue

    for...of מבקר על כל פריט במערך (או על כל אות במחרוזת) בתור, ללא צורך בניהול אינדקס:

    const fruits = ["apple", "kiwi", "plum"];
    for (const fruit of fruits) {
      console.log(fruit.toUpperCase());
    }
    // APPLE
    // KIWI
    // PLUM
    

    break יוצא מהלולאה מיד; continue דוחה את שארית המעבר הנוכחי וממשיך למעבר הבא:

    const marks = [55, 80, -1, 90];
    let sum = 0;
    for (const m of marks) {
      if (m < 0) {
        break;            // -1 means "end of the data"
      }
      if (m < 60) {
        continue;         // skip a fail, keep looping
      }
      sum += m;
    }
    console.log(sum);     // 80
    

    שגיאות נפוצות

    • טעות של יחידה אחת: i < 3 רץ עבור 0, 1, 2; i <= 3 רץ פעם נוספת. ספור את העוברים.
    • התחלת הסכום בתוך הלולאה: let total = 0; חייב לבוא לפני הלולאה, אחרת הוא מוחזר לכל עובר.
    • לולאת while תמשיך לרדת לעולם אם התנאי נשאר אמיתי ואין הגעה ליציאה.
  • 6 פונקציות
    6.1

    פרמטרים והחזרה

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

    function greet(name) {
      return `Hello, ${name}!`;
    }
    
    console.log(greet("Mei"));   // Hello, Mei!
    console.log(greet("Tom"));   // Hello, Tom!
    
    • name הוא פרמטר: משתנה שקבלת ערך כשהפונקציה נקראת.
    • "Mei" הוא הארגומנט: הערך בפועל שעבר.
    • return שולח ערך בחזרה למקור הקריאה ומסתיימת הפונקציה מיד.

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

    function area(width, height) {
      return width * height;
    }
    
    const a = area(4, 3);
    console.log(a + 1);          // 13  (a returned value can be used again)
    
    6.2

    פונקציות חצים

    פונקציית חץ היא דרך קצרה יותר לכתוב פונקציה. שמרו אותה ב-const:

    const square = (n) => n * n;
    const add = (a, b) => a + b;
    
    console.log(square(5));      // 25
    console.log(add(2, 3));      // 5
    
    • עם ביטוי אחד לאחר =>, הערך שלו מוחזר בלי לכתוב return.
    • עם סוגריים מסולסים צריך שוב return:
    const grade = (mark) => {
      if (mark >= 50) {
        return "pass";
      }
      return "fail";
    };
    console.log(grade(64));      // pass
    

    פונקציות חצים מועברות לעיתים קרובות לפונקציות אחרות, כפי שראיתם עם map ו-filter בנושא 7.

    6.3

    תחום (Scope)

    התחום של משתנה הוא החלק בקוד שיכול לראות אותו. משתנה שנעשה עם let או const בתוך { } נגיש בתוך הבלוק הזה ובתחומים הממוקמים בתוכו. פונקציה ממוקמת יכולה לשמור גישה גם אחרי שהקריאה החיצונית חזרה:

    const level = "global";
    
    function show() {
      const inside = "local";
      console.log(level);        // global  (outer variables are visible)
      console.log(inside);       // local
    }
    
    show();
    console.log(typeof inside);  // undefined  (inside does not exist out here)
    
    • משתנה שנעשה בתוך פונקציה הוא משתנה מקומי; כל קריאה מקבלת משתנה חדש.
    • העבירו ערכים בתוך הפרמטרים וקבלו תוצאות חוצה בעזרת return, במקום לשנות משתנים חיצוניים מתוך הפונקציה.

    שגיאות נפוצות

    • שכחתם return: הפונקציה מחשבת את התוצאה, אך מחזירה undefined.
    • קריאה ללא סוגריים: greet היא הפונקציה עצמה; greet("Mei") מפעילה אותה.
    • הדפסה בתוך הפונקציה וגם הדפסת התוצ שלה מדפיסה פעמיים, או מדפיסה undefined.
  • 7 מערכים
    7.1

    יצירה ועריכת מערכים

    An array 数组 holds a list of values in order, inside square brackets. Each item is an element 元素, and the first index is 0:

    const scores = [72, 88, 95];
    console.log(scores[0]);        // 72
    console.log(scores.length);    // 3
    scores[1] = 90;                // change one element
    console.log(scores);           // [72,90,95]
    
    • const stops you giving scores a whole new array, but you can still change what is inside it.
    • Reading past the end gives undefined: scores[3] is undefined.

    Add and remove at the end with push and pop:

    const queue = ["Ann", "Ben"];
    queue.push("Cai");             // add to the end
    console.log(queue);            // ["Ann","Ben","Cai"]
    const last = queue.pop();      // remove from the end and return it
    console.log(last);             // Cai
    console.log(queue.length);     // 2
    

    An array can hold arrays. That makes a grid, read with two indexes, row first:

    const grid = [
      [1, 2, 3],
      [4, 5, 6],
    ];
    console.log(grid[1][2]);       // 6  (row 1, column 2)
    
    7.2

    map, filter & reduce

    English

    These methods take a function and apply it to the array elements. They return a new array (or value) without themselves replacing the original items. The function you pass in can still change the original array or its objects:

    • map makes a new array by changing every element.
    • filter keeps only the elements for which the function returns true.
    • reduce combines all the elements into one value, such as a total.
    const prices = [4, 10, 25];
    const withTax = prices.map((p) => p * 1.1);
    console.log(withTax.map((p) => p.toFixed(2)));   // ["4.40","11.00","27.50"]
    
    const cheap = prices.filter((p) => p < 20);
    console.log(cheap);                              // [4,10]
    
    const total = prices.reduce((sum, p) => sum + p, 0);
    console.log(total);                              // 39
    

    In reduce, sum is the accumulator. It starts at the last argument (0) and takes the function's result after each element.

    7.3

    חיפוש וסינון

    English
    sort() with no compare function sorts numbers as text
    Method Gives back Example with [5, 8, 2] Result
    .includes(x) true or false .includes(8) true
    .indexOf(x) the first index of x, or -1 .indexOf(2) 2
    .find(f) the first element where f is true .find((n) => n > 6) 8
    .findIndex(f) its index, or -1 .findIndex((n) => n > 6) 1

    sort puts the elements in order. With no function, it sorts them as text, so numbers come out in the wrong order:

    const nums = [10, 9, 100, 1];
    console.log([...nums].sort());                   // [1,10,100,9]   (as text!)
    console.log([...nums].sort((a, b) => a - b));    // [1,9,10,100]
    console.log([...nums].sort((a, b) => b - a));    // [100,10,9,1]
    
    • The compare function returns a negative number when a should come first, and a positive number when b should.
    • sort changes the array itself. [...nums] makes a copy first, so nums keeps its order.

    Common mistakes

    • The last element is arr[arr.length - 1], not arr[arr.length].
    • map and filter do not change the array: store their result.
    • nums.sort() on numbers sorts them as text. Pass (a, b) => a - b.
  • 8 אובייקטים
    8.1

    אובייקטים ותכונות

    אובייקט מקבץ ערכים קשורים תחת שמות. כל זוג שם-ערך הוא תכונה. השם נקרא המקדמת:

    const pupil = {
      name: "Mei",
      age: 17,
      form: "11A",
    };
    console.log(pupil.name);       // Mei
    console.log(pupil["form"]);    // 11A  (bracket form, with the key as a string)
    
    • לקרוא לתכונה עם נקודה (pupil.age) או עם סוגריים מרובעים (pupil["age"]). השתמש בסוגריים מרובעים כאשר המקדמת נמצאת במשתנה: pupil[field].
    • מקדמת שאינה קיימת מחזירה undefined.

    שנה תכונה, או הוסף חדשה, על ידי הקצאה אליה:

    const pupil = { name: "Mei", age: 17 };
    pupil.age = 18;                // change
    pupil.house = "Red";           // add
    console.log(pupil);            // {"name":"Mei","age":18,"house":"Red"}
    
    8.2

    מערכים של אובייקטים

    רשימת רשומות היא מערך של אובייקטים. שלב אותו עם שיטות המערך מנושא 7:

    const pupils = [
      { name: "Mei", mark: 88 },
      { name: "Tom", mark: 64 },
      { name: "Sara", mark: 95 },
    ];
    
    const passed = pupils.filter((p) => p.mark >= 70);
    console.log(passed.map((p) => p.name));            // ["Mei","Sara"]
    
    const best = [...pupils].sort((a, b) => b.mark - a.mark)[0];
    console.log(`${best.name} has the top mark`);       // Sara has the top mark
    

    לסכום תכונה, השתמש בreduce או בטבעה:

    const pupils = [{ mark: 88 }, { mark: 64 }, { mark: 95 }];
    let sum = 0;
    for (const p of pupils) {
      sum += p.mark;
    }
    console.log((sum / pupils.length).toFixed(1));      // 82.3
    
    8.3

    טביעה באובייקט

    Object.keys מחזירה מערך של המקדמות, וObject.entries מחזירה זוגות [key, value], כך שניתן לעבור עליהם:

    const stock = { pens: 12, rulers: 0, books: 5 };
    
    console.log(Object.keys(stock));             // ["pens","rulers","books"]
    
    for (const [item, count] of Object.entries(stock)) {
      if (count === 0) {
        console.log(`${item}: sold out`);
      }
    }
    // rulers: sold out
    

    אובייקט הוא סופר טוב: השתמש בכל דבר שהכופרת בו כמקדמת.

    const words = ["red", "blue", "red", "red"];
    const counts = {};
    for (const w of words) {
      counts[w] = (counts[w] || 0) + 1;   // 0 the first time the key is seen
    }
    console.log(counts);                  // {"red":3,"blue":1}
    

    שגיאות נפוצות

    • pupil.field מחפש מקדמת בשם field. כאשר המקדמת נמצאת במשתנה, כתוב pupil[field].
    • פסקה נמצאת בין תכונות, ולא נקודה-פסקה: { name: "Mei", age: 17 }.
    • for...of לא יכול לעבור על אובייקט ישירות. עבור על Object.keys(...) או Object.entries(...).
  • 9 שגיאות
    9.1

    קריאת הודעות שגיאה

    כאן שJavaScript אינו יכול להמשיך, הוא מפסיק ומציג שגיאה. המילה הראשונה מזהה את סוג השגיאה; שאר החלקים מסבירים מה קרה שגwrong ואיפה. קרא אותה, ואז חפש את השורה שמציינת.

    SyntaxError: missing ) after argument list
    ReferenceError: totl is not defined
    TypeError: Cannot read properties of undefined (reading 'length')
    
    Error משמעות סיבה נפוצה
    SyntaxError הקוד אינו כתוב נכון, ולכן אף דבר לא פועל סוגריית חסר או תגיות עטירה
    ReferenceError שם שלא קיים טעות כתיב: totl במקום total
    TypeError הערך הוא בסוג הלא נכון למה שעשית שימוש ב.length על undefined

    ניסוח מדויק עשוי להשתנות בין דפדפנים, אך שם השגיאה זהה. תוכנית זו תופסת כל שגיאה כדי שהיא תוכל להדפיס את שמה:

    try {
      const total = 5;
      console.log(totl);
    } catch (e) {
      console.log(e.name);           // ReferenceError
    }
    
    try {
      const pupil = undefined;
      console.log(pupil.length);
    } catch (e) {
      console.log(e.name);           // TypeError
    }
    

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

    9.2

    try, catch & throw

    קוד שעלול להיכשל מונח בתוך בלוק try. אם קורה שם טעות, JavaScript קופץ ל-catch במקום לעצור, ו-e מכיל את הטעות:

    try {
      JSON.parse("{not valid}");
      console.log("parsed");         // skipped
    } catch (e) {
      console.log("Could not read the data");
    }
    console.log("The program carries on");
    

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

    function average(list) {
      if (list.length === 0) {
        throw new Error("the list is empty");
      }
      return list.reduce((s, x) => s + x, 0) / list.length;
    }
    
    console.log(average([4, 6]));    // 5
    try {
      average([]);
    } catch (e) {
      console.log(`Error: ${e.message}`);   // Error: the list is empty
    }
    
    • new Error("…") makes an error whose message is your text.
    • השתמש ב-try רק סביב קוד שיכול באמת לכשל, כמו קריאת נתונים. אל תשתמש בו כדי להסתיר שגיאות בקוד שלך.

    שגיאות נפוצות

    • דילוג על ההודעה. השורה הראשונה שלה מציין את סוג הטעות ומה התקלקל; התחל משם.
    • catch שלא עושה כלום (catch (e) {}) מסתיר את הבעיה: לפחות הדפס את e.message.
    • throw "text" עובד, אך throw new Error("text") גם מקליט היכן שהטעות התרחשה.

היכנס או צור חשבון

IGCSE, A-Level & AP