תנאי If - Else - חלק 3
string מחזיקים את שם המשתמש והסיסמה שהמשתמש הכניס. הערכים האלה נבדקים מול שם משתמש וסיסמה שהוגדרו מראש.if בודק ששם המשתמש והסיסמה נכונים יחד בעזרת && (וגם). אם כן, הדף הבא נפתח.else if ראשון מזהה שם נכון וסיסמה שגויה, ומציג הודעה מתאימה. else if שני מזהה שם שגוי, ומציג הודעה אחרת.if או else אפשר לכתוב בלי סוגריים מסולסלים. כשיש שתי שורות ומעלה, הסוגריים חובה.bool isCredential = (...) ? true : false; שומר את תוצאת הבדיקה, ואחר כך if (isCredential) בודק את המשתנה.if (enteredUserName == validUserName && enteredPassword == validPassword)bool isCredential = (enteredUserName == validUserName && enteredPassword == validPassword) ? true : false;פרקי ההרצאה: תנאי If - Else - חלק 3
תמלול ההרצאה: תנאי If - Else - חלק 3
הטקסט המלא של הדקות הראשונות בהרצאה «תנאי If - Else - חלק 3» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
שלום, שמי אבי, ובהרצאה היום אני הולך להסביר על משפטי בקרה ותכנות, ספציפית על משפטי בקרה מסוג של If-Else ו-Conditional Operator.
אז בסוף ההרצאה הזאת הייתם צריכים לדעת מה הם משפטי בקרה של If-Else ו-Conditional Operator, באיזה הקשרים נעשה בהם שימוש, מתי משתמשים במשפטי בקרה כאלה בתוכניות, וכמובן המהות של ההרצאה זה איך כותבים משפטי בקרה כאלה בקוד.
אז בואו נעבור לשאלה הטריוויאלית של מה הם בעצם משפטי בקרה מסוג של if-else או מה הם משפטי בקרה של תנאים בקוד בכלל.
אז קודם כל, כשתוכנית מחשב מתבצעת, כל תוכנית מחשב כמעט היא מתבצעת כרצף של פעולות, של פקודות שהמתכנת החליט עליהן, ממש אחת אחרי השנייה.
וכשהפקודה האחרונה בתוכנית מסתיימת, התוכנית גם מסתיימת. יש הרבה מאוד מצבים שהמתכנת מעוניין לקבל שליטה על מה מתבצע והוא לא רוצה שהתוכנית תתבצע ברצף אלא הוא רוצה שמשהו מסוים יתבצע אם תנאי מסוים קורה כלומר הוא רוצה לקבל החלטות במהלך הריצה של התוכנית ולפי ההחלטות האלה הוא רוצה שהתוכנית תבצע חלק מסוים ממה שהוא כתב
או לא תבצע חלק מסוים ממה שהוא כתב ובדיוק לשם כך קיימים משפטי if-else, הם מאפשרים לנו לבצע את זה כל מיני דוגמאות שאתם בטח מכירים, אבל אולי לא התייחסתם אליהן בתור משפטי בקרה.
יכולים להיות, לדוגמה, תוכנית כספומט. אם אתם הולכים לכספומט ומקישים את הקוד הסודי שלכם, מתבצעת שם החלטה האם לתת לכם להמשיך הלאה או לא לתת לכם להמשיך הלאה.
אם אתם, האם הסיסמה שהכנסתם היא נכונה, אתם ממשיכים הלאה. אם היא לא נכונה, אתם לא ממשיכים הלאה, אתם מקללים איזו הודעה ומקישים עוד פעם אולי.
עוד דוגמא שכיחה זה דף כניסה לאתר אינטרנט. משתמש מכניס פרטים נכונים. אם הפרטים שלו נכונים, הוא נכנס הלאה. אם הם לא נכונים, הוא מקבל איזו הודעת שגיאה ומנסה להכניס את הפרטים שלו שוב.
עוד דוגמא מאוד שכיחה זה שדה להכנסת אימייל. מכיוון שאימייל זה שדה שמורכב משטרודל, מהתו של שטרודל, אם משתמש מזין את האימייל שלו ובטעות לא הזין את התו של השטרודל, אז האימייל שהוא הכניס הוא לא ולידי, הוא לא חוקי, אי אפשר להשתמש בו, ולכן צריכה להתבצע בדיקה על זה כדי להדע את המשתמש או
כדי לבצע איזושהי התרעה. אז בוא ניגש לדוגמה קטנה שיצרתי. אני יצרתי שתי דפי אינטרנט, שלמעשה המחיר שלנו הוא איך אפשר להשתמש במשפטי בקרה.
הדף הראשון מורכב למעשה מעין דף כניסה, מורכב משם משתמש וסיסמה וכפתור שלח. כשהמשתמש מכניס את השם שמשתמש בסיסמה הנכונים שלו ולוחץ השלח הוא אמור להגיע למסך הבא.
אם הפרטים שהוא הכניס הם שגויים הוא אמור לקבל איזו אינדיקציה שהפרטים שהוא הזין הם שגויים. אז בואו ניגש לקוד ונתחיל לכתוב אותו. אוקיי אז למי שלא יודע רק לצורך השיעור חלק הקוד הזה שנמצא בין הסוגר הזה לבין הסוגר הזה זה למעשה חלק הקוד שאנחנו מגיעים אליו שהתוכנית מגיעה אליו כאשר המשתמש לחץ לחיצה על הכפתור שלח.
אני הגדרתי פה שתי משתנים, משתנה אחד מסוג סטרינג, זה שנקרא Entered Username, זה למעשה משתנה שמייצג את השם המשתמש שהמשתמש הכניס, והמשתנה השני, Entered Password, מייצג את הסיסמה שהמשתמש הכניס.
כרגע שתיהם מאופסים, יש להם סטרינג ריק לשתיהם, אבל כשהמשתמש ילחץ על הכפתור, יהיה בשני המשתנים האלה ערכים, ואז אנחנו נוכל לבדוק אותם.
אז מול מה אנחנו נבדוק אותם? אנחנו רוצים לבדוק האם שם המשתמש והסיסמה שהמשתמש הכניס הם נכונים, אבל אנחנו צריכים לבדוק אותם מול שם משתמש וסיסמה כלשהם.
אז בואו נגדיר פה שני משתנים. המשתנה הראשון נקרא לו valid user name, שזה יהיה שם המשתמש הנכון שצריכים לבדוק מולו, ונקרא לו בשם שלי, אבי.
נגיד שהסיסמה הנכונה תהיה 1234. נראה לי די פשוט. אוקיי, עכשיו בואו נשים פה breakpoint. רייג פוינט, למי שלא יודע, זה דרך שבאמצעותה אנחנו יכולים לבדוק אם הקוד שרשמנו הוא נכון, לבדוק איך חלק מסוים מהקוד שלנו מתנהג, ולנקודה הזאת אנחנו מגיעים כאשר הפעולה שביצענו שקשורה לאותה נקודה מתרחשת.
אז בואו נתחיל לדבק. עכשיו בואו נכניס שם משתמש "אבי" ו-1234, נלחש לך. אנחנו רואים שהגענו לחלק הקוד הזה. אנחנו רואים ששם המשתמש שהמשתמש הכניס זה אבי, והסיסמה שהוא הכניס היא גם 1234. אבל אנחנו רוצים לבדוק האם הסיסמה שהוא הכניס היא באמת סיסמה נכונה, והאם השם המשתמש שהוא הכניס הוא שם משתמש נכון.
אז לאחר שאנחנו מגיעים לנקודה הזאת פה, אנחנו רוצים לבצע את הבדיקה הזאת. כדי לבצע את הבדיקה הזאת אנחנו הולכים לרשום את הדבר הבא if, שבאנגלית זה האם.
האם שם המשתמש שהמשתמש הכניס, שמיוצג על ידי המשתנה הזה, Entered Username, האם הוא שווה לשם המשתמש הזה? וגם, האם הסיסמה שהוא הכניס, שזו הסיסמה הזאת, שווה לסיסמה שמוגדרת פה?
כלומר, יש פה בדיקה. הסימן המוזר הזה שאתם רואים פה זה סימן שהמשמעות שלו זה "וגם". אנחנו עושים פה בדיקה האם שם המשתמש שווה לשם המשתמש שהגדרנו פה, והאם הסיסמה שהוא הכניס שווה לסיסמה שנמצאת פה.
לאחר מכן אנחנו פותחים סוגר סוגר מסולסל, יורדים עוד שורה או שתיים וסוגרים. חלק הקוד שנמצא בין הסוגר הזה לבין הסוגר הזה זה חלק הקוד שאנחנו הולכים להגיע אליו אם התנאי שמופיע פה הוא באמת נכון.
אם הפרטים שהוא הכניס הם נכונים אנחנו הולכים להגיע לחלק הקוד שנמצא פה. חלק הקוד הזה יהיה ששורת הקוד הזאת אומרת בסופו של דבר זה שהמשתמש מועבר לדף הבא.
כלומר, אם הפרטים שהוא הכניס פה הם נכונים, אנחנו נכנסים לחלק הקוד שמורכב כרגע רק משורה אחת, שנמצא בין הסוגר הזה לבין הסוגר הזה.
אבל אם הפרטים שהוא הזין לא נכונים, אלס, אחרת, אנחנו פותחים עוד פעם סוגר וסוגרים סוגר, אנחנו מגיעים לחלק הקוד שנמצא פה.
ופה אנחנו רוצים להציג למשתמש הודעת שגיאה שהמשתמש והסיסמה אינם נכונים, אנחנו רוצים שגם הוא יראה את זה, אוקיי? עכשיו, הסינטקס שרשום פה אולי לא ברור לחלקכם, אבל בשביל הדוגמה, מה ששתי השורות האלה אומרות זה את הדבר הבא:
תכניס הודעת שגיאה מסוימת, שהיא הודעת שגיאה הזאת, ותגרום להודעת שגיאה להיות ויזיבל, כלומר שהמשתמש יראה אותה. זה מה שזה אומר.
עכשיו בואו נראה שהתוכנית באמת עובדת. בואו נכניס את השם שלי, אבי, וסיסמה: 1234. נשלח. אוקיי, הגענו לנקודת הכות הזאת, בואו נתקדם הלאה.
אוקיי, עכשיו הגענו לשורה שבודקת את הפרטים שהזין המשתמש. המשתמש, כלומר אני הזנתי "אבי" ואני בודק האם השם המשתמש שהכנסתי "אבי" שווה למשתנה שהגדרתי פה, שזה גם "אבי", שזה נכון, והאם הסיסמה שהוא הכניס,
"1234" שווה לסיסמה שהזנתי, "1234", שהיא באמת נכונה. מכיוון שהבדיקה הזאת היא בדיקה נכונה, אנחנו עומדים להיכנס לשורה הזאתי, זאת אומרת נכנסנו לשורה הזאתי ואז אנחנו עומדים גם להיכנס לשורה הזאתי שבסופו של דבר אומרת תעביר את המשתמש לדף הבא, אז בואו ניתן לתוכנית לרוץ והמשתמש עבר לדף
הבא שלום אבי בוא נראה מה קורה כשהמשתמש מזין פרטים לא נכונים בוא נזין את השם שלי אבל במקום 1234 נזין 123 נחת שלח מתבצעת פה הבדיקה עכשיו אני הכנסתי אבי שזה באמת שווה לאבי אבל הסיסמה שהכנסתי היא 123 וזה לא שווה ל-1234 שהגדרתי פה.
לכן מה שיקרה זה שבמקום להיכנס לפה, לסוגר הזה, אני עומד להיכנס לפה. בדיקה פה לא הצליחה, לכן אני נכנס לפה. ומה שמופיע פה זה אני מכניס הודעת שגיאה מסוימת וגורם לה שההודעת שגיאה תהיה שם משתמש יראה אותה.
והנה הודעת שגיאה. אוקיי, עוד דבר קטן לפני שאני אעבור הלאה. שימו לב שיש פה סוגר, פותח, וסוגר, סוגר. יש פה שתי סוגרים.
עכשיו, אם יש לי שורת קוד אחת לאחר הif, או שורת קוד אחת לאחר הelse, אני יכול לוותר על שתי הסוגרים האלה ולהשאיר את זה ככה. אם התנאי פה באמת יהיה נכון, אני עדיין אכנס לפה.
כלומר, בהנחה שיש לי שורת קוד לאחר הif, ובהנחה שיש לי שורת קוד לאחר הelse, אני יכול לוותר על שני הסוגרים האלה. אבל פה יש לי שתי שורות קוד, לכן אני חייב להשאיר את שני הסוגרים האלה שם.
אז זה פרט מאוד חשוב. אני אישית מעדיף תמיד לשים סוגר פותח וסוגר סוגר, כי זה יותר קריב ויותר ברור. אז זה בנוגע לזה.
עכשיו, יש עוד חלק מסוים ממשפט בקרה של if ו-else, שגם חשוב שתדעו אותו והוא גם נמצא בשימוש. בוא נגיד שפה אני בודק האם שם המשתמש שהכנסתי שווה לשם המשתמש שנמצא פה, וגם הסיסמה שהכנסתי שווה לסיסמה שהגדרתי פה.
כלומר, אני רוצה לוודא שגם זה קורה וגם זה קורה. אבל בוא נניח שהאזנתי סיסמה, בוא נגיד, לא נכונה, אבל שם המשתמש שהאזנתי הוא נכון.
אז אני רוצה להציג לו, המשתמש, הודעת שגיאה אחרת. אני לא רוצה להציג לו ששם המשתמש והסיסמה אינם נכונים, כי זה לא נכון.
במקרה הזה אני רוצה להגיד לו שהסיסמה שלך היא לא נכונה. אז במקרה כזה יש סינטקס דרך בשפה שבה אנחנו רושמים את זה. אז מיד לאחר הסוגר הזה אני לוחץ Enter ורושם Else, בדיוק כמו שמופיע לי למטה, אבל אני רושם אחר כך If.
כלומר, זאת עוד בדיקה שאני עומד לבצע. האם השם, האם שם המשתמש שהוכנס שווה לשם המשתמש שהגדרתי, ו-Entered, והאם הסיסמה שהוא הכניס שונה מהסיסמה שאני הגדרתי.
כלומר, פה אני מבצע בדיקה שהיא שונה מהבדיקה שאני ביצעתי פה. פה אני בודק עכשיו האם השם המשתמש שהכנסתי הוא נכון, אבל הסיסמה שהכנסתי לא נכונה. פה יש אלס, אחרת אם מה שקורה פה מתרחש, עוד פעם אני פותח סוגר, סוגר, סוגר, ופה אני עוד פעם רוצה להציג למשתמש הודעת שגיאה, אבל הודעת שגיאה אחרת שתתאים למצב הזה,
והיא שם המשפט שהסיסמה שהוזנה שגויה ולדאוג לכך שהמשתמש יראה את ההודעה הזאתי, אוקיי? עכשיו בואו נריץ זה ונראה איך זה מתנהג.
אוקיי, אז בואו אני אזין אבי וסיסמה 123 שהיא סיסמה שגויה. הגענו לפה, עכשיו אנחנו עוברים ומגיעים לפה. שם המשתמש שהוא הזין אבי שווה לאבי, תקין.
והסיסמה שהוא הגיש 123 היא שונה מ-1234 ולכן אנחנו עוברים לבדיקה הבאה אם זה נכשל בוא נראה מה קורה הלאה אנחנו בודקים עכשיו האם שהמשתמש הוא שווה לאבי שזה באמת נכון והסיסמה שהוא הכניס 123 שונה מהסיסמה שהוגדרה פה שזה באמת נכון סיסמה שגויה הסיסמה שגויה שהמשתמש נכון ולכן אנחנו מגיעים
כזה, וממשיכים הלאה, מכניסים את ההודעת שגיאה ודואגים לכך שתהיה זמינה. הסיסמה שהוזנה שגויה. כלומר, יש לנו אפשרות לעשות עוד בדיקה.
למעשה, יש לנו אפשרות לעשות עוד בדיקות רבות. אנחנו יכולים להמשיך ולרשום פה else if, ולדוגמה במקרה הזה, האם השם המשתמש שהוכנס שונה משם המשתמש שאני הגדרתי והסיסמה שהוכנסה שווה לסיסמה שאני הגדרתי.
במקרה הזה אני רוצה להציג מן הסתם הודעת שגיאה אחרת. אני רוצה להציג ששם המשתמש שהוזן שגוי, ולדאוג לכך שהמשתמש יראה את זה.
בואו נריץ את זה ונראה איך זה עובד. בואו נזין פה במקום "אבי" נזין "יוסי", והסיסמה תהיה הסיסמה הנכונה, 1234. בואו נראה מה קורה.
שם המשתמש "יוסי" לא שווה לאבי. סיסמה 1234 שווה, כלומר, הפנה הזה נכשל. עוברים לתנאי הבא, שהיה משתמש יוסי שווה לאבי, לא נכון. הסיסמה היא אותה סיסמה, אז זה גם לא נכון.
עוברים לתנאי הבא, שהיה משתמש יוסי שונה מאבי, נכון מאוד, הוא שונה. והסיסמה, 1234 שווה ל-1234, נכון מאוד. אנחנו מגיעים לחלק הזה, וממשיכים הלאה.
שהיה משתמש שהוא זן שגוי. אוקיי, אז התוכנית מתפקדת כהלכה. כמו שראינו, אנחנו מבצעים פה כל מיני בדיקות, ולפי הבדיקות שאנחנו מבצעים פה, אנחנו מבצעים חלקים מסוימים מהקוד.
אז במקרה הזה, לדוגמה, ביצענו את החלק הזה ולא המשכנו הלאה, או במקרה הזה ביצענו את החלק הזה ולא המשכנו הלאה, ולא המשכנו בשורה הזאת.
אז יש לנו אפשרות של בקרה, יש לנו אפשרות לבדוק מה מתרחש, ולפי מה שמתרחש לבצע פעולה מסוימת. עכשיו, יש עוד משפט בקרה שמאפשר לנו לבצע את זה, שהוא משפט מאוד יעיל, בואו נכתוב את זה פה, אוקיי.
המשפט הזה הוא דומה מאוד לצורת כתיבה של המשפט הזה, אבל בשביל זה אני אגדיר פה עוד משתנה, אני אגדיר פה למעלה. אני אגדיר משתנה מסוג בול, true או false, נקרא לו isCredential.
אוקיי, הגדרתי פה עכשיו משתנה. עכשיו, המשתנה הזה אמור לקבל את התוצאה האם הפרטים שהמשתמש הכניס הם נכונים. כלומר, כל החלק הזה שמתבצע פה, כל הבדיקה הזאת שביצעתי פה, או פה, או פה, אבל לצורך הדוגמא אני אקח את הבדיקה הזאת.
הצעתי פה איזה בדיקה: האם שם המשתמש שהמשתמש הכניס שווה לשם המשתמש שהגדרתי פה, והאם הסיסמה שהוא הכניס שווה לסיסמה שהגדרתי פה. אז את כל החלק הזה אני יכול לכתוב בצורה אחרת.
אז בואו נעשה את הדבר הבא: אני רוצה רק לבדוק ששם המשתמש שהמשתמש הכניס שווה לשם המשתמש שאני הגדרתי, וגם הסיסמה שהוא הכניס שווה לסיסמה שאני הגדרתי.
עד לפה החלק הזה והחלק הזה דומים עכשיו פה מגיע שינוי קטן אני כותב את הדבר הזה בשתי סוגריים ולאחר מכן מקליד סימן שאלה מה שזה אומר זה במקום לכתוב האם הדבר הזה נכון אני רושם את זה קודם כל ואז עושה סימן שאלה שזה למעשה אופרטור בשפת התכנות אופרטור זה חלק מסוים מהקוד שמבצע פעולה מסוימת אז פה מדובר פה על בדיקה.
האם הדבר הזה הוא נכון? סימן שאלה. סימן שאלה זה הסימן שמייצג האם זה נכון. אם זה נכון, אני רוצה לתת למשתנה הזה פה את הערך של חרת, אני נותן לו את הערך של false.
בואו נסביר שוב פעם את מה שיש לנו בשורה הזאת. זה נראה קצת מבלבל, אבל בסופו של דבר זה מאוד פשוט. מה שיש לנו פה זה בדיקה שהיא זהה בדיוק לבדיקה שיש לנו פה.
רק מה? אנחנו שינינו פה את הסדר. במקום שהבדיקה תהיה אחרי, היא מופיעה ראשונה. פה יש לנו if האם הדבר הזה נכון, נבצע את זה.
פה יש לנו את החלק של הבדיקה, ולאחריו סימן שאלה. הסימן הזה למעשה מייצג את אופרטור ההתניה. אנחנו רוצים עכשיו לבדוק משהו. אנחנו רוצים לבדוק את הדבר הזה, האם זה נכון.
אם זה נכון, אנחנו מעבירים את ה-true הזה למשתנה הזה. אם זה לא נכון, אנחנו מעבירים את ה-false למשתנה הזה. ומה אנחנו עושים עם המשתנה הזה?
אנחנו נבדוק האם המשתנה הזה אותרו, ואז אנחנו עושים את מה שעשינו בשורה הזאת למעשה. אחרת, אנחנו עושים את מה שעשינו בשורה בשתי השורות האלה.
אפילו בואו נעתיק אותן. אוקיי, כמו שאתם רואים, יש כמה דרכים בשפת התכנות לבצע בדיקות ולהחליט מה מתבצע ואיך.
במקרה הזה יש לנו גם בדיקה כזאת ואז עוד בדיקה כזאת, ככה שזה נראה מיותר, וזה באמת מיותר, אבל לצורך ההדגמה, הצקתי את האפשרות הזאתי.
אבל שימו לב שהאפשרות הזאתי בהרבה מאוד מקרים היא יעילה. מדובר פה על שורת קוד אחת שאם אין אחריה עוד בדיקה אז היא בהחלט טובה.
אז זה סוף ההרצאה הזאת בנושא הזה. בהרצאה הבאה אני אדבר על עוד משפט בקרה שקשור להתניה שנקרא Switch Case. הוא שונה משני המשפטי בקרה האלה מבחינת איך שהוא איכשהו בנוי באופן מהותי אבל המהות שלו היא די דומה אז נתראה בהרצאה הבאה