>> [השמעת מוסיקה]
חנה: היי, כולם.
תודה לכם כל כך הרבה עבור יוצא במזג האוויר המגעיל לחידון אחד
לסקור פגישה.
כאתם יודעים, חידון אחד הוא ביום רביעי.
אז אנחנו הולכים ללכת דרך חבורה של נושאים.
דווין: היי, אני יכול לומר משהו ממש מהר?
חנה: כן, דווין של הולכים לומר משהו ממש מהר.
דווין: מצטער.
רק ממש מהר, אם יש לך שאלות על החידון, אתה יכול להיכנס לאינטרנט.
עבור 2014 אחד חידון, על החידון.
זה חייב לוגיסטיקה על לאן ללכת, מתי ללכת.
אם אתה לומד בו-זמנית, אנחנו הולך להיות לנו חידון איפור בשעת 5:30.
או אם שלח לי בעיה, יש לך כמה נושא אחר.
אבל 5:30 הוא האיפור זמן ביום רביעי.
אבל אם יש לך שאלות, שאלות כלליות,
באינטרנט יש את כל הלוגיסטיקה.
אז לבדוק שם קודם.
>> חנה: מדהימה.
אז הנה הרשימה הגדולה של נושאים שאנחנו הולכים לעבור היום.
אני הולך כדי לכסות את כל C דברים, והוא שהעמודה הראשונה.
כך שהדברים שאנחנו C מכוסה לאחר חידון אפס.
החל עם רשימה מקושרת, הכולל מצביעים.
>> בסדר, אז שראינו את זה בפגישה הסקירה האחרונה,
אז אני הולך לעבור זה קצת יותר מהר.
רק להרים את היד שלך אם אתה רוצה שאני להאט או לטפל במשהו נוסף.
אבל אנחנו משתמשים רשימות מקושרות, כי התחלנו בC עם מערכים.
ומערכים הם נהדרים, אבל הבעיה היא שיש להם בגודל קבוע.
רשימות מקושרות תאפשר לנו ליצור באופן דינמי בגודל מבני נתונים.
>> ויש לנו הפעולות הבסיסיות שלנו, להוסיף, למחוק, ולחפש.
ואנחנו יכולים לעשות להכניס ב במקרה הגרוע ביותר זמן קבוע
אם אנחנו רק לשים אותו בהתחלה.
למחוק ולחפש, הגרוע ביותר תיק גדול הו זמן n.
אז שוב, רק כדי להעיף באמצעות התמונות הללו,
אני יודע שראינו בפעם האחרונה אלה, אבל אנחנו רוצה לעקוב אחר הרשימה המקושרת שלנו
על ידי שמירה על מסלול של ראש הרשימה המקושרת שלנו.
כי אנחנו יודעים ש כל אחד מצומת שלנו
הוא רק הולך להצביע הצומת הבאה ברשימה המקושרת שלנו.
>> אז ככה אנחנו לעקוב אחר.
למרות שאלו אינם חתיכות רציפות של זיכרון,
אנחנו יכולים למצוא אותם רק על ידי בעקבות החצים השונים.
הנה המבנה שלנו לצומת רשימה מקושרת.
ראינו בפעם האחרונה זה.
יש לנו צומת struct שלנו.
ויש לו שתי תכונות.
מספר אחד, בפועל ערך שאנו רוצים לאחסן.
במקרה זה, זה מספר שלם.
זה יכול להיות מחרוזת, היא יכולה להיות char, מה שאתה רוצה.
ואז, אנחנו צריכים לעקוב אחר הצומת הבאה ברשימה המקושרת שלנו.
אז זה הולך להיות מצביע לצומת הבאה.
אם רק היית עושים חיפוש, כמו שאמרתי קודם,
היית צריך לעקוב את החצים שלך.
הכנסה, שהיית לעקוב אחר היכן שאר הרשימה שלך הוא.
ואתה רוצה להפנות את הראש כדי להצביע על הגורם החדש שלנו, ש
במקרה זה הוא אחד, ואז אחד יצביע
לשאר הרשימה המקושרת.
אז שוב, אני יודע שזה קצת קצת חוזר מהחידון אפס.
אז אנחנו צריכים להיות מאוד זהירים על הסדר שבו אנחנו
לעשות pointings האלה כדי שלא לאבד את החלק האחורי של הרשימה.
OK, שאלות עם רק ביחידים רשימות מקושרים?
מדהים, בסדר, מגניב.
>> אז עכשיו, אנחנו הולכים ללכת על משהו רק מעט יותר מסובך,
כפליים רשימות מקושרות.
אז בנוסף לשמירה מסלול של הצומת הבאה,
אנחנו רוצים גם כדי לעקוב אחר של הצומת הקודמת.
וזה מאפשר לנו, אם אנחנו בשלב מסוים ברשימה המקושרת שלנו,
לא רק ללכת קדימה, אבל גם לחזר אחורה.
כי כמו שראינו ב רשימה מקושרת ביחידים,
אם היינו בחלק הצומת, ו פתאום, החלטנו,
למעשה, אני רוצה ללכת ל זכות הצומת לפניי,
היית צריך ללכת כל בדרך חזרה לראש
ולחזר דרך עד שמצאת הצומת שחיפשת.
>> אז זה עושה את הדברים מעט קל יותר כמו שאנחנו
מנסה לחזר באמצעות הרשימה המקושרת שלנו.
אבל זה מחייב אותנו לעקוב אחר אחד יותר מצביע, כך כוכב צומת אחד יותר.
בסדר, אז הנה מגיע החלק הכיפי.
אנחנו הולכים לתרגל יישום להסיר לרשימות מקושרות כפליים.
אז זה משהו ש משחק לגמרי הוגן לחידון.
זה הופיע בחידוני העבר.
אז בהחלט להיות מוכן קוד קצת בג
אל תשכחו שעם כל PHP זה הכיף ו- JavaScript,
אנחנו עדיין צריכים לזכור לעשות C. אז לרענן את ש
אם אתה מרגיש חלוד.
>> בסדר, בואו תראו אם אנחנו יכולים לעשות את זה.
OK, מגניב.
אז אנחנו הולכים לנסות כדי לערוך את הזכות כאן,
ואני מקווה שזה ילך כמתוכנן.
בסדר, האם מישהו רוצה לתת לי הצעה לגבי איך אני צריך להתחיל?
ההנחה היחידה שאני קבלת היא שאני כבר
הגדיר מבנה, אחד הראיתי בעמוד האחרון,
בשקופית האחרונה.
ואני אחסון ראש שלי מקושר רשימה בחלק המצביע בשם רשימה.
האם מישהו רוצה יתחיל איתי?
>> קהל: אתה יכול ליצור חדש צומת לקרוא ברשימה?
>> חנה: מדהימה, כל כך אנחנו הולכים ליצור
צומת חדשה לזחול ברשימה.
אני אוהב את זה.
אני רק קורא לזה מצביע אם זה בסדר.
ושבו צריך אותו במקור להתחיל?
>> קהל: כנראה ב ראש הרשימה.
חנה: יפה.
אנחנו רוצים להתחיל בראש, ש אמרתי הולך להיות מאוחסן ברשימה.
מדהים.
עד כה, כל כך טוב.
ועכשיו, המטרה שלנו היא איטרציות ברשימה
עד שאנחנו מוצאים את הצומת עם n הערך שאנו רוצים למחוק.
בסדר?
>> אז עכשיו הוא החלק שבו אנחנו רוצים לחזר דרך.
האם מישהו יכול להציע הדרך ללחזר דרך?
>> קהל: לולאה.
>> חנה: לולאה.
אני אוהב את זה.
באופן ספציפי, אנחנו יכולים לנסות לולאה בזמן.
OK, ואנחנו יודעים שאנחנו כבר הגענו סוף הרשימה, כאשר מה שלנו?
קהל: כאשר המצביע הוא null.
חנה: כאשר המצביע הוא null.
יפה, אני אוהב את זה.
OK, מגניב.
כל כך מצטער אם הסד התוחם שלי הוא סוג של נפילה את המסך.
אנחנו הבאנו אותו בחזרה.
OK, מגניב.
מה הלאה?
>> אז אנחנו יודעים שאנחנו רוצים למחוק הצומת שיש n הערך.
אז בואו למצוא את המקרה שבו אנחנו באמת למצוא צומתנו.
אז איך הייתי בודק את זה?
אני פשוט הייתי אומר אם מצביע, ולאחר מכן אם אני רוצה לקבל את הערך מתוך מצביע,
אני פשוט חץ n, שווה n, הפרמטר
שנתנו לפונקציה זו, צומת שאנחנו רוצים למחוק למעשה.
כל שאלות עד כאן?
בְּסֵדֶר.
אוקיי, אז עכשיו בואו לצייר תמונה מהירה על הלוח כדי להמחיש את זה.
>> אז בואו נגיד שיש הצומת היפה שלנו.
ויש לה ערך, אני רק אומר ארבעה.
וזה מצביע על הבא צומת ברשימה המקושרת שלנו.
ואין שום דבר לפני זה.
אז יש לנו הקודם שלנו מצביע על שום דבר.
במקרה זה, אנו מצביעים לאחור.
בסדר, רק הגדרה שלי רשימה מקושרת לכאן.
ויש לנו רשימה שמציינת למבנה הזה מלכתחילה.
אני לצייר עוד אחד ל למען השלמות.
OK.
אני אצביע קדימה זה.
ואני אצביע כי גב אחד.
אופס, מצטער.
כן, יש לי לאחור זה.
לעשות את זה שוב.
בסדר, יש לנו ללכת.
בסדר, יש את זה.
OK, הנה התמונה שלנו.
>> אוקיי, אז אנחנו רוצים לשקול שני מקרים.
המקרה הראשון הוא אם צומת שאנחנו רוצים למחוק
הוא בתחילת מאוד של הרשימה שלנו.
ולאחר מכן, המקרה השני שאנחנו רוצים לקחת בחשבון הוא אם זה בכל מקום אחר.
אני מבין שזה לגמרי מבולגן ציור עם כל המחיקה שלי,
אבל אני מקווה שננסה להבהיר זאת עם כמה קוד.
>> אוקיי, אז בואו לכסות את המקרה שם מצאנו צומתנו,
וזה ממש ב תתחיל מהרשימה המקושרת שלנו.
כל אחד ייתן לי הצעה כאן על מה
אני צריך לעשות בעצם כדי להסיר הצומת שלנו?
זה קצת מסובך.
בסדר?
>> קהל: אתה צריך לקחת צומת שתהיה לפני ש
ולעשות את זה מצביע על אחד שיהיה אחרי זה,
ולקחת את הצומת ש יהיה אחריו ולהפוך את
זה מצביע על הצומת לפני ש.
חנה: בדיוק.
אוקיי, אז זה המקרה where-- יש לנו שני מקרים.
יש לנו המקרה שבו צומת שאנחנו מחפשים
הוא מול הרשימה.
OK, ולאחר מכן במקרה שאתה תיארתי הוא אחרת, נכון?
זה במקום אחר ברשימה.
אז אתה אמר, אנחנו צריכים מסתכל הצומת הקודמת,
ולהפוך את הצומת הקודמת להצביע לקשר הבא.
אז בואו נגיד שאנחנו מנסה להוציא את חמש
בציור מאוד המבולגן שלי כאן.
אנחנו רוצים לוודא ש ארבעה עכשיו מצביעים על שש.
של ארבעה נקודות הבאות לשש.
ושל שש נקודות קודמות לארבעה.
זו המטרה שלנו כאן, נכון?
זה מה שאני חושב שאתה רק אמר שם.
>> אוקיי, אז בואו לקבל את זה החתיכה ראשונה.
בואו לעשות של לי מצביע קודם קודם.
אז של ארבעה הבאים צריכים להצביע על מה?
בדיוק, במקרה זה, שש.
אז אנחנו צריכים לומר מצביע, הבא.
בסדר?
בְּסֵדֶר.
אז בואו להיפטר מהתמונה המכוערת הזאת ולנסות לצייר אחד מעט יותר נחמד.
יש לנו ראש הרשימה שלנו כאן.
וזה מצביע על הצומת הראשונה ב הרשימה שלנו קשורה, שאמרנו היא ארבע.
הנה הצומת השנייה שלנו, חמש.
והצומת השלישית שלנו, שש.
רק מנסה לצייר את אותו הדבר תמונה, רק קצת יותר נקי.
אוקיי, אז הבא של ארבעה במקור מצביע על חמש.
של חמש נקודות הבאות לשש.
של שש נקודות קודמות לחמש.
ושל חמש נקודות קודמות לארבעה.
כל כך הרבה יותר נחמד!
OK, מגניב.
>> אז עכשיו, מה שעשינו רק כאן, שורת קוד הזאת,
שאומר מצביע קודם הבא, אז מה זה אומר?
כלומר, אם אנחנו מסתכלים על חמש, ללכת לצומת הקודמת,
וזה הבא צריך עכשיו נקודה לחמש של הבא.
אז למעשה, מה זה עושה הוא זה מוחק את החץ הזה
ומה שהופך את לדלג תקין בחמש.
האם זה ברור?
אני יודע שיכול להיות קצת גס.
אני רואה כמה הנהוני ראש.
זה טוב.
OK, מגניב.
עכשיו, מה הצעד הבא?
>> אני כבר לאפס הבא.
עכשיו, חץ אחר ש אני צריך לעשות כדי לשנות?
זה אחד ממש כאן.
של שש קודם.
אנחנו לא רוצים שישה של קודמים כדי להצביע על חמש יותר.
אנחנו רוצים את זה כדי להצביע על ארבעה.
האם תמונה שהגיונית?
אז עכשיו אנחנו יכולים למעשה לקחת חמש החוצה.
אז בואו לקבל חתיכה ש.
מה עליי לעשות לפני ש לאפס שש של קודם לארבעה?
יש לך רעיונות לשם?
>> קהל: שחרר את הצומת בין שלהם על ידי הגדרתו לnull?
חנה: מגניב.
בהחלט, המטרה הסופית שלנו היא הולך להיות לשחרר את הצומת.
אז אנחנו יכולים לעשות את זה כאן.
מצביע חינם.
בהחלט.
אבל עוד לפני ש, בואו פשוט- תקין המטרה שלנו
כאן הוא להגדיר מצביע הבא קודם שווה למצביע קודם.
אני יודע שזה הוא מקבל מכוסה.
OK, בואו take-- מגניב.
יכול כולם לראות את שורה תחתונה זה?
או שזה סופר זעיר?
>> אז לפני שאנו מבצעים הקו הזה כאן, אנחנו רוצים
לוודא כי המצביע הוא הבא לא ריק.
כי אם המצביע הבא הוא null, איזה סוג של שגיאה
יהיה שאני מקבל כאשר אני מנסה התייחסות מצביע null?
קהל: אשמת צינוק.
חנה: אשמת SEG, יפה.
אוקיי, אז אם זה לא null, אז אנחנו יכולים לאפס.
ויש לנו שש נקודות שוב לארבעה.
שאלות עד לנקודה זו?
כן?
>> קהל: בך הראשון אם הצהרה, עשיתי לך
אומר שיש על החץ הבא, או [לא ברור]?
חנה: התכוונתי n חץ מצביע.
אז בעצם, מה שאני מנסה לעשות הוא אומר, הצומת הנוכחית שאני
, הצומת הנוכחית iterating על ש אני מסתכל, אני אחסון במצביע.
ואני רוצה לדעת מצביע של ערך, אשר במקרה זה הוא n.
ואני רוצה לראות, הוא הצומת אני מחפש
לצומת שאני מכוון למחיקה?
אז זאת הסיבה שיש לנו כאן מצביע n.
>> קהל: אז החץ הולך לn, תגדיר את הערך
ולאחסן אותו בצומת נקראת n?
>> חנה: אז זה כמו שאם אני עובר רשימה מקושרת זה
ומצביע על חמש.
אם אני רוצה לקבל ערך ש, אם אני רוצה לקבל את המספר הזה, 5,
אני צריך לעשות n חץ מצביע.
מגניב?
כן.
>> קהל: הוא n השם המשתנה?
חנה: כן.
אז אם אנחנו להעיף בחזרה אחד שקופיות, n הוא השם
של הערך הפנימי של צומת ברשימה המקושרת שלנו.
ואני יודע שזה יכול להיות קצת קצת מבלבל גם בגלל ש
קוראים דבר שאנחנו רוצים למחוק את n.
אז זה המקום שבי ש קו אחד מגיע מ.
כן?
>> קהל: מה יש לך [לא ברור] הם איך עובדים?
מצביע [לא ברור]?
>> חנה: בטח.
אתה מדבר? על-- ששורה
קהל: השורה האחרונה [לא ברור].
>> חנה: בטח, OK.
אז בואו נסתכל על התמונה ב כדי לנסות ולהסביר את זה.
אני מצטער, ל מצלמה, השאלה הייתה
אפשר להסביר מצביע חץ המצביע הבא קודם.
אוקיי, אז נניח שאנחנו בחמש והמטרה שלנו היא למחוק חמש.
אז מצביע הבא, שמהן שלושה צמתים שאין לנו?
זה מביא אותנו לצומת השישית, נכון?
>> אוקיי, אז עכשיו אנחנו מבקשים לשל שש קודמים.
בסדר?
ואנחנו איפוס זה להיות שווה לארבעה,
שהיה במקרה של חמש קודמים.
אני יודע, זה סופר קשה לעקוב אחר.
אני באמת ממליץ לך לצייר תמונות אם אתה מקבל שאלה כזאת.
כן?
>> קהל: האם הסיבה ש אין לנו [לא ברור]?
>> חנה: בדיוק.
אז השאלה הייתה, מדוע לעשות אנחנו לא צריכים לבדוק כאן?
למה אנחנו לא צריכים לבדוק ש המצביע קודם הוא לא שווה ל null?
וזה בגלל שיש לנו הופרד כבר
המקרה אם של המצביע ממש בהתחלה.
שאלה טובה מאוד.
שום דבר על זה אחר?
OK, מגניב.
אז בואו נסיים את זה.
אנחנו כמעט שם.
>> אז מה אם זה בראש?
מה אם במקום מנסה למחוק חמש,
אנחנו באמת רוצים למחוק ארבעה?
מה הייתי צריך לעשות?
ובכן, אני רוצה לאפס את הראש שלי למה?
לצעוק את זה?
קהל: אחד אחריו.
חנה: יפה.
OK, אז אנחנו רוצים לרשום להצבעה לכל מה שהצומת הבאה המצביע שלנו היא.
טוב.
ורק בשביל השלמות של למען, הייתי
רוצה לבדוק כל עוד שכפי שהרשימה שלנו אינו null, כל עוד הרשימה שלנו היא לא
ריק, אז אנחנו רוצים להגדיר הקודם השווה null.
שאלה עד כה?
צעד אחד from-- משם?
>> קהל: האם זה יהיה אם הרשימה אינה שווה לnull?
>> חנה: כן, אתה צודק לחלוטין.
אני כל כך מצטער.
האם הרשימה היא לא שווה ל null.
מדהים.
מנסה להביא את זה כל על המסך.
זה סוג של הנפילה.
מצטער, חבר'ה.
ואחרון אחרון חביב, כל אנחנו צריכים לעשות הוא לחזור.
OK.
זה היה הרבה דחוס בבאמת במהירות.
קח רגע כדי להסתכל על זה.
תגיד לי אם יש לך שאלות.
כן?
>> קהל: אם רשימה היא ב הראש, then-- לחכות, Nevermind.
>> חנה: OK, טוב.
אז זה אם רשימה היא בראש, אנו מסירים אותו לכל מה שאנו מוכנסים.
כן?
>> קהל: האם אתה יכול להסביר הראשון אם הצהרה שוב?
אם את המצביע לn שווה לn?
חנה: בטח.
אז המטרה של כל פונקציה זו שלנו היא כדי למחוק את הצומת שיש n הערך.
אז אם אנו מוצאים, כאנחנו iterating דרך הרשימה שלנו,
הצומת עם n הערך, זה אחד שאנחנו רוצים למחוק.
אז כל המחיקה קורה בתוך כך גדול אם ההצהרה.
האם זה הגיוני?
מגניב.
כן?
>> קהל: אולי אתה פשוט לא יכול לראות את זה, אבל אתה לא צריך גם קו
לגלילה ברשימה?
חנה: מדהימה.
בואו נביא את זה קצת, ו אנחנו נזרוק תקין שבתחתית.
אולי הלוח היה לי היה רעיון קצת יותר טוב.
אז איך הייתי להעביר את סמן קדימה?
>> קהל: פוינטר שווה מצביע ועוד אחד.
>> חנה: יפה.
כך שמאפשר לנו תמשיך iterating דרך.
OK.
קהל: האם לא יהיה אחר?
חנה: עוד פעם אחת?
קהל: האם לא יהיה אחר לאחר גדול הישן אם
הצהרה [לא ברור]?
חנה: איזה חלק?
אני מצטער.
>> קהל: חציה, לא צריך להיות אחר?
חנה: אתה בהחלט יכול להיות אחר.
בגלל שיש לי זכות שיבה שם, אתה לא צריך עוד.
אבל כן, שאלה טובה.
OK, כן?
קהל: האם אנחנו יכולים לחשוב על מצביע כי הוא נע ברשימה
כלוקח על הערך של כל צומת ברשימה?
או שאנחנו צריכים לחשוב על זה כ סוג של חיצוני לרשימה?
>> חנה: או אחד היא בסדר, אני חושב.
כמו שאני מניח שזה הוא אני אומר, אוקיי, אני מצביע.
וזה לי.
זה היד שלי.
אני הולך להצביע על שונה דברים שאני רוצה לחזר דרך.
ראשית, אני הולך להצביע לראש הרשימה.
וזה אומר לי שאני הולך להצביע על ארבעה.
וכך, להיות חיצוני לרשימה, אני יכול להצביע על כל אחד מהמרכיבים האלה.
אז אני חושב על עצמי כמצביע.
קהל: אז כאשר אתה מוחק אחד מהמרכיבים האלה,
אתה מוחק את עצמך, אם אפשר לומר כך.
חנה: בדיוק.
אז אתה מוחק את הדבר אתה מצביע.
אז בדוגמא ש ראינו בו אנו נמצאים
מנסה למחוק חמש, כשאני מצביע על חמש,
אני רוצה למחוק דבר שאני מצביע.
בדיוק נכון.
כן?
קהל: האם אנו טופלו מקרה שבו n הוא לא ברשימה?
חנה: אם n הוא לא ברשימה?
כל מה שהולך לקרות הוא שאתה הולך לחזר דרך ולחזר
דרך, ולאחר מכן, אתה הולך כדי להגיע למצביע null להיות,
ואז אתה הולך לעשות.
>> קהל: לעשות אז יש לנו לחזור משהו?
חנה: אנחנו יכולים.
כך שאם זה מוגדר פונקציה, אני רק אומר שזה חוזר
לבטל את קשר.
אבל אתה יכול להיות משהו כמו חוזר מספר שלם,
ויש לו לחזור שלילי 1 אם זה לא מצליח.
משהו כזה.
שאלות with-- כן?
קהל: [לא ברור]?
חנה: מצטער?
קהל: [לא ברור]?
חנה: בטח.
אז זה actual-- פעם יש לנו כל העבודה הזאת נעשתה נעים
כל החיצים האלה מסביב, כולנו המטרה הייתה להיפטר מהצומת
שאנחנו מחפשים.
אז במקרה הזה, לשחרר מצביע, אם אני מצביע לחמישה,
זה כמו מחיקת צומת אמצע זה.
זה חלק המצביע החופשי.
כי תחושה? איפור
>> קהל: אז גם חשב אתה לא [לא ברור]?
>> חנה: אז הנחנו בתחילת היו לנו כמה רשימה שהייתה already--
הם לשים את זה ביחד.
אז כדי לבנות את זה רשימה, הם בטח [לא ברורים].
מגניב.
כל דבר אחר עם זה?
כן?
>> קהל: מה אם הרשימה אינו שווה לקו האפס?
[לא ברור]?
חנה: ממש כאן?
קהל: כן.
חנה: OK, כל מה שאני עושה הוא אני רק מוודא
לפני שאני מנסה לרשימת dereference, לפני שאני מנסה לגשת קודם,
אני רוצה לוודא שזה לא null אז אני לא מקבל אשמת צינוק.
מגניב.
>> בסדר, אני יודע שזה היה די הרבה לעבור אותו.
אז שקופית זו תהיה עומד לרשותך.
אז אתה יכול לעבור את זה בפירוט רב יותר.
כן?
>> קהל: מדוע [לא ברור] ברשימה?
חנה: בטח.
אז רשימה באמת מצביעה על אלמנט זה ממש כאן,
האלמנט הראשון ברשימה.
כך שזה לא יכול להיות קודם.
כן?
>> קהל: האם נקודת המצביע לאותה הכתובת בזיכרון?
האם זה מצביע על אותו כתובת בזיכרון כצומת
שזה מצביע על?
>> חנה: כן, זה מצביע לצומת זה בזיכרון.
>> קהל: נכון, כל כך כאשר [לא ברור]?
>> חנה: במובן מסוים, כן.
OK.
בסדר, בואו נעבור יחד עם זה.
ואם יש לכם עוד שאלות, להישאר בסביבה בסוף,
ואנחנו יכולים לעבור את זה שוב.
OK, מגניב.
עכשיו, אנחנו מקבלים לנוע ב חשיש שולחנות, ניסיונות,
ועצים, שיש לך סופר מכיר באיות חמש, להגדיר p-.
>> אז שולחן חשיש רק מערך עם רשימות מקושרות ביחידים
או צמוד כפליים רשימות יורדים ממנו.
אז יש לנו סוג כלשהו של מערך אסוציאטיבי.
ואיך אנחנו יודעים מי אלה מערכי דליים להיכנס,
אנו משתמשים בפונקצית חשיש.
אז במקרה הזה, כל אחד יכול נחש מה פונקצית החשיש
היה רק ​​להיות מבוסס על כמה של הקלט והפלט?
>> קהל: מספר מכתב של האלפבית.
חנה: בדיוק.
זה פשוט מכניס אותם לפי סדר אלפביתי.
כל מה שמתחיל ב הוא הכניס לתוך הדלי הראשון.
כל מה שעם B הוא להכניס דלי שני, כן הלאה, וכן הלאה.
מדהים, על אישור.
ופונקציה חשיש היא כל פונקציה שלוקחת במילה
ואגיד לך מה דלי הוא שייך ב.
אז איזה ערך בנו מערך זה שייך ב.
>> אז בכל פעם שאני נותן לי חשיש לתפקד מילה,
זה צריך להגיד לי את אותו מקום כל זמן.
אז אם אנו משתמשים בפונקצית החשיש מהשקף הקודם
לאן אנחנו ממיינים לפי אות הראשונה של האלפבית,
בכל פעם שאני נותן לי פונקצית חשיש "תפוח"
זה תמיד צריך להחזיר לי 0.
אז אם יש לי תפוח לשים בטבלת החשיש שלי,
אם אני נותן "תפוח" לפונקצית hash שלי, זה צריך לומר, ללכת לשים אותו בדלי 0.
אם אני מחפש תפוח בטבלת החשיש שלי
ואני אומר, שבו תפוח כוח חי, אתה שואל את פונקצית hash שלך.
וזה אומר, ללכת לדלי 0.
בסדר?
שאלות עם פונקציות חשיש?
מדהים.
>> הנה מעט יותר הסבר מפורט
של מה פונקצית חשיש עשויה להיראות.
בְּסֵדֶר.
עכשיו, הבעיה עם חשיש פונקציות היא בעולם אידיאלי,
תהיה לנו רק אחד דבר בכל אחד מהסלים.
אבל במציאות, יש לא רק מילה אחת
שמתחיל עם א 'יש לא רק מילה אחת שמתחילה עם B. אז
במקרה זה, אם פתאום "ברי",
ואנחנו רוצים לשים את זה לטבלת הגיבוב שלנו,
ואנחנו רואים, אה, לא, בננה היא כבר שם, מה אנחנו הולכים לעשות?
>> ובכן, יש לנו שתי אפשרויות.
האפשרות הראשונה היא ליניארי חיטוט, ש
רק אומר לך תמצא הדלי הריק הבא.
לך תמצא את כניסת המערך הריקה הבאה.
ופשוט לשים "ברי" לשם.
אז אני יודע שזה אמור ללכת עם בננה בדלי אחד.
אבל רק לשים אותו בדלי שלושה, כי דלי שלושה הוא ריקים.
אפשרות נוספת היא כנראה מה אתה מיישם
בp-הסט שלך, שבו אתה היה שרשור נפרד.
אז כל אחד מהדליים שלך, כל אחד מהאלמנטים במערך שלך,
לא רק מחזיק באחד מילות, אך למעשה מחזיק מצביע לרשימה של מילות.
כך שאם היה לך בננה בטבלת החשיש שלך
ואתה רוצה פתאום כדי להוסיף פירות יער, אין בעיה.
רק להוסיף פירות יער עד הסוף, או ל ההתחלה, של הרשימה המקושרת שלך.
OK, מדהים.
שאלות עם חשיש שולחנות לפני שאנחנו הולכים על?
>> בְּסֵדֶר.
עצים ומנסה.
אוקיי, אז זה היה עוד אפשרות ליישום מילון.
אתה יכול היה לנסות.
אז זה סוג מיוחד של עץ ש מתנהג כמו שולחן חשיש רב ברמה.
אז אתה תראה את התמונה שבו יש לך מערך ש
מצביע על חבורה של מערכים נקודה שלחבורה של מערכים
נקודה שלחבורה של מערכים.
ואנו רואים בדיוק מה ש היה נראה כמו בשקופית עתיד.
ואופן כללי יותר, עץ רק כל מבנה נתונים
שבו נתונים הוא מאורגן בהיררכיה מסוימת.
אז איפה ראינו שיש לנו הבנה כלשהי
ברמה עליונה, רמה הבאה, הרמה הבאה, רמה הבאה.
אז זה כנראה ברור ביותר עם כמה דוגמאות ספציפיות.
אז הנה העץ שלנו.
אתה יכול לראות שזה יש רמות מסוימות
כי אנחנו מתחילים עם שצומת השורש, אחד.
ואנחנו יכולים לרדת דרך העץ שלנו.
>> עץ בינארי הוא סוג מסוים של עץ.
והמפרט רק לעץ בינארי
הוא שיש כל צומת לכל היותר שני עלים.
אז אתה לא הולך לראות את כל יש לי של בלוטות אלה שלוש או ארבעה
או מספר אחר של עלים.
ואז אפילו יותר ספציפי הוא עץ חיפוש בינארי
שבו כל צומת בצד השמאל של צומת הוא הולכת להיות ערך קטן יותר.
וכל ערך ל נכון הולך להיות גדול יותר.
אז אם אתה רואה 44 הוא בשורש שלנו, משמאל, 11, 22, ו -33
כולם פחות מהשורש שלנו.
ועל זכותם כל מספרי bigger-- 66, 55, ו -77.
ונכס זה נכון גם בכל רמה של העץ.
>> לכן, כאשר אנחנו יורדים ל 22, 11, ו -33, עדיין 11
הוא קטן יותר מ -22 ו 33 הוא גדולים יותר מ -22.
וזה עושה את זה יותר קל לחפש כי אם אנחנו מחפשים מספר,
אנחנו יודעים בדיוק ש סניף לעקוב למטה.
כך זה צריך להזכיר לך קצת חיפוש בינארי.
כן?
>> קהל: אז כשאתה מתאר בינארי,
אתה אמר שיש לו לכל היותר שני עלים?
חנה: ממ-הממ.
קהל: זה יכול להיות פחות?
חנה: כן.
אז בוא נגיד ש, למשל, אתה לא היה לי אפילו מספר דברים
ואתה לא יכול למלא את כולך עלים, זה בסדר אם יש אחד אחד.
בסדר?
מדהים.
כל שאלות אחרות על עצים?
OK.
>> חזרה לניסיונות שלנו כמו שאני מדבר על קצת קודם לכן,
איך יש לנו מערכים מרובות רמות אלה.
אז במקרה הזה, אנחנו מתחילים בראש.
ואנחנו יכולים לעקוב אחר כל מילה שניתנה במורד.
אז בואו נגיד שאנחנו רוצים לחפש טיורינג.
אנחנו מתחילים ב- T, בצע אותו למערך שמכיל U,
ובצע אותה עד ש להגיע הדלתא הקטנה הזה ש
אומר לנו, כן, מצא את מילה.
ברור על ניסיונות?
כל דבר ללכת לשם?
כן?
קהל: האם הסמל של דלתא צריך לכבוש שטח בתוך לנסות?
חנה: כן, אז זה לא בהכרח גם צריך להיות דלתא.
אבל אנחנו צריכים דרך כלשהי ל לספר computer-- מצטער,
כך שאנו יודעים שTUR הוא לא מילה.
כי בואו נגיד שאין לנו תפיסה זו של דלתא, את המושג הזה
ברכה, שמצאת את מילה, זה יהיה לעבור ולחזר T-U-R,
ואז אומר, מדהים, אני מצאתי את זה!
זה חייב להיות מילה.
אבל זה ממש לא.
אנחנו רוצים כל טיורינג להיות מילה.
אז אנחנו חייבים להיות משהו ב סוף שאומר, מזל טוב,
אתה כבר נמצא מילה לגיטימית.
קהל: אז אם היה לך כמו 26 אותיות האלפבית,
היית באמת צריך 27 מפתחות בניסיון שלך?
>> חנה: מדהימה, כן.
אז בעצם, אני חושב ש יהיה בשקופית הבאה.
טה-דה!
שבו אם יש לך צומת בניסיון שלך, אתה
הולך להיות 27 ילדים במקום 26.
כל שאלות עם זה?
כן?
קהל: מדוע ניסיונות לוקחים כל כך [לא ברור] הרבה מקום כמו שאתה הולך?
למה זה נחשב [לא ברור]?
חנה: בטח.
בואו נחזור.
השאלה היא, מדוע הם מנסה כל כך הרבה יותר גדולים
מאשר משהו כמו שולחן חשיש.
אז לכל אחת מהרמות אלה, גם אם הם לא נמשכים לכאן,
אתה צריך שתהיה לי כל 26 התווים.
והסיבה שאתה לא יכול אומר, אה, אבל כמו לטיורינג, אני
לא צריך להיות כל אחד מאלה אותם דברים ברמה של U. ובכן,
אם פתאום אתה רוצה להוסיף משהו שהיה כמו T-H,
היית צריך לעבור את יכולת של הוספת מילה ש.
אז לכל אות ואות, אתה הולך לי
יש חבורה של מערכים יורדים ממנו.
אז אתה יכול לראות איך זה הייתי לקבל גדול באמת, ממש מהר.
יש עוד שאלות?
בְּסֵדֶר.
כן?
>> קהל: מתי ניסיונות מהר יותר מאשר שולחנות חשיש?
>> חנה: כאשר הם מנסה מהר יותר מאשר שולחנות חשיש?
אז אם היה לך באמת פונקצית hash רעה.
אז בואו נגיד שהיה לי כמו, הנה פונקצית hash שלך.
לא משנה מה מילה אתה נותן לי, אני תמיד
הולך לשים את זה בכניסת מערך 0.
וכך אנחנו בסופו של דבר עם רק לשים הכל ברשימה אחת גדולה ארוך צמודה.
וכך זמן בדיקה היה לוקח במקרה הגרוע n אם זה ממש בסוף של הרשימה שלנו.
עם הניסיון, אנחנו רק צריכים לחזר באמצעות האותיות במילה.
אז גם אם הוספנו חבורה יותר מילות כדי לנסותנו,
זה לא ייקח לנו עוד כדי למצוא מילה מסוימת.
>> כל שעל לעשות הוא, ל למשל, במקרה זה,
נניח שאנחנו מחפשים זום, היינו רק צריך לחזר על
Z-O-O-M, ארבע אותיות.
אז זה פשוט אורך של המילה זום.
זה לא משנה כמה יותר מילות שאנחנו מכניסים לנסות את זה.
אנחנו תמיד יכולים לקבל את זה בארבעת שלבים אלה.
מדהים.
כן?
>> קהל: אז [לא ברור] הוא מערך, נכון?
>> חנה: ממ-הממ.
קהל: אם אתה מחפש [לא ברור],
היית צריך לעבור המערך שלך כדי למצוא [לא ברור]?
חנה: בטח.
קהל: האם זה לא ייקח יותר זמן?
חנה: אם אני הולך ל אומר שהמערך שלי הוא תמיד
הולך להיות A, B, C, D, E, F, G, בלה בלה בלה,
כך שאם אני תמיד יודע זה באותו סדר מדויק,
אם אני תמיד יודע שזה בסדר אלפביתי,
אני רק יכול לומר O הוא מספר כך וכך באלף-הבית.
פשוט לקפוץ למקום הזה.
כי תזכור, עם מערכים, אנו יכולים לגשת
כל אלמנט של מערך שבמתמיד זמן אם אנחנו יודעים איפה אנחנו מחפשים.
כן?
>> קהל: ביום הקודם להחליק [לא ברור] 27,
אך 26 לראשון.
>> חנה: מצטער?
>> קהל: האם לא הראשון אחד 0, כך זה לא יהיה 26?
>> חנה: בטח, ולכן כאשר אנו אומרים 27, זה הולך לתת לנו מדדי 0 עד 26.
אבל אם אתה באמת לספור אותם החוצה, זה הולך להיות 27.
שאלה טובה.
כל דבר אחר?
כן?
>> קהל: אז הם מנסה איטי יותר מאשר שולחנות חשיש?
>> חנה: מנסה הולך להיות, ב תאוריה, שולחנות חשיש מהר יותר
אבל תופס יותר זיכרון.
כן?
קהל: [לא ברור]?
>> חנה: אני מצטער, אני לא שומע אותך.
קהל: [לא ברור].
0-25 נותן לך 26.
>> חנה: 0 עד 25 היית אתן לך 26, תקין.
>> קהל: ואז [לא ברור].
חנה: ימין.
אז המספר שאנחנו מפרטים הוא מספר דברים במערך שלנו.
אז אם יש לנו 27, זה הולך לתת לנו 0
עד 26, אשר ייתן לי שלנו מקום ל, במקרה זה,
אני לא כולל גרש.
אז אנחנו מקבלים 0 עד 25 הם 26 האותיות הראשונות של האלף-בית,
או כל 26 אותיות האלף-בית.
ולאחר מכן שעבר דבר, בכניסה 26, הוא
הולך להיות הצ'ק סימן, או הדלתא.
כל דבר אחר?
מדהים.
איבדתי את המקום שלי.
OK, מגניב.
>> אז אנחנו כבר נגענו בזה.
אבל הסחר הגדול מ בין ניסיונות ושולחנות חשיש
הוא שמנסה לספק, ב התאוריה, קבוע להסתכל למעלה
פעמים אבל להשתמש המון זיכרון.
בסדר, עכשיו יש לנו מעט מבנים פחות מסובכים,
ונגמור עם C, ואנו לנוע ימינה לאורך.
>> אז ערימות, שראינו את זה בהרצאה שבו אתה
יש משהו כמו ערימה של מגשים בי
הדבר האחרון שאתה שם על הערימה הולכת
להיות הדבר הראשון שאתה להמריא.
אז זה מה שבאמת מגדיר ערימה הוא שהדבר האחרון שאתה שם על
הולך להיות הראשון דבר שאתה להמריא.
והטרמינולוגיה שאנו משתמשים בי אם אנחנו הולכים לשים משהו,
אם אנחנו הולכים להוסיף משהו ל הערימה שלנו, אנחנו קוראים לזה דוחף.
ואם ניקח משהו את, אנחנו קוראים לזה נפץ.
ואם אנחנו הולכים ל ליישם ערימה, אנחנו
צריך להיות בטוח כדי לעקוב אחר שני בגודל ובקיבולת.
אז המספר הכולל של אלמנטים שאנחנו יכולים להחזיק ואת המספר הנוכחי של אלמנטים
שאנו מחזיקים.
>> ודומה מאוד, יש לנו תורים.
וההבדל היחיד הוא במקום עם ערימות,
אמרנו הדבר האחרון שאנחנו שמים על זה הדבר הראשון שאנחנו להמריא.
אז עם תורים, דבר ראשון שאנחנו מכניסים ל
הולך להיות הדבר הראשון שאנחנו מוציאים.
אז זה כמו שאם אתה למעשה בתור בחנות
ואתה להיות עזר, אז האדם הראשון בשורה
צריך להיות האדם הראשון שעזר.
אז זה יהיה תור.
>> אז אנחנו צריכים לעקוב אחר גודל, קיבולת, וראש מאז שאנחנו
הולך לקחת את כולם בחזית הרשימה במקום בחזרה.
שאלות על זה?
כל שאלות C המטרידות אותך?
מבני נתונים, כל זה דברים כיפיים?
בסדר, מגניב.
אז אני למסור אותו לאליסון ל לקפוץ לתוך כמה תכנות יותר.
>> אליסון: אה, אנחנו תראו.
נצטרך לראות איך גם אני עושה כאן.
בסדר, אני הולך לנסות ולעוף באמצעות החומר הזה, בחורים.
חנה הלכה מאוד ב עומק על כל הדברים שלה.
אני הולך לנסות לתת לי שלכם סקירה פיצוץ מהירה
כדי שנוכל להגיע לDavin עם כל הדברים JavaScript וביטחון הכיף
שאולי אתה בעצם רוצה לשמוע עוד על.
>> OK, חנה אמרה, אם יש לך שאלות,
אני הולך מהר מדי, אנא, תן לי לדעת.
אני אענה על שאלות במידת צורך.
אז כדי להתחיל, אנחנו הולכים להתחיל עם כנראה אחד הדברים הראשונים
למדת עם אינטרנט תכנות, הרשאות.
אז chmod, אתם צריכים להיות אדונים בשלב זה עם כל האינטרנט
תכנות שיש לך עושה בזמן האחרון.
זה בעצם רק פקודה שמשנה את ההרשאות
או הרשאות הגישה של האובייקטים במערכת קבצים שלנו.
כמובן, לבעצם רואה את אלה, אם אתה
איזושהי בעיה עם אלה במהלך סטי הבעיה שלך,
ייתכן שהשתמשת -l ls, שאורכו, כדי לקבל את סוג התצוגה של כזה,
שבו אתה בעצם רואה את כל ההרשאות לקובץ.
>> ובאמת, אנחנו רק הולכים דרך די מהר רק יפה
הרבה מה כל אחד מהם אומר.
אז יש לנו ד ממש כאן, ש פשוט עומד לספרייה.
ברור שממש כאן, אנו רואים rwx, ש הוא קריא, הניתן לכתיבה, והפעלה.
אלה גם יכולים להיות מיוצגים כביטים, שיהיה לנו בעמוד הבא.
אז כל שלשה שראינו כאן, אז זה שלוש שלישיות.
יש לנו rwx, x שום דבר r r ו שום דבר X עבור קובץ ראשון זה.
זה מבנה כללי זה.
>> אז יש לנו כמה ספרייה.
יש לנו כמה קבוצת משתמשים עם הרשאות אלה.
חלק הקבוצה שיש לו הרשאות אלה, ועולם שיש לו אישור.
אתה יכול לחשוב על אלה כשלישייה.
אתה יכול לחשוב על אלה כשלוש חתיכות.
אז הם יכולים להחזיק ערכים בכל מקום בין 0 עד
עד 7, וזו הסיבה שלפעמים היו לנו שאתה עושה chmod
600 במקום chmod RW מה.
אנחנו נגיע לדוגמה לשם.
אבל בעיקרון, אתה יכול לחשוב אלה כמו גם פשוט rwx,
או שאתה יכול לחשוב עליהם כחלק מ מספר שבו ראשון זה כאן
מייצג מספר בין 0 ו -7, שני אחת זה
מייצג מספר בין 0 ו -7, והשליש
מייצג מספר בין 0 ל 7, בסדר?
>> יש r ערך 4. w יש ערך של 2, וx
יש לו ערך של 1, ולכן זה רשות כאן תהיה chmod 700.
כי במקרה זה כאן, זה אומר שאנחנו יש קצת הראשון יש הדליק.
אז יש לנו 4 לקריאה.
קצת השני הוא התהפך על ל w, שהוא 2, אז עכשיו יש לנו 6.
וקצת השלישי הדליקו לx, שהוא 1, ולכן אנחנו מקבלים שבע.
ו, הקבוצה שלנו כמובן והעולם שלנו הם כל 0.
אז זה גם מקבילה של chmod 700.
ואני בהחלט אנסה להבין את המיפוי בין אלה.
אני לא בטוח אם יש לו לבוא בחידון לפני,
אבל זה יהיה שאלה שאני יכול לשאול.
>> רק קצת הולכים אפילו נוסף לchmod כאן, כאן
הוא מאוד כללי מבנה של שיחת chmod.
אז כמובן, יש לנו כאן chmod.
אזכור, מה זה מתייחס להוא מי אנחנו נותנים הרשאות אלה ל
או שאנחנו לוקחים אלה הרשאות מ.
אז יש לנו כאן בהרשאות, כמו שנתנו לך chmod x בתוספת,
כפי שנראה בקרוב.
רק אומר לתת ספציפי אלה הרשאות לכולם.
תן להם לכל.
אז אתה יכול מאוד להיות u תוספת x או גרם בתוספת x או o בתוספת x או מרובה
שלהם.
כך שהחלק הראשון הוא תמיד הולך להיות אזכור.
מי אנחנו נותנים הרשאות אלה ל, או שאנחנו לוקחים אותם מ?
>> השני הוא המפעיל.
אז אתם בעיקר עסקו בתוספת.
זה נותן הרשאות ל מי שאתה נותן להם,
בעוד פחות, באופן הגיוני, מסיר אותם.
כך ששום דבר נורא מדי שם.
ולאחר מכן מצבים הוא על מה דברנו עם קריאה, כתיבה, או ביצוע.
אז בתוספת x פירושו לתת הפעלה הרשאות לכולם.
ואז, כמובן, שב קובץ ספציפי או ספרייה.
בסדר?
כולם טובים עם chmod?
לא רע?
>> אוקיי, אז HTML, כל אחד מכם הוא ישן מספיק to-- גיל MySpace?
אני שלחתי את זה לקטע שלי, ופשוטו כמשמעו מחצית האנשים
הסתכל עליי כאילו אני משוגע.
ואני הייתי כמו, בחורים, אנחנו לא כל כך ישנים.
יאללה.
אז HyperText Markup Language, זה באמת רק דרך בשבילך
כדי להציג דברים מסוימים באינטרנט.
אז זה שפת סימון.
זה לא שפת scripting.
אין היגיון בזה.
זה פשוט לשנות את מוצג דרך משהו.
אוקיי, אז זה חשוב הבחנה לעשות.
זה נחשב שפת סימון, לא שפת scripting.
>> אז הנה יש לנו תגי HTML שלנו.
בשקופית זו הן כנראה רוב אלה שאתה צריך להיות מוכר עם
ולהיות באמת בנוח עם.
אז ברור, שיש לנו תג HTML שלנו, ש
מייעד את כל מה שב בין שני אלה יהיו HTML.
יש לנו כמה קישור, ש כמובן אתן לך
קישור לדף אינטרנט חיצוני.
כותרת מסוימת, בתוך הראש שלנו כאן.
ויש לנו הגוף שלנו עם h1, אשר הוא כותרת,
כך זה יהיה לעשות את זה נחמד ונועז וגדול יותר.
ואז, יש לנו כמה p, שהוא סעיף.
אתה כנראה צריך לדעת ולהיות מוכר עם דברים
כמו איך אתה מכניס תמונה, הם יש כיתות כותרת אחרות?
הייתי בהחלט להיות נוח עם div.
אז יש לי אלה רוב התגים כי אתה צריך להיות מוכר.
אבל כמובן, כמו בכל דבר ב 50 CS, הרשימה אינה ממצה.
כדי לוודא שאתה לרענן את זה.
>> CSS, כך CSS, אם מישהו מכם לצפות ב הסמינר שלי מלפני שבועיים,
היא באמת רק דרך לסגנון דף האינטרנט שלך?
אוקיי, אז יש לנו כמה שפת סימון.
HTML, שדואג רק את הטקסט ואיפה שזה עשוי להיות בעמוד.
אבל CSS הוא באמת מה שעושה את זה יפה.
אתה יכול להיות אלה ב- HTML שלך קבצים, אך כפי שאנו נדבר על מאוחר יותר,
אני די בטוח שזה אולי להיות השקופית הבאה, זה
הוא מנהג נפוץ, ולמעשה תרגול שאנחנו באמת לעודד,
כדי שתוכלו לשמור על הפריד ביניהם כאשר אנו לדבר על MVC, וכי כל הפרדיגמה.
זה באמת מה זה הזנות לתוך.
>> אז CSS הוא רק דרך ל לעשות את הדברים נראים יפה.
הדברים כאן, כמו גוף ו#title ו.info,
אלה נקראים בוררים ומה הם עושים הוא שהם בוחרים דברים ספציפיים
בתוך קובץ HTML שלך ולהחיל מה סגנון,
מה סוג של דברים שאתה רוצה, שלאלמנט מסוים של האינטרנט שלך
דף.
אז הנה, יש לנו צבע רקע וצבע
ומשפחה גופן זה להיות יחול על כל מה שהוא בגוף.
אז אם אנחנו הבטנו לאחור כאן, זה לא אחול על התואר.
זה רק יחול על מה הוא בבוררי גוף אלה, בסדר?
>> עם הכותרת כאן, זה הוא הולך להיות אותו הדבר,
צבע הטקסט להיות כחול הוא רק הולך
כדי להשפיע על מה הוא בתוך בוררי הכותרת.
כמו גם מידע כאן, הטקסט יהיה ורוד,
מה של מידע, שנמצא ממש כאן.
כך שהדבר היחיד ש יהיה ורוד בדף זה
הוא תאריך, יום שני, נובמבר 17, 2014.
אוקיי, אז CSS הוא רק דרך ל יש להם יותר שליטת over-- כן?
>> קהל: למה יש לך להשתמש בחשיש עם כותרת?
>> חנה: השקופית הבאה, מבטיח!
אנחנו נגיע לשם.
אז בגלל זה אנחנו צריכים להשתמש בחשיש.
אז בוררים לקחת על שלושה עיקרי צורות שאנחנו מדברים אתם על.
אני fyou רוצה ללמוד יותר, יש הרבה שם בחוץ.
יש תיעוד CSS גדול.
יש תג שם, שבו יש לעשות רק עם התגים הרגילים שלך ב- HTML.
אז h1, p, div, H2, אלה מיני דברים.
ואנחנו יכולים רק שם אלה כפי שהוא.
אז כפי שאנו רואים כאן עם גוף, זה תג נורמלי.
אז אנחנו פשוט יכולים לשים את הגוף בעת אנחנו מדברים בקובץ CSS שלנו.
>> עם כותרת, כל הסיבה ש יש לי חשיש זה שיש לנו מה
נחשב ID.
אז ID צריך להיות תמיד ייחודי בתוך דף ה- HTML שלך
כך שכאשר אתה בהתייחסו לזה, אתה
יודע שאתה מתייחס רק דבר אחד ספציפי.
אז במקרה הזה כאן, עם שלנו h1 כאן, CS 50 מושב ביקורתם,
יש לנו id של כותרת.
אז כדי רק כדי להתייחס של חתיכת HTML שלנו, אנחנו עושים כותרת חשיש.
רק על ידי אמנה, מזהים מיועדים עם חשיש לפניהם.
באותו אופן, אנו רואים מידע כאן הוא בכיתה.
וכך בכיתה עם CSS היא מיועד כתובענה dot
או dot מה הכיתה שהיא.
אז במקרה הזה כאן, זה מידע.
>> אז אני חוזר בי.
שני אלה יהיו ורוד לCSS שלנו כאן
כי לשניהם יש מעמד של מידע.
ובקובץ CSS שלנו, יש לנו מיועד כל דבר שעם כיתה של מידע
יהיה ורוד.
האם זה הגיוני?
כן?
>> קהל: אם היית עושה הכל בלבן גוף,
ואז אתה מנסה לעשות משהו בתוכו כחול,
היה שגורם לבעיות?
>> חנה: אז CSS הוא גיליונות סגנון מדורג.
אז מה הוא לכיוון תחתון הם הקובעים.
אז אם אתה עושה משהו עם גוף, ואתה עושה את כל מה שלבן,
ואז בשלב מאוחר יותר אתה לשנות את הכותרת או שאתה לשנות את הטקסט בתוך גוף,
זה מחליף את זה.
אז כל דבר לכיוון תחתון הם הקובעים.
כן?
>> קהל: ומזהים ייחודיים, אבל שיעורים יכולים להיות יותר?
חנה: ימין.
אז מזהים צריכים להיות ייחודיים, ושיעורים יכולים מתייחס לכמה שיותר דברים כמו שאתה רוצה.
יש עוד שאלות?
כן.
>> קהל: [לא ברור].
אני תוהה אם שעושה את הבדל.
חנה: אני מצטער, מה הייתה השאלה?
קהל: יש קטן "F" ובירה "פ"
חנה: אז ההבדל בין "f" הקטן והון "F"
לא צריך לעשות את הבדל.
אז "f" יהיו 15 או כך.
מגניב, כל דבר אחר?
כולם טובים, CSS?
כן?
>> קהל: מצטער.
יכול להיות שאתה בכיתה ומזהה?
>> חנה: כן, אתה יכול.
דברים יכולים להיות גם בכיתה וזיהוי.
ואני מאוד ממליץ בדיקות אלה בעצמך.
CSS אתה לומד הכי טוב רק על ידי ביצוע משהו, דף אינטרנט פשוט מאוד,
ציור קצת CSS, ורק לראות כיצד הם פועלים.
ותוכל להרוויח טוב מאוד, אינטואיטיבי תחושה לאיך זה עובד.
>> OK, כולם טובים עם CSS?
אתה כל הולך לעשות אתרים יפים עם CSS עכשיו.
OK, שיטות עבודה מומלצת, רק דברים שכדאי לזכור, דברים
that-- זו הסיבה שאנחנו לעגון לך על מעצב ומה לא.
אז לסגור את כל תגי HTML שלך.
אז אם יש לך גוף פתוח, לא צריך להיות גוף קרוב.
אם יש לך סעיף פתוח, לא צריך להיות סגור פיסקה.
בדקו את הדף שלך מאמת.
אתם צריכים להיות מאוד מוכרים עם זה משבע להגדיר p-
עם CS מימון 50 עם validator W3.
וכפי שאמרתי קודם, אחד מפרדיגמות הגדולות שלנו
מפריד את הסגנון שלך עם CSS מהסימון שלך, שהוא HTML.
ואז, כמובן, יש לנו XKCD זה נהדר כאן למטה.
Yay, אתנחתא קומית!
>> OK, TCP / IP.
בין אלה וHTTP, בעצם שניהם הפרוטוקולים.
אז רק אתה יכול לחשוב מהם כמערכת של כללים
הקובעים כיצד דברים להעביר דרך האינטרנט.
אז שליטת שידור פרוטוקול, או פרוטוקול אינטרנט,
הוא רק דרך לוודא נתונים שמקבל לאן זה הולך
ושאנחנו יודעים אם שנהיה אי פעם חסר נתונים.
אז אם אתם חושבים לחזור להרצאה כמה שבועות לפני עם דוד
שבו היו לנו ארבע מעטפות, הם היו כל ממוספר כמו אחד מארבעה,
שתיים מתוך ארבעה, שלוש מתוך ארבעה, ארבעה מ ארבעה, זה רק מערכת של כללים.
אנחנו אמרו, בסדר, בכל פעם שאנחנו שליחת מנות יותר מפעם אחת,
אנחנו הולכים למספר אותו עם מה מספר זה
וכמה כולל ש המשתמש צריך לקבל.
>> וזה רק אומר מי ש הוא מקבל את הנתונים אם הם
מקבל הכל או אם משהו הלך לאיבוד בדרך.
והם צריכים לבקש את זה שוב.
זה באמת רק מערכת של כללים.
ככה אתה יכול לחשוב על זה, בסדר?
וגם, היא קובעת את הנמל, ש אתם can-- אני יודע בהרצאה,
היה להם רשימה של יציאות כולו.
אבל אין לנו אותם כאן עכשיו.
>> פרוטוקול העברת היפר-טקסט כל כך הוא, שוב, זה פרוטוקול אחר.
אז זה עוד סט של כללים ששולטים, במקרה זה,
איך היפרטקסט מועבר.
אז זה רק מאפשר דפדפנים לדבר עם שרתי אינטרנט.
וכמו שאמרנו כאן, זה כמו לחיצת יד של אדם.
זה פשוט דרך למשול איך שרת האינטרנט הוא
הולך אינטראקציה עם הדפדפן שלך.
ויש לנו רק כמה דוגמאות.
יש לנו כמה בקשות כאן שבו מקבל הוא השיטה.
יש לנו HTTP 1.1, שהוא גרסת פרוטוקול עבורנו.
ולאחר מכן, המארח, וזה מה ש אנחנו באמת מנסים לגשת.
ולאחר מכן, כפי שאתה רואה כאן, אנחנו לקבל תגובה מסוימת עם 200 זה
אישור כקוד תגובת HTTP שלנו.
יש לנו רשימה גדולה אני הולך כדי למשוך את בשנייה אחת
כי אתם צריכים להיות מוכרים עם.
ויש לנו טקסט / HTML סוג תוכן זה, אשר רק אומר איזה סוג של נתונים
אנחנו מקבלים מהשרת, בסדר?
מארח זה וסוג תוכן זה הם חלק מכותרות HTTP.
אתה יכול לקבל כמה שפחות או מעט ככל הכרחי להקשר של מה ש
עם יש לך עסק.
לפעמים יהיה לך הרבה מידע שמגיע מהשרת שלך.
אולי הם מבקשים הרבה מידע מהמשתמש.
זה משתנה בהתאם להקשר.
אם אתה מסתכל על CS 50 מחקר, יש הרבה יותר על זה.
אבל יש לנו הרבה כדי לקבל דרך, אז אני הולך
ללכת זכות קדימה אם זה בסדר איתכם?
מגניב.
תחזיק חזק.
בהחלט יש לי ש רשימה כל ל-- הא!
אני לא יודע למה זה כל הדרך לכאן.
חשבתי שאני ממש עברתי זה בזמן שאני היה sitting--
>> דווין: האם אתה רוצה ללמד אותו?
או שאתה רוצה אותי ללמד אותו?
>> קהל: חשבתי שנוכל רק להראות להם להתחיל עם.
אני מתכוון, אתה יכול ללכת ל אותם עוד יותר, אבל אני
חשבתי שיותר הגיוני מאז ש רק דיברתי על סטטוסי HTTP.
אז הנה כל הרשימה.
אני מניח מה שהולך לקרות הוא דווין הולך להיכנס אליהם מאוחר יותר.
אבל יש כל רשימה, תצוגה מקדימה של הטעם לבוא.
בסדר, אנחנו הולכים blow-- זה הולך להיות קורס מזורז PHP שאין כמותו.
>> אז PHP, preprocessor היפרטקסט, זה backronym רקורסיבית,
מה שאומר שהיה שם משהו אחר.
ולאחר מכן הם היו כמו, זה לא ממש הגיוני.
אז הם פשוט בשם it-- וזה היה ראשי תיבות,
אז הם פשוט עשו את זה PHP preprocessor היפרטקסט, ש
רק לא הגיוני.
סיפור משעשע.
זו שפת תכנות.
כל כך הרבה כמו שאני מדגיש ש HTML הוא לא שפת תכנות,
זה שפת סימון, PHP היא שפת תכנות.
איך אתה יודע שזה כי יש היגיון.
יש תניות.
יש לנו משתנה, ואילו אנחנו יש אף אחד מהדברים האלה ב- HTML.
>> בסדר, אז יש לנו את זה קצת קצת כאן זה כמו טעם של PHP.
אז יסודות, שמות משתנים להתחיל עם סימן דולר.
הרבה אנשים אוהבים את זה.
מזכיר לנו כסף.
זה כל גדול.
כולנו רוצים PHP.
אז אנחנו לא תציינו הסוג של משתנה יותר.
היא נקבעת בזמן הריצה.
המתורגמן יהיה כמו, הו, אנחנו פשוט לרוץ דרך,
ועל-פי ההקשר, נראה מה סוגים של סוגים
משתנה אלה צריכים להיות.
אין פונקציה העיקרית.
דברים פשוט ירוצו.
אתם עם היבוא שלך בך להגדיר p-אחרון, תבחין זה.
לא הייתה באמת פונקציה העיקרית.
אתה פשוט כתב את מה ש אתה רוצה שקורה.
וזה קרה רק סוג של.
אז זה PHP בשבילך.
>> מערכים דומים מאוד.
עדיין יש לנו מסגרת זו.
הנה, יש לנו כמה משתנים בשם arr, וזה שווה
to-- יש לנו נורמלי שלנו סימון הסוגר.
ויש לנו כמה ערך מפתח.
וההבדל הגדול בין מערכי C ו- PHP
הוא שיכול להיות לנו associate-- זה אנו יכולים לשייך את הערכים למפתחות.
אז במקום שיש רק מערך זה צמוד
במספר או העמדה של אלמנט שבמערך,
אנחנו באמת יכולים לקשר את זה עם מפתח.
שבו אנו יכולים לומר, בסדר, אני רוצה כל מה ש הערך קשור לפרות.
ואולי יש לנו פירות הלכו לבננה.
אז זה הייתי לחזור בננה אלינו.
>> אבל בעיקרון, רוב דבר חזק על זה
הוא שאם אתם זוכרים הדגמה מהרצאה שבו אנחנו בעצם
איות שכתב בPHP, וזה בדיקת was-- הייתה באמת רק רוצה,
אין מפתח זה קיים?
זה באמת סוג של הכח שלו.
אתה לא צריך לחזר באמצעות המערך שלך.
אתה לא צריך לדעת מה מרחב זה ב.
זה יכול להיות בסוף או בתחילת.
כל עוד אתה יודע את המפתח המשויך לערך,
PHP רק יכול לירוק ערך ש זכות חזרה החוצה אליך, בסדר?
>> ולאחר מכן, אנחנו גם רק יש רק בגלל שאנחנו
יכול להיות זוגות ערך מפתח זה לא אומר שיש לך.
אתה יכול גם פשוט ליצור מערך רגיל כמו כאן,
בתחתית, שבו זה רק אחד, שתיים, שלוש, ארבעה.
אלה הם הערכים שלנו.
ולמעשה, את המפתחות שלהם הם המדדים.
אז המפתח לאחד יהיה אפס.
המפתח לשני יהיה אחד.
כן הלאה וכן הלאה, אלא אם כן אתה במפורש להקצות מקש,
אתה יכול להניח ש ערך הוא רק המדד שלהם.
האם זה הגיוני לכולם?
אין שאלות?
מדהים.
>> OK, foreach הוא דרך ל לחזר באמצעות המערכים שלך.
אז יש לנו כאן משהו, רק המבנה הכללי.
אז foreach, את שמו של המערך שלנו, כמו כל מה ש
אתה רוצה לקרוא לכל אחד אלמנט במערך שלך,
ואנחנו יכולים לעשות משהו עם שאלמנט או עם ערך ש.
אז יש לנו דוגמא כאן.
יש לנו אסוציאטיבי מערך עם שני ערכים אלה
עם בר להיות קשור foo וqux להיות קשור עם באז.
אז מפתחות הם foo ואז.
ערכים הם בר וqux.
אז foreach, יש לנו המערך שלנו כאן, כזוג ערך המפתח.
זה מאפשר לנו גישה שני מפתח וערך.
אולי אתה פשוט רוצה ערך, ובמקרה זה
אתה יכול פשוט לעשות כמו arr כערך $, ואז אתה
רק גישה הערך כפי שאתה לחזר באמצעות.
אבל אולי, לכמה סיבה, אתה רוצה את המפתח,
וזו הסיבה שבחרתי דוגמא זו במקום.
אז אתה בעצם יכול לתפעל מפתח וערך במקרה זה.
בסדר?
שאלה?
>> קהל: אם אתה רוצה רק לתפעל את המפתח, היה
אתה צריך לעשות foreach--
>> אליסון: ימין.
אז אם אתם רוצים לתפעל רק את המפתח,
אתה עדיין צריך את זה תחביר, כי אם אתה רק
יש לי עיבוד כמשהו, כדבר אחד, זה
הולך להניח שאתה רוצה הערך, לא את המפתח.
אז אם אתה אי פעם רק צריך בדיוק כמו עיבוד: כ, אולי זה כמו אלמנט $,
זה הולך להניח שאתה שואל רק הערך בכל נקודה.
אם אתה רוצה באופן מפורש לעשות משהו עם המפתח,
גם אם אתה לא הולך ל לעשות משהו עם הערך,
אתה צריך את המבנה הזה שיש לנו כאן
שבו אתה מבקש באופן מפורש לשניהם את המפתח והערך.
שאלה גדולה.
כל דבר אחר?
מגניב.
>> בסדר, PHP ו- HTML.
הו, אנחנו בחזרה לשבע שוב להגדיר p-.
כך זה צריך להיראות קצת מוכר.
אז זה קצת טופס HTML פשוט שיש לו כמה קלט שם של שלום.
ואנחנו רואים שיש לנו שיטת GET שלנו.
ואם אנחנו זוכרים מp-סטנו, כאשר טופס זה יוגש,
הוא שולח מערך נקרא _GET $ שיש לי כל התשומות אלה או משתנים מ
הטופס שצריכה להיות מניפולציות בPHP שלנו.
אז במקרה הזה, המשתמש היה שם בשמם.
הם יפרסמו אותה.
ואנחנו רואים שאנחנו מקבלים כמה מערך כאן.
יש לנו מערך GET שלנו.
ואנחנו ניגשים לשם.
>> כך שאומר, בסדר, תן לי את ערך המשויך לשם,
שם להיות המפתח כאן.
ושממפה ישירות למה ש אמרנו שם הקלט שלנו הוא.
אז זה היה נותן לך את המפתח למה ש הוא הולך להיות במערך שלך כאן.
האם זה הגיוני לכולם?
כן?
>> קהל: האם את השם בGET מתייחס לקו הסגול ב[ לא ברור]?
>> אליסון: הוא מתייחס לזה כאן.
אז תחום זה ממש כאן, הוא מתייחס לשם זה כאן.
אז זה היה יכול להיות שם כמו מספר טלפון, או משהו כזה.
שם זה אומר בעצם, מה ש אתה מתקשר תחום זה?
איך אתה מתכוון ל מתייחס לתחום הזה?
ושם זה הוא למעשה רוצה, אנחנו אומר תחום זה נקרא שם.
ככה אנחנו הולכים לגשת אליו.
>> קהל: אז האם זה אוהב, שם קלט שווה בוב, and--
>> אליסון: ימין, אז אתה היית מקבל בוב שם למטה.
בדיוק.
כולם מגניבים?
בסדר, אז לקבל לעומת POST, אלה הם שתי הדרכים עיקריות
שאנו עוברים נתונים בבקשת HTTP.
אתם צריכים לראות שניהם תקווה אלה.
אז עם GET, המידע עובר דרך את כתובת האתר.
אז אם אי פעם לעשות Google חיפושים, YouTube, שתצליח
כנראה להבחין בכמה סימן שאלה.
ולאחר מכן, כל המילים כי אתה פשוט לשים שם.
וPOST מעביר את הנתונים בגוף ההודעה HTTP.
כך שלא כמו GET, אתה סוג של חשבון כי הנתונים חבוי מהמשתמש.
אבל מה שבאמת חשוב להבין
הוא שזה עדיין רק חסר ביטחון כמו GET.
האנלוגיה אני רוצה להשתמש היא אם יש לך את מספר חשבון הבנק שלך
ואתה כותב את זה בצד החיצוני של מעטפה, זה די בטוח.
אם היית כותב אותו על פיסת נייר והכניס אותו למעטפה,
זה עדיין לא בטוח, כי באמת כל מה שאתה צריך לעשות הוא לפתוח את ש
ולהסתכל על התוכן הממשי של ההודעה כדי לראות את זה.
אז זה "נסתר", ואנשים כמו ל חושב שזה בטוח, אבל זה ממש לא.
ואני בטוח שיהיה Davin להיכנס לזה יותר, אולי.
אבל זה חשוב הבחנה לעשות
ומשהו ממש טוב כדי להבין.
>> OK, SQL, שפת שאילתות מובנית.
כל הדברים ש שראינו עד לאחרונה!
אז זה בעצם רק נועד, ברור, לניהול נתונים.
היו לך בחורים הרבה ניסיון עם זה בשולחנות שלך עם MyAdmin PHP.
ויש ארבע שאילתות נפוצות כי אנחנו רוצים אתכם לדעת.
אז יש עדכון, להוסיף, לבחור, ולמחוק.
כדי לוודא שאתה יודע אותם ממש טוב.
אנחנו הולכים ללכת דרך אותם ממש מהר.
>> אז לעדכן, באמת, כמו מה ש אולי אתה חושב שהיא עושה,
זה פשוט מעדכן נתונים במסד הנתונים שלך.
אז יש לנו כמה דוגמא כאן.
זה בכלל מבנה של שאילתא עדכון.
אז אנחנו לעדכן את הטבלה על זה אנחנו מדברים.
ואנחנו רוצים להגדיר מסוימים ערכים, עמודות מסוימות
שווה לערכים ספציפיים.
אז זה רק מעדכן את השולחן, שינוי ערכים בכל השורות במקרה זה.
אז בזה כאן למטה, בפועל דוגמא, יש לנו מצטער insert--.
השקופית שהתקדמה ללא להבין את זה.
>> אז להגדיר שולחן עדכונים זה col1 שווה לVAL1 בי הבית שווה "קורייר".
מה זה עושה הוא זה רק משנה, זה רק
מעדכן את הערכים הללו במקומות מסוימים.
אז בהתחלה זה אחד, זה משנה אלה ערכים לכל דבר בשולחן שלך,
בסדר?
זה הולך לשנות את זה עמודה עבור כל כניסה,
לכל שורה.
אבל איפה זה, אתה יכול חושב על זה כעל מוקדמות.
כך שזה הולך רק לשינוי זה במקומות מאוד מסוימים.
אז בשבעה, כאשר אתה מגדיר p- אולי עדכן את כמות המזומנים
שהמשתמש שלך, אתה כנראה לא היית לי מסוים שבם מזהה שווה מזהה הפעלה, נכון?
>> מכיוון שאתה לא רוצה לשנות את כמות המזומנים
לכל אדם ש היה שימוש באתר שלך.
אתה רוצה לשנות את זה לאחד אדם מסוים, אותו אדם להיות
מי שהיה משתמש בו באותה העת.
נכון?
אוקיי, אז להכניס, להכניס ערכים מסוימים לשולחנות.
זה כמו כשאתה יצירת משתמש חדש לגמרי.
המבנה הכללי כאן הוא להכניס לתוך כל מה ששולחן
אנחנו מדברים.
ערכים, הערכים להיות ש אנחנו באמת רוצים להכניס.
אוקיי, אז כפי שאנו רואים כאן, אנחנו יש להכניס לטבלה.
זהו עמודות ספציפיות עם ערכים תואמים.
אז זה אומר, להוסיף שורה חדשה מכילה
VAL1 ערכים וVAL2 תחת העמודות ספציפיות האלה.
>> אז אולי אתה רוצה רק כדי למלא את מחצית הדברים בשורה זו.
זה מה שחלק זה כאן מאפשר לך לעשות.
הוא מאפשר לך למעשה איזה חלק.
כן?
>> קהל: אתה יכול רק [לא ברור] תאים בשורה [לא ברור]?
>> אליסון: אם אתה ממלא רק ב חלקים מסוימים של השורה שלך,
שאר תאים אלה הם רק ריקים.
כל עוד אתה מאפשר להם להיות ריק, זה לא בעיה.
אם אתה מנסה לגשת אליהם, זה הולך לחזור כמה אלמנט ריק.
אבל חשוב לדעת כי בשולחנות מסוימים,
הם צריכים להיות מותר null.
ייתכן שנתקלת ב בעיה במהלך p-הסט שלך
בגלל שלא נתנו לאף הערכים שלך יהיו בטלים.
אבל אתה יכול לציין ערך אופציונאלי בשולחן שלך.
>> OK, בחר, אז זה רק דרך להגיע
נתונים ספציפיים משולחן ב כמה מזהה שאתה רוצה.
כוכב אז בחר משולחן שבו col שווה משהו רק אומר,
תן לי את כל הנתונים הקשורים שם עמודה מסוימת זה נכון.
אז הכוכב במקרה זה יהיה להחזיר את כל השורה אליך, בסדר?
>> ואז, במקרה זה, בחר כוכב מ שולחן פשוט נותן לך את הטבלה כולה.
ולאחר מכן, להסיר ספק, זה פשוט מוחק את השורה מהשולחן.
אז למחוק משולחן, מה שולחן אנחנו
התייחסות, שבו כמה ספציפי מזהה או כמה מצב נכון.
כן?
>> קהל: שאלה.
למה אתה משתמש כפול ציטוטים, ואם אתה
לעשות מרכאות כפולות או בודדת ציטוטים, אין זה משנה?
>> אליסון: ציטוטים זוגי או גרשיים בודדים לא לעשות את הבדל בSQL.
חשבתי שראיתי כבר שאלה אחרת.
כן?
>> קהל: האם זה לא משפיע על מה ש מקבל נמלט מהשאילתה?
>> אליסון: רוב?
>> ROB: מה זאת אומר נמלט מהשאילתה?
>> קהל: אם למישהו יש שאילתא אחת בצורה של--
>> ROB: אם מישהו היה לשים ציטוט אחד ב,
אז כל עוד אתה חיטוי הקלט שלך, אז זה לא משנה.
אבל אם אתה משתמש באחת הצעת מחיר ואתה באופן שגוי
בריחת התשומות שלך, אז כן, הם צריכים
לשים ציטוט אחד כדי לשבור הקוד שלך. אם אתה משתמש במרכאות כפולות,
הם צריכים לשים כפולים לצטט לשבור את הקוד שלך.
אבל כל עוד אתה להימלט דברים נכון, זה לא משנה.
זה רק הולך להיות מתורגם לסמל הנכון בכל מקרה.
>> קהל: מה בריחה זה אומרת?
אליסון: ובכן, כמו חיטוי ובריחה.
הבחינה שיש לנו, XKCD הגדול קומיקס שהם מושכים את בו יש לך,
oh--
ROB: זה השקופית האחרונה.
אליסון: זה השקופית האחרונה, באמת?
אוי אלוהים.
יש לנו ללכת, מושלם.
אוקיי, אז בעצם, אתה יכול להזריק משהו לשאילתא SQL זה
שבו הוא שובר שלך קוד, או כפי שהראה דוד
בכיתה, אם יש לנו כמה בודד ציטוט 1 שווה 1 ואם בקוד שלנו,
אנחנו פשוט להעתיק ישירות שב, ו יש לנו הצעה אחת שהסתיימה,
מה שקורה הוא שאנחנו מקבלים ביטוי כלשהו ש
מעריך לנכון שיהיה לתת למישהו להיכנס לבסיס הנתונים של
ולקבל את הנתונים ש לא רוצה אותם כדי לקבל.
אז חיטוי התשומות רק אומר שכדי לוודא ש
שאנחנו בורחים אלה דמויות ומייעד אותם
כתווים ולא דברים כי יש לאפשר ל
להילקח פשוטו כמשמעו כהצהרת SQL שלנו.
>> אז הדבר הגדול שאמרנו כי אתם צריכים להיות באמצעות
היו תווים מיוחדים HTML, וזה משהו ש
שאולי כדאי לך להעיף מבט על.
OK, למחוק.
סוגי נתונים, כל זה יהיה באינטרנט.
מאז יש לנו 15 דקות לסיום, אני רק הולך ישר דרך זה.
PHP ו- SQL, בעצם זה רק שהיו לנו פונקצית שאילתא ש
סייע בהגנה מפני התקפות זדוניות אלה.
אז בכל פעם שאתה משתמש ב שאילתא, אנחנו עושים בטוחים
שדברים מחוטא ומה לא.
>> MVC הוא רק הפרדיגמה עיצוב, כך מודל, נוף, בקר.
זה פשוט דרך לשמור על דברים נחמד ונפרד באותה הדרך
שאנו נוטים גורם קוד אל פונקציות.
זוהי רק מסגרת עיצוב אתרים המאפשר לך לעשות את אותו הדבר.
אני הולך לדלג על זה.
>> זה משהו שאני יהיה סופר נוח עם.
זה שולחן קטן גדול שם.
זה נותן לך את הפונקציה דוגמא למודל.
אני רק עובר את זה כי אני באמת רוצה Davin להיות מסוגל לדבר.
אם יש לך שאלות, אל תהסס.
אני אהיה כאן אחרי.
רק יבואו לדבר איתי.
עם זה, יש לנו סטטוסי HTTP.
ודווין של הולכים לפוצץ דרך זה ב- 15 דקות.
זה הולך להיות גדול.
>> דווין: OK.
אה, המיקרופון שלך?
כן.
מצטער.
אליסון: דרך להיות מוכן.
דווין: לא, אני מוכן.
אני מוכן.
בואו נעשיתי את זה.
הוא מוכן.
OK.
מצטער.
שפכתי קפה על עצמי.
אני לא יודע אם אני יותר מבואס שנראה טיפשי,
או שאין לי קפה יותר.
בכל מקרה, רק הודעה מהירה על גיליון יש לכם.
אז גיליון זה יש לך חבר 'הוא לא הרשמי מה על החידון.
זה רשמי מה על החידון.
כמו כן, באתר האינטרנט, אנו אומרים לי אתה, בסדר, זה יהיה בחידון.
אז בגיליון לרמות הקטן יש לך, לא רשמי.
ויש טעויות בזה.
אז הכי טוב לא רק בעיוורון להשתמש בו.
אז כן, זהו זה.
אז בואו להיכנס ממש מהר זה.
>> אז HTTP סטטוסים.
אז מה קורה כאשר אתר, הכל בסדר.
אישור של כל דבר.
הכל חוזר ל לך את הדרך שאתה רוצה זה.
אתה מקבל אישור 200.
301, שבו יש לנו לראות כי 301 לפני?
חכה, מה קורה?
מצטער.
ראינו הרצאת פח אני בביטחון.
אז בביטחון, כך שאם דוד הקליד ב http ולאחר מכן ניסיתי ללכת לcs50.net,
אתה הולך לראות 301 עבר.
למה?
בגלל זה הולך להפנות אתה באופן אוטומטי לHTTPS שלנו.
>> אז 301 עברו, רק שזה בעצם ניתוב מחדש.
ואתה יכול לחשוב על זה ככה.
כל אחד מהסטטוסים שיתחילו עם 2 של, אלה הם כמו, בסדר, בסדר של כל דבר.
כל אחד מהסטטוסים שיתחילו עם 3, אלה הם ניתוב מחדש.
סטטוסים שיתחילו עם 4, כי אמצעים יש איזה סוג של שגיאת לקוח.
סטטוסים שיתחילו עם 5, זה סוג של שגיאת שרת.
אז אתה סוג של לשבור את סטטוסים כמו ש.
אז 304 לא לא שונו, כך בך server.c p-סטים, אז בואו נגיד שאתה
cat.html הטעון.
הכל חוזר, אתה מקבל 200s, OK, גדול.
>> בואו נגיד שאתה רענון זה.
ובכן, בתוך ש cat.html, יש לך JPEG.
ובכן, JPEG, כי הוא לא הולך לקבל מחדש.
אתה לא הולך לתפקיד אחר GET בקשה לשרת,
ולאחר מכן לקבל את כל מידע שיחזור.
זה הולך רק כדי be-- תמונה שהיא הולך להיות במטמון במחשב שלך.
וכך תמונה שתהיה 304.
אז זה לא שונה.
אם לאחר מכן לסגור את, ברור עוגיות, ולאחר מכן רענן
ומנסה לטעון שדף שוב, אתה הולך לראות 200s.
אתה לא הולך לראות 304 ש.
>> 400, בקשה רעה, אמיתי כמו אם מהיר, אתה
היו הולכים לשלוח אובייקט JSON לשרת
ואובייקט JSON שלך היה שגוי, תראה משהו כזה.
403, אסורים.
כאשר היית רואה אסור?
כנראה כנראה?
קהל: chmod.
דווין: chmod, כן.
אז לא הגדרת הרשאות נכונה.
404, לא נמצאו.
זה פשוט לא קיים.
אז אם אתה מקליד את כתובת האתר השגויה.
500, שגיאת שרת פנימית, השרת כנראה אינו מוגדר כראוי.
משהו לא בצד שלך, אבל משהו בצד השרת.
ו503?
הרבה אנשים ראו 503s בp-הסט האחרון.
כשזה יקרה?
שמעתי לחישות.
>> קהל: כאשר גוגל מחליט שאתה רובוט.
דווין: כן, כאשר גוגל מחליטה אתה רובוט, אתה מקבל 503s.
אז זה עומס יתר.
אם ביקש מהשרת יותר מדי, זה בדרך כלל זמני.
ורובכם שמו לב לזה.
אז אתה ראית 503.
אתה עלול לקחת קצת הפסקה, אז 503s הלך,
והכל היה בסדר.
>> גייב: Real מהיר, כאשר אתם מקבלים 500 בככל הנראה הבעיה האחרונה זה נקבע?
כן?
>> קהל: בדרך כלל אם יש שרת קובץ איבד
או [לא ברור] מכונה [לא ברור].
>> גייב: אז זה יכול להיות תצורה נושא בPHP שלך בשרת שלך.
אבל זה יכול להיות רק משהו כמו פסיק ששכח.
אם אתה מקליד PHP, כמה תחביר שגוי
עשוי להביא לך משהו כזה.
בסדר?
>> דווין: מגניב.
האם אתה רוצה שאני אעשה רק עד AJAX?
>> גייב: [לא ברור].
דווין: OK.
אז מה DOM?
מה DOM לבלוט ל?
>> קהל: מודל אובייקט מסמך.
דווין: נחמד.
ולמה אנחנו אוהבים את זה?
מדהים.
טוב, אז זה רק מאפשר לנו גישה HTML, לגשת לדף שלנו במהירות רבה.
למה?
כי אנחנו בטיפול שלנו דף, טיפול בתגי HTML שלנו,
הכל טיפול כאילו הם אובייקטים.
אם אנחנו מטפלים בהם כמו שהם אובייקטים, אז מה אנחנו יכולים לעשות?
ובכן, אנחנו יכולים לקרוא לפונקציות עליהם.
וזה חשוב למה?
ובכן, כי אנחנו הולכים להשתמש JavaScript כדי לעדכן HTML שלנו,
לעדכן את החפצים האלה.
אז אם אנחנו מתייחסים אליהם כאל חפצים, אז אנחנו יכולים לקרוא לפונקציות עליהם.
אני הולך להיכנס לזה קצת יותר כשאני הולך לJavaScript,
אבל אתה ראית את כל כמו document.getElementById.
אז מסמך הוא שלך אלמנט, לקבל אלמנט לפי תעודת זהות,
אז אתה הולך לחפש עבור חלק מהזהות של בתג HTML.
ואז, אתה יכול לעשות משהו שאחר.
לדוגמא, כמו document.body, אז אתה יכול לצרף ילד.
אז אתה הולך למצוא את המסמך.
יש לך את המסמך.
אתה הולך למצוא את הגופה.
אתה מצאת את הגופה.
ואז, אתה הולך קורא כמה פונקציה על זה.
אז לצרף ילד, ואתה יכול לצרף כמה HTML על הסוף בתוך הגוף שלך.
אז בעצם, אתה פשוט בטיפול זה כמו חפץ.
אתה מתייחס HTML תגים כמו אובייקט.
וזה עושה את זה קל מאוד ומהיר לעבור אותם.
אבל זה גם מאפשר לך קוראים פונקציות עליהם
כך שאתה יכול לתפעל ולשנות את האלמנטים.
>> גייב: בהתחשב בזה, למה הוא כזה JavaScript שפה נחמדה אינטראקציה עם HTML?
רוב הסיכויים הם, כאשר אנשים היו בוחרים השפה עבור הדפדפן,
לצד הלקוח, JavaScript היא ממש נחמדה,
זה ממש טוב בטיפול בחפצים.
ואובייקטי סוג שלהם אוהבים האובייקטים המופיעים בHTML,
אז זה קל מאוד עבור JavaScript לעשות את זה סוג של טיפול.
דווין: נחמד.
אז הנה רק דוגמא.
אז אני חושב על החידון בשנה שעברה, או אולי לפני שנתיים, אנחנו
ביקשתי ממך ליצור עץ.
אז זה בדיוק מה שהיית עושה.
אז אתה מתחיל לצאת עם מסמך.
ואז אתה בעצם רק להסתכל על התגים.
אז אם אתה מסתכל, אנחנו מתחיל בתג HTML.
ואז, אתה מקבל רמזים על איך לעשות את זה מבוסס על השקע.
אז סוג ראש מסתעף.
בתוך הראש, יש לנו תג נוסף לתואר.
אז, יש לנו תג כותרת.
ובתוך כך, יש לנו כמה מחרוזת.
וכך אנו מייצגים מחרוזת במעגל.
ואת כל התגים נמצאים בריבועים.
>> ואם אתה מסתכל, אם לחשוב על זה כעץ,
ונניח שHTML הוא הורה, אז ראש וגוף
הולכים להיות אחים.
הם שניהם הולכים להיות ילדיו של ההורה ש.
אז בגלל שהם שני האחים, שהם
הולך להיות סוג של ליד אחד את השני במודל העץ שלנו.
ואז, אתה בעצם לעשות את אותו הדבר בדיוק.
אז לא קשה, אבל יש לנו שאלנו שאלות כמו זו לפני בחידון.
גייב: האם מישהו יש לך שאלות עד כה?
האם זה טוב?
דווין: מגניב.
JavaScript, אישור, את הדברים טובים.
אז JavaScript, מה הוא JavaScript?
ובכן, JavaScript is-- זה , אבל אלה מסובכים
כמה מרגעי השיא שאתה צריך לזכור.
ראשית, זה שהוקלד באופן רופף.
מה זה אומר?
אז PHP was-- כן, מה קורה?
>> קהל: אין לך לבמפורש מדינה איזה סוג של משתנה זה.
דווין: מושלם.
אז הוא אמר שאין לך ל במפורש סוג משתנה.
זה בדיוק נכון.
אז בC, אם היה לי int i שווה 50, לאחר מכן ב- PHP, זה בדיוק כמו זה, $ i,
שווה 50.
ואז ב- JavaScript, מה הייתה השיחה להיות?
Var, נכון?
זה יהיה כמו שאני var שווה 50.
אבל אתה לא צריך להיות כמו, אוקיי, זה int.
OK, זה הוא מחרוזת.
אין צורך לעשות את זה.
זה שפה פירשה.
אז מה זה אומר?
>> קהל: לא נאסף.
>> דווין: מה שלא נערך אומר?
כן?
>> קהל: אין לך לבנות מחדש את הקוד
כדי לקבל את זה מוכן ל המחשב כדי להפעיל אותו.
זה פשוט לקח בזמן ביצוע והמחשב [לא ברור].
דווין: כן, אז זה הולך עובר באמצעות מתורגמן.
אבל אתה בדיוק נכון.
כך שלעולם לא הולכים כדי לקמפל את זה, נכון?
כאשר אתה עושה שלך PHP וקוד JavaScript,
אתה אף פעם לא קראת הידור.
אתה אף פעם לא קראת משהו כזה לעשות או משהו כזה.
זה בגלל שהוא פירש.
אז בכל פעם שהוא עובר דפדפן, זה הולך באמצעות מתורגמן.
וזה הולך לפרש אותו בדיוק בזמן אמיתי מייד בשבילך.
אז מה הם כמה חיוביים וגם שליליים שיש לפרש שפה
ויש להם שפת הידור?
אז compiling-- כן, מה קורה?
>> קהל: המפורש הוא איטי יותר.
דווין: באיזה מובן?
>> קהל: לאחר ש לקמפל, אין לך
לעשות כל צעדים נוספים כדי לבצע זה, ואילו [לא ברור] זה.
>> דווין: ימין, מושלם.
אז מה שאמרת הוא בעצם שקומפילציה,
כאשר אתה מהדר, יש לך הרבה עלויות מראש, נכון?
אתה הולך לעבד אותו.
אבל אחרי שאתה לקמפל אותו, מהדר הולך לייעל את זה.
זה הולך להיות מהיר.
זה הולך בעצם להיות מהיר כמו שזה יכול להיות.
לפרש, אתה אף פעם לא יש שעלות מראש.
במקום זאת, זה הולך להיות קצת יותר איטי כל פעם שאתה מפרש אותו.
ואתה הולך צריך לפרש אותו בכל פעם.
אז במקום שיש זה עלות פעם אחת, עכשיו אתה
אצטרך לפרש את זה בכל פעם הדף הופך.
>> אז מתורגמנים טובים, כי אתה לא צריך לקמפל אותו,
אבל הם רעים שבכל עת את הדף נטען, זה
אצטרך לפרש JavaScript זה.
וזה הולך לרוץ מעט איטי מאשר אם היה לך לעבד אותו.
מאפשר לך communicate-- הו, לחכות.
משמש כדי לתפעל תוכן ומראה.
אנחנו רק דיברנו על זה.
היא משתמשת DOM.
AJAX, נקבל ל AJAX בקצת.
ואז, זה בצד הלקוח.
אז PHP היא צד שרת.
JavaScript היא בצד הלקוח.
מה הם חיוביים לזה?
זה אומר שזה.
זה מהיר, נכון?
מכיוון שאתה לא צריך to-- זה יותר מהר.
אתה לא צריך לתקשר עם כמה מכשיר אחר.
אם אתה רק עליך הלקוח, אתה אף פעם לא
תצטרך ללכת ו לראות מה בשרת
ואז לדווח בחזרה או משהו כזה.
אז בצד הלקוח נוטה להיות קצת יותר מהר.
>> גייב: כן, אבל זה זה לא אומר שPHP היא
מהר יותר מאשר JavaScript או כל דבר של כדומה.
הם רצים סוג של באותו מהירות כי הם שניהם
שפות פירשו.
הדבר זה איטי כאן היא הבקשה.
אז אתה בעצם הולך כל הדרך לברזיל
כדי לקבל קצת מידע שגרתי שם.
אבל PHP ו- JavaScript, הם סוג של לרוץ באותה המהירות.
זה לא שהוא אחד מהר יותר מאשר אחרים.
זה, גם, שאלת טריק כאן.
אז JavaScript לא הופך קוד מכונה, אמת או שקר?
>> קהל: False.
גייב: False.
זה חייב להיות מכונה קוד כי קוד המכונה הוא
הדבר היחיד שמכונה מבין.
למרות שזה לא הידור, זה עדיין הופך קוד מכונה
כי המתורגמן הוא רק תכנית שהולכת שורה אחרת שורה
והופך את קו של משהו במחשב מבין.
בסדר?
מגניב.
>> דווין: הנה רק בסיסי מאוד שלום תכנית JavaScript עולם.
אז אני לא יודע if-- שראית את זה.
אבל בדיוק יש לך HTML כאן.
ובמקום באמת לשים JavaScript בתגי script,
אז בדרך כלל היית לשים אותו בראש.
יש לך תגי סקריפט.
אתה מפיל אותו שם.
כל מה שעשינו כאן הוא שאנחנו מקושרים in-- אז אנחנו כבר מקושרים בקובץ JavaScript
כמו זה.
ועשית כולך את זה, נכון?
לכן, כאשר אתה משתמש jQuery ו underscore.js בp-הסט האחרון,
אין לך טונות של קוד ב תגי התסריט שלך, בראש שלך.
אתה יכול לעשות את זה, אבל במקום אתה פשוט מחבר אותו ב.
ואתה מקשר אותו ב רק אתה אוהב לעשות עם CSS.
אז זה פשוט עושה את זה קל יותר לקריאה כל כך הקוד שלך לא אוהב ארוך 1,000 קווים
עם טונות של פונקציות ש ייתכן שאתה לא משתמש.
>> במקום זאת, אתה רק לקשר אותו ב.
זה תאים, זה.
זה כמו לכתוב כמה קובץ כותרת, ו לאחר מכן, כולל שקובץ הכותרת בג
תחשוב על זה בדיוק כמו זה.
אז מה זה עושה?
ובכן, זה הולך לרוץ.
זה הולך כדי להתריע.
אז אתה הולך לקבל קצת צץ בשם שלום עולם.
שאלה מהירה, בדיקת שפיות רק, כך שאתם רואים כאן בגוף,
אומר שגוף, HTML כאן.
מה בא קודם?
האם אני רואה את הגוף, HTML כאן, או שאני רואה את ההתראה ראשונה?
>> קהל: התראה.
>> דווין: נכון.
לדבריו, ערניים.
למה?
>> קהל: מכיוון שאתה ללכת מלמעלה עד למטה.
>> דווין: כן.
מושלם.
אז הוא אומר, שאתה הולך מלמעלה תחתון, שהיא נכונה באופן מוחלט.
אתה הולך מלמעלה למטה.
ובJavaScript, jQuery, יש לך פונקציה זו onload כמו, או מוכן,
וזה אומר, בסדר, תחכה עד ש כל HTML זה נטען.
ואז, קורא JavaScript.
כי אין לנו את זה כאן, דבר הראשון שהולך לקרות
הוא זה הולך ללכת מלמעלה עד למטה.
זה הולך להכות שJS קורא, זה הולך כדי להתריע.
לאחר שתלחץ על אישור, ההתראה שהולכת משם.
אז זה הולך להראות אתה הגוף HTML כאן.
נחמד.
>> OK, מהירה, כתיבה כל כך פשוט אמיתית ב- JavaScript הוא סופר מהיר.
כדי להכריז שם. משתנה, var
אז בC, יש לך אני int, יש לך להכריז איזה סוג של סוג זה.
PHP, $.
JavaScript, var.
דברנו על זה.
בסדר, בואו נלך.
>> לולאות, אותו דבר.
אותו דבר.
הצהרות פונקציה, כך בדיוק כמו שראית בג
הדבר היחיד שהשונה הוא כל כך כש אתה מגיע לשפות תכנות אחרות,
כמו שלוקח 51 סמסטר הבא ואתה עושה עם ocaml,
אתה יכול להתמודד עם פונקציות בעילום שם.
אז זה בדיוק מה שיש לך כאן.
אז אתה רוצה לשים בסכום, איזה ערך הסכום.
אבל ייתכן שרק עושה את זה פעם אחת.
אז אתה לא רוצה לקרוא לזה פונקציה סכום, נותן לו הצהרה על פונקציה.
במקום זאת, אתה פשוט להשתמש בו כפונקציה אנונימית.
ושראית את זה הרבה.
תראה דוגמא ל זה בכמה שקופיות.
כן, אנחנו תראו.
גייב: שאלה טובה.
כאשר ייתכן שתרצה להשתמש ב פונקציה אנונימית כאן?
בעיקרון, כאשר אתה רוצה משהו, כמו אירוע, שיקרה.
לכן, כאשר העכבר הוא לחץ, למשל,
אתה רוצה קצת פונקציה שתיקרא.
אז אתה עובר לאירוע מטפל, אתה עובר לאירוע,
סוג של, הפונקציה ש אתה רוצה שתיקרא.
ומה שאתה עובר זה כמו, בסופו של הדבר
שלו של היום, רק מצביע ל הוראה ש, לפונקציה.
אז זה לא כמו שאתה עובר כל הקוד, בדיוק כפי ש
מצביע לפונקציה.
ולאחר מכן, כאשר מישהו לוחץ על עכבר, אז פונקציה שנקראת.
>> דווין: מערכים, כך ש יש לי הכרזת מערך.
ואז, מערך לשים את הדברים ב.
ממש מהר, מה זה להדפיס את?
מה האלמנט השלישי יהיה?
>> קהל: "JS".
>> דווין: נכון, זה יהיה "JS".
חכה, לחזור.
מהו האורך?
>> קהל: שלוש.
דווין: שלוש, נכון?
בדיוק מה שאתה חושב.
אוקיי, עכשיו ללכת.
מערכים, אתה יכול להוסיף להם דברים.
אז אתה יכול ללכת מעבר ל הגבולות הראשוניים שלהם.
רק משהו שכדאי לזכור.
PHP, JavaScript, הם קצת קצת יותר סלחני במונחים של דברים
כמו ש.
אובייקטים, דומה מאוד ל structs בC, מאוד
כמו מערכים אסוציאטיביים ב- PHP.
היה לך כל ניסיון עם זה.
אז JSON, כאשר אתה עובר JSON הלוך ושוב בשמונה להגדיר p-,
זה האובייקט שלך.
>> אז כן, דוגמא, דוגמא מהירה אמיתית.
כאן הוא אובייקט.
הדרך בה אתה אזכור זה אובייקט, כל כך פשוט ממש מהר,
בואו נגיד שאני רוצה למצוא , בסדר, מה הוא הקורס?
ולכן שם האובייקט כאן הוא CS50.
ולאחר מכן, אם היה לי אסוציאטיבי מערך, איך אני אעשה את זה?
אני אהיה באמצעות מפתח, נכון?
אז יש לי את שמו של המערך.
יש לי הסוגר, ציטוטים, מפתח, ציטוטי סוף, תושבת הסוף,
ושיהיה התייחסות ש אלמנט בתוך המערך האסוציאטיבי שלי.
איך אני הפניה כמובן בתוך האובייקט שלי?
מישהו יודע?
>> קהל: [לא ברור].
>> דווין: מה קורה?
קהל: CS50.course.
דווין: נכון, כן.
אז CS50.course.
אז דרכך הפניה דברים בתוך אובייקט JSON הוא עם נקודה.
>> קהל: אתה יכול גם להשתמש בתחביר מערך.
>> דווין: OK, בסדר.
>> גייב: אתה יכול גם להשתמש בסוגר CS50, מחרוזת, כמו מרכאות.
קהל: אני חושב שזה זהה ל- PHP.
גייב: זה אותו הדבר.
דווין: פיין!
אבל אתה תראה במקומות אחרים זה.
כן, אז תמשיך.
זה מה שאני רק אמרתי.
אז לדוגמא JavaScript jQuery.
אז זה DOM שלי, נכון?
ממש מהר, כך שיש לי ראש, שלום עולם, גוף.
יש לי לחץ.
זה אומר "לדחוף אותי," אז אני רוצה לדחוף אותו.
ואני רוצה לעשות משהו כאשר הוא לחץ.
ימין, הבא.
>> נכון, אז זה JavaScript שלי.
אז jQuery הוא פשוט יותר קל דרך לכתוב JavaScript.
אז זה, ומה שאני הולך להראות לי אתה הבא, הולך להיות jQuery,
זהים.
אז הם יעשו את אותם דברים.
רק jQuery נוטה להיות קצת יותר קל.
אנשים נוטים לאהוב את זה יותר.
יש לו הרבה פונקציונלי.
אז אנשים נוטים להשתמש jQuery.
כל מה שאתה משמש jQuery בp-הסט האחרון.
אז מה זה יעשה?
מה יהיה JavaScript-- זה כל כך זה פשוט JavaScript.
מה זה יעשה?
מה הוא יעשה?
>> אז קודם כל, אתה רואה חלון onload.
נכון?
אז אנחנו לא רואים את זה לפני.
אז זה הולך לחכות עד לטעינת החלון כולו.
אז זה הולך לחכות עד עומס HTML, כל התמונות
לפני שהוא עושה משהו.
אז בואו נגיד שDOM שלנו עמוס.
כל מה שיש שם.
אז מה הולך לקרות?
כן?
>> קהל: לחצן מופיע.
>> דווין: לחצן כבר שם.
כן, כל כך שלהן כבר שם.
אבל זה הולך לומר, OK, אם אני לוחץ על הכפתור,
כך על הכפתור כבר שם, כמו שתג HTML.
חכה, לחזור ממש מהר.
תג זה נכון כאן הוא הולך להיות לחצן כבר.
יש כבר כפתור.
אבל אז, JavaScript תג, ממש כאן,
זה אומר, בסדר, אני רוצה כדי לקבל אלמנט לפי תעודת זהות,
כך כפתור חיפוש פשוט אומר, בסדר, אני רוצה כדי למפות משתנה זה ללחצן זה.
אז משתנה כי הוא פשוט דרך קלה יותר לגשת ללחצן זה.
ואני אומר, אוקיי, אם אני לוחץ ש כפתור, כך שאם אני לוחץ על אלמנט ש,
ויסוד זה מתייחס ל הכפתור, אם אני לוחץ עליו,
אז אני רוצה לקרוא לפונקציה.
הנה אחד אנונימי אלה פונקציות שאנחנו מדברים על.
>> פשוט לקרוא כמה פונקציה.
בתוך פונקציה ש, בעצם משהו שראינו הרבה, ערני.
אתה לוחץ על כפתור החיפוש.
זה הולך להן בעצם.
אתה לוחץ עליו.
אתה מקבל התראה ש.
X החוצה.
זֶה הַכֹּל.
כן?
>> קהל: אז אם אתה שם את התסריט , תג תסריט [לא ברור] ב- HTML שלך?
>> דווין: אתה יכול לשים את התסריט ישר תג בראש
כי יש לך onload זה.
זה גם שיש לך בלחיצה.
אז זה הולך לחכות עד אתה לוחץ על משהו.
אבל onload הוא רק כדי להיות בטוח, כדי להפוך את עומסים בטוחים הכל ל- HTML שלך
לפני כן.
כן?
אתה רוצה להגיד משהו?
>> גייב: [לא ברור].
דווין: כן.
>> קהל: נמנע אז onload הגדרת כפתור החיפוש משתנה
על ידי רק אומר document.getElementById dot כפתור חיפוש [לא ברור].
>> דווין: בהחלט, אבל אז המחרוזת שלך פשוט מקבלת עצומה.
בדיוק, אז זה רק ל לעשות את זה יותר קל לך, כן.
כן?
>> קהל: מאיפה אנחנו ליצור window.onload?
או document.ready?
>> דווין: כן, יש.
כן, יש, בדקתי.
>> גייב: לא לאכפת להם על.
>> דווין: אוקיי, אז אני הולך להגיד לך בכל מקרה.
אז בעצם, רק באופן כללי, כל כך window.onload מחכה עד DOM שלך, את כל
HTML שלך, המון.
הוא ממתין עד לעומס התמונות שלך.
הוא ממתין עד לעומסי הכל.
document.ready, זה פשוט מחכה עד עומסי DOM שלך.
ברגע HTML הוא כל מה שיש, ברגע ש DOM שלך הוא שם, מתחיל לרוץ.
זה ההבדל היחיד.
>> גייב: שפיות מהירה לבדוק כאן.
אז זה ניתן לראות סוג של כמו שורת קוד, נכון?
כי זה window.onload שווה חבורה של דברים.
כאשר JavaScript קורא, או נכון זה שווא, הפונקציה מקבלת להורג.
שווא.
בסדר?
מה קורה כאן, אתה פשוט עובר פונקציה זו כפונקציות בעילום שם
לwindow.onload.
ואז כשזה הולך בעצם לקבל להורג?
כאשר עומסי החלון.
זה אירוע.
אז זה דבר לא jus אנחנו מדבר קודם לכן, נכון?
לכן, כאשר האירוע מתרחש, הפונקציה קורה.
אותו דבר עם onclick.
>> דווין: אוקיי, אז מישהו לקח משם document.ready.
אבל זה יהיה same-- המדויק
קהל: סימן הדולר, כי הוא document.ready.
זה קיצור דרך.
>> דווין: אה, זה הוא?
אוקיי, אז זה אמצעי document.ready, קיצור.
אבל זה אותו הדבר כמו window.onload מלבד ההבדל קטן
סיפרתי לכם על.
וזה jQuery.
אז זה אותו הדבר thing-- זה JavaScript.
זה פשוט- כמה אנשים חושבים על זה כמשקל קל יותר, גרסה מלוטשת
כי יש הרבה פונקציונלי כי אתה בטח תשתמש.
אז זה עושה את אותו דבר בדיוק.
>> אז דברים להצביע על סוג של.
אז בדוגמא אחרת, אנחנו היה לי document.getElementById,
אז היו לנו כל כך הרבה זמן מחרוזת שהולכת לקבל
האלמנט על ידי כל מה שיש לו תעודת זהות.
זה הוחלף על ידי קריאה זו ממש כאן.
אז אתה רואה סימן הדולר, אז אתה רואה ציטוט, hashtag.
Hashtag תמיד בורר.
זה אומר, בסדר, זה קשור לזיהוי.
מה את הבורר לכיתה?
>> קהל: Dot.
>> דווין: Dot, תקין.
אם אתה רק הולך בחר תג, מה זה?
זה פשוט התג, בדיוק.
ואתה יכול להשתמש בזה כאן, גם כן.
>> גייב: ולפי תגית, אנחנו מתכוונים כמו div, למשל, או את הראש.
>> דווין: או או גוף או p משהו כזה, כן.
אז הנה, אישור, במקום לומר document.getElementById,
זה רק מדויק אותו הדבר.
רק בjQuery, זה קצר יותר.
אז זה פשוט יותר.
אז, לא יותר onclick, פשוט לחץ.
פונקצית jQuery, לקרוא לפונקציה זו.
התראה היא אותו הדבר.
אז זה קצת או קצת קטנים יותר, קטן
קצר יותר, אנשי bit-- קטנים חושבים זה קצת יותר קל לכתוב את,
קצת יותר קל להבין.
אבל זה jQuery.
הרבה אנשים לקבל קצת קצת מבולבל ומודאג
והם חושבים, בסדר, jQuery שונה מJavaScript.
אני צריך לזכור אלה שני דברים שונים.
זה לא.
אני מתכוון, זה תחביר שונה.
אבל jQuery הוא JavaScript.
זה רק לכאורה גרסה טובה יותר ש
יכול להיות קל יותר להבין שאנשים משתמשים.
גייב: כן, להיות , שסימן דולר כנה
שאתה רואה בjQuery, זה רק שם של פונקציה שjQuery מגדיר.
זה לא חייב שום דבר מיוחד.
האם זה רק השם של פונקציה, בדיוק כמו שאתה יכול להגדיר סימן דולר.
>> דווין: כן, אז דיבר על זה.
כמה דברים שימושיים.
אני מסתכל אחורה בחידונים הישנים.
בכמה חידוני העבר, יש להם הייתי צריך להשתמש בדברים כאלה.
אז document.ready, כך לוודא שפעלו כראוי
נטען לפני שאתה מתחיל לעשות דברים.
בחר ID, או בחר כיתה, זה פשוט הייתי
להיות ציטוט נקודה מסוים בכיתה, סוף ציטוט.
שלח, כך שאם אתה הגשת טופס ושיחה
פונקציה זו לאחר הטופס מגישה.
ערך, אז בואו נגיד שיש לי טופס הגשה, כמו שם משתמש, דוא"ל,
מה.
היה לי תיבת טקסט.
אז אני מקליד לתוך תיבת טקסט.
ובכן, אם אתה רוצה לקבל את הערך מתוך שתיבת הטקסט, אתה משתמש בנקודה val.
ואז, כאן למטה, נקודת HTML הוא אותו
זה כמו נקודת מסמך getElementByID הנקודה innerHTML.
אז זה הולך לחזור אתה HTML מזיהוי ש.
הנה, אתה פשוט להשתמש בכמה מזהה או מה נקודת HTML.
שיקבל את ה- HTML מאלמנט ש.
אם אתה רוצה אז לשנות את זה HTML, אתה יכול להעביר אותו משהו.
אז אתה רוצה להיות כמו HTML נקודה, ולאחר מכן בתוך, ציטוטים, HTML או משהו החדש.
>> גייב: אוקיי, אז AJAX.
אני באמת רוצה להבין AJAX ממש טוב.
אז אני רוצה שבחורים ל להבין AJAX ממש טוב.
כי אם אתה עושה, אתה הולך פחות או יותר
כדי להבין את כל מה ש יש לעשות עם HTTP, PHP,
JavaScript כי זה כל מגיע יחד בAJAX.
AJAX הוא לא שפה.
AJAX הוא טכניקה.
והוא משתמש בהרבה כלים שונים.
AJAX עומד ל XML JavaScript אסינכרוני.
אז השיטה, השפה, את הנתונים.
>> אז את השפה העיקרית שאנו משתמשים בי ב- AJAX כדי לעורר הכל
ולהתמודד עם כל דבר מאוחר יותר הוא JavaScript.
זו הסיבה לכך שהיא מתייחסת קרוב מאוד לJavaScript.
ולאחר מכן אסינכרוני הוא כי אנחנו לא עושים את זה
בבת אחת כשאנחנו טעינת הדף.
זה הדבר שאנחנו יכולים לעשות דברים מסוג של במקביל.
הרעיון המרכזי מאחורי AJAX הוא שאתה רוצה
זה כדי לקבל קצת מידע ספציפי.
לדוגמא, כאשר אתה מקליד חדש שם משתמש בעת רישום שם משתמש,
שם המשתמש שלי הוא abc123.
ולאחר מכן, בסוף צורה, אתה צריך ללחוץ על שלח.
וזה הייתי צריך ללכת לשרת, ולאחר מכן בדוק אם באתר,
abc123 הוא כבר שם.
ואם הוא כבר נמצא שם, הוא אומר, שם משתמש כבר במסד הנתונים.
והם, אתה צריך למלא מתוך כל הצורה שוב.
וזה היה ממש, ממש רע.
>> ואז אנשים אומרים, OK, למה אנחנו לא יכולים פשוט
לעשות בקשת HTTP קטנה רק כדי לבדוק כדי לראות אם משתמש זה הוא באתר
לפני שהיה לי למשתמש להגיש את הטופס כולו?
כך למשל, כאשר משתמשים מסיים להקליד abc123,
בואו פשוט ללכת לשרת קטן קצת ופשוט לקבל אמת או שקר
מהשרת כדי לראות אם זה שם משתמש תקף או לא.
אוקיי, אז זה אחד העיקרי משתמש ב- AJAX בימינו עדיין.
>> דווין: אז ממש מהר, ב שיחת אייאקס בjQuery,
אתה יכול לסמן ש רוצה שזה יהיה סינכרוני.
אתה לא צריך לעשות את זה.
אבל אתה יכול לעשות את זה.
ואם אתה עשית את זה, מה היה קורה?
ובכן, לדוגמא, כשאתה מקבל את החדשות או כל דבר אחר,
הדפדפן שלך הוא רק הולך לחכות עד שכל השיחה היא מלאה
במקום לתת לך לעשות אחרים דברים נכון לאחר לחיצה עליו.
>> גייב: זה לא עובר יותר.
אוי אלוהים.
סליחה!
כן.
"בעבר, הלקוח צריך בקשה
כל התוכן של אתר אינטרנט. "
זה מה שאמרתי.
זה מאפשר לנו לשלוח GET או POST נוסף
בקשות מבלי כדי לטעון מחדש הדפדפן שלנו.
אז בסופו של היום, אנחנו למעשה מה שהופך את בקשות HTTP
כאן באמצעות JavaScript.
כי לפני, אנחנו רק משמשים JavaScript כדי לשנות את ה- HTML שהגיע כבר.
ועכשיו, אנחנו יכולים להשתמש בו להתממשק עם שרתי האינטרנט, כמו גם.
הדרך זה קורה הוא שיש לנו לקוח.
דווין הוא לקוח.
ויש לו את כל JavaScript פועל מפני HTML הוא מטומטם.
JavaScript היא חכמה.
אז יש דווין Davin החכם חלק והחלק המטומטם שלו.
הוא הולך להשתמש בחלק החכם שלו עכשיו.
הוא הולך להשתמש ב- JavaScript לבקשה, לדוגמא,
אם abc123 הוא ב מסד נתונים או לא.
>> אז Davin, בבקשה, אתה רק שלח לי בקשת HTTP.
תודה לך.
אז הוא פשוט שלח בקשת HTTP.
אתה רואה את זה?
וזה רק באותה הדרך כי כל בקשת HTTP נשלחה.
הדפדפן, Google Chrome או משהו, הוא
הולך לראות שDavin של מנסה לשלוח בקשת HTTP,
הולך לעזור HM קצת.
וזה הולך ללכת כל הדרך לשרת.
עכשיו, השרת הוא הולך להיות PHP כאן, או כל שפה אחרת.
בדיוק כמו בבקשת HTTP רגילה.
זה פחות או יותר בקשת HTTP רגילה.
>> ולאחר מכן, השרת הולך להגיד, בסדר,
דווין רוצה אותי כדי לבדוק אם abc123 זה באתר.
תלכו לדבר עם המודל.
המודל אומר שזה לא. abc123 הוא שם משתמש טוב.
ולאחר מכן, שרת האינטרנט הולך להשתמש PHP כדי להבהיר בצורה כלשהי של קובץ.
זה יכול להיות ממש ממש קובץ המכיל "כן" בזה, או "לא,
או משהו כזה.
זה יכול להיות כל קובץ.
>> זה יכול להיות כמו שאני הולך לשלוח Davin תמונה של ברווז
אם זה באתר ו לשלוח תמונה של אוגר
אם זה לא במסד הנתונים.
זה יהיה סוג של מטומטם, אבל זה יעבוד.
אוקיי, אז אני שולח ברווז לDavin.
Davin לי ברווז.
ועכשיו, מי הולך כדי להתמודד עם הברווז?
החלק החכם של דווין שוב, כך JavaScript, נכון?
JavaScript שלח בקשה, וJavaScript
הוא הולך לקבל את הבקשה ולפרש אותו בצורה כלשהי.
>> ובמובן זה, זה הולך אומר, בסדר, אם ברווז אז אני טוב.
אם אוגר, אז אני הולך לומר, לא, שם משתמש כבר
קיים במסד הנתונים.
אבל בדרך כלל, אתה לא הולך לשלוח ברווז.
אתה הולך לשלוח משהו מעט חכמה יותר.
ומה שאנו משתמשים הוא XML.
ולאחרונה, אנו משתמשים JSON.
JSON הוא רק JavaScript סימון אובייקט, ש
בעצם אתה מקבל אובייקט JavaScript כולו.
ואתה שם אותו בקובץ, בדיוק כמו שאובייקט CS50 שאתם ראו.
אתה שם אותו בקובץ, ו אתה שולח אותו לDavin.
>> אז במקרה הזה, הייתי להפוך את אובייקט JavaScript
ורק אומר, משתמשים קיימים, כן.
או משתמש קיים, לא.
ולשלוח אותו בחזרה אליו.
ומדוע JSON?
כי האדם מי שקיבל זה
הולך להשתמש ב- JavaScript כדי להתמודד עם התגובה.
וJavaScript עובד כל כך טוב, כי זה נקרא סימון אובייקט JavaScript.
נכון?
אז הוא יכול פשוט לקרוא לפונקציה ולקבל אובייקט זה נחמד מהתגובה.
ולאחר מכן, הוא הולך לדעת אם המשתמש שהוא באתר או לא.
>> אז אתה רואה, כל זה בא יחד בשרת האינטרנט,
ואז יש HTTP אחד לבקשה ותגובה אחד HTTP והכל.
כדי לוודא שאתה בחורים להבין שיחת AJAX זה
כי זה עוזר לך להבין את כל על המושגים שאנחנו מדברים.
>> אז הנה דוגמא של AJAX עם jQuery.
והנה, אנחנו עושים עם JSON גט.
אז אנחנו לא מנסים להשיג תמונה של חתול כאן, או ברווז.
אנחנו מנסים לקבל קובץ JSON.
ואז נחכה עד זה נעשה, נעשה נקודה.
זה אומר שאני מחכה לתגובה.
זה עלול לקחת קצת זמן.
ואז, אתה רואה קצת טעינה.
אם אתה רוצה לעשות את זה באתר האינטרנט שלך.
אז dot עשה, ואז מה קורה כאשר עושה את זה?
אתה עובר בעילום שם פונקציה, בדיוק כמו שראינו קודם.
בגלל לעשות הוא אירוע, רק כמו לחיצה עכבר או מה,
לjQuery.
אז אתה עובר בפונקציה זו עם הנתונים, טקסט, מעמד, וjqXHR.
ובעצם, זה רק חלק ממשתנים
כי אתה יכול להשתמש מאוחר יותר כדי לי הסטטוס של בקשת HTTP,
נתונים שזה הולך לשלוח בחזרה אליך.
אז אתה יכול בשלב מאוחר יותר לפרש את זה ולעשות משהו משמעותי עם זה.
ואם זה לא מצליח, כשזה עלול להיכשל?
ובכן, כאשר בקשת HTTP נותנת אתה 500 או משהו כזה.
ואז, זה הולך לספר לכם מעמד, איזה סוג של כישלון שהיה,
וכל מיני דברים.
אתה צריך לוודא ש כדי לטפל בשני המקרים,
אחרת התכנית משתגעת.
>> דווין: אז כן, זה בדיוק מה שראית בp-הסט האחרון שלך.
שיחת AJAX בפועל היא בJSON הגט.
זה השיחה.
ולאחר מכן, נקודה עשתה היא כמו הוא בודק אם זה מצליח.
אם הוא מוצלח, אתה רוצה לעשות משהו עם הנתונים.
אתה מקבל בחזרה שמ נתוני בקשת JSON.
זה מה שאתה מקבל בחזרה.
אז אם אתה זוכר מp-הסט שלך, הרבה היית כמו הסוגר נתונים i
או מה, קישור נקודה או כותרת.
לא משנה מה חוזר מJSON ש, מה ש
השדות שבאובייקט JSON, זה מה שאתה מקבל בחזרה.
הנתונים הוא מה שאתה מקבל בחזרה.
מצב טקסט, פשוט משהו ש מאפשר לך לדעת מה קרה.
ולאחר מכן, jqXHR, זה רק בקשת HTTP XML jQuery.
זה בדיוק כמו אובייקט.
ואז להיכשל, בדיוק כמו גייב אמר.
גייב: בדוגמא הקטנה שלנו abc123 רק כדי לבדוק אם זה באתר
או לא, הנתונים יהיו משהו שאתה הייתי עושה, אם שם משתמש dot נתונים קיים,
וזה מה שPHP שלך נוצר ל לך, אם שם משתמש dot נתונים קיים, אז
אני הולך כדי להתריע, משתמש שם כבר קיים.
אחר, אני פשוט הולך לתת לי משתמשים להמשיך למלא את הטופס.
OK, ביטחון, מגניב.
>> דווין: רוצה אותי?
>> גייב: אני אוהב את זה.
אז משהו שנראה מוכר.
אנחנו כמעט סיימנו.
אז זה רק הדוגמא אתם ראו בכיתה.
הייתם משתמש argv1 כאן.
זה כמו ויכוח שורת הפקודה.
ואנחנו ממ העתקה ש למאגר של גודל 12.
מה הבעיה כאן?
הצפת מאגר!
כי יש לנו מאגר של גודל 12.
argv1 שאולי יש לי גודל של שני מליארד דולרים.
אנחנו לא עושים שום בדיקת גבולות.
אז אנחנו יכולים להעתיק הרבה זיכרון.
ואנחנו נהיה במיוחד רע על זה.
מה שאנחנו יכולים לעשות זה מאוד, מאוד אומר במקרה זה?
כן?
קהל: חלק משני מליארד הדברים מכיל קוד הפעלה שחוזר
[לא ברור].
גייב: בדיוק.
אז זה הסוג של דבר שאנשים משתמשים ב
לjailbreak iPhone, למשל.
אז זה סוג של דבר.
כי אתה יכול פשוט להפוך את המכשיר לבצע כל קוד שאתה אוהב.
התיקון, כך התיקון קל.
רק לבדוק את הגבולות.
אתה לבדוק null כי אנחנו תמיד לבדוק null
כאשר עם מחרוזות יש לנו עסק.
ואז, אתה לוקח אורך שרשרת לפני.
ואם המחרוזת אורך הוא מחרוזת חוקית
אורך, אשר נמצא ב0 ו -12, אז אנחנו טובים.
>> דווין: אם אתה לא בודק ל null, ממש מהר, מה יקרה?
זה יהיה צינוק באשמה.
למה זה SEG פגם?
בגלל שאתה קורא strlen על null.
גייב: כן.
אמת או שקר, באמצעות אחת סיסמא היא רעיון טוב.
>> קהל: False.
>> גייב: False.
השתמש בסיסמות רבות, וגדול עוד יותר,.
סמלי מנעול להבטיח את הביטחון.
>> קהל: False.
>> גייב: False.
זה לא אומר שום דבר.
זה רק סמל.
SSL מגן מפני איש בפיגוע במרכז.
קהל: False.
גייב: False.
אוקיי, אז כל אלה הם שקריים.
נחמד.
[לא ברור]
רוצה לדבר על זה?
עכשיו תורך.
דווין: סוגים של התקפות, גבר באמצע.
מה איש בפיגוע במרכז?
קהל: [לא ברור].
דווין: אם אתה שולח HTTP בקשה, שהם יכולים לעשות את זה, נכון?
אבל אם אתה שולח HTTPS, הם כנראה לא יהיה מסוגל לעשות את זה.
יש הרבה נקודות לאורך החיבור שלך.
יש לך נתב.
יש לך שרתי DNS.
אם מישהו מסוגל פיזי לראות את מה שאתה שולח,
אז מישהו יכול למעשה לקבל בינך,
הלקוח, והשרת, והוא תוכל לראות את מה שאתה שולח,
מדובר באדם בפיגוע במרכז.
אז כדי לראות את מה שאתה מנסה להשיג מ השרת, או שתוכל see-- גרוע,
ייתכן שתוכל לראות עוגיות או משהו כזה.
>> כך למשל, אם אתה לא משתמש ב- SSL, הוא
ייתכן שתוכל לראות העוגיות מזהה ההפעלה שלך.
וזה נקרא חטיפת הפעלה משום שהוא רואה בקבצי עוגיות שלך,
ולאחר מכן הוא מסוגל ללכת של אתר ומתיימר להיות אתה.
כי כמו ב- PHP, זוכר כאשר אנו מחוברים, מה אנחנו עושים?
אנו קובעים מזהה הפעלה שווה לזיהוי.
כך שמזהה אותך.
זו הסיבה שאתה יכול לראות תיק ההשקעות שלך ולא של כולם תיק.
>> ובכן, אם אני יכול לקבל עוגייה ש, אז אני יכול להיכנס לדף זה.
ואז, אני יכול רק לראות את הדברים שלך ולהתחיל לקנות ולמכור דברים.
אז זה חטיפת הפעלה.
אבל אתה לא צריך להיות מסוגל to-- כך ש ניתן להשתמש באיש בפיגוע במרכז
גם אם הם משתמשים ב- SSL.
אבל אתה לא צריך להיות מסוגל.
אם הם משתמשים ב- SSL, אתה לא יכול לחטוף מושב.
למה?
כי זה כל זה מוצפן, נכון? אם זה מוצפן,
ואני עדיין גבר ב אמצע, אני עדיין מקבל את הנתונים שלך.
זה בסדר.
אבל זה מוצפן.
אז אני באמת לא יכול להשתמש בו.
אז זה שתי.
>> ממש מהר, זיוף בקשת אתר צלב.
זה רק אם יש קישור והקישור שעושה משהו
כי אתה לא חושב שזה צריך לעשות.
כך למשל, אם הקישור היה הולך לקנות מניות או למכור מניות,
ואתה לא יודע את זה.
אתה לוחץ על הקישור, שלח בקשה, קנתה
או נמכר משהו ש שלא התכוון לעשות.
זהו זה.
>> האתר לחצות scripting, אז הנה, אתה עובר בבאמצעות q משתנה,
במקום עובר באיזשהו של ערך, אולי q הוא כמו שם.
אז במקום עובר שווים q דווין או משהו כזה,
אם אתה לא משתמש ב- HTML תווים מיוחדים, אם אתה
לא לברוח זה כדי לוודא שזה OK, אז אני יכול לעבור במקום,
נניח כאן שאני אומר הדפסה או משהו כזה,
אז אני יכול לעבור לכאן שיחת תסריט.
>> אז, במקום פשוט מקבל משתנה,
אז הייתי לבצע שיחת התסריט הזה.
אז בתוך שהתסריט קורא, מה הוא עושה?
מיקום נקודת מסמך, שהולך לשנות את מיקומו של המסמך.
אז אני הולך להפנות למקום אחר.
זה נקרא איש רע ב דוגמא זו, טוב מאוד.
לא יכולתי לחשוב על המילה.
ולאחר מכן, מה גם יותר גרוע הוא שאני הולך
לעוגייה ולאחר מכן קבעה, שהוא חלק מ משתנה שיש לי באתר זה.
אני הולך להגדיר את זה שווה לעוגיית dot המסמך.
לכן, אני הולך לגנוב העוגייה שלך.
ואני הולך להפנות קצת מידע לאתר אינטרנט
כי אתה לא צריך להיות גישה.
וזה הכל קורה בגלל שאתה לא לברוח מה שראית.
כן?
>> קהל: אז רק כדי להבהיר את זה, זה
vulnerable.com ש הוא פגיע לזה.
אז קישור שיכול להופיע בכל דף נתון.
מישהו לוחץ עליו, הולך לvulnerable.com.
יש לך עוגייה לvulnerable.com.
בואו נגיד שפייסבוק היא פגיע כל כך, facebook.com.
יש לך העוגייה שלך בפייסבוק.
מה זה עושה, אתה הולך facebook.com,
זה הפניית מייד לך badguy.com,
אבל כולל מידע העוגייה שלך.
אז זה הפניה מהירה, אבל העוגייה שלך בפייסבוק
כלול בהפניה ש, וככה הם [לא ברורים].
גייב: כן, יש כמה דברים מאוד ממוצעים
שאנשים יכולים לעשות אם יש זה.
לדוגמא, אם פייסבוק מותר כולם לשנות את שם המשתמש שלך,
והם לא עשו שום בדיקות שפיות, כך ש
יכול להכניס דבר JavaScript ש משנה את התמונה שלך לאוגר.
וזה מכניס את אותו JavaScript לכל מי שרואה בדף שלך.
אז כל מי שרואה את הדף שלך יש את אותו הדבר בשם המשתמש.
ומכיוון שמדוברים בוירוס, הוא מתפשט באופן אקספוננציאלי.
דווין: אנחנו לדלג האחרונים אחד, ולאחר מכן שנסיים.
אז זה הוא רק דוגמא נוספת.
אז זה שהם לא בריחת שולחן SQL שלהם.
אז אתה יכול לשחרר אותו.
אז אתה רוצה לברוח דברים.
זה היה הדוגמא הקודמת עם האתר לחצות scripting.
מצטער שרצנו קצת מאוחר.
מחר, מצטער!
מחר, יש לנו שעתי עבודה.
אז שעתי עבודה בCabbot 8:00-11:00.
שעתי העבודה הן אך ורק לשאלות חידון.