מתכונת 7 במדעי המחשב - תכנות באינטרנט 899372

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

רעיון – בשרת ASP.NET יש שני אובייקטים לשמירת מידע בין בקשות ובין דפים:

מונה כניסות שכל המבקרים רואים חייב להיות משותף – לכן Application.

פתרון – נעבור על האפשרויות:

שימוש אפשרי בקוד בצד השרת:

if (Application["count"] == null)
    Application["count"] = 0;
Application["count"] = (int)Application["count"] + 1;
Response.Write("מספר הכניסות לאתר: " + Application["count"]);

תשובה: ד.

בדיקה – שני מבקרים (דנה נכנסה פעמיים, יוסי פעם אחת): המונה ב־Application מגיע ל־3 ושני המבקרים רואים אותו, ואילו מונה שנשמר ב־Session של יוסי מראה רק 1.

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

מה נדרש – להחזיר שתי עמודות (flightCode ו-price) של הטיסות המקיימות שלושה תנאים יחד.

רעיון – אחרי SELECT כותבים את שתי העמודות, מופרדות בפסיק. ב-WHERE מחברים את שלושת התנאים ב-AND:

פתרון

SELECT flightCode, price
FROM Flights
WHERE destination = 'Rome' AND price < 800 AND seatsLeft >= 10;

בדיקה – השאילתה על טבלה קטנה לדוגמה:

התוצאה: (LY381, 720), (IZ211, 650).

טעות נפוצה: לכתוב seatsLeft > 10 – כך הטיסה IZ211 עם 10 מקומות בדיוק לא תוחזר, למרות ש"לפחות 10" כולל את 10.

מה נדרש: שאילתה שמחזירה שתי עמודות (performer, price) רק עבור הופעות שמקיימות שני תנאים.

רעיון:

פתרון:

SELECT performer, price
FROM Concerts
WHERE city = 'Haifa' AND tickets >= 2000

בדיקה: השאילתה על טבלה לדוגמה (בשאלה אין שורות) עם שש הופעות: ארבע ב-Haifa (5200, 2000, 1999 ו-900 כרטיסים) ושתיים בערים אחרות (אחת מהן עם 8000 כרטיסים). התקבלו רק שתי שורות: ההופעה עם 5200 כרטיסים (מחיר 180) וההופעה עם 2000 כרטיסים בדיוק (מחיר 250). ההופעה עם 1999 כרטיסים לא נבחרה, וגם ההופעות בערים אחרות לא נבחרו, אף שנמכרו בהן הרבה כרטיסים.

טעות נפוצה: לכתוב tickets > 2000 (ואז הופעה עם 2000 כרטיסים בדיוק לא תיבחר), או לשכוח את הגרשים סביב 'Haifa'.

מה נדרש – להשלים 5 ביטויים בפונקציה שמחזירה true רק אם בשדה phone יש 10 תווים בדיוק, שמתחילים ב-05, וכולם ספרות.

רעיון – לקרוא את ערך השדה לפי ה-id שלו; לפסול אורך שאינו 10; לפסול אם התו הראשון אינו 0 או התו השני אינו 5; ואז לעבור על שאר התווים (מהמקום 2, כי שני הראשונים כבר נבדקו) ולהחזיר false ברגע שמוצאים תו שאינו ספרה. אם הלולאה הסתיימה – המספר תקין.

פתרון

גם ביטויים שקולים מתקבלים, למשל ב-(4) !(x.charAt(i) >= '0' && x.charAt(i) <= '9'), וב-(3) x[1] != '5'.

הפונקציה המלאה:

function isValidPhone()
{
  var x = document.getElementById("phone").value;
  if (x.length != 10)
     return false;
  if (x.charAt(0) != '0' || x.charAt(1) != '5')
     return false;
  for (var i=2; i<x.length; i++)
  {
     if (x.charAt(i) < '0' || x.charAt(i) > '9')
        return false;
  }
  return true;
}

בדיקה:

בנוסף בדקנו את הפונקציה מול ההגדרה על כל המחרוזות מעל {0, 5, 9, a} עד אורך 10 (1,398,101 מחרוזות) – התוצאה נכונה בכולן.

טעות נפוצה: לכתוב ב-(3) && במקום || בתנאי כולו (או לחשוב שצריך x.charAt(1) == '5') – התנאי צריך להיות "אחד מהשניים שגוי", ולכן || עם !=. טעות נוספת: לכתוב phone בלי מירכאות.

מה נדרש: קוד צד שרת (C#) שמעביר את המטפס לאחד משלושה דפים לפי ערכי שלושה משתני Session.

רעיון:

פתרון (בקובץ ה-code behind של הדף):

protected void Page_Load(object sender, EventArgs e)
{
    int height = (int)Session["height"];
    bool parentOk = (bool)Session["parent_ok"];
    int climbs = (int)Session["climbs"];

    if (parentOk && (climbs >= 8 || height >= 160))
        Response.Redirect("advancedWall.aspx");
    else if (parentOk && height >= 120)
        Response.Redirect("beginnersWall.aspx");
    else
        Response.Redirect("infoPage.aspx");
}

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

טעות נפוצה:

מה נדרש: פונקציה ב-C# (צד שרת) שבודקת שבין כל שתי ספרות סמוכות במספר ההפרש הוא בדיוק 1, ושיש במספר לפחות שתי ספרות.

רעיון:

פתרון – הקוד המלא בלשונית C#:

public bool isStairs(int num)
{
    if (num < 10)
        return false;
    int prev = num % 10;
    num = num / 10;
    while (num > 0)
    {
        int d = num % 10;
        if (d - prev != 1 && prev - d != 1)
            return false;
        prev = d;
        num = num / 10;
    }
    return true;
}

בדיקה – מעקב על 4565 ועל 4566:

ב-4566: prev=6, d=6 ⇐ הפרש 0 ⇐ false כבר בסיבוב הראשון.

על הדוגמאות שבשאלה: 4565, 10, 98789, 3210 ⇐ True; ‏4566, 1357, 7, 120 ⇐ False.

טעות נפוצה: לבדוק רק "עולה ב-1" (d - prev == 1) – אז 4565 יחזיר בטעות false; או לשכוח את המספרים החד-ספרתיים – בלי הבדיקה בהתחלה הלולאה לא מתבצעת והפונקציה תחזיר true עבור 7.

מה נדרש: מספר החניונים (כמה שורות) שבהם spaces גדול או שווה ל-200.

רעיון: מסננים ב-WHERE את השורות עם spaces >= 200 ("לפחות" = גדול או שווה), וסופרים אותן ב-COUNT(*).

פתרון:

SELECT COUNT(*) AS bigLots
FROM ParkingLots
WHERE spaces >= 200;

בדיקה: על טבלת הדוגמה: 350, 200, 500 עומדים בתנאי; 120, 80, 150 לא. התקבל 3, כמו בדוגמה.

טעות נפוצה: לכתוב spaces > 200 – אז חניון הים (בדיוק 200) לא ייספר ויתקבל 2.

מה נדרש: הערך הגדול ביותר בעמודה hourPrice.

רעיון: פונקציית הצבירה MAX מחזירה את הערך הגדול ביותר בעמודה. אין צורך ב-WHERE – בודקים את כל החניונים.

פתרון:

SELECT MAX(hourPrice) AS topPrice
FROM ParkingLots;

בדיקה: המחירים הם 12, 8, 15, 6, 10, 9. התקבל 15, כמו בדוגמה.

טעות נפוצה: לכתוב SELECT hourPrice FROM ParkingLots WHERE hourPrice = MAX(hourPrice) – אי אפשר להשתמש בפונקציית צבירה בתוך WHERE.

מה נדרש: שם ומספר מקומות של כל חניון שבו nightCars > 2 · morningCars.

רעיון: בוחרים את העמודות lotName ו-spaces, ובתנאי WHERE משווים עמודה אחת לביטוי חשבוני על עמודה אחרת באותה שורה (2 * morningCars).

פתרון:

SELECT lotName, spaces
FROM ParkingLots
WHERE nightCars > 2 * morningCars;

בדיקה: על טבלת הדוגמה:

(150 > 120, 180 > 100, 130 > 120; לעומת זאת 40 < 600, 30 < 200 ו-10 < 140.)

טעות נפוצה: לכתוב nightCars * 2 > morningCars – הכפל על העמודה הלא נכונה.

מה נדרש: סכום העמודה morningCars, רק בשורות שבהן hourPrice < 10.

רעיון: קודם WHERE מסנן את השורות (החניונים הזולים), ואחר כך פונקציית הצבירה SUM מחברת את morningCars בשורות שנשארו.

פתרון:

SELECT SUM(morningCars) AS morningCheap
FROM ParkingLots
WHERE hourPrice < 10;

בדיקה: החניונים שמחירם קטן מ-10: חניון השוק (100), חניון הספרייה (70), חניון המרכז (60). חניון האצטדיון (בדיוק 10) לא נכלל. 100 + 70 + 60 = 230 – התוצאה 230, כמו בדוגמה.

טעות נפוצה: לשכוח את ה-WHERE – אז מתקבל סכום כל החניונים (640); או לכתוב <= 10 ולקבל 280.

מה נדרש – להשלים את סוף הפעולה: לפי השורות שהשאילתה החזירה (כל ההזמנות של הטלפון שהוקלד) להחליט לאן להפנות.

רעיון

פתרון – הקוד שנכתב במקום הכוכביות:

if (ds.Tables[0].Rows.Count == 0)
{
    Response.Redirect("newCustomer.aspx");
}
else
{
    int sum = 0;
    foreach (DataRow dr in ds.Tables[0].Rows)
    {
        sum += int.Parse(dr["total"].ToString());
    }
    if (sum >= 1000)
    {
        Session["vip"] = true;
        Response.Redirect("vip.aspx");
    }
    else
    {
        Response.Redirect("regular.aspx");
    }
}

הפעולה המלאה:

protected void CheckCustomer(string connectionString){
    SqlConnection connection = new SqlConnection(connectionString);
    SqlCommand command = new SqlCommand();
    DataSet ds = new DataSet();
    command.CommandText = string.Format("Select * From orders Where phone = '{0}'",
    Request.Form["phone"]);
    command.Connection = connection;
    connection.Open();
    SqlDataAdapter adapter = new SqlDataAdapter(command);
    adapter.Fill(ds);
    connection.Close();

    // ---- the missing code ----
    if (ds.Tables[0].Rows.Count == 0)
    {
        Response.Redirect("newCustomer.aspx");
    }
    else
    {
        int sum = 0;
        foreach (DataRow dr in ds.Tables[0].Rows)
        {
            sum += int.Parse(dr["total"].ToString());
        }
        if (sum >= 1000)
        {
            Session["vip"] = true;
            Response.Redirect("vip.aspx");
        }
        else
        {
            Response.Redirect("regular.aspx");
        }
    }
}

בדיקה – הפעולה המלאה על הטבלה orders מהשאלה:

הלקוח 054-3333333 בודק את הגבול: 1000 בדיוק הוא "1000 לפחות".

טעות נפוצה: לבדוק רק את השורה הראשונה (Rows[0]["total"]) – עבור 050-1111111 מתקבל 450, והלקוח יופנה בטעות ל־regular.aspx למרות שסכום הזמנותיו 1150. טעות נוספת: לאפס את sum בתוך הלולאה, או לכתוב sum > 1000.

מה נדרש – לכתוב מחרוזת SQL ולהציב אותה ב-command.CommandText.

רעיון

פתרון

command.CommandText = "SELECT title, price FROM Paintings " +
                      "WHERE likes > 3 * dislikes AND RIGHT(title, 1) = RIGHT(painter, 1)";

(המחרוזת מפוצלת לשתי שורות בעזרת + רק לנוחות הקריאה; שימו לב לרווח בסוף החלק הראשון, אחרת יתקבל PaintingsWHERE.)

אותה לוגיקה בכתיב SQL אחר, שבו במקום RIGHT משתמשים ב-substr עם מיקום שלילי:

SELECT title, price
FROM Paintings
WHERE likes > 3 * dislikes AND substr(title, -1, 1) = substr(painter, -1, 1);

בדיקה – על טבלת הדוגמה:

השאילתה מחזירה שורה אחת – Sunset | 5000 – ולכן הפעולה תדפיס Number of paintings: 1. בטבלה מורחבת הוספנו את The Swan / Rubin עם 301 "אהבתי" ו־100 "לא אהבתי" – הוא הוחזר (301 > 300), ואילו ציור עם אותיות אחרונות שונות לא הוחזר גם כשהיו לו הרבה "אהבתי".

טעות נפוצה: להשתמש ב-LEFT במקום RIGHT, או לכתוב likes >= 3 * dislikes ("גדול מ..." הוא גדול ממש).