[סקירה: 1 חידון]
 [עלי Nahm, Oreoluwa Barbarinsa, לוקאס פרייטס, רוב אודן] [אוניברסיטת הרווארד]
 [זה CS50.] [CS50.TV]
 [לוקאס פרייטס] ברוכים הבאים לכולם. זו ביקורת לחידון 1.
 בדיוק כמו ויתור, זה - אני מתכוון, אנחנו הולכים לנסות לכסות
 חומר רב ככל האפשר, אבל זה לא אומר ש
 אנחנו הולכים כדי לכסות את כל הדברים שיכולים להיות בחידון 1.
 אז כדי להיות בטוח גם אתה תסתכל בהרצאה, חלקים, כל מה שאתה יכול.
 חידון 1 הולך להיות ביום רביעי, ביום רביעי הבא.
 כדי להיות בטוח כדי ללמוד. זה הולך להיות, פחות או יותר, כמו החידון הראשון
 לגבי הפורמט שלה, אבל זה כנראה הולך להיות הרבה יותר קשה.
 לפחות, בשנה שעברה כאשר לקחתי 50, חשבתי שזה היה הרבה יותר קשה.
 אז ללמוד הרבה.
 

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

ראשית, רשימות מקושרות. רשימות מקושרות הן למעשה דומות מאוד למערכים,
 אבל ההבדל בין רשימה מקושרת ומערך,
 קודם כל הוא, שיש לו רשימה מקושרת בגודל גמיש מאוד,
 בעוד שבמערכים אתה צריך גם לבחור גודל גדול מאוד למערך,
 אז אתה יודע שאתה הולך להיות מסוגל לאחסן את כל הנתונים שלך במערך זה,
 או שאתה צריך להשתמש malloc יש אורך גמיש של מערך.
 ברשימות מקושרות זה קל מאוד רק כדי לקבל יותר אלמנטים,
 לשים יותר אלמנטים ברשימה המקושרת או להסיר אלמנטים.
 ובעצם, אם אתה לא רוצה הרשימה המקושרת להיות מסודרת,
 אתה יכול לחפש ולהסיר את האלמנטים בזמן קבוע,
 כך O (1) זמן, כך שזה מאוד נוח.
 אתה פשוט צריך להיות זהיר תמיד לזכור malloc ובחינם צמתים,
 רק בגלל שאם לא תעשה זאת, תהיה לך דליפות זיכרון.
 רשימות קשורות כל כך - ההגדרה של צומת היא בדיוק כמו מה שיש לנו שם.
 שמתי n int, אבל אתה יכול לאחסן את כל הנתונים שאתה רוצה.
 אז אם אתה רוצה לאחסן מחרוזת, שזה בסדר.
 אם ברצונך לאחסן struct, שזה בסדר, כפול, מה שאתה רוצה.
 אני פשוט לשים n int לדוגמות כאן.
 ויש לך מצביע לצומת הבאה.
 אז, בעצם, יש רשימה מקושרת נתונים מסוימים, ולאחר מכן הוא מצביע לצומת הבאה.
 אם זה האלמנט האחרון ברשימה המקושרת, זה הולך להצביע על NULL.
 אז זו דוגמא לרשימה מקושרת.
 

אוקיי, אז עכשיו בואו נראה מה אנחנו צריכים לעשות אם אני רוצה להכניס אלמנט ברשימה מקושרת.
 ראשית, הוספת פונקציה תהיה של חלל הסוג
 כי אני לא רוצה לחזור כל דבר.
 ואני הולך לקחת int כטיעון,
 כי אני רוצה לדעת מה אני רוצה להוסיף.
 אז מה הדבר הראשון שאני צריך לעשות? ובכן, אני צריך malloc על newnode,
 כך הוא השורה הראשונה.
 אני רק יוצר צומת חדש לשים ברשימה מקושרת.
 אז מה אני יכול לעשות? ובכן, אנו יודעים כי ביישומים של רשימות מקושרות שלנו
 בכיתה, אנחנו תמיד לשים את הראש כמשתנה גלובלית.
 אז מה אנחנו יכולים לעשות הוא לשנות את הראש.
 אני יכול להפוך את הצומת חדשה זה תהיה הראש החדש,
 וזה הולך כך שיצביע על הראש הקודם.
 איך אנחנו יכולים לעשות את זה? הדבר הראשון שאני צריך לעשות
 הוא לשנות את 'n' בצומת החדשה לערך,
 שמועבר לפונקציה.
 אז newnode הלאה הולך להיות בראש.
 הראש הולך להיות newnode. אז זה די פשוט.
 למחיקת צומת, אנחנו יכולים לעשות את זה כמו -
 אחת דרכים שאנו יכולים לעשות את זה היא אומר,
 בסדר, אם אני רוצה למחוק, למשל, 3,
 מה שאני יכול לעשות הוא רק להצביע על הצומת הקודמת
 לצומת הבאה של 3.
 אז הייתי עושה משהו כזה פשוט.
 אבל מה הבעיה עם עושה את זה?
 יש לי דליפת זיכרון, ולכן אין לי גישה למספר 3 יותר.
 הבעיה עם זה היא שאני לא הולך להיות מסוגל לשחרר את הצומת.
 אני הולך יש דליפת זיכרון ו( לא ברורה) הולכת לשנוא אותי.
 אז במקום לעשות את זה, צריך כנראה יש לי מצביע זמני.
 אז שמתי את טמפ. זה הולך להצביע לקשר שאני רוצה למחוק.
 ואז אני יכול להזיז את צמתים הקודמים לנקודה לקשר הבא
 של הצומת שאני רוצה למחוק.
 ולבסוף, אני יכול לשחרר את המצביע.
 האם אני צריך לשחרר את המצביע שאני יצרתי ממש שם?
 אין לי, רק בגלל ש--
 ההבדל הוא שצומת זה נוצרה באמצעות malloc,
 כך שזה בערימה, ואילו זה היה רק ​​הכריז כמתג NULL בערימה. אז אני לא צריך לשחרר אותו.
 

אוקיי. אז עכשיו בואו נדבר על ערימות.
 ערימות הן די פשוטות.
 עשינו את ערימות ותורים בכיתה רק באמצעות מערכים,
 אבל אתה צריך להיות מוכר - רק להיות מודע
 כי אתה גם יכול לעשות את הערימות בתורים באמצעות רשימות מקושרות גם כן.
 אז אם יש לך מערך, מה יהיה ערימה?
 מחסנית, ראשונה, תצטרך להיות בגודל.
 אתה צריך לאחסן את מה שהוא בגודל של הערימה שיש לך עכשיו.
 וגם היית צריך מערך, במקרה זה של מספרים,
 אבל אם אתה רוצה, זה יכול להיות מערך
 של מחרוזות, מערך של struct, כל דבר שברצונך לאחסן.
 על הערימה: ההבדל בין ערימה ורשימה מקושרת
 הוא שבמחסנית יש לך רק גישה לאלמנט האחרון שהוכנס למחסנית.
 זה נקרא אחרון נכנס, ראשון יוצא.
 בדיוק כמו שיש לך ערימה של מגשים,
 אם אתה שם את מגש על ראש הערימה,
 אתה צריך להסיר את המגש שראשון שיש להם גישה למגשים האחרים.
 זה אותו הדבר עם ערימות.
 אז אם אני רוצה, למשל, להוסיף אלמנט למחסנית, מה אני צריך לעשות?
 זה נקרא לדחוף, וזה די פשוט.
 הדבר הראשון שאתה צריך לעשות הוא לבדוק אם הגודל של המחסנית
 אינו גדול או שווה לקיבולת של המחסנית.
 כי אם אתה כבר בתפוסה מלאה, אתה לא יכול להוסיף עוד משהו.
 ולאחר מכן, אם לא, אתה רק צריך להוסיף את האלמנט לערימה.
 ולבסוף, להגדיל את הגודל. אז זה די פשוט.
 אז אני פשוט להוסיף את המספר 2.
 ואם אני רוצה לקפוץ, מה שאומר שאני רוצה להסיר
 האלמנט האחרון שנוסף ולהחזיר את הערך של האלמנט,
 הדבר הראשון שצריך לבדוק הוא שהמחסנית אינה ריקה.
 כי אם זה ריק, אני לא יכול להחזיר כלום.
 במקרה כזה, אני מחזיר -1.
 אחרת, אני הולך הפחת הגודל של המפרט,
 ולחזור מספרים (s.size).
 למה אני הפחת הגודל ולאחר מכן לחזור s.size?
 זה בגלל, במקרה זה, המפרט יש גודל 4,
 ואני רוצה להחזיר את היסוד הרביעי, נכון?
 אבל מה הוא המדד של האלמנט הרביעי? שלוש.
 מאז אני גודל - הוא הולך להיות 3, אני יכול רק לחזור s.numbers (s.size)
 בגלל שזה 3. אז זה רק המדד.
 

עכשיו תורים. תורים הם פחות או יותר את אותו הדבר.
 ההבדל היחיד הוא שבמקום שיש אחרון, את הראשון,
 יש לך ראשון, את הראשון.
 סביר להניח שאם אתה מחכה ללכת לקונצרט,
 לא היית שמח אם היה לך ערימה במקום לתור.
 להיות האדם האחרון שיבוא יהיה האדם הראשון שנכנס לקונצרט.
 אתה כנראה לא יהיה מאושר.
 בתור, האדם הראשון כדי לקבל בהוא גם האדם הראשון לצאת.
 אז בהגדרה של תור, חוץ מזה שיש את הגודל במערך,
 אתה גם צריך שתהיה לי הראש, המהווה את המדד לראש הערימה.
 אז האלמנט הראשון עכשיו.
 הוסף לתור הוא אותו הדבר כמו לדחוף לערימות.
 אם היית נאיביים מאוד, היית אומר רק,
 כן, אני יכול פשוט לעשות בדיוק את אותו הדבר כמו שעשיתי לדחיפה.
 אני רק יכול לבדוק אם זה לא מעבר ליכולת.
 אם כן, אני חוזר שווא, אחרת אני יכול פשוט לייצא את הערך החדש
 ולאחר מכן להגדיל את הגודל.
 אבל למה זה לא בסדר?
 בואו לראות את הדוגמא הזאת.
 אני מנסה Enqueue חבורה של דברים,
 ולאחר מכן אני הולך dequeue וEnqueue.
 יש הרבה פקודות, אבל זה מאוד פשוט.
 אני הולך Enqueue 5, אז תוסיף 5, ולאחר מכן 7,
 1, 4, 6, ולאחר מכן אני רוצה dequeue משהו,
 מה שאומר שאני הולך להסיר את האלמנט הראשון.
 אז אני הולך להסיר את המספר 3, נכון?
 האלמנט הראשון. אוקיי.
 עכשיו, אם אני מנסה Enqueue משהו אחר, מה הולך לקרות?
 על פי הביצוע שלי,
 אני הולך לשים את המספר הבא בq.size המדד.
 במקרה זה, הגודל הוא 8,
 כך המדד 8 יהיה ממש כאן בתפקידו האחרון.
 אם אני מנסה Enqueue 1 ממש כאן, הייתי להחליף בתפקידו האחרון
 למספר 1, שהוא טועה לחלוטין.
 מה שאני רוצה לעשות הוא לעטוף ולעבור לעמדה הראשונה.
 אולי היית אומר פשוט, טוב, אני רק צריך לבדוק
 אם אני באמת יכול לשים שם משהו.
 אם לא, אני רק אומר, אה, הקיבולת מלאה החדשה
 הוא למעשה יכולת - 1, ואתה לא יכול לשים את אלמנט שם.
 אבל מה הבעיה? הבעיה היא שאם אני רק dequeue הכל נכון כאן
 ולאחר מכן אני מנסה להוסיף משהו אחר, זה הייתי אומר רק,
 טוב, היית במלוא יכולתו, אשר היא 0.
 אז התור שלך נעלם.
 אתה צריך לעטוף, ודרך של גלישה מסביב
 שאתם למדו בחזון והאחר psets השתמשו mod.
 אתה יכול לנסות את זה בבית כדי להבין למה היית עושה q.size + q.head
 קיבולת mod, אבל אם תבדוק כאן,
 אנו יכולים לראות שזה עובד.
 אז בדוגמא האחרונה, q.size היו 8
 והראש היה 1, כי זה היה תפקיד זה כאן של המערך.
 אז זה יהיה 8 + 1, 9. Mod קיבולת 9 תהיה 0.
 זה הייתי הולך למדד 0. אנחנו נהיה במצב הנכון. ולאחר מכן לנסות את התור בבית.
 כמה דברים חשובים: לנסות להבין את ההבדל בין ערימה ותור.
 בבית, לנסות להשיג מאוד מוכר עם יישום Enqueue, dequeue, לדחוף ופופ.
 וגם להבין מתי היית משתמש כל אחד מהם.
 

אז בואו להירגע ל10 שניות עם חבורה של Pokemons.
 ועכשיו בואו נחזור למבני נתונים.
 חשיש שולחנות. הרבה אנשים פחדו משולחנות חשיש.
 בבעיה להגדיר 6, בודק איות.
 שולחנות ומנסים חשיש, הרבה אנשים נבהלים מהם.
 הם חושבים שהם כל כך קשים להבנה. כן?
 [רוב אודן] הבעיה להגדיר 5. 

בעיה להגדיר 5, כן. תודה רוב.
 כן. שש היו הף n 'פאף, כן.
 בעיה להגדיר 5 היה בודק איות, ואתה הייתי צריך להשתמש גם שולחן חשיש או לנסות.
 הרבה אנשים חשבו שהם היו סופר קשים להבנה, אבל הם בעצם די פשוט.
 מהו שולחן חשיש, בעצם? שולחן חשיש הוא מערך של רשימות מקושרות.
 ההבדל היחיד בין מערך ושולחן חשיש
 הוא שבשולחן החשיש יש לך משהו שנקרא פונקצית חשיש.
 מה היא פונקצית חשיש?
 אני לא יודע אם אתם יכולים לקרוא כאן.
 זוהי דוגמא של שולחן חשיש.
 אז אתה יכול לראות שיש לך מערך עם 31 באלמנטים.
 ומה שאנחנו עושים בשולחן חשיש יש פונקצית חשיש
 כי הוא הולך לתרגם מפתח, כל int למדד.
 אם, למשל, אם אני רוצה לבחור לB. Harrison,
 הייתי שם ב 'הריסון בפונקציות החשיש שלי,
 ופונקציית hash תחזור 24.
 אז אני יודע שאני רוצה לאחסן ב 'הריסון ב24.
 אז זה ההבדל בין סתם מערך ויש להם שולחן חשיש.
 בשולחן החשיש תצטרך פונקציה שהולכת לספר לכם
 היכן לאחסן את הנתונים שברצונך לאחסן.
 לפונקצית החשיש, אתה רוצה לחפש פונקצית חשיש
 כי הוא דטרמיניסטי ומופץ היטב.
 כפי שאתם יכולים לראות כאן, אתה רואה שהרבה נתונים שאני רוצה חנות היה למעשה 19
 במקום להשתמש ביום 31 וב30 ו29, שכולם היו חופשיים.
 אז פונקצית החשיש שנהגתי לא הייתה מופצת היטב.
 כאשר אנו אומרים מופצים היטב, זה אומר שאנחנו רוצים להיות,
 בערך, לפחות 1 או 2 לכל אחד מ--
 כמו, הבדל של 1 או 2 לכל אחד מהמדדים במערכים.
 אתה רוצה להיות, פחות או יותר, אותו המספר של אלמנטים בכל רשימה מקושרת במערך.
 ואת זה קל לבדוק אם זה חוקי בשולחן החשיש, להציג טבלאות חשיש.
 

אז עצים. זה עץ.
 עצים במדעי מחשב הם במהופך מסיבה כלשהי.
 אז כאן יש לך את השורש של העץ ולאחר מכן את העלים.
 אתה פשוט צריך לדעת את המינוח להורים ולילדים.
 יש כל צומת ילדיה, שהם צמתים שנמצאים מתחת להורה.
 כך, למשל, 2 הולכים להיות ההורה ל3 ועבור הילד השני ממש שם,
 תוך 3 הולכים להיות ההורה ל1 וילדים האחרים שנמצאים שם.
 ו1 הולך להיות של 3 ילדים, וכן הלאה.
 יש לנו משהו הרבה יותר מעניין, שנקרא עץ חיפוש בינארי,
 שבו כל הערכים בצד הימין של צומת
 הולך להיות בצד הימין, ממש כאן - בצד הימין,
 הולכים להיות גדול יותר מהאלמנט בשורש.
 אז אם יש לי המספר 5 ממש כאן, את כל האלמנטים בצד הימין
 הולכים להיות גדול מ 5, ועל השמאל
 כל האלמנטים הולכים להיות פחות מ 5.
 למה זה שימושי?
 ובכן, אם אני רוצה לבדוק אם המספר 7 הוא כאן, למשל,
 פשוט אני הולך ל5 ראשון ואני הולך לראות, הוא 7 גדול יותר או פחות מ 5?
 זה גדול יותר, ולכן אני יודע שזה הולך להיות בצד הימין של העץ.
 אז יש לי הרבה פחות דברים להסתכל.
 ביישום של עץ חיפוש בינארי, הצומת, אני פשוט אצטרך לקבל נתונים,
 כך int n, אתה יכול להיות גם מחרוזת
 או כל דבר שאתה רוצה.
 אתה פשוט צריך להיות זהיר בהגדרה מה הוא גדול יותר, מה פחות.
 אז אם היה לך מחרוזות, לדוגמא, אתה יכול להגדיר
 כי את כל הדברים האלה בצד הימין הולכים להיות באורך גדול יותר,
 השמאל הולך להיות אורכים נמוכים יותר, כך שזה באמת תלוי בך.
 

איך אני יכול לממש למצוא עבור BST?
 הדבר הראשון שנצטרך לעשות הוא לבדוק אם השורש הוא NULL.
 אם זה NULL, זה אומר שהדבר הוא לא שם
 משום שאפילו אין לך עץ, נכון?
 אז אני חוזר שווא.
 אחרת, אני הולך לבדוק אם המספר הוא גדול יותר
 מהערך בשורש.
 אני הולך לנסות למצוא את האלמנט בצד הימין
 של העץ.
 אתה רואה שאני משתמש ברקורסיה כאן.
 ואז אם זה פחות, אני הולך להסתכל על צד שמאל.
 ולבסוף, בדרך אחרת, אם זה לא פחות או לא יותר,
 זה אומר שזה הערך עצמו.
 אז אני רק החזר אמיתי.
 אתם יכולים לראות כאן, כי אני משמש אם, אם, אם.
 ותזכור, בחידון 0, היה לנו בעיה שהייתה לי אם, אם, אם,
 ושהייתם אמור למצוא את חוסר היעילות,
 וחוסר היעילות שבה השתמש היה אם. היית צריכים להשתמש בו אם, אם אחר, אם אחר, ועוד.
 אז, אני צריך להשתמש אחר אם ואם אחר ואחר כאן?
 האם מישהו - כן?
 [מתייחס לסטודנט, לא נשמע]
 זה מצוין. אז היא אומרת שזה לא משנה,
 רק בגלל חוסר היעילות שהייתה לנו קודם
 זה היה בגלל, אולי אם כמה מצב היה מרוצה,
 כך שאתה ביצעת פעולה כלשהי, אבל אז אתה הולך לבדוק את כל התנאים האחרים.
 אבל במקרה הזה, זה חזר מייד, אז זה לא משנה.
 אז אתה לא צריך להשתמש אחר אם.
 

ולבסוף, בואו נדבר על ניסיונות,
 שהוא אהוב על כולם.
 ניסיון הוא עץ של מערכים.
 זה מהר מאוד כדי לחפש את ערכים, אבל הוא משתמש בהרבה זיכרון.
 וזה בדרך כלל כדי לסנן מילות, ולכן כאשר אתה
 רוצה ליישם, למשל, אני לא יודע, כמו ספר טלפונים בטלפון שלך
 ואתה רוצה להיות מסוגל להקליד B
 ורק צריכים שמות של אנשים שיש להם ב '
 זה קל מאוד ליישום שבאמצעותו לנסות, למשל.
 איך אתה מגדיר את צומת בלנסות?
 אתה פשוט צריך שתהיה לי bool שהוא הולך להיות is_word.
 המייצג כי באמצעות כל הדמויות לפני הצומת כי,
 היית מסוגל ליצור מילה,
 ואז יהיה לך מערך של מצביעים לצומת.
 האם אתה יכול לראות שיש לנו מערך של בלוטות להורה, ולכן צומת מערך *? כן?
 אז בואו לראות איך זה יעבוד. לבדיקת האיות,
 יש לנו מערך של 27 אלמנטים,
 כי יש לנו את כל האותיות בתוספת הגרש.
 לפני כאן אני רק הולך להשתמש 2 כי אני רוצה להיות מסוגל לכתוב על הלוח.
 אוקיי. אז זו דוגמא לניסיון.
 אם אני רק להגדיר את הצומת הראשונה, יהיה לי מערך של 2 אלמנטים
 כי הם 2 מצביעים ל NULL, אז אני פשוט שמתי '' ו 'ב'.
 ואני הולך לי bool שאומר is_word.
 זה הולך להיות שווא לראשון,
 רק בגלל, לפני שאתה לא צריך את כל תווים.
 אז מילה ריקה היא לא מילה. אז זה שקר.
 אם אני רוצה להוסיף "" למילון זה, מה הייתי צריך לעשות?
 הייתי רק צריך malloc צומת חדשה עבור '",
 ולאחר מכן להוסיף את המילה שלה לנכון.
 אז זה פשוט מייצג כי לאחר ש''הולך להיות אמיתי. הגיוני?
 אז אם אני רוצה להוסיף "תואר ראשון", אני אצטרך malloc 1 עבור 'ב',
 ולאחר מכן אני הולך להגדיר את בוליאני לכוזב,
 כי 'ב' על ידי עצמו הוא לא מילה.
 ואז אני הולך malloc עוד אחד עבור 'a', ולכן 'תואר ראשון',
 ולאחר מכן אני הולך להגדיר את זה מילה נכונה.
 בגלל 'תואר ראשון' הוא מילה.
 ואז אם אני רוצה לראות אם 'ב' הוא במילון זה,
 אני רק יכול ללכת ראשון, 'ב'. אני יורד, ואני מסתכל על זה מילה, וזה אומר שקר.
 אז זה לא מילה. אם אני רוצה לבדוק 'תואר ראשון',
 אני הולך לראשון, 'ב', ולאחר מכן ללכת '', ואני רואה נכון, אז זה מילה. הגיוני?
 הרבה אנשים מתבלבלים מנסה. לא?
 

לבסוף, האפמן קידוד. קידוד האפמן הוא מאוד שימושי
 כדי לחסוך בזיכרון ולדחוס את קבצי טקסט,
 רק בגלל שהרבה פעמים אתה משתמש '' ו 'דואר', למשל,
 במסמכים שלך, אבל אני לא יודע אם אתם משתמשים 'ש' או 'Z' באותה מידה.
 יש רק 1 בתים עבור כל תו בודד,
 כל - 256 הדמויות שיש לנו בטבלת ASCII היא לא מאוד אופטימליות,
 רק בגלל שיש כמה דמויות שאתה משתמש בהרבה יותר,
 אז אתה כנראה צריך להשתמש בפחות זיכרון לזכרם.
 כיצד ניתן להשתמש בקידוד האפמן?
 אנחנו חייבים לעשות את עץ האפמן.
  יש עץ האפמן צמתים
 שיש להם סמל, כי הוא הולך להיות כמו, 'a', 'b', 'c', המכתב,
 כל מה שיש לך מכתב, תדר שהוא התדר שהמילה מופיעה בטקסט,
 שאתה יוצר את עץ האפמן ל,
 ולאחר מכן צומת כי הוא הולך להצביע לשמאל לעץ האפמן
 וצומת אחרת כי הוא הולך להצביע לימין. אז בדיוק כמו עץ.
 איך לבנות עץ האפמן?
 אתה הולך לבחור את 2 צמתים שיש להם את התדרים הנמוכים ביותר.
 אם יש לך עניבה שאתה הולך לבחור את 2 צמתים
 שיש להם ערכי ASCII הנמוכים ביותר גם כן.
 ואז אתה הולך ליצור עץ חדש מתוך 2 צמתים אלה
 שהוא הולך להיות בתדירות המשולבת בצומת האב.
 ואז אתה הולך להוציא את הילדים 2 מן היער
 ולהחליף אותם עם ההורה.
 ואתה הולך לחזור על זה עד שיש לך רק 1 עץ ביער.
 אז בואו נראה איך היית עושה את עץ האפמן לZAMYLA.
 אתם יכולים לראות כאן, כי יש את כל האותיות בתדר 1 למעט ''; שיש תדירות 2.
 אז אני יצרתי את צמתים לכל האותיות שמתי במטרה של ערך ASCII ותדר.
 אז אם אני רוצה ליצור את העץ הראשון, זה יהיה עם 'L' ו 'ק'.
 אז זה כאן. התדירות של הזוג תהיה 2
 כי זה 1 + 1, ולאחר מכן 2 הבאים עם התדרים הנמוכים ביותר הם 'Y' ו 'Z'.
 ואז יש לי את כולם להיות - להיות בתדר של 2.
 אז אילו הם אלה שיש לי ערך ASCII הנמוך ביותר לצד אחד?
 '' ו 'L'. אז אני יוצר צומת החדש,
 ולבסוף, זה 4 ו 2, אז 2 הולך להיות בצד השמאל.
 וזה עץ האפמן. אז אם אני רוצה לכתוב טקסט כלשהו,
 כמו בינארי להמיר לטקסט, תוך שימוש בעץ האפמן הוא קל מאוד.
 לדוגמא, אם אני אומר שנע שמאלה הוא 0 ונע לימין הוא 1,
 מה שהולך לייצג?
 אז כמו 1, 1, כל כך בסדר, בסדר,
 ולאחר מכן 0, ולכן עזבו את יהיו L, ולאחר מכן 1, 0, 0.
 אז 1, 0, כל כך פשוט 1, 0, 'A'.
 ואז 0, 1, ולכן "Z".
 ולאחר מכן 1, 0, 0 - לא.
 0, 0 יהיו 'Y', כל כך עצלנים.
 אז זה הכל בשבילי, רוב של הולך להשתלט על.
 

[רוב אודן] לכן, בשבוע 7 דברים.
 יש לנו הרבה לעבור על ממש מהר.
 מפעילי bitwise, גלישת מאגר,
 ספריית CS50, ולאחר מכן ה-HTML, HTTP, CSS.
 בסך כמו 15-20 דקות.
 מפעילי bitwise. ישנן 6 מהם, כי אתה צריך לדעת.
 ביטים ו, ​​ביטים או, XOR, משמרת עזבה, שינוי תקין, ולא.
 נכון לעבור ולא אתה בקושי ראית בהרצאה בכלל.
 אנחנו נלך עליו במהירות לכאן, אבל זה טוב לדעת כי אלו הם 6 שקיימים.
 זכור כי מפעילי bitwise הם כמו כשאתה עושה 3 + 4.
 אתה לא עוסק בינארי של 3 ו -4.
 עם מפעילי bitwise אתה בעצם התמודדות עם פיסות בודדות של המספרים 3 ו -4.
 

אז הראשון שנגיד הוא bitwise לא,
 וכל שהיא עושה הוא להפוך את כל החלקים.
 אז הנה, אם אתה כותב את זה ב-C, לא היית כותב את זה
 כמו ~ 11011 או מה שלא, היית רוצה לכתוב את זה ~ 4,
 ואז זה יהיה להעיף את הייצוג בינארי של 4.
 אז הנה, ~ של חלק מספר בינארי 1101101 הולכים להעיף בדיוק כל 1 של 0 של וכל 0 עד 1 של.
 כמו שאני אומר שם, השימוש התכוף בזה,
 ואנו רואים אותו בקצת, זה כמו שאנחנו רוצים לבוא עם כמה מספר
 שבו כל הביטים הם 1, פרט לאחד מהם.
 אז זה בדרך כלל קל יותר לבטא את המספר
 שבו רק כי קצת בודד מוגדר,
 ולאחר מכן לקחת ~ שלו, ולכן כל פיסה אחרת מוגדר פרט לזה.
 אז זה מה שאנחנו הולכים להשתמש יותר במעט.
 

Bitwise או. הנה 2 מספרי בינאריים, ו 2 המספרים האלה
 די מייצג, כיוון שהם מייצגים בכל אפשריים
 שילוב של ביטים שאתה יכול צריך לפעול הלאה.
 הנה, כשאני or'd כל קצת, אנחנו רק הולכים להשוות ישר למטה.
 אז בצד השמאל יש לנו 1 ו 1.
 כשBitwise | אלה, מה אני הולך לקבל? אחד.
 אז Bitwise | 0 ו -1 הוא הולכים לתת לי? אחד.
 Bitwise 1 ו 0 הולכים להיות אותו דבר, אחד.
 Bitwise 0 | 0 הוא הולך לתת לי 0.
 אז המקרה היחיד שבו אני מקבל 0 הוא ב0 | 0 מקרה.
 ואתה יכול לחשוב על זה בדיוק כמו ORS הלוגי שלך.
 אז אם אתה חושב על 1 אמיתי וכ0 ככוזבים, אותו הדבר חל כאן.
 כל כך נכון או אמיתי הוא אמיתי; אמת או שקר היא אמת.
 שקר או אמת נכונה; שווא או שקר הוא הדבר היחיד שבעצם מזויף.
 הנה הדוגמא שאתם צריכים לדעת
 כדוגמא די טובה כאשר מפעילי bitwise משמשים.
 הנה אם אנחנו או 'A' עם ההון Ox20,
 ואנו מסתכלים על אלה בשניים, אנחנו מקבלים משהו.
 ואם אנחנו או אותיות קטנות "עם Ox20, אנחנו מקבלים משהו.
 אז בואו להרים את טבלת ASCII.
 אוקיי. כאן אנו רואים כי א 'הוא -
 כאן יש לנו '' הוא עשרוני 65.
 אבל אני אלך עם הקסדצימלי, שהוא Ox41.
 די בטוח שראינו אותו בכיתה. אני חושב שראינו את זה בכיתה
 שזה די קל להמיר מהקסדצימלי לינארי.
 אז הנה, אם אני רוצה לשים 4 לינארי,
 זה רק הולך להיות 0100.
 זה המקום של 1, 2 של מקום, מקום של 4, אז זה 4.
 ואז אני יכול לפצל 1 לינארי, שהולך להיות 0001.
 וכך זה הולך להיות הייצוג של 'A' בינארי.
 אם ניקח אותיות קטנות ', עכשיו זה הולך להיות Ox61,
 שבו, פיצול אלה עד לינארי שלה, ולכן 6 -
 בואו באמת עושים את זה - שאין מחק? מחק.
 Ox61. אז פיצול 6 לינארי הולך להיות 0 + 4 + 2 + 0.
 ופיצול 1 הולך להיות 0001.
 כאשר מסתכל על ההבדל בין 2 אלה,
 אנו רואים כי ההבדל היחיד בין אותיות קטנות ו''הון הוא קצת הבודד הזה.
 אז חוזר לכאן - בסדר.
 חוזר לכאן, אם אנחנו מסתכלים על מה שהוא קצת Ox20,
 Ox20 כך פיצול לינארי שלו,
 הוא 0010, 0000.
 Ox20, קצת היחידים שמוגדרת הוא קצת זה שאנו עוסקים,
 עם מעבר בין ההון ואותיות קטנות ".
 אם אני או 'A', שהוא זה, 'A',
 אם אני או 'A' עם Ox20,
 מה שאני הולך לקבל?
 [סטודנטים, לא נשמע] 

'' האותיות הקטנות, כי זה הולך להעיף את זה קצת ל1.
 ואם אני או '' עם Ox20, מה אני הולך לקבל?
 אותיות קטנות, כי רק oring '' עם Ox20,
 אני רק הולך להיות oring קצת בודד זה ל1, זה כבר 1, כך שזה לא משנה.
 אז אנחנו מקבלים '' ו ''.
 

Bitwise ו. שוב, אנחנו יכולים לחשוב על זה כמקבילו הלוגי ושלנו.
 בצד השמאל יש לנו נכון ואמיתי.
 זה הולך להיות אמיתי, ולכל אחד מהמקרים,
 שקר ואמת או אמיתי וכוזב, או שקרי וכוזב,
 אף אחד מהדברים האלה הם אמיתיים.
 אז מה אנחנו בסופו של דבר מקבלים הוא 1,000.
 אז עכשיו, כאן, כאן מקום שבו אני השתמשתי bitwise אמין לא,
 שם היה לנו Ox20. אז זה Ox20.
 עכשיו מה שאני רוצה לעשות, ביטים ~ של Ox20.
 כי הוא הולך להעיף את כל החלקים.
 אז יש לי 1101, 1111.
 וכך '"anded עם ~ Ox20 הוא הולך לתת לי את מה?
 קצת רק אנחנו באמת צריכים לחשוב עליו הוא זה,
 שכן, אם כל הביטים הללו הוגדרו 1,
 אז אנחנו הולכים לקבל בדיוק את מה '"היה,
 למעט, אולי, מה זה קצת.
 כי אם זה היה 1, עכשיו זה הולך להיות מוגדר 0,
 כי מה זה, anded עם זה הולך להיות 0.
 אז מה הוא "'& ~ Ox20 הולך לתת לי?
 [סטודנטים לענות, לא נשמע] 

ומה הוא '' ו-- זה '".
 ומה הוא '' Ox20 & ~ הולך לתת לי?
 'א' בגלל זה הוא כרגע 1.
 Anding עם 0 זה הולך להפוך אותו 0,
 ועכשיו אנחנו הולכים לקבל "A".
 

שניהם ',' ואחרון חביב מסוג זה,
 יש לנו XOR. זה דומה מאוד או,
 מלבד זה אומר באופן בלעדי או.
 זה כמו מה שאתה בדרך כלל חושב על כאו בעולם האמיתי.
 אז אתה עושה או 'x' או 'y', אבל לא שניהם.
 כאן 1 ^ 1 הולך להיות 0.
 מכיוון שזה נכון, זה הוא - זה לא עובד, כמו גם עם לוגי האמת ושקר
 כביטים ואו לעשות,
 אבל נכון ^ אמיתי הוא כוזב.
 מכיוון שאנחנו רק רוצים לחזור נכון אם רק אחד מהם הוא נכונים.
 אז 1 ^ 1 הוא 0. מה עם 0 ^ 1?
 האם 1. 1 ^ 0 הוא 1, 0 ^ 0 הוא 0.
 אז בכל הנסיבות, 0 bitwise משהו 0 הולך להיות 0.
 1 bitwise משהו 0 או 0 ביטים 1,
 אם זה | או ^, זה יהיה 1, ואם זה וזה יהיה 0.
 והמקרה היחיד שבו ביטים 1 1 אינו 1 הוא עם או בלעדי.
 זה 0110.
 אז הנה עכשיו, באמצעות XOR - אז אנחנו שוב ב20.
 '' ^ Ox20 הוא 2 הביטים האלה אנחנו משווים.
 אז 1 ^ 0 הוא הולך לתת לי את מה? אחד.
 '' ^ Ox20 הוא הולך לתת לי? אותיות קטנות.
 '' ^ Ox20 הוא הולך לתת לי? א הון
 כי מה שזה עושה, זה XORing עם Ox20
 הוא מרפרף ביעילות כל מה שקצת זה.
 אם זה 0, עכשיו זה הולך להיות 1.
 מכיוון שמדובר ב1, 1 ^ 1 הוא 0.
 אז '' הפך '' ו '' שלנו הפך '".
 אז XOR הוא דרך ממש נוחה רק מרפרף המקרה.
 אתה רק רוצה לחזר על מחרוזת של אותיות
 וחלופי במקרה של כל דמות ודמות,
 אתה פשוט כל מה XOR עם Ox20.
 

עכשיו שנשארנו לנו במשמרות. משמרת נותרת היא פשוט, הולכת בעצם,
 לדחוף את כל המספרים ל, או לשמאל, ולהכניס 0 של מאחוריהם.
 אז הנה יש לנו 00,001,101.
 אנחנו הולכים לדחוף 3 ב0 מהימין,
 ואנחנו מקבלים 01,101,000.
 במונחי nonbinary,
 אנחנו רואים שזה באמת התמודדות 13 עם 3-השתנה שמאל, שנותן לנו 104.
 הסטה אז שמאל, שאנו רואים כאן, x << y הוא בעצם x * 2 ^ y.
 13 * 2 ^ 3, 2 ^ 3 הוא 8, ולכן 13 * 8 הוא 104.
 אם אתה רק חושב על ינארי באופן כללי, איך כל ספרה,
 אם תתחילו מימין, זה מקום של 1, ולאחר מכן של 2 מקום, אז המקום של 4.
 אז על ידי דחיפה ב0 מימין,
 אנחנו פשוט דוחפים דברים שלא היו במקום של 4 למקום של 8,
 ודברים שהיו במקום של 8 למקום של 16.
 כל משמרת רק מכפילה פי 2. כן?
 [סטודנטים] מה קורה אם אתה מוזז על ידי 5?
 [אודן] אם אתה מוזז על ידי 5 אתה תאבד רק ספרות.
 באופן בלתי נמנע, זה אותו הדבר. כמו, מספרים שלמים הם רק 32 ביטים,
 כך שאם אתה מוסיף 2 מספרים שלמים גדולים באמת, זה פשוט לא מתאים במספר שלם.
 אז זה אותו הדבר כאן. אם אתה מוזז על ידי 5,
 נאבד כי אחד פשוט.
 וזה סוג של מה שאני מתכוון "בערך",
 שבו אם אתה משמרת רחוק מדי, אתה מאבד את הביטים.
 

המשמרת ימנית הולכת להיות הפוך,
 לאן אנחנו הולכים לדחוף 0 את הסוף,
 ולענייננו, למלא ב0 מהשמאל.
 אז עושה את זה, אנחנו בעצם היפוך מה שכבר נעשו.
 ואנו רואים כי שלושת 0 בצד הימין יש להם רק נפלו,
 ויש לנו דחפתי 1101 כל הדרך לצד ימין.
 זה עושה 104 

3, שהוא, למעשה, x / 2 ^ y.
 אז עכשיו, הנה, זה רעיון דומה.
 למה זה רק בערך x / 2 ^ y, ולא ממש x / 2 ^ y?
 כי אם הייתי מוזז על ידי 4, הייתי מאבד 1.
 בעיקרון, מה שאתה חושב, רק לחשוב על חלוקה של מספרים שלמים באופן כללי.
 אז, כמו 5/2 הוא 2. זה לא 2.5.
 זה אותו הרעיון כאן. כאשר אנו מחלקים ל -2,
 אנחנו יכולים לאבד את החלקים שונים ומשונים לאורך הדרך.
 אז עכשיו - זהו זה לביטים. זה כל מה שאתה צריך לדעת.
 זכור את מקרי השימוש שראינו בכיתה,
 כמו מסכה קצת שימושית עבור מפעילי bitwise,
 או שאתה משתמש בם למסכות קצת.
 אותיות גדולות ואותיות קטנות, המרות היא דוגמא די טיפוסית.
 

אוקיי, אז חיץ התקפות גלישה.
 מישהו זוכר מה היה לא בסדר בפונקציה זו?
 שימו לב שהכרזנו על מערך של 12 בתים, 12 תווים,
 ואז אנחנו להעתיק למאגר של 12 תווים השלם בר מחרוזת שלנו. אז מה הבעיה כאן?
 מספר הקסם 12 צריך פחות או יותר מייד קופץ החוצה כמו - מדוע 12?
 מה אם בר קורה ליותר מ 12 תווים?
 מה אם הבר מיליוני תווים?
 כאן הבעיה היא ה memcpy. אם בר הוא מספיק זמן,
 זה יהיה פשוט לגמרי - 'C', 'c' לא אכפת שזה היה רק ​​12 תווים;
 'C' לא אכפת שזה לא יכול להתאים לבתים שרבים.
 זה יחליף char פשוט לחלוטין, הבתים 12 אנחנו כבר הוקצו לו,
 וכל מה שעבר את זה בזיכרון שלא ממש שייך לחיץ ש
 עם כל מה שבר המחרוזת הוא.
 אז זו הייתה התמונה שראינו בכיתה
 שבו יש לנו הערימה שלנו גדלה.
 יש להשתמש לך את התמונות האלה או להכיר אותם שוב.
 יש לנו הערימה שלנו גדלה, כתובות זיכרון מתחילות ב 0 בחלק העליון
 ולגדול עד לאוהבים 4 מיליארדים בתחתית.
 יש לנו 'ג'שלנו המערך אי שם בזיכרון,
 אז יש לנו המצביע שלנו לבר שממש מתחתיה,
 ואז יש לנו מצביע זה הציל מסגרת בכתובת שולחנו וערימה של השגרה האם שלנו.
 זוכר מה היא כתובת השולח?
 זה היה רגע שבי עיקרי קורא foo פונקציה, קורא שורת פונקציה,
 באופן בלתי נמנע, בר תשואות.
 לכן, כאשר חוזרים לבר, הם צריכים לדעת שזה הולך לחזור לfoo שקרא לזה.
 אז כתובת השולח היא הכתובת של הפונקציה שיש לה כדי לחזור לכאשר חוזר לתפקד.
 הסיבה שזה חשוב להתקפות גלישת חוצץ לכך היא, בנוחות,
 האקרים רוצים לשנות את זה כתובה שולח.
 במקום לחזור לfoo, אני הולך לחזור לכל המקום בו ההאקר רוצה אותי לחזור אליו.
 וגם, במיקום נוח, שבו ההאקר לעתים קרובות רוצה לחזור ל
 הוא ההתחלה של החיץ שבמקור היה לנו.
 אז שם לב, שוב, ליטל הודית.
 המכשיר הוא דוגמא למערכת הודית קטנה,
 כך מספר שלם או מצביע מאוחסן עם הבתים הפוכים.
 אז הנה אנחנו רואים - זה? כן.
 אנו רואים Ox80, OxC0, Ox35, OxO8.
 זכור הספרות הקסדצימלי?
 אנחנו לא להפוך את הספרות הקסדצימלי בליטל ההודית,
 בגלל 2 ספרות הקסדצימלי מרכיבות את בית אחד, ואנחנו להפוך את הבתים.
 בגלל זה אנחנו לא שומרים, כמו, 80530CO8.
 אנו מאחסנים, במקום זאת, כל זוג של 2 ספרות, החל מהימין.
 כתובת המתייחסת לכתובת של תחילת
 של החיץ שלנו, כי אנחנו באמת רוצים להעתיק למקום הראשון.
 הסיבה שזה שימושי לכך היא, מה אם הפורץ
 קרה לי, במקום שיש מחרוזת שהייתה רק
 מחרוזת בלתי מזיקה כמו, השם שלהם או משהו,
 מה אם, במקום זאת, המחרוזת שהיו רק חלק הקוד שרירותי
 כי עשה מה שהם רוצים לעשות את זה?
 אז הם יכולים - אני לא יכול לחשוב על שום קוד מגניב.
 זה יכול להיות כל דבר, אם כי. כל קוד הרסני.
 אם הם רוצים, הם יכולים פשוט לעשות משהו בתקלות צינוק, אבל זה יהיה חסר טעם.
 בדרך כלל הם עושים את זה כדי לפרוץ את המערכת שלך.
 

אוקיי. ספריית CS50.
 זה, בעצם, getInt, getString, כל פונקציות אלה שאנחנו ניתן לך.
 אז יש לנו מחרוזת char *, וזה ההפשטה שעפנו
 בשלב מסוים במהלך הסמסטר.
 זכור שמחרוזת היא פשוט מערך של תווים.
 אז הנה אנחנו רואים גרסה מקוצרת של getString.
 אתה צריך להסתכל אחורה עליו לזכור איך זה מיושם בפועל.
 פרטי מפתח הם, שימו לב שאנחנו מקבלים בתו בודד בכל פעם
 מסטנדרטי ב, שהוא בדיוק כמונו הקלדה במקלדת.
 אז תו בודד בכל פעם, ואם אנחנו מקבלים תווים רבים מדי,
 כך שאם n + 1 הוא גדול יותר מקיבולת,
 אז אנחנו צריכים להגדיל את הקיבולת של המאגר שלנו.
 אז הנה אנחנו מכפילים את גודלו של המאגר שלנו.
 וזה ממשיך הולך, אנחנו מכניסים את הדמות למאגר שלנו
 עד שנקבל שורה או סוף הקובץ או מה שלא חדשה,
 ובמקרה זה, אנחנו עושים עם החוט, ואז getString האמיתי
 מכווץ את הזיכרון, כמו אם שהוקצו זיכרון יותר מדי זה יהיה לחזור ולהתכווץ מעט.
 אז אנחנו לא מראים את זה, אבל הרעיון המרכזי הוא
 זה יש לקרוא בתו בודד בכל פעם.
 זה יכול לא רק לקרוא בכל דבר בבת אחת,
 בגלל החיץ שלהם הוא רק בגודל מסוים.
 אז אם את המחרוזת שהוא מנסה להכניס למאגר היא גדולה מדי, ואז זה יהיה על גדותיה.
 אז הנה אנחנו למנוע את זה על ידי קריאה רק בתו יחיד
 בכל פעם וגדל בכל פעם שאנו צריכים.
 אז getInt ופונקציות ספריית CS50 האחרות נוטים להשתמש getString
 ביישומים שלהם.
 אז הדגיש את הדברים החשובים כאן.
 היא מכנה getString לקבל מחרוזת.
 אם getString לא הצליח לחזור בזיכרון,
 לזכור שgetString mallocs משהו, לכן בכל פעם שאתם קוראים getString
 אתה לא צריך (לא מובן) לשחרר את המחרוזת שיש לך.
 אז הנה, אם זה לא הצליח malloc משהו, אנחנו חוזרים INT_MAX כבדיוק דגל ש,
 היי, לא היינו ממש מסוגל לקבל מספר שלם.
 אתה צריך להתעלם מכל מה שאני חוזר אליך, או
 אתה לא צריך להתייחס לזה כקלט חוקי. לבסוף, בהנחה שלא יצליח, אנו משתמשים sscanf עם זה דגל מיוחד,
 מה שאומר, שתתאים למספר שלם ראשון,
 לאחר מכן להתאים כל תו לאחר המספר שלם.
 אז שמתי לב שאנחנו רוצים שזה שווה 1.
 חוזר אז sscanf כמה משחקים, אם בוצע בהצלחה?
 זה יחזיר 1 אם זה מתאים שלם בהצלחה,
 זה יחזיר 0 אם זה לא התאים למספר שלם, והיא תחזיר 2
 אם זה מתאים שלם ואחריו איזו דמות.
 אז שם לב שאנחנו לנסות שוב אם אנו מתאימים שום דבר, אבל 1.
 אז אם נכנסנו 1, 2, 3, ג או 1, 2, 3, X,
 אז 1, 2, 3 הייתם מקבל מאוחסן במספר השלם,
 X הייתי לקבל מאוחסנים בתו,
 sscanf יחזור 2, ואנחנו היינו לנסות שוב, בגלל שאנחנו רק רוצים מספר שלם.
 

מהירות נושבת דרך HTML, HTTP, CSS.
 HyperText Markup Language הוא המבנה וסמנטיקה של האינטרנט.
 הנה הדוגמא מהרצאה שבה יש לנו תגי HTML.
 יש לנו תגי ראש, תגי גוף,
 יש לנו דוגמאות לתגים ריקים שבו אנחנו באמת לא צריכים להתחיל ולסגור תג,
 פשוט יש לנו קישור ותמונה.
 אין תג תמונת סגירה; יש רק תג יחיד שמשיג כל מה שהתג צריך לעשות.
 הקישור הוא דוגמא; אנחנו תראו איך אתה מקשר ל-CSS,
 התסריט הוא דוגמא לאופן שאתה מקשר לJavaScript חיצוני.
 זה די פשוט, ולזכור, HTML הוא לא שפת תכנות.
 כאן, זוכר איך היית מגדיר את טופס או לפחות מה זה היית עושה?
 יש כאלה צורה פעולה ושיטה.
 השיטות שאתה היחיד שאי פעם תראה הן לקבל ולפרסם.
 אז קבל את הגרסה שבו הדבר מקבל לשים את כתובת האתר.
 POST הוא שבו הוא לא מכניס את כתובת האתר.
 במקום זאת, כל הנתונים מהטופס מוכנס מוסתרים יותר בבקשת HTTP.
 אז הנה, פעולה מגדירה שבו בקשת HTTP הולכת.
 לאן זה הולך הוא google.com / חיפוש.
 שיטה. זכור את ההבדלים בין לקבל ולפרסם,
 ו, רק אומר כדוגמא, אם אתה רוצה משהו סימנייה.
 אתה לעולם לא יהיה מסוגל הסימנייה URL POST
 משום שהנתונים אינו כלולים ב-URL.
 

HTTP, עכשיו, הוא פרוטוקול העברת היפרטקסט.
 HyperText Transfer Protocol, היית מצפה לה למסור את
 Hypertext Markup Language, ושהיא עושה.
 אבל זה גם מעביר את כל תמונות שאתה מוצא באינטרנט,
 כל הורדות שאתה עושה להתחיל כבקשת HTTP.
 אז HTTP הוא רק השפה של-World Wide Web.
 וכאן אתם צריכים להכיר של בקשת HTTP מסוג זה.
 הנה HTTP/1.1 בצד רק אומר שזה הגרסה
 לפרוטוקול אני משתמש.
 זה פחות או יותר תמיד יהיה HTTP/1.1, כפי שתראה אותו.
 ואז אנחנו רואים שזו הייתה GET, החלופה להיות POST, שאתה יכול לראות.
 ואת כתובת האתר שאני מנסה לבקר היה www.google.com/search?q = בלה, בלה, בלה.
 אז לזכור שזה, ש סימן השאלה = בלה בלה בלה,
 הוא הסוג של חומר שהוגש על ידי טופס.
 התגובה שזה יכול להחזיר לי הייתה נראית משהו כזה.
 שוב, מתחיל עם הפרוטוקול, שהוא הולך להיות ש,
 ואחריו את קוד המצב. הנה זה 200 אישור.
 ולבסוף, את דף האינטרנט שאני בעצם ביקשתי יהיה אחריו.
 קוד המצב האפשרי שאתה יכול לראות, ואתה צריך לדעת כמה מהם.
 200 אישור יש לך כנראה ראה בעבר.
 403 אסור, 404 לא נמצא, שגיאה 500 שרת פנימי
 בדרך כלל אם אתה הולך לאתר ומשהו לא שבור או קוד PHP קריסות שלהם,
 בעוד שבמכשיר יש לנו שקופסה כתומה גדולה
 שבא ואומר, כאילו, משהו לא בסדר, הקוד הזה לא עובד
 או של רע בפונקציה זו.
 בדרך כלל אתרים לא רוצים אותך לדעת מה פונקציות הן בעצם רעות,
 אז במקום שהם פשוט נותנים לך 500 שגיאות שרת פנימיות.
 

TCP / IP הוא שכבה 1 מתחת HTTP.
 זכור שיש באינטרנט מחוץ ל- World Wide Web.
 כמו שאם אתה משחק במשחק באינטרנט שלא הולך דרך HTTP,
 זה עובר אחר - זה עדיין משתמש באינטרנט,
 אבל זה לא להשתמש בפרוטוקול HTTP.
 HTTP הוא רק דוגמא אחת של פרוטוקול בנוי על TCP / IP.
 IP פשוטו כמשמעו פרוטוקול האינטרנט.
 לכל מחשב כתובת ה-IP, הם דברים 4 ספרות אלה
 כמו 192.168.2.1, או כל דבר אחר, זה נוטה להיות אחד מקומי.
 אבל זה הדפוס של כתובת ה-IP.
 אז DNS, שירות שמות תחומים,
 זה מה שמתרגם את הדברים כמו google.com לכתובת ה-IP אמיתית.
 אז אם אתה מקליד לתוך כתובת אתר שכתובת ה-IP,
 שיביא אותך לגוגל, אבל אתה נוטה שלא לזכור את הדברים האלה.
 אתה נוטה לזכור google.com במקום.
 הדבר האחרון שיש לנו הוא יציאות, שבו זה חלק מפרוטוקול TCP-IP.
 TCP עושה יותר. תחשוב על, כאילו, יש לך הריצה דפדפן האינטרנט שלך.
 אולי יש לך קצת ריצה יישום דואר אלקטרוני;
 אולי יש לך תכנית אחרת שמשתמשת בריצת האינטרנט.
 כולם צריך גישה לאינטרנט,
 אבל המחשב שלך יש רק כרטיס WiFi 1 או משהו כזה.
 אז יציאות הן הדרך שאנחנו יכולים להתפצל
 איך יישומים אלה יוכלו להשתמש באינטרנט.
 כל יישום מקבל 1 יציאה מסוימת שהוא יכול להאזין ב,
 וברירת מחדל, HTTP משתמש ביציאה 80. שירותי דואר אלקטרוני מסוימים משתמשים 25.
 אלה ממוספרים נמוכים נוטים להיות שמורות.
 אתה בדרך כלל מסוגל לקבל אלה ממוספרים גבוהים יותר בעצמך.
 

CSS, גיליונות סגנון מדורג.
 דפי אינטרנט שסגנון עם CSS, ולא עם ה-HTML.
 יש 3 מקומות שאתה יכול לשים CSS שלך.
 זה יכול להיות בתוך שורה, בין תגי סגנון, או בקובץ נפרד לחלוטין ולאחר מכן מקושר פנימה
 וכאן הוא רק דוגמא של CSS.
 אתה צריך לזהות את הדפוס הזה,
 איפה הדוגמא הראשונה הוא שאנחנו התאמת תג הגוף,
 וכאן אנחנו מרכוז תג הגוף.
 הדוגמא השנייה, אנחנו התאמת הדבר
 עם כותרת תחתונה זהות, ואנחנו מיישמים כמה סגנונות לזה.
 שים לב שמזהה תחתונה טקסט מיושר לשמאל,
 ואילו מרכז גוף טקסט מיישר.
 כותרת תחתונה היא בתוך הגוף.
 זה, במקום, יישור טקסט שמאלה, למרות שגוף אומר מרכז יישור טקסט.
 זה כל החלק המדורג שלו.
 יכול להיות לך - אתה יכול לציין סגנונות לגוף,
 ואז דברים בגוף שאתה יכול לציין סגנונות ספציפיים יותר,
 ודברים עובדים כמו שאתה מצפה.
 מצייני CSS יותר ספציפיים הם הקובעים.
 אני חושב שזה זה.
 

[עלי Nahm] שלום לכולם. אם רק יכל לקבל את תשומת הלב שלך.
 אני עלי ואני הולך לעבור את PHP ו-SQL ממש מהר.
 אז אנחנו יכולים להתחיל. PHP הוא קיצור של PHP: Hypertext Preprocessor.
 וכפי שכולכם צריך לדעת, זה שפה scripting בצד השרת,
 ואנחנו משתמשים בו לקצה האחורי של אתרי אינטרנט,
 ואיך זה עושה הרבה חישובים, חלק מאחורי הקלעים.
 תחביר. זה לא כמו C, הפתעה, הפתעה.
 זה תמיד צריך להתחיל עם, אם אתה יכול לראות, - אני לא יכול להתקדם.
 אתה יכול לראות מה שאתה צריך סוגים החדשים של פלטה ואז אתה גם צריך? PHP.
 זה תמיד איך אתה צריך מסגרת טקסט PHP שלך, קוד PHP שלך.
 אז זה לא יכול להיות רק כמו C, שבו אתה סוג של לשים על זה ראשון.
 אתה צריך תמיד מקיף אותו.
 ועכשיו, בתחביר העיקרי הוא שכל המשתנים צריכים להתחיל עם הדמות של $.
 אתה צריך לעשות את זה כשאתה מגדיר אותם, אתה צריך לעשות את זה
 כשאתה מתכוון לאליהם בהמשך.
 אתה תמיד צריך ש$. זה החבר הכי טוב החדש שלך, פחות או יותר.
 אתה לא - שלא כמו C, אתה לא צריך לשים איזה סוג של סוג משתנה שהוא.
 אז בזמן שאתה צריך לעשות $, אתה לא צריך לשים, כמו,
 x או y int מחרוזת, וכו ', וכו'.
 אז הבדל קטן.
 כתוצאה מזה, זה אומר שPHP היא סוג חלוש.
 PHP היא שפת סוג חלושה, והוא הקליד בחולשה משתנים.
 במילים אחרות, זה אומר שאתה יכול לעבור בין סוגים שונים של סוגים משתנים שונים.
 אתה יכול לאחסן את המספר שלך 1 כמו int,
 אתה יכול לאחסן אותו כמחרוזת, ואתה יכול לאחסן אותו כמצוף,
 ואת כל זה יהיה המספר ש1.
 למרות שאתה לאחסן אותו בצורות שונות,
 זה עדיין - הסוגים משתנים עדיין מחזיקים בסופו של הדבר.
 אז אם אתה מסתכל פה, אם אתה זוכר מpset 7,
 רבים מכם בוודאי היו בעיות עם זה.
 שני סימנים שווים, 3 סימנים שווים, 4 סימנים שווים.
 אוקיי, אין 4 סימנים שווים, אבל יש 2 ו -3.
 אתה משתמש 2 שלטים שווים לבדוק את הערכים.
 הוא יכול לבדוק על פני סוגים.
 אז אם אתה יכול לראות בדוגמא הראשונה,
 יש לי num_string == num_int.
 אז int שלך ומחרוזת שלך הם שניהם, מבחינה טכנית, 1,
 אבל הם סוגים שונים. אבל השווה הכפול, זה עדיין עובר.
 עם זאת, לשווים משולשים, הוא בודק ערך, כמו גם סוגים השונים.
 זה אומר שזה לא הולך לעבור שבמקרה השני כאן,
 שבו אתה משתמש 3 סימנים שווים במקום.
 אז זה הבדל גדול, כי אתה צריך את כל הראו עכשיו.
 

שרשור מחרוזת הוא דבר חזק אחר שאתה יכול להשתמש ב-PHP.
 זה בעצם רק סימון הנקודה הזה שימושי,
 וככה אתה יכול לקשור חוטים יחד.
 אז אם יש לך חתול ויש לך כלב, ואתה רוצה לשים 2 חוטים יחד,
 אתה יכול להשתמש בתקופה, וזה סוג של איך זה עובד.
 אתה יכול גם פשוט למקם אותם אחד ליד שני,
 כפי שאתה יכול לראות כאן בדוגמא למטה,
 שבו יש לי הד מחרוזת 1, מחרוזת חלל 2.
 PHP תדע להחליף אותם ככאלה.
 מערכים. עכשיו, ב-PHP, ישנם 2 סוגים של מערכים שונים.
 אתה יכול לקבל מערכים רגילים, וגם אתה יכול לקבל מערכים אסוציאטיביים,
 ואנחנו הולכים לעבור אותם עכשיו.
 מערכים רגילים הם רק זה ב-C,
 ואז יש לך מדדים שממוספרים.
 כרגע אנחנו פשוט הולכים ליצור אחד ולשים -
 אז זה איך אנחנו יוצרים מערך ריק, אז אנחנו הולכים
 להכניס את מספר אינדקס 0.
 אנחנו הולכים לשים את המספר 6, הערך 6.
 אפשר לראות את זה בתחתית כאן.
 Where's - במספר אינדקס 1 אנחנו הולכים לשים את מספר ערך 4,
 ואז אתה יכול לראות שיש 6, יש 4,
 ולאחר מכן כפי שאנו מדפיסים דברים,
 כאשר אנו מנסים ולהדפיס את הערך שמאוחסן במספר אינדקס 0,
 אז אנחנו תראו את הערך 6 שהדפיס. מגניב?
 אז זה מערכים רגילים בשבילך.
 דרך נוספת שאתה יכול גם להוסיף דברים למערכים רגילים עכשיו
 הוא שאתה יכול פשוט לצרף אותם בסוף. זה אומר שאתה לא צריך לציין את המדד הספציפי.
 אתה יכול לראות את מספר, ולאחר מכן בסוגריים מרובעים אין שום מדד שצוין.
 והוא יודע - PHP תדע רק להוסיף אותו לסוף הרשימה, המקום החופשי הבא.
 אז אתה יכול לראות את 1 ממש שם באותה הנקודה 0,
 2 הלכו ממש שם במקום הראשון.
 3 הולך - הוא הוסיף לשם גם כן.
 אז זה סוג של היגיון. אתה פשוט מוסיף אותו כל הזמן,
 ואז כאשר אנחנו מהדהדים את המדד של מספר 1,
 זה יהיה להדפיס את הערך 2.
 

אז יש לנו מערכים שהם מערכים אסוציאטיביים.
 מערכים אסוציאטיביים, במקום שיש מדדים מספריים,
 מה שהם עושים הוא, יש להם מדדים שעל ידי חוט.
 אתה יכול לראות, במקום - נפטרתי מכל מדדי מספר אלה,
 ועכשיו זה key1, key2, key3, והם נמצאים במרכאות כפולות כדי לסמן שהם כולם המחרוזות.
 אז אנחנו יכולים להיות דוגמא לכך.
 דוגמא לכך היא שיש לנו TF, וזה השם שהמדד.
 אנחנו הולכים לשים את "עלי", כשמו, במדד, קלוריות אכלו,
 אנחנו יכולים לשים int הפעם במקום מחרוזת,
 ולאחר מכן באוהב המדד, אנחנו יכולים לשים את כל מערך הפנימי שלו.
 אז זה סוג של - זה רעיון דומה לאופן שהיה לנו
 מדדים במספרים, אבל עכשיו אנחנו יכולים לשנות את המדדים ברחבי
 כדי לקבל אותם כמחרוזות במקום.
 גם אתה יכול לעשות את זה, חוץ מזה רק עושה את זה באופן אישי,
 אתה יכול לעשות את כל זה בחתיכה אחת. אז אתה יכול לראות שTF של מערך זה,
 ואז אנחנו להגדיר את כולם בסט סוגר אחד ענק מרובע.
 אז זה יכול לזרז את עניינים.
 זה יותר בחירה סגנונית יותר מאשר לא.
 יש לנו גם לולאות.
 ב-C יש לנו לולאות שעובדות ככה.
 היו לנו המערך שלנו, והלכנו מאינדקס 0 עד סוף הרשימה,
 ואנחנו להדפיס את כל זה, נכון?
 מלבד הבעיה היא, למערכים אסוציאטיביים,
 אנו לא בהכרח יודעים מדדים מספריים אלה
 כי עכשיו יש לנו את מדדי המחרוזת.
 עכשיו אנחנו משתמשים בלולאות foreach, אשר, שוב, אתה תקווה משמש בpset 7.
 לולאות foreach רק תדע כל חלק אחד של הרשימה.
 וזה לא צריך לדעת את המדד המספרי בדיוק שיש לך.
 אז יש לך את תחביר foreach, כך שזה foreach, אתה שם את המערך.
 אז המערך שלי נקרא pset, ולאחר מכן כ, המילה כמו,
 ולאחר מכן אתה מכניס משתנה זמני מקומי זה שאתה הולך להשתמש
 רק בשביל דבר מסוים זה הולך להחזיק ספציפי -
 מקרה אחד או חלק אחד של המערך.
 num Pset יחזיק 1, ואז אולי זה יחזיק המספר 6,
 ואז זה יהיה להחזיק את המספר 2.
 אבל זה מובטח לעבור בכל ערך שהוא במערך.
 פונקציות שימושיות שאתה צריך לדעת ב-PHP הן לדרוש,
 כך שמוודא כי אתה כולל את קבצים מסוימים, הד, יציאה, ריק.
 אני מאוד ממליץ לך להסתכל על pset 7 ומסתכלים על פונקציות אלה.
 ייתכן שאתה צריך לדעת אותם,
 כך שאני בהחלט יודע מה, בדיוק, אלה כל עושים.
 

ועכשיו אנחנו הולכים לעבור היקף ממש מהר.
 בהיקפה, PHP היא סוג של דבר פאנקי, שלא כמו C,
 ואז אנחנו פשוט הולכים לעבור את זה במהירות.
 אז בואו נגיד שאנחנו מתחילים בחץ שיש לנו שם.
 ואנחנו הולכים להתחיל עם i $. אז משתנה 'אני' הולך להיות 0,
 ואנחנו רק הולכים לשמור על דפוס זה שבקופסה לבנה גדולה שם.
 אנחנו הולכים להתחיל עם i0, ולאחר מכן אנחנו הולכים להדהד אותו.
 אז יש 0.
 ואז אנחנו הולכים להגדיל אותו על ידי ללולאה,
 ואז זה הולך להיות ערך של 1.
 אחת מהן הוא פחות מ -3, כך שזה הולך לעבור את זה בשביל לולאה,
 ואז אנחנו הולכים לראות את זה מודפס שוב.
 אנחנו הולכים להגדיל את זה שוב ל 2,
 ו 2 הוא פחות מ -3, כך שזה יעבור ללולאה, וזה יהיה להדפיס את 2.
 לאחר מכן תוכלו לשים לב כי 3 הוא לא פחות מ 3, אז אנחנו לפרוץ את ללולאה.
 אז עכשיו אנחנו כבר יצאנו, ואז אנחנו הולכים להיכנס aFunction.
 אוקיי. אז אתה צריך לשים לב כי משתנה זה שיצרנו,
 משתנה 'אני', אינה scoped באופן מקומי.
 זה אומר שזה לא מקומי ללולאה,
 ומשתנה שאנחנו עדיין יכולים לגשת ולשנות לאחר מכן, וזה עדיין יהיה יעיל.
 אז אם אתה נכנסת לפונקציה עכשיו, אתה תראה שאנחנו גם להשתמש במשתנה 'i',
 ואנחנו הולכים להגדיל 'i' + +.
 אפשר היה לחשוב, בהתחלה, המבוסס על C, שזה עותק של המשתנה "אני".
 זה דבר אחר לגמרי, שהוא נכון.
 לכן, כאשר אנו להדפיס אותו, אנחנו הולכים להדפיס 'i' + +, שהוא הולך להדפיס את ש4,
 ואז אנחנו הולכים - מצטערים.
 ואז אנחנו הולכים בסופו מתוך פונקציה,
 ואנחנו הולכים להיות בו החץ שהוא עכשיו.
 זה אומר שלאחר מכן, עם זאת, למרות שהפונקציה שינתה את הערך של 'אני',
 זה לא שינה מחוץ לפונקציה,
 בגלל הפונקציה בעלת היקף נפרד.
 כלומר, כאשר אנו הד 'אני', זה לא השתנה בהיקף של הפונקציה,
 וכך אז אנחנו הולכים להדפיס 3 שוב.
 דברים שונים לגבי היקף ב-PHP מאשר בג 

עכשיו ב-PHP ו-HTML.
 PHP משמש כדי להפוך את דפי אינטרנט דינמיים.
 זה גורם לדברים שונים.
 יש לנו את זה שונה מ-HTML.
 עם HTML, תמיד רק שיש לנו את אותו הדבר סטטי, כמו איך רוב הראו,
 ואילו PHP, אתה יכול לשנות דברים מבוסס על שהמשתמש הוא.
 אז אם יש לי את זה, יש לי ", נכנסו כ -" ולאחר מכן את השם,
 ואני יכול לשנות את השם. אז עכשיו את השם הוא יוסף,
 ויש לו את "עליי", אבל אז אני גם יכול לשנות את השם ליש טומי.
 וזה יהיה דבר שונה.
 אז אנחנו יכולים גם לשנות דברים שונים עליו,
 וזה יראה לי תוכן שונה המבוסס על שמו.
 אז PHP סוג של יכול לשנות את מה שקורה באתר שלך.
 אותו דבר כאן. ובכל זאת, שים לב שיש להם תוכן שונה,
 למרות שאתה עדיין מבחינה טכנית גישה לאותו דף אינטרנט על פני השטח.
 יצירת ה-HTML. ישנן 2 דרכים שונות, כי אתה יכול לעשות את זה.
 כך תהיה לנו לעבור את זה עכשיו. הדרך הראשונה היא, שיש לך - כן, מצטער.
 אז פשוט יש לך רגיל שלך ללולאה ב-PHP,
 ואז אתה הד ב-PHP ואתה מהדהד את ה-HTML.
 באמצעות מה שהראה לך רוב של הסקריפט ב-HTML
 ולאחר מכן באמצעות ההדפסה PHP רק כדי להדפיס אותו לדף האינטרנט.
 הדרך החלופית היא לעשות את זה כאילו אתה להפריד את PHP ו-HTML.
 אז אתה יכול לקבל קו של PHP שמתחיל ללולאה,
 אז אתה יכול לקבל את הקו של ה-HTML בדבר נפרד,
 ואז אתה בסופו הלולאה, שוב, עם PHP.
 אז זה סוג של הפרדה אותו החוצה.
 בצד השמאל, אתה יכול, כי יש לך את כל -
 זה רק 1 נתח של PHP.
 מימין אתם יכולים לראות שיש לך קו של PHP,
 יש לך קו של ה-HTML, ויש לך קו של PHP שוב.
 אז מפריד את זה למה שהם עושים.
 ואתה שים לב כי בכל מקרה, לכל אחד מהם,
 הם עדיין להדפיס את התמונה, התמונה, התמונה,
 כך ה-HTML שעדיין מודפסת באותה צורה.
 ואז אתה תראה עדיין 3 התמונות מופיעות באתר האינטרנט שלך.
 אז זה 2 דרכים לעשות את אותו הדבר שונים.
 

עכשיו יש לנו טפסים ובקשות. כמו רוב הראה לך,
 יש צורות של ה-HTML, ואנחנו פשוט רוח באמצעות זה.
 יש לך פעולה ויש לכם שיטה, והפעולה שלך
 סוג של מראה לך לאן אתה הולך לשלוח אותו, והשיטה היא האם
 זה הולך להיות GET או POST.
 ובקשת GET, כפי שאמרה רוב, פירושו שאתה הולך לשים אותו בצורה
 ואתה רואה את זה ככתובת אתר, ואילו בקשת POST לא תוכל לראות בכתובת אתר.
 אז הבדל קטן.
 עם זאת, דבר אחד שזה דבר דומה
 הוא כי POST ומקבלים הם חסרי ביטחון באותה מידה.
 אז אתה יכול לחשוב שרק בגלל שאתה לא רואה את זה ב-URL,
 זה אומר POST הוא מאובטח יותר,
 אבל אתה עדיין יכול לראות אותו בעוגיות שלך במידע שאתה שולח.
 אז לא חושב שעל זה או אחר.
 דבר נוסף שיש לציין הוא כי יש לך גם משתני סעיף.
 אתם השתמשו בזה בpset 7 כדי לקבל מידע זיהוי המשתמש שלך.
 מה שקרה הוא שאתה יכול להשתמש במערך האסוציאטיבי הזה,
 _SESSION $, ואז אתה יכול לגשת לדברים שונים
 ולאחסן דברים שונים על פני הדפים.
 

הדבר האחרון הוא שיש לנו SQL, שפת שאילתות מובנית,
 ואת זה הוא שפת תכנות לניהול מסדי נתונים.
 מה, בדיוק, הם מסדי נתונים? הם אוספים של שולחנות,
 וכל שולחן יכול להיות סוגים דומים של אובייקטים.
 אז היה לנו שולחן של משתמשים בpset המימון שלך.
 ולמה הם שימושיים? כי זה דרך של באופן קבוע לאחסון מידע.
 זוהי דרך של מעקב אחר דברים וניהול דברים
 ובאמת רואה את זה בדפים שונים ואחר שמירה.
 לעומת זאת, אם אתה רק לאחסן אותו באותו רגע אחד מיידי
 ולאחר מכן להשתמש בו מאוחר יותר, לא תוכל לגשת לשום דבר, כי אתה כבר הצלת.
 יש לנו 4 דברים עיקריים שאנו משתמשים לפקודות SQL.
 יש לנו נבחרת, להוסיף, למחוק, ולעדכן.
 אלה הם באמת חשובים בשבילכם לדעת לחידון שלך.
 

ניסע במהירות על בחר עכשיו.
 בעיקרון, אתה בוחר שורות ממסד נתונים.
 אז אם יש לך, ממש כאן -
 יש לנו 2 הדברים השונים הללו, ואנחנו רוצים לבחור מטבלת הכיתות
 שם מדהים - שבו בעמודה מדהימה הערך הוא 1.
 אז אתם יכולים לראות כאן, יש לנו 2 דברים משם בכיתה אלה,
 CS50 וStat110, ויש לנו את תעודות הזהות של הכיתה והסיסמה.
 אז אנחנו רוצים לבחור את כל המידע הזה.
 אז אתה יכול לראות ממש כאן, כי זה סוג של בחירה מתוך שהטור מדהים,
 שבו כל הדברים שהם 1, ולאחר מכן יש לו את מעמד זהות, שם המחלקה וסיסמא שהוא יכול לבחור.
 איך בדיוק אתה עושה את זה בקוד? אתה צריך להשתמש ב-PHP.
 אז זה סוג של איך PHP ו-SQL הקשורים זה לזה.
 עכשיו יש לנו את הקוד שלנו, ואנחנו הולכים להשתמש בפונקצית השאילתה שלנו
 כפי שעשינו בpset 7, ואנחנו הולכים כדי להפעיל את שאילתת SQL.
 ואז אנחנו הולכים להיות -
 תמיד יש לנו כדי לבדוק אם של השורה שווה המשולש אם שווא. אז שוב, אתה רוצה לבדוק את הסוג והערך,
 ואז אם זה לא עובד, אז אתה רוצה להתנצל, כרגיל, כפי שעשינו בpset 7.
 אחרת, אתה רוצה לולאה דרך כל דבר בהישג היד אלה
 foreach לולאות שאנחנו פשוט ניגשנו.
 עכשיו שאנחנו לולאה דרך ושעשינו את זה בעבר,
 בואו נניח שהשאילתה שלנו עברה, עכשיו יש לנו לולאת foreach שלנו.
 ויש לו בשורה הראשונה אותו, אז הנה בשורה, ממש כאן, אלא בקופסא.
 זה הולך להדפיס את כל המידע שהוא קיבל.
 אז זה הולך להדפיס בתחתית "רוצה ללמוד HTML?"
 אז זה הולך לשורה הבאה, כי זה הושלם הראשון ללולאה,
 וכך אז זה הולך להדפיס את השורה השנייה שלו,
 שהוא הולך להיות STAT110, מצא את כל הרגעים.
 

הדבר האחרון הוא על הפגיעויות של SQL.
 אני יודע שהדוד נגע בזה קצת בהרצאה.
 אתה יכול לקרוא בהמשך. זה באמת מצחיק.
 הזרקת SQL היא סוג של דבר מסובך.
 בואו נגיד שאתה פשוט מקל המשתנים האלה ישר לתוך השאילתה שלך,
 כפי שאתה יכול לראות שבשורה ראשונה.
 אז זה נראה בסדר, נכון? אתה פשוט מכניס את שם המשתמש
 וסיסמא לשאילתא SQL שלך, ואתה רוצה לשלוח אותו ולקבל את כל מה שהוא בטבלת הנתונים שלך.
 זה נראה די פשוט. אז נניח שמישהו מעמיד ב,
 לסיסמה, או זה טקסט ממש כאן -
 צריך להיות ממש בתיבה האדומה.
 אז בואו נגיד שהם הכניסו את הסיסמה של-- זה מה שהם נכנסים.
 אז הם שמים או "1" = 1.
 סוג של סיסמא מטופשת שיש.
 עכשיו בואו פשוט להחליף בזה, ואתה תשים לב שבשאילתא SQL עכשיו,
 זה מוערך תמיד נכון, כי אתה לציין כי
 אתה יכול שאילתת SQL לבחור את כל המידע הזה
 או שאתה יכול פשוט צריך 1 = 1.
 כך שתמיד הולך להעריך לנכון.
 זה לא הולך באמת לעבודה, כי זה אומר שההאקר יכול לפרוץ למערכת שלך.
 הפתרון לזה הוא שאתה צריך להשתמש במערכת PDO,
 מה שאומר שאתה צריך להשתמש בסימני שאלה,
 וזה מה שהיה לכם פעם בpset 7,
 לאן אתה הולך להשתמש בסימן שאלה במקום שבו אתה רוצה לשים משהו,
 ואז אתה הולך להיות פסיק, ואז יהיה לך אחר כך,
 לאחר המחרוזת שלך, את המשתנים השונים שאתה רוצה להחליף לסימן השאלה שלך.
 אז תוכל לציין כאן כי עכשיו יש לי סימני שאלה האדומים האלה.
 ואז אני שם את המשתנים אחרי המחרוזות שלי אז אני יודע להחליף אותם על מנת שלאחר מכן.
 זה יהיה לוודא שאם מישהו עושה את זה ככה,
 ויש להם 1 = 1 או מצב, שיוודא,
 בקצה האחורי, לוודא שזה לא יהיה ממש לשבור את שאילתת SQL.
 אוקיי, אז זה פחות או יותר אותו, מערבולת של PHP ו-SQL.
 מיטב של מזל לכולכם, ועכשיו לאורגון
 

[Oreoluwatomiwa Babarinsa] כולם בסדר. זמן לעבור על כמה JavaScript
 ועוד כמה דברים מהר מאוד ולכן אנחנו לא מחזיקים אותך הלילה.
 ב-JavaScript. כן. JavaScript היא סוג של דבר מגניב, כביכול.
 הדברים שאתה באמת צריך לדעת על JavaScript, זה כמו סוג של
 הסוף בצד הלקוח של מה יישום האינטרנט שלך הולך לעשות.
 יש כמה דברים שאתה פשוט לא רוצה לטפל בכל הזמן בצד השרת.
 כל האינטראקציות הקטנות, המדגיש דבר אחד, מה שהופך משהו ייעלם.
 אתה באמת לא רוצה צריך לדבר עם השרת שלך כל הזמן לזה.
 וחלק מזה הוא אפילו לא ניתן לעשות בצד השרת.
 זו הסיבה שאנחנו צריכים משהו כמו JavaScript.
 דברים מגניבים על JavaScript: הוא הקליד באופן דינמי.
 מה שזה אומר הוא שהתכנית שלך לא צריכה לדעת
 מה, בדיוק, את המשתנים הם כשאתה כותב את זה.
 זה פשוט סוג של להבין את זה כפי שהוא פועל.
 דברים אחרים שהם מגניבים על זה: זו שפת סד מתולתלת,
 מה שאומר שהתחביר דומה ל-C ו-PHP.
 אתה לא צריך לעשות הרבה חוזר כאשר אתה לומד ב-JavaScript.
 כאן יש לנו קצת ב-JavaScript.
 דבר מעניין כאן הוא שאם אתה מסתכל על זה,
 יש לנו קצת JavaScript ממש שם בתג הראש.
 מה זה עושה הוא בעצם רק לכלול קובץ ב-JavaScript.
 זוהי דרך אחת שאתה יכול לכלול JavaScript לתכנית שלך.
 אז קצת השני הוא למעשה חלק JavaScript מוטבע,
 דומה מאוד לסגנון מובנה עם CSS,
 ואתה פשוט כותב איזה קוד מהר מאוד שם.
 יש JavaScript מערכים.
 רק עוד דרך לשמור על הנתונים בסביבה, מאוד שימושיים.
 תחביר מאוד נחמד וקל.
 אתה משתמש בסוגריים מרובעים כדי לגשת לכל דבר ולשמור על הכל ביחד.
 שום דבר מורכב מדי.
 הדבר מגניב על JavaScript ושפות סקריפטים באופן כללי
 הוא שאתה לא צריך לדאוג לגדלי מערך.
 אתה יכול פשוט להשתמש array.length ולעקוב אחר זה,
 וגם המערך יכול לגדול או להתכווץ כמו שאתה צריך את זה.
 אז אתה אפילו לא צריך לדאוג לגבי כל סוג של,
 הו לא, אני צריך להקצות יותר דברים, או משהו כזה.
 

הדבר מגניב כאן הוא שJavaScript יש משהו שנקרא אובייקטים. זה שפה מונחה עצמים, אז מה זה, בעצם,
 יחד דרך בשבילך כדי לקבץ נתונים, דומה במקצת למבנה,
 אבל אתה יכול לגשת אליו כמו מבנה או בתחביר מערך אסוציאטיבי.
 זה די פשוט ומה שאתה יכול לעשות עם זה הוא נתוני קבוצה יחד
 אם יש לך חבורה של נתונים שקשורים.
 בגלל שזה כל הדברים שאתה צריך לתאר את מכונית,
 אתה לא צריך לעשות את זה בחבורה של מקומות שונים.
 אתה יכול פשוט לתקוע אותו לתוך אובייקט 1 ב-JavaScript.
 כפי שאתה בוודאי יודע, חזרה הוא אחת המשימות מייגע אלה.
 אתה פשוט עושה את זה מעל שוב. אתה צריך לדבר עם כל חפץ במכונית,
 או שאתה צריך לעבור כל פריט ברשימה או משהו כזה.
 אז יש JavaScript, בדומה ל-PHP, תחביר foreach.
 במקרה זה, זה בלולאה.
 אתה רוצה להשתמש בזה רק על אובייקטים.
 יש כמה בעיות שעלולות להתעורר אם אתה משתמש בזה על מערכים.
 זה בדרך כלל הוא אחד מאותם דברים, אם כי, כי הוא מאוד שימושי,
 כי אתה מבטל הרבה תקורה
 כי אתה לא צריך למשוך את הכל באובייקט שלך בכוחות עצמך.
 אתה לא צריך לזכור את כל שמות המפתח.
 אתה פשוט סוג של להחזיר אותם בתחביר זה.
 בחודש זה, עם ל, אתה רק רוצה לזכור
 שאתה מקבל בחזרה את כל המפתחות, באופן דומה מאוד לחשיש שולחן.
 אם אתה זוכר מזה, כשאתה הייתי שם במחרוזת אתה יכול להוציא משהו
 שיהיה לי ערך הקשורים אליו.
 מה אתה יכול לעשות עם זה הוא שאתה יכול להגיד, בסדר,
 אני שם במכונית, ואני קראתי לזה פרארי.
 אז אתה יכול לשים במחרוזת פרארי שוב מאוחר יותר, ואתה יכול לקבל את זה.
 ואתה יכול לעשות את זה בלולאה, עם בלולאה.
 אז פשוט יותר על אובייקטים. דבר מפתח מזה שאתה צריך לזכור
 הוא שאתה יכול להשתמש בstruct האובייקט כמו תחביר בכל פעם שאתה רוצה עם אלה,
 אלא אם מה שלך הולך להשתמש כמחרוזת אינו שם משתנה חוקי.
 אז אם אתה מסתכל על שיש, יש לנו מפתח עם רווחים.
 ובכן, אם היית לשים object.key, מרחב, עם, מרחב, מרחב,
 כי פשוט לא יהיה הגיוני מבחינה תחבירית.
 אז אתה יכול רק לעשות את זה עם סוג כזה של תחביר סוגר.
 

כמו כן, JavaScript היא מאוד היקף חכם ל-PHP.
 יש לך 2 דרכים להתמודדות עם היקפה.
 אתה לא יכול להיות var מול משתנה,
 וזה רק אומר שזה גלובלי.
 אתה יכול לראות אותו מכל מקום. גם אם היית לשים את זה באם הצהרה,
 בכל מקום אחר בקוד שלך אחרי נקודה שאתה יכול לראות שמשתנה.
 דבר נוסף, אם כי, הוא עם var, זה מוגבל לכל מה פונקציה שאתה נמצא בו
 אם אתה לא בתפקיד, טוב, זה גלובלי.
 אבל אם אתה נמצא בתפקיד זה רק נראה לעין בתוך הפונקציה.
 אין לי דוגמא, אבל, כן. זה אחד מאותם דברים שבו
 אתה יכול לנהל את מה שמשתנים שאתה רוצה להיות גלובלי,
 מה משתנה אתה רוצה להיות מקומי, אבל אתה צריך להיות זהיר לגבי זה,
 כי אין לך את הסוג של שליטת תבואה בסדר שאתה עושה ב-C,
 שבו אם הוא הכריז משהו ללולאה, שזה הולך להישאר בכי ללולאה.
 הדבר שאנחנו באמת אכפת להם באמצעות JavaScript להוא מניפולציה דפי אינטרנט, נכון?
 אני מתכוון, זה למה אנחנו עושים את זה.
 

כדי לעשות זאת, אנו משתמשים במשהו שנקרא ה-DOM.
 סוג Document Object Model.
 בעיקרון, מה שהיא עושה זה לוקח את כל HTML שלך
 ומודלים אותה לתוך חבורה של אובייקטים שמקוננים בתוך אחד את השני.
 אתה מתחיל לצאת עם משהו כזה.
 יש לך, על הזכות בשבילי, חבורה של קוד שם בחוץ, כי זה סוג של -
 היית חושב שאהיה קשה מאוד לתמרן,
 כי אתה רוצה להיות בניתוח דרך חבורה של טקסט
 ויש להם חתיכת דברים בנפרד. ומה אם זה לא היה מעוצב בצורה נכונה?
 דברים רעים לא יקרה.
 אז JavaScript מטפל בזה בשבילך, ואתה מקבל מבנה נתונים נחמד,
 כמו אחד משמאלי, שבו אתה רק צריך מסמך,
 ובתוך שיש לך משהו שנקרא HTML,
 ובתוך שיש לך בראש וגוף,
 ובתוך הראש שיש לך כותרת, וכו ', וכו', וכו '.
 זה מפשט מניפולציה דף אינטרנט, כך שזה פשוט,
 הו, אני רק רוצה לדבר איתי אובייקט זה.
 סוג של דרך דומה מאוד שהיית מדבר אל אובייקט אחר שעשית בעצמך.
 כמו שאמרתי, כל DOM הוא באובייקט המסמך.
 או שזה רק מקום אחד ואז אתה יכול ללכת בתוכו למצוא דברים,
 ואתה יכול לעשות את זה - זה הסגנון הישן של עושה את זה, שם למעלה,
 איפה אתה עושה document.getElementById, ולאחר מכן את השם,
 וכמו שאתם בטח יכולים לספר, זה נהיה מאוד מסורבל אחרי כמה זמן.
 אז אתה כנראה לא רוצה לעשות את זה. זו הסיבה שיש לנו
 הדבר הבא שאנחנו הולכים לדבר עליו אחרי זה.
 הדבר העיקרי כאן הוא ש, בסדר, יש לך את כל המרכיבים האלה, נכון?
 אז אולי אני יכול לשנות את הצבע של משהו כאשר הדף נטען.
 אז מה? מה אם המשתמש שלי לוחץ על משהו?
 אני רוצה שזה יעשה משהו מעניין כאשר הם לוחצים על משהו.
 זו הסיבה שיש לנו אירועים. אתה יכול, בעצם, למצוא שום גורם בDOM שלך,
 ואז אומר, היי. כאשר זה טוען או מישהו לוחץ עליו,
 או כאשר הם עכבר מעליו, לעשות משהו עם זה.
 ומה יש לך, יש לך פונקציות שמטפלות בזה בשבילך.
 פונקציות אלה הן מטפלים באירועים.
 מה הוא פזור - זה רק דרך מגונדרת להגיד,
 פונקציה זו מתבצעת רק כאשר אירוע זה מתרחש.
 אז הוא מטפל באירוע שמתרחש.
 זה איך אתה הייתי פורש את מטפל באירועים.
 יש לי איזה כפתור, וכאשר אתה לוחץ עליו, הוא מתפוצץ.
 אז אל תלחץ על הכפתור.
 זוהי דרך אחת שמתקרב לזה, נכון?
 יש לך תגן, ועל לחץ שיש לך מחרוזת שאומרת,
 אה, דרך אגב, אני עושה את הדבר מתפוצץ לי את זה.
 אחרת, זה בדיוק כמו כפתור רגיל אתה פשוט עשה.
 אתה יכול גם לעשות את זה בדרך אחרת,
 על ידי גרירת אלמנט DOM, אבל אנחנו נשמור את זה אחרי שאנחנו מדברים על jQuery.
 

JQuery: זוהי ספרייה שהיא דפדפן צולב.
 אתה יכול להשתמש בו בכמעט כל דבר.
 וזה רק נותן לך הרבה כלים לעבוד איתו.
 בגלל JavaScript, תוך עוצמה, אין את כל הכלים הדרושים לך
 מחוץ לקופסה באמת להתמודד עם יישום אינטרנט, ייתכן שתרצה לעשות.
 אז זה מפשט הרבה דברים, נותן לך הרבה פונקציות
 מחוץ לקופסה כי אתה בדרך כלל צריך לכתוב בעצמך, שוב ושוב ושוב.
 ופשוט עושה דברים פשוטים מאוד.
 יש לך גם בוררים, אשר מאפשרים לך לקחת את כל אותם האלמנטים
 מDOM שלך הרבה יותר פשוט, במקום שיש להשתמש בקריאות פונקציה ארוכות מאוד אלה.
 נוסף על בוררים אלה. יש לך, שם למעלה שיש לך, בואו נגיד
 אני רוצה לקבל את אלמנט עם המזהה "הסלע".
 ובכן, בjQuery, זה רק $ ולאחר מכן מחרוזת שיש לו קילו, ולאחר מכן "סלע".
 זה פשוט מאוד והרבה יותר מהר מאשר בדרך המסורתית של JavaScript התמודדות עם בעיה זו.
 ויש לך דברים דומים לשיעורים וסוגי אלמנט.
 jQuery היא - אחת התכונות מגניבים הוא סוג של אתה יכול לדחוס
 את השאילתות שלך על DOM שלך מאוד, מהר מאוד.
 עכשיו אנחנו חוזרים לטיפול באירוע, וזה איך היית להתמודד עם אירוע אחד בjQuery.
 אז מה אנחנו הולכים כאן הוא שאנחנו אומרים, הכל בסדר. יש לי תג סקריפט, נכון?
 אז יש לי בשורה זו ב-JavaScript.
 מה שאנחנו הולכים לעשות הוא שאנחנו הולכים לומר, הכל בסדר.
 כאשר המסמך מוכן, מה שאומר שהמסמך שנטען,
 אנחנו הולכים ללכת לתפקיד זה, ואנחנו הולכים להגיד, בסדר,
 פונקציה זו בעצם עושה משהו אחר.
 זה בעצם אומר, בסדר, ישיג לי את האלמנט עם המזהה "myid".
 ולאחר מכן לתת את זה מטפל פונקציה שמבצע כאשר אתה לוחץ עליו.
 בעיקרון מה שזה עושה זה, זה אומר, בסדר.
 הדף נטען, ולכן אני הולך ב, למצוא את האלמנט הזה,
 לתת לו מטפל אירוע זה, וזה בעצם מגדיר את הדף שלך בשבילך.
 וזה איך שאתה רוצה לחשוב על טיפול באירוע.
 אתה רק רוצה לחשוב על זה, בסדר, כשמשהו מתרחש, מה אני רוצה שקורה?
 אתה לא רוצה לחשוב על זה, בסדר, אני צריך לעשות שיחות הדבר הזה בטוחים לדבר הזה,
 הדבר הזה בלה בלה בלה, כי אתה רק רוצה לדבר דבר במונחים של אירועים.
 כאשר זה קורה, זה קורה. כאשר זה קורה, זה קורה.
 ואם דברים לעורר דברים אחרים, זה נהדר.
 אבל אתה לא רוצה לנסות ולעשות קוד מסובך
 לאן אתה מפעילה דברים מרובים באותו הזמן,
 כי אתה פשוט הולך לתת לעצמך כאב ראש.
 

בסדר. עכשיו אנחנו יכולים להגיע לדף שלנו לטפל באירועים,
 אבל בואו נגיד שהמשתמש שלי לוחץ על כפתור.
 מה אם אני רוצה לשלוח את הבקשה שבחזרה לשרת,
 אבל אני לא רוצה לטעון מחדש את הדף, כי צורך לטעון מחדש דף חדש
 בכל פעם שמקבלת סוג של מייגע, ולמה אני צריך
 לניתץ את הכותרת שוב, ושוב תחתונה,
 ואת כל האלמנטים של הדף שוב
 רק כדי לרענן את ברכה או את הזמן?
 אז זאת הסיבה שיש לנו משהו כמו אייאקס.
 מה אנחנו יכולים לעשות כאן עם אייאקס הוא שאנחנו יכולים לומר, בסדר,
 אני רוצה לשלוח כמה נתונים לשרת,
 ואני רוצה לקבל תגובה בחזרה כדי שאוכל לעדכן את הדף שלי,
 או אולי רק לעשות קצת חישוב אלגוריתמי שלא בהכרח מראה שום דבר למשתמש.
 מה אתה צריך לעשות את זה? ובכן, אתה צריך כתובת אתר שאתה צריך לדבר איתו.
 השרת שלך לא יכול פשוט קסם להקשיב במשום מקום.
 אתה צריך מקום מסוים אתה שולח את הנתונים ל.
 ואתה גם צריך קצת נתונים כדי לשלוח, או אולי זה שאילתת dataless.
 אתה רק רוצה לאותת בחזרה לשרת ואומר, היי, אני בחיים, או משהו כזה.
 ואז אתה רוצה פונקציה שבעצם מטפלת בהצלחה.
 בואו נגיד לך לחזור קצת מידע מהשרת שלך,
 ואתה רוצה לשנות את הכותרת של המשתמש בדף שלהם.
 אז היית מקבל את המידע בחזרה,
 והיית לדחוף את זה על המסך.
 מה שקורה הוא, כאשר הדף מוכן,
 אתה יוצר בפונקציה לחץ על הכפתור הזה שנקרא מברך. מה זה אז עושה הוא, כאשר הכפתור שנדחף,
 אתה מדבר עם greetings.php, שתבצע בקשת POST,
 ואתה אומר, היי, תשיג לי משהו מהדף שלך.
 אנחנו לא באמת צריכים לתאר את זה, אבל greetings.php,
 בואו רק נאמר, נותן בחזרה "שלום עולם".
 אז אנחנו מקבלים בחזרה "שלום עולם", ועל הצלחתו של זה,
 בהנחה ששום דבר לא ישתבש, אז אנחנו פשוט הולכים למקום יעד זה
 שצוינו ואנחנו רק מקל את התגובה שם.
 וזו היא דרך פשוטה מאוד של הקמת שאילתת אייאקס.
 

מהר מאוד, רוב הזכיר את זה כבר סוג של,
 דברים יכולים להשתבש, דברים רעים יכולים לקרות,
 אז אתה רוצה להכיר את עצמך עם קודי תגובת HTTP אלה.
 מה אלה הם רק, כאילו, 200, הכל הלך בסדר.
 משהו אחר, דברים רעים קרו.
 זה בדרך כלל הדבר שאתה רוצה לזכור.
 אבל זה נחמד לדעת את כל אלה.
 ולבסוף, ברגע שאנחנו כבר עברנו את כל זה,
 אנחנו צריכים לדבר מהר מאוד על עיצוב,
 ואז אנחנו יכולים לתת את כל שאתה עוזב.
 עיצוב. דברים שאתה רוצה לזכור.
 שאל את עצמך את השאלות הבאות: מי אהיה באמצעות זה?
 יהיו מה שהם משתמשים בו ל? מה המשתמשים שלי אכפת?
 מה לא אכפת להם?
 אתה פשוט לא רוצה להפוך את האפליקציה ולתת לו רק לגדול
 ולהפוך לענק זה, דבר כל רב שאתה אפילו לא יכול לסיים.
 אתה רוצה להיות מטרות דיסקרטיות ותוכניות ודברים שאתה רוצה להתייחס.
 להפוך אותו ללא מאמץ. כל זה אומר, בעצם,
 לעשות את זה קל עבור המשתמש על מנת להשתמש בו, אל תעשה את זה כתם ענק של טקסט כמו שקופית זו היא, למעשה.
 אתה רק רוצה שזה יהיה משהו שבו זה קל מאוד עבור מישהו ללכת ב
 ולעשות מה שהם רוצים לעשות.
 אתה לא רוצה שהם צריכים לנווט 5 דפים
 כדי להגיע לתפקוד הממשלה שלך באתר שלך.
 אם גוגל היו 5 דפים עוד לפני שאתה יכול לחפש משהו,
 אף אחד לא היה משתמש בו.
 ולבסוף, אב טיפוס נייר, קבוצת מיקוד.
 יש עיצוב טוב ושיטות בדיקה.
 רק בגלל שאתה חושב שזה עובד בשבילך,
 זה לא אומר שמישהו אחר חושב שזה עובד.
 אבל כן, זה הכל.
 [CS50.TV]