1 00:00:00,000 --> 00:00:02,270 >> [סקירה: 1 חידון] 2 00:00:02,270 --> 00:00:04,620 [עלי Nahm, Oreoluwa Barbarinsa, לוקאס פרייטס, רוב אודן] [אוניברסיטת הרווארד] 3 00:00:04,620 --> 00:00:07,660 [זה CS50.] [CS50.TV] 4 00:00:07,660 --> 00:00:11,610 [לוקאס פרייטס] ברוכים הבאים לכולם. זו ביקורת לחידון 1. 5 00:00:11,610 --> 00:00:15,040 בדיוק כמו ויתור, זה - אני מתכוון, אנחנו הולכים לנסות לכסות 6 00:00:15,040 --> 00:00:17,770 חומר רב ככל האפשר, אבל זה לא אומר ש 7 00:00:17,770 --> 00:00:20,780 אנחנו הולכים כדי לכסות את כל הדברים שיכולים להיות בחידון 1. 8 00:00:20,780 --> 00:00:25,270 אז כדי להיות בטוח גם אתה תסתכל בהרצאה, חלקים, כל מה שאתה יכול. 9 00:00:25,270 --> 00:00:28,240 חידון 1 הולך להיות ביום רביעי, ביום רביעי הבא. 10 00:00:28,240 --> 00:00:33,800 כדי להיות בטוח כדי ללמוד. זה הולך להיות, פחות או יותר, כמו החידון הראשון 11 00:00:33,800 --> 00:00:36,390 לגבי הפורמט שלה, אבל זה כנראה הולך להיות הרבה יותר קשה. 12 00:00:36,390 --> 00:00:39,600 לפחות, בשנה שעברה כאשר לקחתי 50, חשבתי שזה היה הרבה יותר קשה. 13 00:00:39,600 --> 00:00:42,410 אז ללמוד הרבה. 14 00:00:42,410 --> 00:00:45,190 >> אני הולך לכסות את מבני נתונים והאפמן קידוד. 15 00:00:45,190 --> 00:00:47,910 זה משהו שהרבה אנשים חושבים הוא מורכב, 16 00:00:47,910 --> 00:00:51,930 אבל אני הולך לנסות לעשות את זה קל ככל האפשר. 17 00:00:51,930 --> 00:00:56,330 קודם כל, מה שאנחנו רוצים אתם לדעת לחידון 1 הוא 18 00:00:56,330 --> 00:01:00,970 להבין את התיאור הרעיוני של כל אחד ממבני הנתונים שאני הולך להציג. 19 00:01:00,970 --> 00:01:03,960 זה אומר שאין לך בעצם 20 00:01:03,960 --> 00:01:07,020 ליישם שולחן חשיש בחידון 1 שלך. 21 00:01:07,020 --> 00:01:10,250 אנחנו לא מבקשים שתיישמו את שולחן חשיש כולו, אולי ננסה 22 00:01:10,250 --> 00:01:13,090 כדי לגרום לך ליישם כמה פונקציות, 23 00:01:13,090 --> 00:01:16,940 פעולות הנפוצות ביותר, אבל אנחנו לא הולכים לעשות לך ליישם את כל מה. 24 00:01:16,940 --> 00:01:21,010 אז זה חשוב לך להבין את הרעיון מאחורי כל מבנה נתונים 25 00:01:21,010 --> 00:01:23,510 וגם כי אתה יכול לקודד ב-C, 26 00:01:23,510 --> 00:01:27,880 רק פעולות הנפוצות ביותר שיש להם עבור כל מבנה הנתונים. 27 00:01:27,880 --> 00:01:30,090 וגם להיות מסוגל לבדוק את המצביעים וstructs, 28 00:01:30,090 --> 00:01:33,470 כי הם מופיעים הרבה במבני נתונים אלה. 29 00:01:33,470 --> 00:01:37,380 >> ראשית, רשימות מקושרות. רשימות מקושרות הן למעשה דומות מאוד למערכים, 30 00:01:37,380 --> 00:01:39,930 אבל ההבדל בין רשימה מקושרת ומערך, 31 00:01:39,930 --> 00:01:45,160 קודם כל הוא, שיש לו רשימה מקושרת בגודל גמיש מאוד, 32 00:01:45,160 --> 00:01:50,060 בעוד שבמערכים אתה צריך גם לבחור גודל גדול מאוד למערך, 33 00:01:50,060 --> 00:01:53,710 אז אתה יודע שאתה הולך להיות מסוגל לאחסן את כל הנתונים שלך במערך זה, 34 00:01:53,710 --> 00:01:59,370 או שאתה צריך להשתמש malloc יש אורך גמיש של מערך. 35 00:01:59,370 --> 00:02:03,680 ברשימות מקושרות זה קל מאוד רק כדי לקבל יותר אלמנטים, 36 00:02:03,680 --> 00:02:07,210 לשים יותר אלמנטים ברשימה המקושרת או להסיר אלמנטים. 37 00:02:07,210 --> 00:02:09,370 ובעצם, אם אתה לא רוצה הרשימה המקושרת להיות מסודרת, 38 00:02:09,370 --> 00:02:13,950 אתה יכול לחפש ולהסיר את האלמנטים בזמן קבוע, 39 00:02:13,950 --> 00:02:16,800 כך O (1) זמן, כך שזה מאוד נוח. 40 00:02:16,800 --> 00:02:20,660 אתה פשוט צריך להיות זהיר תמיד לזכור malloc ובחינם צמתים, 41 00:02:20,660 --> 00:02:25,510 רק בגלל שאם לא תעשה זאת, תהיה לך דליפות זיכרון. 42 00:02:25,510 --> 00:02:31,480 רשימות קשורות כל כך - ההגדרה של צומת היא בדיוק כמו מה שיש לנו שם. 43 00:02:31,480 --> 00:02:35,110 שמתי n int, אבל אתה יכול לאחסן את כל הנתונים שאתה רוצה. 44 00:02:35,110 --> 00:02:37,280 אז אם אתה רוצה לאחסן מחרוזת, שזה בסדר. 45 00:02:37,280 --> 00:02:41,690 אם ברצונך לאחסן struct, שזה בסדר, כפול, מה שאתה רוצה. 46 00:02:41,690 --> 00:02:44,630 אני פשוט לשים n int לדוגמות כאן. 47 00:02:44,630 --> 00:02:46,800 ויש לך מצביע לצומת הבאה. 48 00:02:46,800 --> 00:02:51,940 אז, בעצם, יש רשימה מקושרת נתונים מסוימים, ולאחר מכן הוא מצביע לצומת הבאה. 49 00:02:51,940 --> 00:02:56,710 אם זה האלמנט האחרון ברשימה המקושרת, זה הולך להצביע על NULL. 50 00:02:56,710 --> 00:02:59,060 אז זו דוגמא לרשימה מקושרת. 51 00:02:59,250 --> 00:03:05,960 >> אוקיי, אז עכשיו בואו נראה מה אנחנו צריכים לעשות אם אני רוצה להכניס אלמנט ברשימה מקושרת. 52 00:03:05,960 --> 00:03:08,810 ראשית, הוספת פונקציה תהיה של חלל הסוג 53 00:03:08,810 --> 00:03:11,350 כי אני לא רוצה לחזור כל דבר. 54 00:03:11,350 --> 00:03:14,200 ואני הולך לקחת int כטיעון, 55 00:03:14,200 --> 00:03:17,090 כי אני רוצה לדעת מה אני רוצה להוסיף. 56 00:03:17,090 --> 00:03:21,840 אז מה הדבר הראשון שאני צריך לעשות? ובכן, אני צריך malloc על newnode, 57 00:03:21,840 --> 00:03:24,240 כך הוא השורה הראשונה. 58 00:03:24,240 --> 00:03:27,580 אני רק יוצר צומת חדש לשים ברשימה מקושרת. 59 00:03:27,580 --> 00:03:32,360 אז מה אני יכול לעשות? ובכן, אנו יודעים כי ביישומים של רשימות מקושרות שלנו 60 00:03:32,360 --> 00:03:38,180 בכיתה, אנחנו תמיד לשים את הראש כמשתנה גלובלית. 61 00:03:38,180 --> 00:03:41,800 אז מה אנחנו יכולים לעשות הוא לשנות את הראש. 62 00:03:41,800 --> 00:03:44,300 אני יכול להפוך את הצומת חדשה זה תהיה הראש החדש, 63 00:03:44,300 --> 00:03:46,670 וזה הולך כך שיצביע על הראש הקודם. 64 00:03:46,670 --> 00:03:50,390 איך אנחנו יכולים לעשות את זה? הדבר הראשון שאני צריך לעשות 65 00:03:50,390 --> 00:03:54,770 הוא לשנות את 'n' בצומת החדשה לערך, 66 00:03:54,770 --> 00:03:57,530 שמועבר לפונקציה. 67 00:03:57,530 --> 00:04:01,050 אז newnode הלאה הולך להיות בראש. 68 00:04:01,050 --> 00:04:05,800 הראש הולך להיות newnode. אז זה די פשוט. 69 00:04:05,800 --> 00:04:10,090 למחיקת צומת, אנחנו יכולים לעשות את זה כמו - 70 00:04:10,090 --> 00:04:14,790 אחת דרכים שאנו יכולים לעשות את זה היא אומר, 71 00:04:14,790 --> 00:04:18,160 בסדר, אם אני רוצה למחוק, למשל, 3, 72 00:04:18,160 --> 00:04:24,850 מה שאני יכול לעשות הוא רק להצביע על הצומת הקודמת 73 00:04:24,850 --> 00:04:27,580 לצומת הבאה של 3. 74 00:04:27,580 --> 00:04:29,400 אז הייתי עושה משהו כזה פשוט. 75 00:04:29,400 --> 00:04:33,400 אבל מה הבעיה עם עושה את זה? 76 00:04:33,400 --> 00:04:37,400 יש לי דליפת זיכרון, ולכן אין לי גישה למספר 3 יותר. 77 00:04:37,400 --> 00:04:42,480 הבעיה עם זה היא שאני לא הולך להיות מסוגל לשחרר את הצומת. 78 00:04:42,480 --> 00:04:45,360 אני הולך יש דליפת זיכרון ו( לא ברורה) הולכת לשנוא אותי. 79 00:04:45,360 --> 00:04:49,370 אז במקום לעשות את זה, צריך כנראה יש לי מצביע זמני. 80 00:04:49,370 --> 00:04:53,210 אז שמתי את טמפ. זה הולך להצביע לקשר שאני רוצה למחוק. 81 00:04:53,210 --> 00:04:58,170 ואז אני יכול להזיז את צמתים הקודמים לנקודה לקשר הבא 82 00:04:58,170 --> 00:05:00,390 של הצומת שאני רוצה למחוק. 83 00:05:00,390 --> 00:05:02,730 ולבסוף, אני יכול לשחרר את המצביע. 84 00:05:02,730 --> 00:05:07,480 האם אני צריך לשחרר את המצביע שאני יצרתי ממש שם? 85 00:05:07,480 --> 00:05:09,560 אין לי, רק בגלל ש-- 86 00:05:09,560 --> 00:05:13,430 ההבדל הוא שצומת זה נוצרה באמצעות malloc, 87 00:05:13,430 --> 00:05:17,280 כך שזה בערימה, ואילו זה היה רק ​​הכריז כמתג NULL בערימה. 88 00:05:17,280 --> 00:05:20,000 אז אני לא צריך לשחרר אותו. 89 00:05:20,000 --> 00:05:22,030 >> אוקיי. אז עכשיו בואו נדבר על ערימות. 90 00:05:22,030 --> 00:05:24,680 ערימות הן די פשוטות. 91 00:05:24,680 --> 00:05:29,540 עשינו את ערימות ותורים בכיתה רק באמצעות מערכים, 92 00:05:29,540 --> 00:05:32,820 אבל אתה צריך להיות מוכר - רק להיות מודע 93 00:05:32,820 --> 00:05:40,740 כי אתה גם יכול לעשות את הערימות בתורים באמצעות רשימות מקושרות גם כן. 94 00:05:40,740 --> 00:05:44,460 אז אם יש לך מערך, מה יהיה ערימה? 95 00:05:44,460 --> 00:05:46,810 מחסנית, ראשונה, תצטרך להיות בגודל. 96 00:05:46,810 --> 00:05:49,950 אתה צריך לאחסן את מה שהוא בגודל של הערימה שיש לך עכשיו. 97 00:05:49,950 --> 00:05:52,980 וגם היית צריך מערך, במקרה זה של מספרים, 98 00:05:52,980 --> 00:05:55,120 אבל אם אתה רוצה, זה יכול להיות מערך 99 00:05:55,120 --> 00:06:00,380 של מחרוזות, מערך של struct, כל דבר שברצונך לאחסן. 100 00:06:00,380 --> 00:06:03,240 על הערימה: ההבדל בין ערימה ורשימה מקושרת 101 00:06:03,240 --> 00:06:08,590 הוא שבמחסנית יש לך רק גישה לאלמנט האחרון שהוכנס למחסנית. 102 00:06:08,590 --> 00:06:11,770 זה נקרא אחרון נכנס, ראשון יוצא. 103 00:06:11,770 --> 00:06:15,090 בדיוק כמו שיש לך ערימה של מגשים, 104 00:06:15,090 --> 00:06:17,670 אם אתה שם את מגש על ראש הערימה, 105 00:06:17,670 --> 00:06:22,670 אתה צריך להסיר את המגש שראשון שיש להם גישה למגשים האחרים. 106 00:06:22,670 --> 00:06:26,310 זה אותו הדבר עם ערימות. 107 00:06:26,310 --> 00:06:31,220 אז אם אני רוצה, למשל, להוסיף אלמנט למחסנית, מה אני צריך לעשות? 108 00:06:31,220 --> 00:06:34,070 זה נקרא לדחוף, וזה די פשוט. 109 00:06:34,070 --> 00:06:37,130 הדבר הראשון שאתה צריך לעשות הוא לבדוק אם הגודל של המחסנית 110 00:06:37,130 --> 00:06:40,150 אינו גדול או שווה לקיבולת של המחסנית. 111 00:06:40,150 --> 00:06:45,810 כי אם אתה כבר בתפוסה מלאה, אתה לא יכול להוסיף עוד משהו. 112 00:06:45,810 --> 00:06:51,140 ולאחר מכן, אם לא, אתה רק צריך להוסיף את האלמנט לערימה. 113 00:06:51,140 --> 00:06:54,530 ולבסוף, להגדיל את הגודל. אז זה די פשוט. 114 00:06:54,530 --> 00:06:57,140 אז אני פשוט להוסיף את המספר 2. 115 00:06:57,140 --> 00:07:00,350 ואם אני רוצה לקפוץ, מה שאומר שאני רוצה להסיר 116 00:07:00,350 --> 00:07:03,870 האלמנט האחרון שנוסף ולהחזיר את הערך של האלמנט, 117 00:07:03,870 --> 00:07:09,180 הדבר הראשון שצריך לבדוק הוא שהמחסנית אינה ריקה. 118 00:07:09,180 --> 00:07:11,510 כי אם זה ריק, אני לא יכול להחזיר כלום. 119 00:07:11,510 --> 00:07:14,820 במקרה כזה, אני מחזיר -1. 120 00:07:14,820 --> 00:07:18,960 אחרת, אני הולך הפחת הגודל של המפרט, 121 00:07:18,960 --> 00:07:22,510 ולחזור מספרים (s.size). 122 00:07:22,510 --> 00:07:27,230 למה אני הפחת הגודל ולאחר מכן לחזור s.size? 123 00:07:27,230 --> 00:07:30,930 זה בגלל, במקרה זה, המפרט יש גודל 4, 124 00:07:30,930 --> 00:07:33,810 ואני רוצה להחזיר את היסוד הרביעי, נכון? 125 00:07:33,810 --> 00:07:36,030 אבל מה הוא המדד של האלמנט הרביעי? שלוש. 126 00:07:36,030 --> 00:07:44,510 מאז אני גודל - הוא הולך להיות 3, אני יכול רק לחזור s.numbers (s.size) 127 00:07:44,510 --> 00:07:48,410 בגלל שזה 3. אז זה רק המדד. 128 00:07:48,410 --> 00:07:50,380 >> עכשיו תורים. תורים הם פחות או יותר את אותו הדבר. 129 00:07:50,380 --> 00:07:54,950 ההבדל היחיד הוא שבמקום שיש אחרון, את הראשון, 130 00:07:54,950 --> 00:07:57,480 יש לך ראשון, את הראשון. 131 00:07:57,480 --> 00:07:59,460 סביר להניח שאם אתה מחכה ללכת לקונצרט, 132 00:07:59,460 --> 00:08:04,260 לא היית שמח אם היה לך ערימה במקום לתור. 133 00:08:04,260 --> 00:08:07,730 להיות האדם האחרון שיבוא יהיה האדם הראשון שנכנס לקונצרט. 134 00:08:07,730 --> 00:08:09,760 אתה כנראה לא יהיה מאושר. 135 00:08:09,760 --> 00:08:15,020 בתור, האדם הראשון כדי לקבל בהוא גם האדם הראשון לצאת. 136 00:08:15,020 --> 00:08:18,720 אז בהגדרה של תור, חוץ מזה שיש את הגודל במערך, 137 00:08:18,720 --> 00:08:23,360 אתה גם צריך שתהיה לי הראש, המהווה את המדד לראש הערימה. 138 00:08:23,360 --> 00:08:29,000 אז האלמנט הראשון עכשיו. 139 00:08:29,000 --> 00:08:32,710 הוסף לתור הוא אותו הדבר כמו לדחוף לערימות. 140 00:08:32,710 --> 00:08:34,980 אם היית נאיביים מאוד, היית אומר רק, 141 00:08:34,980 --> 00:08:39,289 כן, אני יכול פשוט לעשות בדיוק את אותו הדבר כמו שעשיתי לדחיפה. 142 00:08:39,289 --> 00:08:44,030 אני רק יכול לבדוק אם זה לא מעבר ליכולת. 143 00:08:44,030 --> 00:08:48,760 אם כן, אני חוזר שווא, אחרת אני יכול פשוט לייצא את הערך החדש 144 00:08:48,760 --> 00:08:50,630 ולאחר מכן להגדיל את הגודל. 145 00:08:50,630 --> 00:08:52,750 אבל למה זה לא בסדר? 146 00:08:52,750 --> 00:08:55,010 בואו לראות את הדוגמא הזאת. 147 00:08:55,010 --> 00:08:57,020 אני מנסה Enqueue חבורה של דברים, 148 00:08:57,020 --> 00:08:58,390 ולאחר מכן אני הולך dequeue וEnqueue. 149 00:08:58,390 --> 00:09:00,550 יש הרבה פקודות, אבל זה מאוד פשוט. 150 00:09:00,550 --> 00:09:04,790 אני הולך Enqueue 5, אז תוסיף 5, ולאחר מכן 7, 151 00:09:04,790 --> 00:09:09,310 1, 4, 6, ולאחר מכן אני רוצה dequeue משהו, 152 00:09:09,310 --> 00:09:12,000 מה שאומר שאני הולך להסיר את האלמנט הראשון. 153 00:09:12,000 --> 00:09:14,640 אז אני הולך להסיר את המספר 3, נכון? 154 00:09:14,640 --> 00:09:17,320 האלמנט הראשון. אוקיי. 155 00:09:17,320 --> 00:09:21,450 עכשיו, אם אני מנסה Enqueue משהו אחר, מה הולך לקרות? 156 00:09:21,450 --> 00:09:24,290 על פי הביצוע שלי, 157 00:09:24,290 --> 00:09:31,040 אני הולך לשים את המספר הבא בq.size המדד. 158 00:09:31,040 --> 00:09:35,140 במקרה זה, הגודל הוא 8, 159 00:09:35,140 --> 00:09:38,640 כך המדד 8 יהיה ממש כאן בתפקידו האחרון. 160 00:09:38,640 --> 00:09:43,900 אם אני מנסה Enqueue 1 ממש כאן, הייתי להחליף בתפקידו האחרון 161 00:09:43,900 --> 00:09:45,870 למספר 1, שהוא טועה לחלוטין. 162 00:09:45,870 --> 00:09:49,870 מה שאני רוצה לעשות הוא לעטוף ולעבור לעמדה הראשונה. 163 00:09:49,870 --> 00:09:52,870 אולי היית אומר פשוט, טוב, אני רק צריך לבדוק 164 00:09:52,870 --> 00:09:55,600 אם אני באמת יכול לשים שם משהו. 165 00:09:55,600 --> 00:09:58,560 אם לא, אני רק אומר, אה, הקיבולת מלאה החדשה 166 00:09:58,560 --> 00:10:02,010 הוא למעשה יכולת - 1, ואתה לא יכול לשים את אלמנט שם. 167 00:10:02,010 --> 00:10:06,150 אבל מה הבעיה? הבעיה היא שאם אני רק dequeue הכל נכון כאן 168 00:10:06,150 --> 00:10:08,240 ולאחר מכן אני מנסה להוסיף משהו אחר, זה הייתי אומר רק, 169 00:10:08,240 --> 00:10:11,210 טוב, היית במלוא יכולתו, אשר היא 0. 170 00:10:11,210 --> 00:10:13,620 אז התור שלך נעלם. 171 00:10:13,620 --> 00:10:16,990 אתה צריך לעטוף, ודרך של גלישה מסביב 172 00:10:16,990 --> 00:10:22,040 שאתם למדו בחזון והאחר psets השתמשו mod. 173 00:10:22,040 --> 00:10:29,090 אתה יכול לנסות את זה בבית כדי להבין למה היית עושה q.size + q.head 174 00:10:29,090 --> 00:10:31,080 קיבולת mod, אבל אם תבדוק כאן, 175 00:10:31,080 --> 00:10:34,760 אנו יכולים לראות שזה עובד. 176 00:10:34,760 --> 00:10:37,760 אז בדוגמא האחרונה, q.size היו 8 177 00:10:37,760 --> 00:10:47,590 והראש היה 1, כי זה היה תפקיד זה כאן של המערך. 178 00:10:47,590 --> 00:10:51,970 אז זה יהיה 8 + 1, 9. Mod קיבולת 9 תהיה 0. 179 00:10:51,970 --> 00:10:56,640 זה הייתי הולך למדד 0. אנחנו נהיה במצב הנכון. 180 00:10:56,640 --> 00:10:59,750 ולאחר מכן לנסות את התור בבית. 181 00:10:59,750 --> 00:11:04,950 כמה דברים חשובים: לנסות להבין את ההבדל בין ערימה ותור. 182 00:11:04,950 --> 00:11:11,620 בבית, לנסות להשיג מאוד מוכר עם יישום Enqueue, dequeue, לדחוף ופופ. 183 00:11:11,620 --> 00:11:16,560 וגם להבין מתי היית משתמש כל אחד מהם. 184 00:11:16,560 --> 00:11:22,830 >> אז בואו להירגע ל10 שניות עם חבורה של Pokemons. 185 00:11:22,830 --> 00:11:26,080 ועכשיו בואו נחזור למבני נתונים. 186 00:11:26,080 --> 00:11:29,770 חשיש שולחנות. הרבה אנשים פחדו משולחנות חשיש. 187 00:11:29,770 --> 00:11:33,650 בבעיה להגדיר 6, בודק איות. 188 00:11:33,650 --> 00:11:35,980 שולחנות ומנסים חשיש, הרבה אנשים נבהלים מהם. 189 00:11:35,980 --> 00:11:38,540 הם חושבים שהם כל כך קשים להבנה. כן? 190 00:11:38,540 --> 00:11:41,490 [רוב אודן] הבעיה להגדיר 5. >> בעיה להגדיר 5, כן. תודה רוב. 191 00:11:41,490 --> 00:11:43,370 כן. שש היו הף n 'פאף, כן. 192 00:11:43,370 --> 00:11:49,340 בעיה להגדיר 5 היה בודק איות, ואתה הייתי צריך להשתמש גם שולחן חשיש או לנסות. 193 00:11:49,340 --> 00:11:55,360 הרבה אנשים חשבו שהם היו סופר קשים להבנה, אבל הם בעצם די פשוט. 194 00:11:55,360 --> 00:12:01,290 מהו שולחן חשיש, בעצם? שולחן חשיש הוא מערך של רשימות מקושרות. 195 00:12:01,290 --> 00:12:06,730 ההבדל היחיד בין מערך ושולחן חשיש 196 00:12:06,730 --> 00:12:09,730 הוא שבשולחן החשיש יש לך משהו שנקרא פונקצית חשיש. 197 00:12:09,730 --> 00:12:12,080 מה היא פונקצית חשיש? 198 00:12:12,080 --> 00:12:13,970 אני לא יודע אם אתם יכולים לקרוא כאן. 199 00:12:13,970 --> 00:12:16,090 זוהי דוגמא של שולחן חשיש. 200 00:12:16,090 --> 00:12:19,220 אז אתה יכול לראות שיש לך מערך עם 31 באלמנטים. 201 00:12:19,220 --> 00:12:22,440 ומה שאנחנו עושים בשולחן חשיש יש פונקצית חשיש 202 00:12:22,440 --> 00:12:26,660 כי הוא הולך לתרגם מפתח, כל int למדד. 203 00:12:26,660 --> 00:12:31,740 אם, למשל, אם אני רוצה לבחור לB. Harrison, 204 00:12:31,740 --> 00:12:34,190 הייתי שם ב 'הריסון בפונקציות החשיש שלי, 205 00:12:34,190 --> 00:12:36,960 ופונקציית hash תחזור 24. 206 00:12:36,960 --> 00:12:40,930 אז אני יודע שאני רוצה לאחסן ב 'הריסון ב24. 207 00:12:40,930 --> 00:12:46,580 אז זה ההבדל בין סתם מערך ויש להם שולחן חשיש. 208 00:12:46,580 --> 00:12:48,740 בשולחן החשיש תצטרך פונקציה שהולכת לספר לכם 209 00:12:48,740 --> 00:12:54,740 היכן לאחסן את הנתונים שברצונך לאחסן. 210 00:12:54,740 --> 00:12:57,040 לפונקצית החשיש, אתה רוצה לחפש פונקצית חשיש 211 00:12:57,040 --> 00:13:00,600 כי הוא דטרמיניסטי ומופץ היטב. 212 00:13:00,600 --> 00:13:07,810 כפי שאתם יכולים לראות כאן, אתה רואה שהרבה נתונים שאני רוצה חנות היה למעשה 19 213 00:13:07,810 --> 00:13:12,470 במקום להשתמש ביום 31 וב30 ו29, שכולם היו חופשיים. 214 00:13:12,470 --> 00:13:16,920 אז פונקצית החשיש שנהגתי לא הייתה מופצת היטב. 215 00:13:16,920 --> 00:13:20,710 כאשר אנו אומרים מופצים היטב, זה אומר שאנחנו רוצים להיות, 216 00:13:20,710 --> 00:13:26,520 בערך, לפחות 1 או 2 לכל אחד מ-- 217 00:13:26,520 --> 00:13:32,190 כמו, הבדל של 1 או 2 לכל אחד מהמדדים במערכים. 218 00:13:32,190 --> 00:13:43,950 אתה רוצה להיות, פחות או יותר, אותו המספר של אלמנטים בכל רשימה מקושרת במערך. 219 00:13:43,950 --> 00:13:48,600 ואת זה קל לבדוק אם זה חוקי בשולחן החשיש, להציג טבלאות חשיש. 220 00:13:48,600 --> 00:13:51,770 >> אז עצים. זה עץ. 221 00:13:51,770 --> 00:13:56,400 עצים במדעי מחשב הם במהופך מסיבה כלשהי. 222 00:13:56,400 --> 00:14:00,150 אז כאן יש לך את השורש של העץ ולאחר מכן את העלים. 223 00:14:00,150 --> 00:14:05,630 אתה פשוט צריך לדעת את המינוח להורים ולילדים. 224 00:14:05,630 --> 00:14:12,880 יש כל צומת ילדיה, שהם צמתים שנמצאים מתחת להורה. 225 00:14:12,880 --> 00:14:19,660 כך, למשל, 2 הולכים להיות ההורה ל3 ועבור הילד השני ממש שם, 226 00:14:19,660 --> 00:14:25,290 תוך 3 הולכים להיות ההורה ל1 וילדים האחרים שנמצאים שם. 227 00:14:25,290 --> 00:14:29,990 ו1 הולך להיות של 3 ילדים, וכן הלאה. 228 00:14:29,990 --> 00:14:34,610 יש לנו משהו הרבה יותר מעניין, שנקרא עץ חיפוש בינארי, 229 00:14:34,610 --> 00:14:39,040 שבו כל הערכים בצד הימין של צומת 230 00:14:39,040 --> 00:14:41,660 הולך להיות בצד הימין, ממש כאן - בצד הימין, 231 00:14:41,660 --> 00:14:46,780 הולכים להיות גדול יותר מהאלמנט בשורש. 232 00:14:46,780 --> 00:14:49,780 אז אם יש לי המספר 5 ממש כאן, את כל האלמנטים בצד הימין 233 00:14:49,780 --> 00:14:51,940 הולכים להיות גדול מ 5, ועל השמאל 234 00:14:51,940 --> 00:14:56,770 כל האלמנטים הולכים להיות פחות מ 5. 235 00:14:56,770 --> 00:14:58,780 למה זה שימושי? 236 00:14:58,780 --> 00:15:01,660 ובכן, אם אני רוצה לבדוק אם המספר 7 הוא כאן, למשל, 237 00:15:01,660 --> 00:15:05,960 פשוט אני הולך ל5 ראשון ואני הולך לראות, הוא 7 גדול יותר או פחות מ 5? 238 00:15:05,960 --> 00:15:09,540 זה גדול יותר, ולכן אני יודע שזה הולך להיות בצד הימין של העץ. 239 00:15:09,540 --> 00:15:13,980 אז יש לי הרבה פחות דברים להסתכל. 240 00:15:13,980 --> 00:15:19,520 ביישום של עץ חיפוש בינארי, הצומת, אני פשוט אצטרך לקבל נתונים, 241 00:15:19,520 --> 00:15:21,750 כך int n, אתה יכול להיות גם מחרוזת 242 00:15:21,750 --> 00:15:23,630 או כל דבר שאתה רוצה. 243 00:15:23,630 --> 00:15:28,100 אתה פשוט צריך להיות זהיר בהגדרה מה הוא גדול יותר, מה פחות. 244 00:15:28,100 --> 00:15:30,390 אז אם היה לך מחרוזות, לדוגמא, אתה יכול להגדיר 245 00:15:30,390 --> 00:15:34,690 כי את כל הדברים האלה בצד הימין הולכים להיות באורך גדול יותר, 246 00:15:34,690 --> 00:15:40,940 השמאל הולך להיות אורכים נמוכים יותר, כך שזה באמת תלוי בך. 247 00:15:40,940 --> 00:15:44,930 >> איך אני יכול לממש למצוא עבור BST? 248 00:15:44,930 --> 00:15:47,840 הדבר הראשון שנצטרך לעשות הוא לבדוק אם השורש הוא NULL. 249 00:15:47,840 --> 00:15:50,920 אם זה NULL, זה אומר שהדבר הוא לא שם 250 00:15:50,920 --> 00:15:53,330 משום שאפילו אין לך עץ, נכון? 251 00:15:53,330 --> 00:15:55,790 אז אני חוזר שווא. 252 00:15:55,790 --> 00:15:58,740 אחרת, אני הולך לבדוק אם המספר הוא גדול יותר 253 00:15:58,740 --> 00:16:01,720 מהערך בשורש. 254 00:16:01,720 --> 00:16:04,250 אני הולך לנסות למצוא את האלמנט בצד הימין 255 00:16:04,250 --> 00:16:08,590 של העץ. 256 00:16:08,590 --> 00:16:11,310 אתה רואה שאני משתמש ברקורסיה כאן. 257 00:16:11,310 --> 00:16:14,150 ואז אם זה פחות, אני הולך להסתכל על צד שמאל. 258 00:16:14,150 --> 00:16:18,330 ולבסוף, בדרך אחרת, אם זה לא פחות או לא יותר, 259 00:16:18,330 --> 00:16:20,660 זה אומר שזה הערך עצמו. 260 00:16:20,660 --> 00:16:23,010 אז אני רק החזר אמיתי. 261 00:16:23,010 --> 00:16:26,360 אתם יכולים לראות כאן, כי אני משמש אם, אם, אם. 262 00:16:26,360 --> 00:16:30,820 ותזכור, בחידון 0, היה לנו בעיה שהייתה לי אם, אם, אם, 263 00:16:30,820 --> 00:16:32,780 ושהייתם אמור למצוא את חוסר היעילות, 264 00:16:32,780 --> 00:16:35,180 וחוסר היעילות שבה השתמש היה אם. 265 00:16:35,180 --> 00:16:39,060 היית צריכים להשתמש בו אם, אם אחר, אם אחר, ועוד. 266 00:16:39,060 --> 00:16:44,240 אז, אני צריך להשתמש אחר אם ואם אחר ואחר כאן? 267 00:16:44,240 --> 00:16:46,200 האם מישהו - כן? 268 00:16:46,200 --> 00:16:51,140 [מתייחס לסטודנט, לא נשמע] 269 00:16:51,140 --> 00:16:53,480 זה מצוין. אז היא אומרת שזה לא משנה, 270 00:16:53,480 --> 00:16:55,930 רק בגלל חוסר היעילות שהייתה לנו קודם 271 00:16:55,930 --> 00:16:59,550 זה היה בגלל, אולי אם כמה מצב היה מרוצה, 272 00:16:59,550 --> 00:17:03,570 כך שאתה ביצעת פעולה כלשהי, אבל אז אתה הולך לבדוק את כל התנאים האחרים. 273 00:17:03,570 --> 00:17:06,319 אבל במקרה הזה, זה חזר מייד, אז זה לא משנה. 274 00:17:06,319 --> 00:17:09,220 אז אתה לא צריך להשתמש אחר אם. 275 00:17:09,220 --> 00:17:11,740 >> ולבסוף, בואו נדבר על ניסיונות, 276 00:17:11,740 --> 00:17:13,800 שהוא אהוב על כולם. 277 00:17:13,800 --> 00:17:15,980 ניסיון הוא עץ של מערכים. 278 00:17:15,980 --> 00:17:20,369 זה מהר מאוד כדי לחפש את ערכים, אבל הוא משתמש בהרבה זיכרון. 279 00:17:20,369 --> 00:17:22,530 וזה בדרך כלל כדי לסנן מילות, ולכן כאשר אתה 280 00:17:22,530 --> 00:17:27,920 רוצה ליישם, למשל, אני לא יודע, כמו ספר טלפונים בטלפון שלך 281 00:17:27,920 --> 00:17:30,440 ואתה רוצה להיות מסוגל להקליד B 282 00:17:30,440 --> 00:17:32,510 ורק צריכים שמות של אנשים שיש להם ב ' 283 00:17:32,510 --> 00:17:37,960 זה קל מאוד ליישום שבאמצעותו לנסות, למשל. 284 00:17:37,960 --> 00:17:39,820 איך אתה מגדיר את צומת בלנסות? 285 00:17:39,820 --> 00:17:43,910 אתה פשוט צריך שתהיה לי bool שהוא הולך להיות is_word. 286 00:17:43,910 --> 00:17:48,660 המייצג כי באמצעות כל הדמויות לפני הצומת כי, 287 00:17:48,660 --> 00:17:51,920 היית מסוגל ליצור מילה, 288 00:17:51,920 --> 00:17:57,230 ואז יהיה לך מערך של מצביעים לצומת. 289 00:17:57,230 --> 00:18:03,120 האם אתה יכול לראות שיש לנו מערך של בלוטות להורה, ולכן צומת מערך *? כן? 290 00:18:03,120 --> 00:18:06,050 אז בואו לראות איך זה יעבוד. לבדיקת האיות, 291 00:18:06,050 --> 00:18:08,230 יש לנו מערך של 27 אלמנטים, 292 00:18:08,230 --> 00:18:12,150 כי יש לנו את כל האותיות בתוספת הגרש. 293 00:18:12,150 --> 00:18:17,800 לפני כאן אני רק הולך להשתמש 2 כי אני רוצה להיות מסוגל לכתוב על הלוח. 294 00:18:17,800 --> 00:18:20,230 אוקיי. אז זו דוגמא לניסיון. 295 00:18:20,230 --> 00:18:25,600 אם אני רק להגדיר את הצומת הראשונה, יהיה לי מערך של 2 אלמנטים 296 00:18:25,600 --> 00:18:29,290 כי הם 2 מצביעים ל NULL, אז אני פשוט שמתי '' ו 'ב'. 297 00:18:29,290 --> 00:18:32,430 ואני הולך לי bool שאומר is_word. 298 00:18:32,430 --> 00:18:34,420 זה הולך להיות שווא לראשון, 299 00:18:34,420 --> 00:18:37,370 רק בגלל, לפני שאתה לא צריך את כל תווים. 300 00:18:37,370 --> 00:18:40,900 אז מילה ריקה היא לא מילה. אז זה שקר. 301 00:18:40,900 --> 00:18:46,320 אם אני רוצה להוסיף "" למילון זה, מה הייתי צריך לעשות? 302 00:18:46,320 --> 00:18:49,760 הייתי רק צריך malloc צומת חדשה עבור '", 303 00:18:49,760 --> 00:18:54,630 ולאחר מכן להוסיף את המילה שלה לנכון. 304 00:18:54,630 --> 00:19:00,180 אז זה פשוט מייצג כי לאחר ש''הולך להיות אמיתי. הגיוני? 305 00:19:00,180 --> 00:19:04,120 אז אם אני רוצה להוסיף "תואר ראשון", אני אצטרך malloc 1 עבור 'ב', 306 00:19:04,120 --> 00:19:07,550 ולאחר מכן אני הולך להגדיר את בוליאני לכוזב, 307 00:19:07,550 --> 00:19:10,160 כי 'ב' על ידי עצמו הוא לא מילה. 308 00:19:10,160 --> 00:19:13,010 ואז אני הולך malloc עוד אחד עבור 'a', ולכן 'תואר ראשון', 309 00:19:13,010 --> 00:19:16,290 ולאחר מכן אני הולך להגדיר את זה מילה נכונה. 310 00:19:16,290 --> 00:19:18,950 בגלל 'תואר ראשון' הוא מילה. 311 00:19:18,950 --> 00:19:21,910 ואז אם אני רוצה לראות אם 'ב' הוא במילון זה, 312 00:19:21,910 --> 00:19:26,730 אני רק יכול ללכת ראשון, 'ב'. אני יורד, ואני מסתכל על זה מילה, וזה אומר שקר. 313 00:19:26,730 --> 00:19:30,110 אז זה לא מילה. אם אני רוצה לבדוק 'תואר ראשון', 314 00:19:30,110 --> 00:19:38,010 אני הולך לראשון, 'ב', ולאחר מכן ללכת '', ואני רואה נכון, אז זה מילה. הגיוני? 315 00:19:38,010 --> 00:19:41,950 הרבה אנשים מתבלבלים מנסה. לא? 316 00:19:41,950 --> 00:19:44,740 >> לבסוף, האפמן קידוד. קידוד האפמן הוא מאוד שימושי 317 00:19:44,740 --> 00:19:47,550 כדי לחסוך בזיכרון ולדחוס את קבצי טקסט, 318 00:19:47,550 --> 00:19:52,270 רק בגלל שהרבה פעמים אתה משתמש '' ו 'דואר', למשל, 319 00:19:52,270 --> 00:19:57,710 במסמכים שלך, אבל אני לא יודע אם אתם משתמשים 'ש' או 'Z' באותה מידה. 320 00:19:57,710 --> 00:20:02,040 יש רק 1 בתים עבור כל תו בודד, 321 00:20:02,040 --> 00:20:08,520 כל - 256 הדמויות שיש לנו בטבלת ASCII היא לא מאוד אופטימליות, 322 00:20:08,520 --> 00:20:11,410 רק בגלל שיש כמה דמויות שאתה משתמש בהרבה יותר, 323 00:20:11,410 --> 00:20:15,180 אז אתה כנראה צריך להשתמש בפחות זיכרון לזכרם. 324 00:20:15,180 --> 00:20:17,560 כיצד ניתן להשתמש בקידוד האפמן? 325 00:20:17,560 --> 00:20:20,010 אנחנו חייבים לעשות את עץ האפמן. 326 00:20:20,010 --> 00:20:23,370  יש עץ האפמן צמתים 327 00:20:23,370 --> 00:20:27,760 שיש להם סמל, כי הוא הולך להיות כמו, 'a', 'b', 'c', המכתב, 328 00:20:27,760 --> 00:20:32,990 כל מה שיש לך מכתב, תדר שהוא התדר שהמילה מופיעה בטקסט, 329 00:20:32,990 --> 00:20:36,280 שאתה יוצר את עץ האפמן ל, 330 00:20:36,280 --> 00:20:41,800 ולאחר מכן צומת כי הוא הולך להצביע לשמאל לעץ האפמן 331 00:20:41,800 --> 00:20:47,210 וצומת אחרת כי הוא הולך להצביע לימין. אז בדיוק כמו עץ. 332 00:20:47,210 --> 00:20:49,440 איך לבנות עץ האפמן? 333 00:20:49,440 --> 00:20:54,020 אתה הולך לבחור את 2 צמתים שיש להם את התדרים הנמוכים ביותר. 334 00:20:54,020 --> 00:20:56,490 אם יש לך עניבה שאתה הולך לבחור את 2 צמתים 335 00:20:56,490 --> 00:20:59,870 שיש להם ערכי ASCII הנמוכים ביותר גם כן. 336 00:20:59,870 --> 00:21:02,420 ואז אתה הולך ליצור עץ חדש מתוך 2 צמתים אלה 337 00:21:02,420 --> 00:21:08,030 שהוא הולך להיות בתדירות המשולבת בצומת האב. 338 00:21:08,030 --> 00:21:13,240 ואז אתה הולך להוציא את הילדים 2 מן היער 339 00:21:13,240 --> 00:21:15,570 ולהחליף אותם עם ההורה. 340 00:21:15,570 --> 00:21:18,930 ואתה הולך לחזור על זה עד שיש לך רק 1 עץ ביער. 341 00:21:18,930 --> 00:21:23,840 אז בואו נראה איך היית עושה את עץ האפמן לZAMYLA. 342 00:21:23,840 --> 00:21:29,220 אתם יכולים לראות כאן, כי יש את כל האותיות בתדר 1 למעט ''; שיש תדירות 2. 343 00:21:29,220 --> 00:21:34,090 אז אני יצרתי את צמתים לכל האותיות שמתי במטרה של ערך ASCII ותדר. 344 00:21:34,090 --> 00:21:40,090 אז אם אני רוצה ליצור את העץ הראשון, זה יהיה עם 'L' ו 'ק'. 345 00:21:40,090 --> 00:21:43,100 אז זה כאן. התדירות של הזוג תהיה 2 346 00:21:43,100 --> 00:21:49,470 כי זה 1 + 1, ולאחר מכן 2 הבאים עם התדרים הנמוכים ביותר הם 'Y' ו 'Z'. 347 00:21:49,470 --> 00:21:53,180 ואז יש לי את כולם להיות - להיות בתדר של 2. 348 00:21:53,180 --> 00:22:00,470 אז אילו הם אלה שיש לי ערך ASCII הנמוך ביותר לצד אחד? 349 00:22:00,470 --> 00:22:04,830 '' ו 'L'. אז אני יוצר צומת החדש, 350 00:22:04,830 --> 00:22:09,930 ולבסוף, זה 4 ו 2, אז 2 הולך להיות בצד השמאל. 351 00:22:09,930 --> 00:22:12,430 וזה עץ האפמן. 352 00:22:12,430 --> 00:22:16,060 אז אם אני רוצה לכתוב טקסט כלשהו, 353 00:22:16,060 --> 00:22:24,440 כמו בינארי להמיר לטקסט, תוך שימוש בעץ האפמן הוא קל מאוד. 354 00:22:24,440 --> 00:22:30,220 לדוגמא, אם אני אומר שנע שמאלה הוא 0 ונע לימין הוא 1, 355 00:22:30,220 --> 00:22:32,410 מה שהולך לייצג? 356 00:22:32,410 --> 00:22:35,530 אז כמו 1, 1, כל כך בסדר, בסדר, 357 00:22:35,530 --> 00:22:40,370 ולאחר מכן 0, ולכן עזבו את יהיו L, ולאחר מכן 1, 0, 0. 358 00:22:40,370 --> 00:22:43,950 אז 1, 0, כל כך פשוט 1, 0, 'A'. 359 00:22:43,950 --> 00:22:47,540 ואז 0, 1, ולכן "Z". 360 00:22:47,540 --> 00:22:52,170 ולאחר מכן 1, 0, 0 - לא. 361 00:22:52,170 --> 00:22:56,780 0, 0 יהיו 'Y', כל כך עצלנים. 362 00:22:56,780 --> 00:23:06,060 אז זה הכל בשבילי, רוב של הולך להשתלט על. 363 00:23:06,060 --> 00:23:08,400 >> [רוב אודן] לכן, בשבוע 7 דברים. 364 00:23:08,400 --> 00:23:11,390 יש לנו הרבה לעבור על ממש מהר. 365 00:23:11,390 --> 00:23:13,430 מפעילי bitwise, גלישת מאגר, 366 00:23:13,430 --> 00:23:16,760 ספריית CS50, ולאחר מכן ה-HTML, HTTP, CSS. 367 00:23:16,760 --> 00:23:20,990 בסך כמו 15-20 דקות. 368 00:23:20,990 --> 00:23:24,330 מפעילי bitwise. ישנן 6 מהם, כי אתה צריך לדעת. 369 00:23:24,330 --> 00:23:31,200 ביטים ו, ​​ביטים או, XOR, משמרת עזבה, שינוי תקין, ולא. 370 00:23:31,200 --> 00:23:35,420 נכון לעבור ולא אתה בקושי ראית בהרצאה בכלל. 371 00:23:35,420 --> 00:23:40,480 אנחנו נלך עליו במהירות לכאן, אבל זה טוב לדעת כי אלו הם 6 שקיימים. 372 00:23:40,480 --> 00:23:45,070 זכור כי מפעילי bitwise הם כמו כשאתה עושה 3 + 4. 373 00:23:45,070 --> 00:23:49,420 אתה לא עוסק בינארי של 3 ו -4. 374 00:23:49,420 --> 00:23:56,550 עם מפעילי bitwise אתה בעצם התמודדות עם פיסות בודדות של המספרים 3 ו -4. 375 00:23:56,550 --> 00:23:59,120 >> אז הראשון שנגיד הוא bitwise לא, 376 00:23:59,120 --> 00:24:02,340 וכל שהיא עושה הוא להפוך את כל החלקים. 377 00:24:02,340 --> 00:24:05,500 אז הנה, אם אתה כותב את זה ב-C, לא היית כותב את זה 378 00:24:05,500 --> 00:24:09,380 כמו ~ 11011 או מה שלא, היית רוצה לכתוב את זה ~ 4, 379 00:24:09,380 --> 00:24:12,970 ואז זה יהיה להעיף את הייצוג בינארי של 4. 380 00:24:12,970 --> 00:24:24,800 אז הנה, ~ של חלק מספר בינארי 1101101 הולכים להעיף בדיוק כל 1 של 0 של וכל 0 עד 1 של. 381 00:24:24,800 --> 00:24:27,600 כמו שאני אומר שם, השימוש התכוף בזה, 382 00:24:27,600 --> 00:24:30,830 ואנו רואים אותו בקצת, זה כמו שאנחנו רוצים לבוא עם כמה מספר 383 00:24:30,830 --> 00:24:35,460 שבו כל הביטים הם 1, פרט לאחד מהם. 384 00:24:35,460 --> 00:24:38,560 אז זה בדרך כלל קל יותר לבטא את המספר 385 00:24:38,560 --> 00:24:40,630 שבו רק כי קצת בודד מוגדר, 386 00:24:40,630 --> 00:24:44,650 ולאחר מכן לקחת ~ שלו, ולכן כל פיסה אחרת מוגדר פרט לזה. 387 00:24:44,650 --> 00:24:50,300 אז זה מה שאנחנו הולכים להשתמש יותר במעט. 388 00:24:50,300 --> 00:24:58,220 >> Bitwise או. הנה 2 מספרי בינאריים, ו 2 המספרים האלה 389 00:24:58,220 --> 00:25:00,780 די מייצג, כיוון שהם מייצגים בכל אפשריים 390 00:25:00,780 --> 00:25:07,290 שילוב של ביטים שאתה יכול צריך לפעול הלאה. 391 00:25:07,290 --> 00:25:13,540 הנה, כשאני or'd כל קצת, אנחנו רק הולכים להשוות ישר למטה. 392 00:25:13,540 --> 00:25:15,410 אז בצד השמאל יש לנו 1 ו 1. 393 00:25:15,410 --> 00:25:20,510 כשBitwise | אלה, מה אני הולך לקבל? אחד. 394 00:25:20,510 --> 00:25:25,320 אז Bitwise | 0 ו -1 הוא הולכים לתת לי? אחד. 395 00:25:25,320 --> 00:25:27,840 Bitwise 1 ו 0 הולכים להיות אותו דבר, אחד. 396 00:25:27,840 --> 00:25:31,880 Bitwise 0 | 0 הוא הולך לתת לי 0. 397 00:25:31,880 --> 00:25:37,300 אז המקרה היחיד שבו אני מקבל 0 הוא ב0 | 0 מקרה. 398 00:25:37,300 --> 00:25:40,020 ואתה יכול לחשוב על זה בדיוק כמו ORS הלוגי שלך. 399 00:25:40,020 --> 00:25:44,830 אז אם אתה חושב על 1 אמיתי וכ0 ככוזבים, אותו הדבר חל כאן. 400 00:25:44,830 --> 00:25:50,040 כל כך נכון או אמיתי הוא אמיתי; אמת או שקר היא אמת. 401 00:25:50,040 --> 00:25:57,150 שקר או אמת נכונה; שווא או שקר הוא הדבר היחיד שבעצם מזויף. 402 00:25:57,150 --> 00:26:00,100 הנה הדוגמא שאתם צריכים לדעת 403 00:26:00,100 --> 00:26:05,160 כדוגמא די טובה כאשר מפעילי bitwise משמשים. 404 00:26:05,160 --> 00:26:08,660 הנה אם אנחנו או 'A' עם ההון Ox20, 405 00:26:08,660 --> 00:26:11,830 ואנו מסתכלים על אלה בשניים, אנחנו מקבלים משהו. 406 00:26:11,830 --> 00:26:16,020 ואם אנחנו או אותיות קטנות "עם Ox20, אנחנו מקבלים משהו. 407 00:26:16,020 --> 00:26:26,750 אז בואו להרים את טבלת ASCII. 408 00:26:26,750 --> 00:26:34,000 אוקיי. כאן אנו רואים כי א 'הוא - 409 00:26:34,000 --> 00:26:36,920 כאן יש לנו '' הוא עשרוני 65. 410 00:26:36,920 --> 00:26:45,120 אבל אני אלך עם הקסדצימלי, שהוא Ox41. 411 00:26:45,120 --> 00:26:48,280 די בטוח שראינו אותו בכיתה. אני חושב שראינו את זה בכיתה 412 00:26:48,280 --> 00:26:52,730 שזה די קל להמיר מהקסדצימלי לינארי. 413 00:26:52,730 --> 00:26:55,280 אז הנה, אם אני רוצה לשים 4 לינארי, 414 00:26:55,280 --> 00:26:59,550 זה רק הולך להיות 0100. 415 00:26:59,550 --> 00:27:03,620 זה המקום של 1, 2 של מקום, מקום של 4, אז זה 4. 416 00:27:03,620 --> 00:27:08,550 ואז אני יכול לפצל 1 לינארי, שהולך להיות 0001. 417 00:27:08,550 --> 00:27:14,280 וכך זה הולך להיות הייצוג של 'A' בינארי. 418 00:27:14,280 --> 00:27:22,720 אם ניקח אותיות קטנות ', עכשיו זה הולך להיות Ox61, 419 00:27:22,720 --> 00:27:27,050 שבו, פיצול אלה עד לינארי שלה, ולכן 6 - 420 00:27:27,050 --> 00:27:37,830 בואו באמת עושים את זה - שאין מחק? מחק. 421 00:27:37,830 --> 00:27:48,220 Ox61. אז פיצול 6 לינארי הולך להיות 0 + 4 + 2 + 0. 422 00:27:48,220 --> 00:27:54,610 ופיצול 1 הולך להיות 0001. 423 00:27:54,610 --> 00:27:56,520 כאשר מסתכל על ההבדל בין 2 אלה, 424 00:27:56,520 --> 00:28:04,250 אנו רואים כי ההבדל היחיד בין אותיות קטנות ו''הון הוא קצת הבודד הזה. 425 00:28:04,250 --> 00:28:11,810 אז חוזר לכאן - בסדר. 426 00:28:11,810 --> 00:28:15,920 חוזר לכאן, אם אנחנו מסתכלים על מה שהוא קצת Ox20, 427 00:28:15,920 --> 00:28:22,210 Ox20 כך פיצול לינארי שלו, 428 00:28:22,210 --> 00:28:27,310 הוא 0010, 0000. 429 00:28:27,310 --> 00:28:33,470 Ox20, קצת היחידים שמוגדרת הוא קצת זה שאנו עוסקים, 430 00:28:33,470 --> 00:28:38,210 עם מעבר בין ההון ואותיות קטנות ". 431 00:28:38,210 --> 00:28:47,610 אם אני או 'A', שהוא זה, 'A', 432 00:28:47,610 --> 00:28:50,580 אם אני או 'A' עם Ox20, 433 00:28:50,580 --> 00:28:53,490 מה שאני הולך לקבל? 434 00:28:53,490 --> 00:28:58,960 [סטודנטים, לא נשמע] >> '' האותיות הקטנות, כי זה הולך להעיף את זה קצת ל1. 435 00:28:58,960 --> 00:29:04,170 ואם אני או '' עם Ox20, מה אני הולך לקבל? 436 00:29:04,170 --> 00:29:08,780 אותיות קטנות, כי רק oring '' עם Ox20, 437 00:29:08,780 --> 00:29:14,580 אני רק הולך להיות oring קצת בודד זה ל1, זה כבר 1, כך שזה לא משנה. 438 00:29:14,580 --> 00:29:17,960 אז אנחנו מקבלים '' ו ''. 439 00:29:17,960 --> 00:29:24,820 >> Bitwise ו. שוב, אנחנו יכולים לחשוב על זה כמקבילו הלוגי ושלנו. 440 00:29:24,820 --> 00:29:28,180 בצד השמאל יש לנו נכון ואמיתי. 441 00:29:28,180 --> 00:29:31,160 זה הולך להיות אמיתי, ולכל אחד מהמקרים, 442 00:29:31,160 --> 00:29:36,270 שקר ואמת או אמיתי וכוזב, או שקרי וכוזב, 443 00:29:36,270 --> 00:29:38,550 אף אחד מהדברים האלה הם אמיתיים. 444 00:29:38,550 --> 00:29:44,170 אז מה אנחנו בסופו של דבר מקבלים הוא 1,000. 445 00:29:44,170 --> 00:29:48,830 אז עכשיו, כאן, כאן מקום שבו אני השתמשתי bitwise אמין לא, 446 00:29:48,830 --> 00:29:52,230 שם היה לנו Ox20. 447 00:29:52,230 --> 00:29:54,350 אז זה Ox20. 448 00:29:54,350 --> 00:29:59,570 עכשיו מה שאני רוצה לעשות, ביטים ~ של Ox20. 449 00:29:59,570 --> 00:30:03,600 כי הוא הולך להעיף את כל החלקים. 450 00:30:03,600 --> 00:30:09,330 אז יש לי 1101, 1111. 451 00:30:09,330 --> 00:30:18,940 וכך '"anded עם ~ Ox20 הוא הולך לתת לי את מה? 452 00:30:18,940 --> 00:30:22,430 קצת רק אנחנו באמת צריכים לחשוב עליו הוא זה, 453 00:30:22,430 --> 00:30:26,020 שכן, אם כל הביטים הללו הוגדרו 1, 454 00:30:26,020 --> 00:30:29,000 אז אנחנו הולכים לקבל בדיוק את מה '"היה, 455 00:30:29,000 --> 00:30:31,260 למעט, אולי, מה זה קצת. 456 00:30:31,260 --> 00:30:34,460 כי אם זה היה 1, עכשיו זה הולך להיות מוגדר 0, 457 00:30:34,460 --> 00:30:39,810 כי מה זה, anded עם זה הולך להיות 0. 458 00:30:39,810 --> 00:30:43,280 אז מה הוא "'& ~ Ox20 הולך לתת לי? 459 00:30:43,280 --> 00:30:48,200 [סטודנטים לענות, לא נשמע] >> ומה הוא '' ו-- זה '". 460 00:30:48,200 --> 00:30:52,170 ומה הוא '' Ox20 & ~ הולך לתת לי? 461 00:30:52,170 --> 00:30:56,720 'א' בגלל זה הוא כרגע 1. 462 00:30:56,720 --> 00:30:59,570 Anding עם 0 זה הולך להפוך אותו 0, 463 00:30:59,570 --> 00:31:02,530 ועכשיו אנחנו הולכים לקבל "A". 464 00:31:02,530 --> 00:31:06,600 >> שניהם ',' ואחרון חביב מסוג זה, 465 00:31:06,600 --> 00:31:10,830 יש לנו XOR. זה דומה מאוד או, 466 00:31:10,830 --> 00:31:14,400 מלבד זה אומר באופן בלעדי או. 467 00:31:14,400 --> 00:31:18,420 זה כמו מה שאתה בדרך כלל חושב על כאו בעולם האמיתי. 468 00:31:18,420 --> 00:31:23,190 אז אתה עושה או 'x' או 'y', אבל לא שניהם. 469 00:31:23,190 --> 00:31:28,700 כאן 1 ^ 1 הולך להיות 0. 470 00:31:28,700 --> 00:31:33,650 מכיוון שזה נכון, זה הוא - זה לא עובד, כמו גם עם לוגי האמת ושקר 471 00:31:33,650 --> 00:31:37,150 כביטים ואו לעשות, 472 00:31:37,150 --> 00:31:40,100 אבל נכון ^ אמיתי הוא כוזב. 473 00:31:40,100 --> 00:31:44,810 מכיוון שאנחנו רק רוצים לחזור נכון אם רק אחד מהם הוא נכונים. 474 00:31:44,810 --> 00:31:50,950 אז 1 ^ 1 הוא 0. מה עם 0 ^ 1? 475 00:31:50,950 --> 00:31:56,010 האם 1. 1 ^ 0 הוא 1, 0 ^ 0 הוא 0. 476 00:31:56,010 --> 00:32:03,890 אז בכל הנסיבות, 0 bitwise משהו 0 הולך להיות 0. 477 00:32:03,890 --> 00:32:10,270 1 bitwise משהו 0 או 0 ביטים 1, 478 00:32:10,270 --> 00:32:14,660 אם זה | או ^, זה יהיה 1, ואם זה וזה יהיה 0. 479 00:32:14,660 --> 00:32:20,850 והמקרה היחיד שבו ביטים 1 1 אינו 1 הוא עם או בלעדי. 480 00:32:20,850 --> 00:32:24,580 זה 0110. 481 00:32:24,580 --> 00:32:36,520 אז הנה עכשיו, באמצעות XOR - אז אנחנו שוב ב20. 482 00:32:36,520 --> 00:32:43,480 '' ^ Ox20 הוא 2 הביטים האלה אנחנו משווים. 483 00:32:43,480 --> 00:32:50,020 אז 1 ^ 0 הוא הולך לתת לי את מה? אחד. 484 00:32:50,020 --> 00:32:58,430 '' ^ Ox20 הוא הולך לתת לי? אותיות קטנות. 485 00:32:58,430 --> 00:33:04,010 '' ^ Ox20 הוא הולך לתת לי? א הון 486 00:33:04,010 --> 00:33:09,310 כי מה שזה עושה, זה XORing עם Ox20 487 00:33:09,310 --> 00:33:15,380 הוא מרפרף ביעילות כל מה שקצת זה. 488 00:33:15,380 --> 00:33:21,240 אם זה 0, עכשיו זה הולך להיות 1. 489 00:33:21,240 --> 00:33:26,160 מכיוון שמדובר ב1, 1 ^ 1 הוא 0. 490 00:33:26,160 --> 00:33:33,280 אז '' הפך '' ו '' שלנו הפך '". 491 00:33:33,280 --> 00:33:36,910 אז XOR הוא דרך ממש נוחה רק מרפרף המקרה. 492 00:33:36,910 --> 00:33:39,960 אתה רק רוצה לחזר על מחרוזת של אותיות 493 00:33:39,960 --> 00:33:44,330 וחלופי במקרה של כל דמות ודמות, 494 00:33:44,330 --> 00:33:50,680 אתה פשוט כל מה XOR עם Ox20. 495 00:33:50,680 --> 00:33:55,220 >> עכשיו שנשארנו לנו במשמרות. משמרת נותרת היא פשוט, הולכת בעצם, 496 00:33:55,220 --> 00:34:01,250 לדחוף את כל המספרים ל, או לשמאל, ולהכניס 0 של מאחוריהם. 497 00:34:01,250 --> 00:34:05,550 אז הנה יש לנו 00,001,101. 498 00:34:05,550 --> 00:34:08,560 אנחנו הולכים לדחוף 3 ב0 מהימין, 499 00:34:08,560 --> 00:34:13,580 ואנחנו מקבלים 01,101,000. 500 00:34:13,580 --> 00:34:16,380 במונחי nonbinary, 501 00:34:16,380 --> 00:34:24,699 אנחנו רואים שזה באמת התמודדות 13 עם 3-השתנה שמאל, שנותן לנו 104. 502 00:34:24,699 --> 00:34:32,530 הסטה אז שמאל, שאנו רואים כאן, x << y הוא בעצם x * 2 ^ y. 503 00:34:32,530 --> 00:34:40,139 13 * 2 ^ 3, 2 ^ 3 הוא 8, ולכן 13 * 8 הוא 104. 504 00:34:40,139 --> 00:34:45,679 אם אתה רק חושב על ינארי באופן כללי, איך כל ספרה, 505 00:34:45,679 --> 00:34:49,530 אם תתחילו מימין, זה מקום של 1, ולאחר מכן של 2 מקום, אז המקום של 4. 506 00:34:49,530 --> 00:34:51,330 אז על ידי דחיפה ב0 מימין, 507 00:34:51,330 --> 00:34:55,080 אנחנו פשוט דוחפים דברים שלא היו במקום של 4 למקום של 8, 508 00:34:55,080 --> 00:34:57,920 ודברים שהיו במקום של 8 למקום של 16. 509 00:34:57,920 --> 00:35:01,280 כל משמרת רק מכפילה פי 2. כן? 510 00:35:01,280 --> 00:35:05,210 [סטודנטים] מה קורה אם אתה מוזז על ידי 5? 511 00:35:05,210 --> 00:35:10,790 [אודן] אם אתה מוזז על ידי 5 אתה תאבד רק ספרות. 512 00:35:10,790 --> 00:35:15,410 באופן בלתי נמנע, זה אותו הדבר. כמו, מספרים שלמים הם רק 32 ביטים, 513 00:35:15,410 --> 00:35:20,750 כך שאם אתה מוסיף 2 מספרים שלמים גדולים באמת, זה פשוט לא מתאים במספר שלם. 514 00:35:20,750 --> 00:35:23,660 אז זה אותו הדבר כאן. אם אתה מוזז על ידי 5, 515 00:35:23,660 --> 00:35:25,650 נאבד כי אחד פשוט. 516 00:35:25,650 --> 00:35:28,820 וזה סוג של מה שאני מתכוון "בערך", 517 00:35:28,820 --> 00:35:37,470 שבו אם אתה משמרת רחוק מדי, אתה מאבד את הביטים. 518 00:35:37,470 --> 00:35:39,830 >> המשמרת ימנית הולכת להיות הפוך, 519 00:35:39,830 --> 00:35:43,090 לאן אנחנו הולכים לדחוף 0 את הסוף, 520 00:35:43,090 --> 00:35:48,400 ולענייננו, למלא ב0 מהשמאל. 521 00:35:48,400 --> 00:35:52,910 אז עושה את זה, אנחנו בעצם היפוך מה שכבר נעשו. 522 00:35:52,910 --> 00:35:57,780 ואנו רואים כי שלושת 0 בצד הימין יש להם רק נפלו, 523 00:35:57,780 --> 00:36:02,020 ויש לנו דחפתי 1101 כל הדרך לצד ימין. 524 00:36:02,020 --> 00:36:08,380 זה עושה 104 >> 3, שהוא, למעשה, x / 2 ^ y. 525 00:36:08,380 --> 00:36:11,200 אז עכשיו, הנה, זה רעיון דומה. 526 00:36:11,200 --> 00:36:18,720 למה זה רק בערך x / 2 ^ y, ולא ממש x / 2 ^ y? 527 00:36:18,720 --> 00:36:22,240 כי אם הייתי מוזז על ידי 4, הייתי מאבד 1. 528 00:36:22,240 --> 00:36:25,950 בעיקרון, מה שאתה חושב, רק לחשוב על חלוקה של מספרים שלמים באופן כללי. 529 00:36:25,950 --> 00:36:31,070 אז, כמו 5/2 הוא 2. זה לא 2.5. 530 00:36:31,070 --> 00:36:35,000 זה אותו הרעיון כאן. כאשר אנו מחלקים ל -2, 531 00:36:35,000 --> 00:36:39,910 אנחנו יכולים לאבד את החלקים שונים ומשונים לאורך הדרך. 532 00:36:39,910 --> 00:36:43,870 אז עכשיו - זהו זה לביטים. זה כל מה שאתה צריך לדעת. 533 00:36:43,870 --> 00:36:46,340 זכור את מקרי השימוש שראינו בכיתה, 534 00:36:46,340 --> 00:36:49,340 כמו מסכה קצת שימושית עבור מפעילי bitwise, 535 00:36:49,340 --> 00:36:53,220 או שאתה משתמש בם למסכות קצת. 536 00:36:53,220 --> 00:36:58,620 אותיות גדולות ואותיות קטנות, המרות היא דוגמא די טיפוסית. 537 00:36:58,620 --> 00:37:01,640 >> אוקיי, אז חיץ התקפות גלישה. 538 00:37:01,640 --> 00:37:05,110 מישהו זוכר מה היה לא בסדר בפונקציה זו? 539 00:37:05,110 --> 00:37:10,140 שימו לב שהכרזנו על מערך של 12 בתים, 12 תווים, 540 00:37:10,140 --> 00:37:18,510 ואז אנחנו להעתיק למאגר של 12 תווים השלם בר מחרוזת שלנו. 541 00:37:18,510 --> 00:37:25,080 אז מה הבעיה כאן? 542 00:37:25,080 --> 00:37:32,270 מספר הקסם 12 צריך פחות או יותר מייד קופץ החוצה כמו - מדוע 12? 543 00:37:32,270 --> 00:37:35,050 מה אם בר קורה ליותר מ 12 תווים? 544 00:37:35,050 --> 00:37:41,200 מה אם הבר מיליוני תווים? 545 00:37:41,200 --> 00:37:46,010 כאן הבעיה היא ה memcpy. אם בר הוא מספיק זמן, 546 00:37:46,010 --> 00:37:50,330 זה יהיה פשוט לגמרי - 'C', 'c' לא אכפת שזה היה רק ​​12 תווים; 547 00:37:50,330 --> 00:37:53,280 'C' לא אכפת שזה לא יכול להתאים לבתים שרבים. 548 00:37:53,280 --> 00:37:58,250 זה יחליף char פשוט לחלוטין, הבתים 12 אנחנו כבר הוקצו לו, 549 00:37:58,250 --> 00:38:01,830 וכל מה שעבר את זה בזיכרון שלא ממש שייך לחיץ ש 550 00:38:01,830 --> 00:38:06,520 עם כל מה שבר המחרוזת הוא. 551 00:38:06,520 --> 00:38:09,780 אז זו הייתה התמונה שראינו בכיתה 552 00:38:09,780 --> 00:38:12,220 שבו יש לנו הערימה שלנו גדלה. 553 00:38:12,220 --> 00:38:16,040 יש להשתמש לך את התמונות האלה או להכיר אותם שוב. 554 00:38:16,040 --> 00:38:21,260 יש לנו הערימה שלנו גדלה, כתובות זיכרון מתחילות ב 0 בחלק העליון 555 00:38:21,260 --> 00:38:26,270 ולגדול עד לאוהבים 4 מיליארדים בתחתית. 556 00:38:26,270 --> 00:38:28,820 יש לנו 'ג'שלנו המערך אי שם בזיכרון, 557 00:38:28,820 --> 00:38:32,260 אז יש לנו המצביע שלנו לבר שממש מתחתיה, 558 00:38:32,260 --> 00:38:38,720 ואז יש לנו מצביע זה הציל מסגרת בכתובת שולחנו וערימה של השגרה האם שלנו. 559 00:38:38,720 --> 00:38:40,800 זוכר מה היא כתובת השולח? 560 00:38:40,800 --> 00:38:45,360 זה היה רגע שבי עיקרי קורא foo פונקציה, קורא שורת פונקציה, 561 00:38:45,360 --> 00:38:48,100 באופן בלתי נמנע, בר תשואות. 562 00:38:48,100 --> 00:38:52,610 לכן, כאשר חוזרים לבר, הם צריכים לדעת שזה הולך לחזור לfoo שקרא לזה. 563 00:38:52,610 --> 00:39:01,360 אז כתובת השולח היא הכתובת של הפונקציה שיש לה כדי לחזור לכאשר חוזר לתפקד. 564 00:39:01,360 --> 00:39:05,830 הסיבה שזה חשוב להתקפות גלישת חוצץ לכך היא, בנוחות, 565 00:39:05,830 --> 00:39:09,580 האקרים רוצים לשנות את זה כתובה שולח. 566 00:39:09,580 --> 00:39:14,950 במקום לחזור לfoo, אני הולך לחזור לכל המקום בו ההאקר רוצה אותי לחזור אליו. 567 00:39:14,950 --> 00:39:17,760 וגם, במיקום נוח, שבו ההאקר לעתים קרובות רוצה לחזור ל 568 00:39:17,760 --> 00:39:22,400 הוא ההתחלה של החיץ שבמקור היה לנו. 569 00:39:22,400 --> 00:39:26,170 אז שם לב, שוב, ליטל הודית. 570 00:39:26,170 --> 00:39:28,490 המכשיר הוא דוגמא למערכת הודית קטנה, 571 00:39:28,490 --> 00:39:34,140 כך מספר שלם או מצביע מאוחסן עם הבתים הפוכים. 572 00:39:34,140 --> 00:39:38,980 אז הנה אנחנו רואים - זה? כן. 573 00:39:38,980 --> 00:39:45,660 אנו רואים Ox80, OxC0, Ox35, OxO8. 574 00:39:45,660 --> 00:39:48,250 זכור הספרות הקסדצימלי? 575 00:39:48,250 --> 00:39:50,640 אנחנו לא להפוך את הספרות הקסדצימלי בליטל ההודית, 576 00:39:50,640 --> 00:39:56,110 בגלל 2 ספרות הקסדצימלי מרכיבות את בית אחד, ואנחנו להפוך את הבתים. 577 00:39:56,110 --> 00:40:00,300 בגלל זה אנחנו לא שומרים, כמו, 80530CO8. 578 00:40:00,300 --> 00:40:07,520 אנו מאחסנים, במקום זאת, כל זוג של 2 ספרות, החל מהימין. 579 00:40:07,520 --> 00:40:10,880 כתובת המתייחסת לכתובת של תחילת 580 00:40:10,880 --> 00:40:15,190 של החיץ שלנו, כי אנחנו באמת רוצים להעתיק למקום הראשון. 581 00:40:15,190 --> 00:40:19,230 הסיבה שזה שימושי לכך היא, מה אם הפורץ 582 00:40:19,230 --> 00:40:24,100 קרה לי, במקום שיש מחרוזת שהייתה רק 583 00:40:24,100 --> 00:40:27,060 מחרוזת בלתי מזיקה כמו, השם שלהם או משהו, 584 00:40:27,060 --> 00:40:33,900 מה אם, במקום זאת, המחרוזת שהיו רק חלק הקוד שרירותי 585 00:40:33,900 --> 00:40:38,610 כי עשה מה שהם רוצים לעשות את זה? 586 00:40:38,610 --> 00:40:45,630 אז הם יכולים - אני לא יכול לחשוב על שום קוד מגניב. 587 00:40:45,630 --> 00:40:47,780 זה יכול להיות כל דבר, אם כי. כל קוד הרסני. 588 00:40:47,780 --> 00:40:51,440 אם הם רוצים, הם יכולים פשוט לעשות משהו בתקלות צינוק, אבל זה יהיה חסר טעם. 589 00:40:51,440 --> 00:40:54,950 בדרך כלל הם עושים את זה כדי לפרוץ את המערכת שלך. 590 00:40:54,950 --> 00:40:59,930 >> אוקיי. ספריית CS50. 591 00:40:59,930 --> 00:41:04,800 זה, בעצם, getInt, getString, כל פונקציות אלה שאנחנו ניתן לך. 592 00:41:04,800 --> 00:41:10,630 אז יש לנו מחרוזת char *, וזה ההפשטה שעפנו 593 00:41:10,630 --> 00:41:12,450 בשלב מסוים במהלך הסמסטר. 594 00:41:12,450 --> 00:41:18,220 זכור שמחרוזת היא פשוט מערך של תווים. 595 00:41:18,220 --> 00:41:23,240 אז הנה אנחנו רואים גרסה מקוצרת של getString. 596 00:41:23,240 --> 00:41:25,920 אתה צריך להסתכל אחורה עליו לזכור איך זה מיושם בפועל. 597 00:41:25,920 --> 00:41:30,950 פרטי מפתח הם, שימו לב שאנחנו מקבלים בתו בודד בכל פעם 598 00:41:30,950 --> 00:41:34,570 מסטנדרטי ב, שהוא בדיוק כמונו הקלדה במקלדת. 599 00:41:34,570 --> 00:41:37,890 אז תו בודד בכל פעם, ואם אנחנו מקבלים תווים רבים מדי, 600 00:41:37,890 --> 00:41:40,580 כך שאם n + 1 הוא גדול יותר מקיבולת, 601 00:41:40,580 --> 00:41:44,140 אז אנחנו צריכים להגדיל את הקיבולת של המאגר שלנו. 602 00:41:44,140 --> 00:41:47,780 אז הנה אנחנו מכפילים את גודלו של המאגר שלנו. 603 00:41:47,780 --> 00:41:51,840 וזה ממשיך הולך, אנחנו מכניסים את הדמות למאגר שלנו 604 00:41:51,840 --> 00:41:56,220 עד שנקבל שורה או סוף הקובץ או מה שלא חדשה, 605 00:41:56,220 --> 00:41:59,380 ובמקרה זה, אנחנו עושים עם החוט, ואז getString האמיתי 606 00:41:59,380 --> 00:42:05,120 מכווץ את הזיכרון, כמו אם שהוקצו זיכרון יותר מדי זה יהיה לחזור ולהתכווץ מעט. 607 00:42:05,120 --> 00:42:08,830 אז אנחנו לא מראים את זה, אבל הרעיון המרכזי הוא 608 00:42:08,830 --> 00:42:11,960 זה יש לקרוא בתו בודד בכל פעם. 609 00:42:11,960 --> 00:42:17,140 זה יכול לא רק לקרוא בכל דבר בבת אחת, 610 00:42:17,140 --> 00:42:19,550 בגלל החיץ שלהם הוא רק בגודל מסוים. 611 00:42:19,550 --> 00:42:26,590 אז אם את המחרוזת שהוא מנסה להכניס למאגר היא גדולה מדי, ואז זה יהיה על גדותיה. 612 00:42:26,590 --> 00:42:28,940 אז הנה אנחנו למנוע את זה על ידי קריאה רק בתו יחיד 613 00:42:28,940 --> 00:42:33,750 בכל פעם וגדל בכל פעם שאנו צריכים. 614 00:42:33,750 --> 00:42:40,270 אז getInt ופונקציות ספריית CS50 האחרות נוטים להשתמש getString 615 00:42:40,270 --> 00:42:42,310 ביישומים שלהם. 616 00:42:42,310 --> 00:42:45,370 אז הדגיש את הדברים החשובים כאן. 617 00:42:45,370 --> 00:42:49,460 היא מכנה getString לקבל מחרוזת. 618 00:42:49,460 --> 00:42:51,710 אם getString לא הצליח לחזור בזיכרון, 619 00:42:51,710 --> 00:42:54,270 לזכור שgetString mallocs משהו, לכן בכל פעם שאתם קוראים getString 620 00:42:54,270 --> 00:42:57,820 אתה לא צריך (לא מובן) לשחרר את המחרוזת שיש לך. 621 00:42:57,820 --> 00:43:02,870 אז הנה, אם זה לא הצליח malloc משהו, אנחנו חוזרים INT_MAX כבדיוק דגל ש, 622 00:43:02,870 --> 00:43:05,650 היי, לא היינו ממש מסוגל לקבל מספר שלם. 623 00:43:05,650 --> 00:43:10,830 אתה צריך להתעלם מכל מה שאני חוזר אליך, או 624 00:43:10,830 --> 00:43:15,540 אתה לא צריך להתייחס לזה כקלט חוקי. 625 00:43:15,540 --> 00:43:21,360 לבסוף, בהנחה שלא יצליח, אנו משתמשים sscanf עם זה דגל מיוחד, 626 00:43:21,360 --> 00:43:23,820 מה שאומר, שתתאים למספר שלם ראשון, 627 00:43:23,820 --> 00:43:26,770 לאחר מכן להתאים כל תו לאחר המספר שלם. 628 00:43:26,770 --> 00:43:29,070 אז שמתי לב שאנחנו רוצים שזה שווה 1. 629 00:43:29,070 --> 00:43:32,940 חוזר אז sscanf כמה משחקים, אם בוצע בהצלחה? 630 00:43:32,940 --> 00:43:37,010 זה יחזיר 1 אם זה מתאים שלם בהצלחה, 631 00:43:37,010 --> 00:43:40,890 זה יחזיר 0 אם זה לא התאים למספר שלם, והיא תחזיר 2 632 00:43:40,890 --> 00:43:45,920 אם זה מתאים שלם ואחריו איזו דמות. 633 00:43:45,920 --> 00:43:49,780 אז שם לב שאנחנו לנסות שוב אם אנו מתאימים שום דבר, אבל 1. 634 00:43:49,780 --> 00:43:55,230 אז אם נכנסנו 1, 2, 3, ג או 1, 2, 3, X, 635 00:43:55,230 --> 00:43:57,400 אז 1, 2, 3 הייתם מקבל מאוחסן במספר השלם, 636 00:43:57,400 --> 00:43:59,620 X הייתי לקבל מאוחסנים בתו, 637 00:43:59,620 --> 00:44:06,410 sscanf יחזור 2, ואנחנו היינו לנסות שוב, בגלל שאנחנו רק רוצים מספר שלם. 638 00:44:06,410 --> 00:44:09,810 >> מהירות נושבת דרך HTML, HTTP, CSS. 639 00:44:09,810 --> 00:44:15,340 HyperText Markup Language הוא המבנה וסמנטיקה של האינטרנט. 640 00:44:15,340 --> 00:44:19,960 הנה הדוגמא מהרצאה שבה יש לנו תגי HTML. 641 00:44:19,960 --> 00:44:22,110 יש לנו תגי ראש, תגי גוף, 642 00:44:22,110 --> 00:44:27,770 יש לנו דוגמאות לתגים ריקים שבו אנחנו באמת לא צריכים להתחיל ולסגור תג, 643 00:44:27,770 --> 00:44:30,820 פשוט יש לנו קישור ותמונה. 644 00:44:30,820 --> 00:44:38,480 אין תג תמונת סגירה; יש רק תג יחיד שמשיג כל מה שהתג צריך לעשות. 645 00:44:38,480 --> 00:44:41,950 הקישור הוא דוגמא; אנחנו תראו איך אתה מקשר ל-CSS, 646 00:44:41,950 --> 00:44:45,910 התסריט הוא דוגמא לאופן שאתה מקשר לJavaScript חיצוני. 647 00:44:45,910 --> 00:44:53,100 זה די פשוט, ולזכור, HTML הוא לא שפת תכנות. 648 00:44:53,100 --> 00:44:58,250 כאן, זוכר איך היית מגדיר את טופס או לפחות מה זה היית עושה? 649 00:44:58,250 --> 00:45:01,740 יש כאלה צורה פעולה ושיטה. 650 00:45:01,740 --> 00:45:06,210 השיטות שאתה היחיד שאי פעם תראה הן לקבל ולפרסם. 651 00:45:06,210 --> 00:45:09,040 אז קבל את הגרסה שבו הדבר מקבל לשים את כתובת האתר. 652 00:45:09,040 --> 00:45:11,680 POST הוא שבו הוא לא מכניס את כתובת האתר. 653 00:45:11,680 --> 00:45:18,520 במקום זאת, כל הנתונים מהטופס מוכנס מוסתרים יותר בבקשת HTTP. 654 00:45:18,520 --> 00:45:22,390 אז הנה, פעולה מגדירה שבו בקשת HTTP הולכת. 655 00:45:22,390 --> 00:45:27,490 לאן זה הולך הוא google.com / חיפוש. 656 00:45:27,490 --> 00:45:32,890 שיטה. זכור את ההבדלים בין לקבל ולפרסם, 657 00:45:32,890 --> 00:45:37,200 ו, רק אומר כדוגמא, אם אתה רוצה משהו סימנייה. 658 00:45:37,200 --> 00:45:40,660 אתה לעולם לא יהיה מסוגל הסימנייה URL POST 659 00:45:40,660 --> 00:45:44,970 משום שהנתונים אינו כלולים ב-URL. 660 00:45:44,970 --> 00:45:49,790 >> HTTP, עכשיו, הוא פרוטוקול העברת היפרטקסט. 661 00:45:49,790 --> 00:45:54,080 HyperText Transfer Protocol, היית מצפה לה למסור את 662 00:45:54,080 --> 00:45:57,710 Hypertext Markup Language, ושהיא עושה. 663 00:45:57,710 --> 00:46:00,170 אבל זה גם מעביר את כל תמונות שאתה מוצא באינטרנט, 664 00:46:00,170 --> 00:46:05,400 כל הורדות שאתה עושה להתחיל כבקשת HTTP. 665 00:46:05,400 --> 00:46:10,350 אז HTTP הוא רק השפה של-World Wide Web. 666 00:46:10,350 --> 00:46:15,610 וכאן אתם צריכים להכיר של בקשת HTTP מסוג זה. 667 00:46:15,610 --> 00:46:19,300 הנה HTTP/1.1 בצד רק אומר שזה הגרסה 668 00:46:19,300 --> 00:46:21,570 לפרוטוקול אני משתמש. 669 00:46:21,570 --> 00:46:25,770 זה פחות או יותר תמיד יהיה HTTP/1.1, כפי שתראה אותו. 670 00:46:25,770 --> 00:46:30,110 ואז אנחנו רואים שזו הייתה GET, החלופה להיות POST, שאתה יכול לראות. 671 00:46:30,110 --> 00:46:40,790 ואת כתובת האתר שאני מנסה לבקר היה www.google.com/search?q = בלה, בלה, בלה. 672 00:46:40,790 --> 00:46:44,240 אז לזכור שזה, ש סימן השאלה = בלה בלה בלה, 673 00:46:44,240 --> 00:46:49,040 הוא הסוג של חומר שהוגש על ידי טופס. 674 00:46:49,040 --> 00:46:51,830 התגובה שזה יכול להחזיר לי הייתה נראית משהו כזה. 675 00:46:51,830 --> 00:46:54,050 שוב, מתחיל עם הפרוטוקול, שהוא הולך להיות ש, 676 00:46:54,050 --> 00:46:59,190 ואחריו את קוד המצב. הנה זה 200 אישור. 677 00:46:59,190 --> 00:47:05,060 ולבסוף, את דף האינטרנט שאני בעצם ביקשתי יהיה אחריו. 678 00:47:05,060 --> 00:47:08,210 קוד המצב האפשרי שאתה יכול לראות, ואתה צריך לדעת כמה מהם. 679 00:47:08,210 --> 00:47:12,770 200 אישור יש לך כנראה ראה בעבר. 680 00:47:12,770 --> 00:47:17,830 403 אסור, 404 לא נמצא, שגיאה 500 שרת פנימי 681 00:47:17,830 --> 00:47:22,140 בדרך כלל אם אתה הולך לאתר ומשהו לא שבור או קוד PHP קריסות שלהם, 682 00:47:22,140 --> 00:47:24,930 בעוד שבמכשיר יש לנו שקופסה כתומה גדולה 683 00:47:24,930 --> 00:47:27,830 שבא ואומר, כאילו, משהו לא בסדר, הקוד הזה לא עובד 684 00:47:27,830 --> 00:47:30,380 או של רע בפונקציה זו. 685 00:47:30,380 --> 00:47:33,230 בדרך כלל אתרים לא רוצים אותך לדעת מה פונקציות הן בעצם רעות, 686 00:47:33,230 --> 00:47:37,880 אז במקום שהם פשוט נותנים לך 500 שגיאות שרת פנימיות. 687 00:47:37,880 --> 00:47:43,050 >> TCP / IP הוא שכבה 1 מתחת HTTP. 688 00:47:43,050 --> 00:47:47,550 זכור שיש באינטרנט מחוץ ל- World Wide Web. 689 00:47:47,550 --> 00:47:52,270 כמו שאם אתה משחק במשחק באינטרנט שלא הולך דרך HTTP, 690 00:47:52,270 --> 00:47:55,740 זה עובר אחר - זה עדיין משתמש באינטרנט, 691 00:47:55,740 --> 00:47:58,900 אבל זה לא להשתמש בפרוטוקול HTTP. 692 00:47:58,900 --> 00:48:02,470 HTTP הוא רק דוגמא אחת של פרוטוקול בנוי על TCP / IP. 693 00:48:02,470 --> 00:48:07,820 IP פשוטו כמשמעו פרוטוקול האינטרנט. 694 00:48:07,820 --> 00:48:11,500 לכל מחשב כתובת ה-IP, הם דברים 4 ספרות אלה 695 00:48:11,500 --> 00:48:16,510 כמו 192.168.2.1, או כל דבר אחר, זה נוטה להיות אחד מקומי. 696 00:48:16,510 --> 00:48:23,390 אבל זה הדפוס של כתובת ה-IP. 697 00:48:23,390 --> 00:48:29,060 אז DNS, שירות שמות תחומים, 698 00:48:29,060 --> 00:48:33,410 זה מה שמתרגם את הדברים כמו google.com לכתובת ה-IP אמיתית. 699 00:48:33,410 --> 00:48:37,700 אז אם אתה מקליד לתוך כתובת אתר שכתובת ה-IP, 700 00:48:37,700 --> 00:48:40,850 שיביא אותך לגוגל, אבל אתה נוטה שלא לזכור את הדברים האלה. 701 00:48:40,850 --> 00:48:45,470 אתה נוטה לזכור google.com במקום. 702 00:48:45,470 --> 00:48:51,560 הדבר האחרון שיש לנו הוא יציאות, שבו זה חלק מפרוטוקול TCP-IP. 703 00:48:51,560 --> 00:48:54,880 TCP עושה יותר. תחשוב על, כאילו, יש לך הריצה דפדפן האינטרנט שלך. 704 00:48:54,880 --> 00:48:58,670 אולי יש לך קצת ריצה יישום דואר אלקטרוני; 705 00:48:58,670 --> 00:49:02,150 אולי יש לך תכנית אחרת שמשתמשת בריצת האינטרנט. 706 00:49:02,150 --> 00:49:05,090 כולם צריך גישה לאינטרנט, 707 00:49:05,090 --> 00:49:08,100 אבל המחשב שלך יש רק כרטיס WiFi 1 או משהו כזה. 708 00:49:08,100 --> 00:49:10,780 אז יציאות הן הדרך שאנחנו יכולים להתפצל 709 00:49:10,780 --> 00:49:13,550 איך יישומים אלה יוכלו להשתמש באינטרנט. 710 00:49:13,550 --> 00:49:17,230 כל יישום מקבל 1 יציאה מסוימת שהוא יכול להאזין ב, 711 00:49:17,230 --> 00:49:19,670 וברירת מחדל, HTTP משתמש ביציאה 80. 712 00:49:19,670 --> 00:49:22,410 שירותי דואר אלקטרוני מסוימים משתמשים 25. 713 00:49:22,410 --> 00:49:24,490 אלה ממוספרים נמוכים נוטים להיות שמורות. 714 00:49:24,490 --> 00:49:29,270 אתה בדרך כלל מסוגל לקבל אלה ממוספרים גבוהים יותר בעצמך. 715 00:49:29,270 --> 00:49:32,010 >> CSS, גיליונות סגנון מדורג. 716 00:49:32,010 --> 00:49:36,030 דפי אינטרנט שסגנון עם CSS, ולא עם ה-HTML. 717 00:49:36,030 --> 00:49:38,440 יש 3 מקומות שאתה יכול לשים CSS שלך. 718 00:49:38,440 --> 00:49:46,300 זה יכול להיות בתוך שורה, בין תגי סגנון, או בקובץ נפרד לחלוטין ולאחר מכן מקושר פנימה 719 00:49:46,300 --> 00:49:48,470 וכאן הוא רק דוגמא של CSS. 720 00:49:48,470 --> 00:49:50,450 אתה צריך לזהות את הדפוס הזה, 721 00:49:50,450 --> 00:49:54,310 איפה הדוגמא הראשונה הוא שאנחנו התאמת תג הגוף, 722 00:49:54,310 --> 00:49:56,680 וכאן אנחנו מרכוז תג הגוף. 723 00:49:56,680 --> 00:50:00,420 הדוגמא השנייה, אנחנו התאמת הדבר 724 00:50:00,420 --> 00:50:04,740 עם כותרת תחתונה זהות, ואנחנו מיישמים כמה סגנונות לזה. 725 00:50:04,740 --> 00:50:07,310 שים לב שמזהה תחתונה טקסט מיושר לשמאל, 726 00:50:07,310 --> 00:50:09,840 ואילו מרכז גוף טקסט מיישר. 727 00:50:09,840 --> 00:50:13,180 כותרת תחתונה היא בתוך הגוף. 728 00:50:13,180 --> 00:50:16,470 זה, במקום, יישור טקסט שמאלה, למרות שגוף אומר מרכז יישור טקסט. 729 00:50:16,470 --> 00:50:18,880 זה כל החלק המדורג שלו. 730 00:50:18,880 --> 00:50:22,110 יכול להיות לך - אתה יכול לציין סגנונות לגוף, 731 00:50:22,110 --> 00:50:25,320 ואז דברים בגוף שאתה יכול לציין סגנונות ספציפיים יותר, 732 00:50:25,320 --> 00:50:28,160 ודברים עובדים כמו שאתה מצפה. 733 00:50:28,160 --> 00:50:34,420 מצייני CSS יותר ספציפיים הם הקובעים. 734 00:50:34,420 --> 00:50:46,140 אני חושב שזה זה. 735 00:50:46,140 --> 00:50:49,260 >> [עלי Nahm] שלום לכולם. אם רק יכל לקבל את תשומת הלב שלך. 736 00:50:49,260 --> 00:50:53,990 אני עלי ואני הולך לעבור את PHP ו-SQL ממש מהר. 737 00:50:53,990 --> 00:51:00,310 אז אנחנו יכולים להתחיל. PHP הוא קיצור של PHP: Hypertext Preprocessor. 738 00:51:00,310 --> 00:51:03,730 וכפי שכולכם צריך לדעת, זה שפה scripting בצד השרת, 739 00:51:03,730 --> 00:51:06,800 ואנחנו משתמשים בו לקצה האחורי של אתרי אינטרנט, 740 00:51:06,800 --> 00:51:12,540 ואיך זה עושה הרבה חישובים, חלק מאחורי הקלעים. 741 00:51:12,540 --> 00:51:17,510 תחביר. זה לא כמו C, הפתעה, הפתעה. 742 00:51:17,510 --> 00:51:22,060 זה תמיד צריך להתחיל עם, אם אתה יכול לראות, - אני לא יכול להתקדם. 743 00:51:22,060 --> 00:51:31,340 אתה יכול לראות מה שאתה צריך סוגים החדשים של פלטה ואז אתה גם צריך? PHP. 744 00:51:31,340 --> 00:51:35,780 זה תמיד איך אתה צריך מסגרת טקסט PHP שלך, קוד PHP שלך. 745 00:51:35,780 --> 00:51:39,180 אז זה לא יכול להיות רק כמו C, שבו אתה סוג של לשים על זה ראשון. 746 00:51:39,180 --> 00:51:42,290 אתה צריך תמיד מקיף אותו. 747 00:51:42,290 --> 00:51:47,610 ועכשיו, בתחביר העיקרי הוא שכל המשתנים צריכים להתחיל עם הדמות של $. 748 00:51:47,610 --> 00:51:49,490 אתה צריך לעשות את זה כשאתה מגדיר אותם, אתה צריך לעשות את זה 749 00:51:49,490 --> 00:51:51,860 כשאתה מתכוון לאליהם בהמשך. 750 00:51:51,860 --> 00:51:56,510 אתה תמיד צריך ש$. זה החבר הכי טוב החדש שלך, פחות או יותר. 751 00:51:56,510 --> 00:52:01,690 אתה לא - שלא כמו C, אתה לא צריך לשים איזה סוג של סוג משתנה שהוא. 752 00:52:01,690 --> 00:52:04,940 אז בזמן שאתה צריך לעשות $, אתה לא צריך לשים, כמו, 753 00:52:04,940 --> 00:52:09,470 x או y int מחרוזת, וכו ', וכו'. 754 00:52:09,470 --> 00:52:11,490 אז הבדל קטן. 755 00:52:11,490 --> 00:52:15,590 כתוצאה מזה, זה אומר שPHP היא סוג חלוש. 756 00:52:15,590 --> 00:52:19,310 PHP היא שפת סוג חלושה, והוא הקליד בחולשה משתנים. 757 00:52:19,310 --> 00:52:24,020 במילים אחרות, זה אומר שאתה יכול לעבור בין סוגים שונים של סוגים משתנים שונים. 758 00:52:24,020 --> 00:52:27,230 אתה יכול לאחסן את המספר שלך 1 כמו int, 759 00:52:27,230 --> 00:52:29,650 אתה יכול לאחסן אותו כמחרוזת, ואתה יכול לאחסן אותו כמצוף, 760 00:52:29,650 --> 00:52:33,550 ואת כל זה יהיה המספר ש1. 761 00:52:33,550 --> 00:52:36,080 למרות שאתה לאחסן אותו בצורות שונות, 762 00:52:36,080 --> 00:52:39,120 זה עדיין - הסוגים משתנים עדיין מחזיקים בסופו של הדבר. 763 00:52:39,120 --> 00:52:41,540 אז אם אתה מסתכל פה, אם אתה זוכר מpset 7, 764 00:52:41,540 --> 00:52:43,500 רבים מכם בוודאי היו בעיות עם זה. 765 00:52:43,500 --> 00:52:47,280 שני סימנים שווים, 3 סימנים שווים, 4 סימנים שווים. 766 00:52:47,280 --> 00:52:49,990 אוקיי, אין 4 סימנים שווים, אבל יש 2 ו -3. 767 00:52:49,990 --> 00:52:53,320 אתה משתמש 2 שלטים שווים לבדוק את הערכים. 768 00:52:53,320 --> 00:52:55,830 הוא יכול לבדוק על פני סוגים. 769 00:52:55,830 --> 00:52:58,770 אז אם אתה יכול לראות בדוגמא הראשונה, 770 00:52:58,770 --> 00:53:02,210 יש לי num_string == num_int. 771 00:53:02,210 --> 00:53:06,710 אז int שלך ומחרוזת שלך הם שניהם, מבחינה טכנית, 1, 772 00:53:06,710 --> 00:53:10,790 אבל הם סוגים שונים. אבל השווה הכפול, זה עדיין עובר. 773 00:53:10,790 --> 00:53:15,510 עם זאת, לשווים משולשים, הוא בודק ערך, כמו גם סוגים השונים. 774 00:53:15,510 --> 00:53:18,760 זה אומר שזה לא הולך לעבור שבמקרה השני כאן, 775 00:53:18,760 --> 00:53:22,350 שבו אתה משתמש 3 סימנים שווים במקום. 776 00:53:22,350 --> 00:53:26,590 אז זה הבדל גדול, כי אתה צריך את כל הראו עכשיו. 777 00:53:26,590 --> 00:53:31,570 >> שרשור מחרוזת הוא דבר חזק אחר שאתה יכול להשתמש ב-PHP. 778 00:53:31,570 --> 00:53:34,080 זה בעצם רק סימון הנקודה הזה שימושי, 779 00:53:34,080 --> 00:53:36,230 וככה אתה יכול לקשור חוטים יחד. 780 00:53:36,230 --> 00:53:40,800 אז אם יש לך חתול ויש לך כלב, ואתה רוצה לשים 2 חוטים יחד, 781 00:53:40,800 --> 00:53:44,080 אתה יכול להשתמש בתקופה, וזה סוג של איך זה עובד. 782 00:53:44,080 --> 00:53:46,660 אתה יכול גם פשוט למקם אותם אחד ליד שני, 783 00:53:46,660 --> 00:53:49,030 כפי שאתה יכול לראות כאן בדוגמא למטה, 784 00:53:49,030 --> 00:53:51,610 שבו יש לי הד מחרוזת 1, מחרוזת חלל 2. 785 00:53:51,610 --> 00:53:56,930 PHP תדע להחליף אותם ככאלה. 786 00:53:56,930 --> 00:53:59,780 מערכים. עכשיו, ב-PHP, ישנם 2 סוגים של מערכים שונים. 787 00:53:59,780 --> 00:54:03,180 אתה יכול לקבל מערכים רגילים, וגם אתה יכול לקבל מערכים אסוציאטיביים, 788 00:54:03,180 --> 00:54:06,040 ואנחנו הולכים לעבור אותם עכשיו. 789 00:54:06,040 --> 00:54:08,280 מערכים רגילים הם רק זה ב-C, 790 00:54:08,280 --> 00:54:11,240 ואז יש לך מדדים שממוספרים. 791 00:54:11,240 --> 00:54:13,160 כרגע אנחנו פשוט הולכים ליצור אחד ולשים - 792 00:54:13,160 --> 00:54:15,500 אז זה איך אנחנו יוצרים מערך ריק, אז אנחנו הולכים 793 00:54:15,500 --> 00:54:17,310 להכניס את מספר אינדקס 0. 794 00:54:17,310 --> 00:54:19,200 אנחנו הולכים לשים את המספר 6, הערך 6. 795 00:54:19,200 --> 00:54:21,500 אפשר לראות את זה בתחתית כאן. 796 00:54:21,500 --> 00:54:24,240 Where's - במספר אינדקס 1 אנחנו הולכים לשים את מספר ערך 4, 797 00:54:24,240 --> 00:54:26,720 ואז אתה יכול לראות שיש 6, יש 4, 798 00:54:26,720 --> 00:54:29,160 ולאחר מכן כפי שאנו מדפיסים דברים, 799 00:54:29,160 --> 00:54:33,550 כאשר אנו מנסים ולהדפיס את הערך שמאוחסן במספר אינדקס 0, 800 00:54:33,550 --> 00:54:36,900 אז אנחנו תראו את הערך 6 שהדפיס. מגניב? 801 00:54:36,900 --> 00:54:40,160 אז זה מערכים רגילים בשבילך. 802 00:54:40,160 --> 00:54:42,750 דרך נוספת שאתה יכול גם להוסיף דברים למערכים רגילים עכשיו 803 00:54:42,750 --> 00:54:44,780 הוא שאתה יכול פשוט לצרף אותם בסוף. 804 00:54:44,780 --> 00:54:47,240 זה אומר שאתה לא צריך לציין את המדד הספציפי. 805 00:54:47,240 --> 00:54:51,000 אתה יכול לראות את מספר, ולאחר מכן בסוגריים מרובעים אין שום מדד שצוין. 806 00:54:51,000 --> 00:54:56,270 והוא יודע - PHP תדע רק להוסיף אותו לסוף הרשימה, המקום החופשי הבא. 807 00:54:56,270 --> 00:54:59,190 אז אתה יכול לראות את 1 ממש שם באותה הנקודה 0, 808 00:54:59,190 --> 00:55:02,690 2 הלכו ממש שם במקום הראשון. 809 00:55:02,690 --> 00:55:04,690 3 הולך - הוא הוסיף לשם גם כן. 810 00:55:04,690 --> 00:55:06,720 אז זה סוג של היגיון. אתה פשוט מוסיף אותו כל הזמן, 811 00:55:06,720 --> 00:55:09,360 ואז כאשר אנחנו מהדהדים את המדד של מספר 1, 812 00:55:09,360 --> 00:55:13,080 זה יהיה להדפיס את הערך 2. 813 00:55:13,080 --> 00:55:16,800 >> אז יש לנו מערכים שהם מערכים אסוציאטיביים. 814 00:55:16,800 --> 00:55:19,370 מערכים אסוציאטיביים, במקום שיש מדדים מספריים, 815 00:55:19,370 --> 00:55:23,630 מה שהם עושים הוא, יש להם מדדים שעל ידי חוט. 816 00:55:23,630 --> 00:55:25,670 אתה יכול לראות, במקום - נפטרתי מכל מדדי מספר אלה, 817 00:55:25,670 --> 00:55:32,140 ועכשיו זה key1, key2, key3, והם נמצאים במרכאות כפולות כדי לסמן שהם כולם המחרוזות. 818 00:55:32,140 --> 00:55:34,470 אז אנחנו יכולים להיות דוגמא לכך. 819 00:55:34,470 --> 00:55:38,790 דוגמא לכך היא שיש לנו TF, וזה השם שהמדד. 820 00:55:38,790 --> 00:55:42,030 אנחנו הולכים לשים את "עלי", כשמו, במדד, קלוריות אכלו, 821 00:55:42,030 --> 00:55:47,640 אנחנו יכולים לשים int הפעם במקום מחרוזת, 822 00:55:47,640 --> 00:55:52,240 ולאחר מכן באוהב המדד, אנחנו יכולים לשים את כל מערך הפנימי שלו. 823 00:55:52,240 --> 00:55:55,490 אז זה סוג של - זה רעיון דומה לאופן שהיה לנו 824 00:55:55,490 --> 00:55:58,930 מדדים במספרים, אבל עכשיו אנחנו יכולים לשנות את המדדים ברחבי 825 00:55:58,930 --> 00:56:03,890 כדי לקבל אותם כמחרוזות במקום. 826 00:56:03,890 --> 00:56:06,070 גם אתה יכול לעשות את זה, חוץ מזה רק עושה את זה באופן אישי, 827 00:56:06,070 --> 00:56:09,400 אתה יכול לעשות את כל זה בחתיכה אחת. אז אתה יכול לראות שTF של מערך זה, 828 00:56:09,400 --> 00:56:13,350 ואז אנחנו להגדיר את כולם בסט סוגר אחד ענק מרובע. 829 00:56:13,350 --> 00:56:15,220 אז זה יכול לזרז את עניינים. 830 00:56:15,220 --> 00:56:19,730 זה יותר בחירה סגנונית יותר מאשר לא. 831 00:56:19,730 --> 00:56:21,550 יש לנו גם לולאות. 832 00:56:21,550 --> 00:56:26,020 ב-C יש לנו לולאות שעובדות ככה. 833 00:56:26,020 --> 00:56:29,690 היו לנו המערך שלנו, והלכנו מאינדקס 0 עד סוף הרשימה, 834 00:56:29,690 --> 00:56:31,740 ואנחנו להדפיס את כל זה, נכון? 835 00:56:31,740 --> 00:56:33,880 מלבד הבעיה היא, למערכים אסוציאטיביים, 836 00:56:33,880 --> 00:56:36,610 אנו לא בהכרח יודעים מדדים מספריים אלה 837 00:56:36,610 --> 00:56:39,610 כי עכשיו יש לנו את מדדי המחרוזת. 838 00:56:39,610 --> 00:56:44,800 עכשיו אנחנו משתמשים בלולאות foreach, אשר, שוב, אתה תקווה משמש בpset 7. 839 00:56:44,800 --> 00:56:48,930 לולאות foreach רק תדע כל חלק אחד של הרשימה. 840 00:56:48,930 --> 00:56:52,450 וזה לא צריך לדעת את המדד המספרי בדיוק שיש לך. 841 00:56:52,450 --> 00:56:56,490 אז יש לך את תחביר foreach, כך שזה foreach, אתה שם את המערך. 842 00:56:56,490 --> 00:57:00,430 אז המערך שלי נקרא pset, ולאחר מכן כ, המילה כמו, 843 00:57:00,430 --> 00:57:04,530 ולאחר מכן אתה מכניס משתנה זמני מקומי זה שאתה הולך להשתמש 844 00:57:04,530 --> 00:57:10,690 רק בשביל דבר מסוים זה הולך להחזיק ספציפי - 845 00:57:10,690 --> 00:57:14,770 מקרה אחד או חלק אחד של המערך. 846 00:57:14,770 --> 00:57:18,350 num Pset יחזיק 1, ואז אולי זה יחזיק המספר 6, 847 00:57:18,350 --> 00:57:20,410 ואז זה יהיה להחזיק את המספר 2. 848 00:57:20,410 --> 00:57:26,630 אבל זה מובטח לעבור בכל ערך שהוא במערך. 849 00:57:26,630 --> 00:57:30,530 פונקציות שימושיות שאתה צריך לדעת ב-PHP הן לדרוש, 850 00:57:30,530 --> 00:57:35,880 כך שמוודא כי אתה כולל את קבצים מסוימים, הד, יציאה, ריק. 851 00:57:35,880 --> 00:57:40,490 אני מאוד ממליץ לך להסתכל על pset 7 ומסתכלים על פונקציות אלה. 852 00:57:40,490 --> 00:57:42,810 ייתכן שאתה צריך לדעת אותם, 853 00:57:42,810 --> 00:57:47,060 כך שאני בהחלט יודע מה, בדיוק, אלה כל עושים. 854 00:57:47,060 --> 00:57:50,080 >> ועכשיו אנחנו הולכים לעבור היקף ממש מהר. 855 00:57:50,080 --> 00:57:53,490 בהיקפה, PHP היא סוג של דבר פאנקי, שלא כמו C, 856 00:57:53,490 --> 00:57:56,170 ואז אנחנו פשוט הולכים לעבור את זה במהירות. 857 00:57:56,170 --> 00:57:58,930 אז בואו נגיד שאנחנו מתחילים בחץ שיש לנו שם. 858 00:57:58,930 --> 00:58:02,900 ואנחנו הולכים להתחיל עם i $. אז משתנה 'אני' הולך להיות 0, 859 00:58:02,900 --> 00:58:06,730 ואנחנו רק הולכים לשמור על דפוס זה שבקופסה לבנה גדולה שם. 860 00:58:06,730 --> 00:58:09,220 אנחנו הולכים להתחיל עם i0, ולאחר מכן אנחנו הולכים להדהד אותו. 861 00:58:09,220 --> 00:58:12,670 אז יש 0. 862 00:58:12,670 --> 00:58:15,210 ואז אנחנו הולכים להגדיל אותו על ידי ללולאה, 863 00:58:15,210 --> 00:58:17,810 ואז זה הולך להיות ערך של 1. 864 00:58:17,810 --> 00:58:20,070 אחת מהן הוא פחות מ -3, כך שזה הולך לעבור את זה בשביל לולאה, 865 00:58:20,070 --> 00:58:23,230 ואז אנחנו הולכים לראות את זה מודפס שוב. 866 00:58:23,230 --> 00:58:25,520 אנחנו הולכים להגדיל את זה שוב ל 2, 867 00:58:25,520 --> 00:58:29,860 ו 2 הוא פחות מ -3, כך שזה יעבור ללולאה, וזה יהיה להדפיס את 2. 868 00:58:29,860 --> 00:58:35,100 לאחר מכן תוכלו לשים לב כי 3 הוא לא פחות מ 3, אז אנחנו לפרוץ את ללולאה. 869 00:58:35,100 --> 00:58:40,050 אז עכשיו אנחנו כבר יצאנו, ואז אנחנו הולכים להיכנס aFunction. 870 00:58:40,050 --> 00:58:45,010 אוקיי. אז אתה צריך לשים לב כי משתנה זה שיצרנו, 871 00:58:45,010 --> 00:58:48,270 משתנה 'אני', אינה scoped באופן מקומי. 872 00:58:48,270 --> 00:58:50,280 זה אומר שזה לא מקומי ללולאה, 873 00:58:50,280 --> 00:58:58,060 ומשתנה שאנחנו עדיין יכולים לגשת ולשנות לאחר מכן, וזה עדיין יהיה יעיל. 874 00:58:58,060 --> 00:59:02,160 אז אם אתה נכנסת לפונקציה עכשיו, אתה תראה שאנחנו גם להשתמש במשתנה 'i', 875 00:59:02,160 --> 00:59:05,320 ואנחנו הולכים להגדיל 'i' + +. 876 00:59:05,320 --> 00:59:09,410 אפשר היה לחשוב, בהתחלה, המבוסס על C, שזה עותק של המשתנה "אני". 877 00:59:09,410 --> 00:59:12,830 זה דבר אחר לגמרי, שהוא נכון. 878 00:59:12,830 --> 00:59:16,560 לכן, כאשר אנו להדפיס אותו, אנחנו הולכים להדפיס 'i' + +, שהוא הולך להדפיס את ש4, 879 00:59:16,560 --> 00:59:19,640 ואז אנחנו הולכים - מצטערים. 880 00:59:19,640 --> 00:59:22,030 ואז אנחנו הולכים בסופו מתוך פונקציה, 881 00:59:22,030 --> 00:59:24,820 ואנחנו הולכים להיות בו החץ שהוא עכשיו. 882 00:59:24,820 --> 00:59:29,190 זה אומר שלאחר מכן, עם זאת, למרות שהפונקציה שינתה את הערך של 'אני', 883 00:59:29,190 --> 00:59:32,620 זה לא שינה מחוץ לפונקציה, 884 00:59:32,620 --> 00:59:35,060 בגלל הפונקציה בעלת היקף נפרד. 885 00:59:35,060 --> 00:59:38,960 כלומר, כאשר אנו הד 'אני', זה לא השתנה בהיקף של הפונקציה, 886 00:59:38,960 --> 00:59:43,660 וכך אז אנחנו הולכים להדפיס 3 שוב. 887 00:59:43,660 --> 00:59:47,520 דברים שונים לגבי היקף ב-PHP מאשר בג 888 00:59:47,520 --> 00:59:51,130 >> עכשיו ב-PHP ו-HTML. 889 00:59:51,130 --> 00:59:53,510 PHP משמש כדי להפוך את דפי אינטרנט דינמיים. 890 00:59:53,510 --> 00:59:58,660 זה גורם לדברים שונים. 891 00:59:58,660 --> 01:00:02,090 יש לנו את זה שונה מ-HTML. 892 01:00:02,090 --> 01:00:05,230 עם HTML, תמיד רק שיש לנו את אותו הדבר סטטי, כמו איך רוב הראו, 893 01:00:05,230 --> 01:00:09,370 ואילו PHP, אתה יכול לשנות דברים מבוסס על שהמשתמש הוא. 894 01:00:09,370 --> 01:00:11,830 אז אם יש לי את זה, יש לי ", נכנסו כ -" ולאחר מכן את השם, 895 01:00:11,830 --> 01:00:14,420 ואני יכול לשנות את השם. אז עכשיו את השם הוא יוסף, 896 01:00:14,420 --> 01:00:18,880 ויש לו את "עליי", אבל אז אני גם יכול לשנות את השם ליש טומי. 897 01:00:18,880 --> 01:00:21,700 וזה יהיה דבר שונה. 898 01:00:21,700 --> 01:00:23,840 אז אנחנו יכולים גם לשנות דברים שונים עליו, 899 01:00:23,840 --> 01:00:27,070 וזה יראה לי תוכן שונה המבוסס על שמו. 900 01:00:27,070 --> 01:00:31,430 אז PHP סוג של יכול לשנות את מה שקורה באתר שלך. 901 01:00:31,430 --> 01:00:33,540 אותו דבר כאן. ובכל זאת, שים לב שיש להם תוכן שונה, 902 01:00:33,540 --> 01:00:38,870 למרות שאתה עדיין מבחינה טכנית גישה לאותו דף אינטרנט על פני השטח. 903 01:00:38,870 --> 01:00:43,450 יצירת ה-HTML. ישנן 2 דרכים שונות, כי אתה יכול לעשות את זה. 904 01:00:43,450 --> 01:00:48,980 כך תהיה לנו לעבור את זה עכשיו. הדרך הראשונה היא, שיש לך - כן, מצטער. 905 01:00:48,980 --> 01:00:51,150 אז פשוט יש לך רגיל שלך ללולאה ב-PHP, 906 01:00:51,150 --> 01:00:56,270 ואז אתה הד ב-PHP ואתה מהדהד את ה-HTML. 907 01:00:56,270 --> 01:00:58,720 באמצעות מה שהראה לך רוב של הסקריפט ב-HTML 908 01:00:58,720 --> 01:01:04,030 ולאחר מכן באמצעות ההדפסה PHP רק כדי להדפיס אותו לדף האינטרנט. 909 01:01:04,030 --> 01:01:09,520 הדרך החלופית היא לעשות את זה כאילו אתה להפריד את PHP ו-HTML. 910 01:01:09,520 --> 01:01:11,940 אז אתה יכול לקבל קו של PHP שמתחיל ללולאה, 911 01:01:11,940 --> 01:01:16,020 אז אתה יכול לקבל את הקו של ה-HTML בדבר נפרד, 912 01:01:16,020 --> 01:01:19,700 ואז אתה בסופו הלולאה, שוב, עם PHP. 913 01:01:19,700 --> 01:01:21,800 אז זה סוג של הפרדה אותו החוצה. 914 01:01:21,800 --> 01:01:24,020 בצד השמאל, אתה יכול, כי יש לך את כל - 915 01:01:24,020 --> 01:01:26,360 זה רק 1 נתח של PHP. 916 01:01:26,360 --> 01:01:28,510 מימין אתם יכולים לראות שיש לך קו של PHP, 917 01:01:28,510 --> 01:01:32,540 יש לך קו של ה-HTML, ויש לך קו של PHP שוב. 918 01:01:32,540 --> 01:01:36,870 אז מפריד את זה למה שהם עושים. 919 01:01:36,870 --> 01:01:39,330 ואתה שים לב כי בכל מקרה, לכל אחד מהם, 920 01:01:39,330 --> 01:01:41,980 הם עדיין להדפיס את התמונה, התמונה, התמונה, 921 01:01:41,980 --> 01:01:44,540 כך ה-HTML שעדיין מודפסת באותה צורה. 922 01:01:44,540 --> 01:01:49,870 ואז אתה תראה עדיין 3 התמונות מופיעות באתר האינטרנט שלך. 923 01:01:49,870 --> 01:01:52,820 אז זה 2 דרכים לעשות את אותו הדבר שונים. 924 01:01:52,820 --> 01:01:55,060 >> עכשיו יש לנו טפסים ובקשות. כמו רוב הראה לך, 925 01:01:55,060 --> 01:01:59,400 יש צורות של ה-HTML, ואנחנו פשוט רוח באמצעות זה. 926 01:01:59,400 --> 01:02:02,040 יש לך פעולה ויש לכם שיטה, והפעולה שלך 927 01:02:02,040 --> 01:02:04,350 סוג של מראה לך לאן אתה הולך לשלוח אותו, והשיטה היא האם 928 01:02:04,350 --> 01:02:06,960 זה הולך להיות GET או POST. 929 01:02:06,960 --> 01:02:11,220 ובקשת GET, כפי שאמרה רוב, פירושו שאתה הולך לשים אותו בצורה 930 01:02:11,220 --> 01:02:15,760 ואתה רואה את זה ככתובת אתר, ואילו בקשת POST לא תוכל לראות בכתובת אתר. 931 01:02:15,760 --> 01:02:17,840 אז הבדל קטן. 932 01:02:17,840 --> 01:02:19,950 עם זאת, דבר אחד שזה דבר דומה 933 01:02:19,950 --> 01:02:22,560 הוא כי POST ומקבלים הם חסרי ביטחון באותה מידה. 934 01:02:22,560 --> 01:02:26,430 אז אתה יכול לחשוב שרק בגלל שאתה לא רואה את זה ב-URL, 935 01:02:26,430 --> 01:02:28,790 זה אומר POST הוא מאובטח יותר, 936 01:02:28,790 --> 01:02:34,420 אבל אתה עדיין יכול לראות אותו בעוגיות שלך במידע שאתה שולח. 937 01:02:34,420 --> 01:02:38,260 אז לא חושב שעל זה או אחר. 938 01:02:38,260 --> 01:02:42,160 דבר נוסף שיש לציין הוא כי יש לך גם משתני סעיף. 939 01:02:42,160 --> 01:02:45,850 אתם השתמשו בזה בpset 7 כדי לקבל מידע זיהוי המשתמש שלך. 940 01:02:45,850 --> 01:02:48,550 מה שקרה הוא שאתה יכול להשתמש במערך האסוציאטיבי הזה, 941 01:02:48,550 --> 01:02:53,310 _SESSION $, ואז אתה יכול לגשת לדברים שונים 942 01:02:53,310 --> 01:02:57,720 ולאחסן דברים שונים על פני הדפים. 943 01:02:57,720 --> 01:03:00,750 >> הדבר האחרון הוא שיש לנו SQL, שפת שאילתות מובנית, 944 01:03:00,750 --> 01:03:04,360 ואת זה הוא שפת תכנות לניהול מסדי נתונים. 945 01:03:04,360 --> 01:03:08,220 מה, בדיוק, הם מסדי נתונים? הם אוספים של שולחנות, 946 01:03:08,220 --> 01:03:10,630 וכל שולחן יכול להיות סוגים דומים של אובייקטים. 947 01:03:10,630 --> 01:03:14,990 אז היה לנו שולחן של משתמשים בpset המימון שלך. 948 01:03:14,990 --> 01:03:20,610 ולמה הם שימושיים? כי זה דרך של באופן קבוע לאחסון מידע. 949 01:03:20,610 --> 01:03:22,840 זוהי דרך של מעקב אחר דברים וניהול דברים 950 01:03:22,840 --> 01:03:25,890 ובאמת רואה את זה בדפים שונים ואחר שמירה. 951 01:03:25,890 --> 01:03:29,930 לעומת זאת, אם אתה רק לאחסן אותו באותו רגע אחד מיידי 952 01:03:29,930 --> 01:03:33,720 ולאחר מכן להשתמש בו מאוחר יותר, לא תוכל לגשת לשום דבר, כי אתה כבר הצלת. 953 01:03:33,720 --> 01:03:37,660 יש לנו 4 דברים עיקריים שאנו משתמשים לפקודות SQL. 954 01:03:37,660 --> 01:03:40,190 יש לנו נבחרת, להוסיף, למחוק, ולעדכן. 955 01:03:40,190 --> 01:03:42,880 אלה הם באמת חשובים בשבילכם לדעת לחידון שלך. 956 01:03:42,880 --> 01:03:45,990 >> ניסע במהירות על בחר עכשיו. 957 01:03:45,990 --> 01:03:48,540 בעיקרון, אתה בוחר שורות ממסד נתונים. 958 01:03:48,540 --> 01:03:52,400 אז אם יש לך, ממש כאן - 959 01:03:52,400 --> 01:03:56,740 יש לנו 2 הדברים השונים הללו, ואנחנו רוצים לבחור מטבלת הכיתות 960 01:03:56,740 --> 01:04:01,480 שם מדהים - שבו בעמודה מדהימה הערך הוא 1. 961 01:04:01,480 --> 01:04:04,460 אז אתם יכולים לראות כאן, יש לנו 2 דברים משם בכיתה אלה, 962 01:04:04,460 --> 01:04:08,490 CS50 וStat110, ויש לנו את תעודות הזהות של הכיתה והסיסמה. 963 01:04:08,490 --> 01:04:13,150 אז אנחנו רוצים לבחור את כל המידע הזה. 964 01:04:13,150 --> 01:04:17,480 אז אתה יכול לראות ממש כאן, כי זה סוג של בחירה מתוך שהטור מדהים, 965 01:04:17,480 --> 01:04:25,170 שבו כל הדברים שהם 1, ולאחר מכן יש לו את מעמד זהות, שם המחלקה וסיסמא שהוא יכול לבחור. 966 01:04:25,170 --> 01:04:28,100 איך בדיוק אתה עושה את זה בקוד? אתה צריך להשתמש ב-PHP. 967 01:04:28,100 --> 01:04:33,830 אז זה סוג של איך PHP ו-SQL הקשורים זה לזה. 968 01:04:33,830 --> 01:04:38,130 עכשיו יש לנו את הקוד שלנו, ואנחנו הולכים להשתמש בפונקצית השאילתה שלנו 969 01:04:38,130 --> 01:04:41,370 כפי שעשינו בpset 7, ואנחנו הולכים כדי להפעיל את שאילתת SQL. 970 01:04:41,370 --> 01:04:43,870 ואז אנחנו הולכים להיות - 971 01:04:43,870 --> 01:04:46,280 תמיד יש לנו כדי לבדוק אם של השורה שווה המשולש אם שווא. 972 01:04:46,280 --> 01:04:49,010 אז שוב, אתה רוצה לבדוק את הסוג והערך, 973 01:04:49,010 --> 01:04:53,880 ואז אם זה לא עובד, אז אתה רוצה להתנצל, כרגיל, כפי שעשינו בpset 7. 974 01:04:53,880 --> 01:04:55,870 אחרת, אתה רוצה לולאה דרך כל דבר בהישג היד אלה 975 01:04:55,870 --> 01:04:59,410 foreach לולאות שאנחנו פשוט ניגשנו. 976 01:04:59,410 --> 01:05:01,280 עכשיו שאנחנו לולאה דרך ושעשינו את זה בעבר, 977 01:05:01,280 --> 01:05:05,080 בואו נניח שהשאילתה שלנו עברה, עכשיו יש לנו לולאת foreach שלנו. 978 01:05:05,080 --> 01:05:11,050 ויש לו בשורה הראשונה אותו, אז הנה בשורה, ממש כאן, אלא בקופסא. 979 01:05:11,050 --> 01:05:14,010 זה הולך להדפיס את כל המידע שהוא קיבל. 980 01:05:14,010 --> 01:05:18,070 אז זה הולך להדפיס בתחתית "רוצה ללמוד HTML?" 981 01:05:18,070 --> 01:05:23,370 אז זה הולך לשורה הבאה, כי זה הושלם הראשון ללולאה, 982 01:05:23,370 --> 01:05:26,510 וכך אז זה הולך להדפיס את השורה השנייה שלו, 983 01:05:26,510 --> 01:05:32,120 שהוא הולך להיות STAT110, מצא את כל הרגעים. 984 01:05:32,120 --> 01:05:34,290 >> הדבר האחרון הוא על הפגיעויות של SQL. 985 01:05:34,290 --> 01:05:37,300 אני יודע שהדוד נגע בזה קצת בהרצאה. 986 01:05:37,300 --> 01:05:40,730 אתה יכול לקרוא בהמשך. זה באמת מצחיק. 987 01:05:40,730 --> 01:05:45,320 הזרקת SQL היא סוג של דבר מסובך. 988 01:05:45,320 --> 01:05:49,890 בואו נגיד שאתה פשוט מקל המשתנים האלה ישר לתוך השאילתה שלך, 989 01:05:49,890 --> 01:05:52,290 כפי שאתה יכול לראות שבשורה ראשונה. 990 01:05:52,290 --> 01:05:54,520 אז זה נראה בסדר, נכון? אתה פשוט מכניס את שם המשתמש 991 01:05:54,520 --> 01:05:58,820 וסיסמא לשאילתא SQL שלך, ואתה רוצה לשלוח אותו ולקבל את כל מה שהוא בטבלת הנתונים שלך. 992 01:05:58,820 --> 01:06:01,450 זה נראה די פשוט. אז נניח שמישהו מעמיד ב, 993 01:06:01,450 --> 01:06:04,910 לסיסמה, או זה טקסט ממש כאן - 994 01:06:04,910 --> 01:06:06,780 צריך להיות ממש בתיבה האדומה. 995 01:06:06,780 --> 01:06:11,920 אז בואו נגיד שהם הכניסו את הסיסמה של-- זה מה שהם נכנסים. 996 01:06:11,920 --> 01:06:16,520 אז הם שמים או "1" = 1. 997 01:06:16,520 --> 01:06:20,880 סוג של סיסמא מטופשת שיש. 998 01:06:20,880 --> 01:06:25,070 עכשיו בואו פשוט להחליף בזה, ואתה תשים לב שבשאילתא SQL עכשיו, 999 01:06:25,070 --> 01:06:29,090 זה מוערך תמיד נכון, כי אתה לציין כי 1000 01:06:29,090 --> 01:06:32,240 אתה יכול שאילתת SQL לבחור את כל המידע הזה 1001 01:06:32,240 --> 01:06:35,420 או שאתה יכול פשוט צריך 1 = 1. 1002 01:06:35,420 --> 01:06:41,030 כך שתמיד הולך להעריך לנכון. 1003 01:06:41,030 --> 01:06:46,610 זה לא הולך באמת לעבודה, כי זה אומר שההאקר יכול לפרוץ למערכת שלך. 1004 01:06:46,610 --> 01:06:49,300 הפתרון לזה הוא שאתה צריך להשתמש במערכת PDO, 1005 01:06:49,300 --> 01:06:51,360 מה שאומר שאתה צריך להשתמש בסימני שאלה, 1006 01:06:51,360 --> 01:06:53,350 וזה מה שהיה לכם פעם בpset 7, 1007 01:06:53,350 --> 01:06:57,620 לאן אתה הולך להשתמש בסימן שאלה במקום שבו אתה רוצה לשים משהו, 1008 01:06:57,620 --> 01:07:01,430 ואז אתה הולך להיות פסיק, ואז יהיה לך אחר כך, 1009 01:07:01,430 --> 01:07:07,610 לאחר המחרוזת שלך, את המשתנים השונים שאתה רוצה להחליף לסימן השאלה שלך. 1010 01:07:07,610 --> 01:07:10,330 אז תוכל לציין כאן כי עכשיו יש לי סימני שאלה האדומים האלה. 1011 01:07:10,330 --> 01:07:15,420 ואז אני שם את המשתנים אחרי המחרוזות שלי אז אני יודע להחליף אותם על מנת שלאחר מכן. 1012 01:07:15,420 --> 01:07:18,470 זה יהיה לוודא שאם מישהו עושה את זה ככה, 1013 01:07:18,470 --> 01:07:24,050 ויש להם 1 = 1 או מצב, שיוודא, 1014 01:07:24,050 --> 01:07:30,490 בקצה האחורי, לוודא שזה לא יהיה ממש לשבור את שאילתת SQL. 1015 01:07:30,490 --> 01:07:33,660 אוקיי, אז זה פחות או יותר אותו, מערבולת של PHP ו-SQL. 1016 01:07:33,660 --> 01:07:41,520 מיטב של מזל לכולכם, ועכשיו לאורגון 1017 01:07:41,520 --> 01:07:44,270 >> [Oreoluwatomiwa Babarinsa] כולם בסדר. זמן לעבור על כמה JavaScript 1018 01:07:44,270 --> 01:07:48,840 ועוד כמה דברים מהר מאוד ולכן אנחנו לא מחזיקים אותך הלילה. 1019 01:07:48,840 --> 01:07:56,930 ב-JavaScript. כן. JavaScript היא סוג של דבר מגניב, כביכול. 1020 01:07:56,930 --> 01:07:59,090 הדברים שאתה באמת צריך לדעת על JavaScript, זה כמו סוג של 1021 01:07:59,090 --> 01:08:03,810 הסוף בצד הלקוח של מה יישום האינטרנט שלך הולך לעשות. 1022 01:08:03,810 --> 01:08:08,280 יש כמה דברים שאתה פשוט לא רוצה לטפל בכל הזמן בצד השרת. 1023 01:08:08,280 --> 01:08:12,880 כל האינטראקציות הקטנות, המדגיש דבר אחד, מה שהופך משהו ייעלם. 1024 01:08:12,880 --> 01:08:15,340 אתה באמת לא רוצה צריך לדבר עם השרת שלך כל הזמן לזה. 1025 01:08:15,340 --> 01:08:18,069 וחלק מזה הוא אפילו לא ניתן לעשות בצד השרת. 1026 01:08:18,069 --> 01:08:21,899 זו הסיבה שאנחנו צריכים משהו כמו JavaScript. 1027 01:08:21,899 --> 01:08:24,359 דברים מגניבים על JavaScript: הוא הקליד באופן דינמי. 1028 01:08:24,359 --> 01:08:27,149 מה שזה אומר הוא שהתכנית שלך לא צריכה לדעת 1029 01:08:27,149 --> 01:08:30,970 מה, בדיוק, את המשתנים הם כשאתה כותב את זה. 1030 01:08:30,970 --> 01:08:34,510 זה פשוט סוג של להבין את זה כפי שהוא פועל. 1031 01:08:34,510 --> 01:08:37,520 דברים אחרים שהם מגניבים על זה: זו שפת סד מתולתלת, 1032 01:08:37,520 --> 01:08:41,359 מה שאומר שהתחביר דומה ל-C ו-PHP. 1033 01:08:41,359 --> 01:08:47,050 אתה לא צריך לעשות הרבה חוזר כאשר אתה לומד ב-JavaScript. 1034 01:08:47,050 --> 01:08:49,180 כאן יש לנו קצת ב-JavaScript. 1035 01:08:49,180 --> 01:08:52,560 דבר מעניין כאן הוא שאם אתה מסתכל על זה, 1036 01:08:52,560 --> 01:08:56,330 יש לנו קצת JavaScript ממש שם בתג הראש. 1037 01:08:56,330 --> 01:08:59,479 מה זה עושה הוא בעצם רק לכלול קובץ ב-JavaScript. 1038 01:08:59,479 --> 01:09:02,260 זוהי דרך אחת שאתה יכול לכלול JavaScript לתכנית שלך. 1039 01:09:02,260 --> 01:09:06,910 אז קצת השני הוא למעשה חלק JavaScript מוטבע, 1040 01:09:06,910 --> 01:09:10,790 דומה מאוד לסגנון מובנה עם CSS, 1041 01:09:10,790 --> 01:09:16,180 ואתה פשוט כותב איזה קוד מהר מאוד שם. 1042 01:09:16,180 --> 01:09:18,120 יש JavaScript מערכים. 1043 01:09:18,120 --> 01:09:20,850 רק עוד דרך לשמור על הנתונים בסביבה, מאוד שימושיים. 1044 01:09:20,850 --> 01:09:25,180 תחביר מאוד נחמד וקל. 1045 01:09:25,180 --> 01:09:29,870 אתה משתמש בסוגריים מרובעים כדי לגשת לכל דבר ולשמור על הכל ביחד. 1046 01:09:29,870 --> 01:09:35,020 שום דבר מורכב מדי. 1047 01:09:35,020 --> 01:09:38,630 הדבר מגניב על JavaScript ושפות סקריפטים באופן כללי 1048 01:09:38,630 --> 01:09:40,920 הוא שאתה לא צריך לדאוג לגדלי מערך. 1049 01:09:40,920 --> 01:09:43,880 אתה יכול פשוט להשתמש array.length ולעקוב אחר זה, 1050 01:09:43,880 --> 01:09:46,960 וגם המערך יכול לגדול או להתכווץ כמו שאתה צריך את זה. 1051 01:09:46,960 --> 01:09:49,279 אז אתה אפילו לא צריך לדאוג לגבי כל סוג של, 1052 01:09:49,279 --> 01:09:57,050 הו לא, אני צריך להקצות יותר דברים, או משהו כזה. 1053 01:09:57,050 --> 01:10:00,090 >> הדבר מגניב כאן הוא שJavaScript יש משהו שנקרא אובייקטים. 1054 01:10:00,090 --> 01:10:04,800 זה שפה מונחה עצמים, אז מה זה, בעצם, 1055 01:10:04,800 --> 01:10:10,100 יחד דרך בשבילך כדי לקבץ נתונים, דומה במקצת למבנה, 1056 01:10:10,100 --> 01:10:17,280 אבל אתה יכול לגשת אליו כמו מבנה או בתחביר מערך אסוציאטיבי. 1057 01:10:17,280 --> 01:10:22,520 זה די פשוט ומה שאתה יכול לעשות עם זה הוא נתוני קבוצה יחד 1058 01:10:22,520 --> 01:10:24,810 אם יש לך חבורה של נתונים שקשורים. 1059 01:10:24,810 --> 01:10:26,850 בגלל שזה כל הדברים שאתה צריך לתאר את מכונית, 1060 01:10:26,850 --> 01:10:29,050 אתה לא צריך לעשות את זה בחבורה של מקומות שונים. 1061 01:10:29,050 --> 01:10:35,300 אתה יכול פשוט לתקוע אותו לתוך אובייקט 1 ב-JavaScript. 1062 01:10:35,300 --> 01:10:39,090 כפי שאתה בוודאי יודע, חזרה הוא אחת המשימות מייגע אלה. 1063 01:10:39,090 --> 01:10:43,810 אתה פשוט עושה את זה מעל שוב. אתה צריך לדבר עם כל חפץ במכונית, 1064 01:10:43,810 --> 01:10:47,340 או שאתה צריך לעבור כל פריט ברשימה או משהו כזה. 1065 01:10:47,340 --> 01:10:51,770 אז יש JavaScript, בדומה ל-PHP, תחביר foreach. 1066 01:10:51,770 --> 01:10:54,590 במקרה זה, זה בלולאה. 1067 01:10:54,590 --> 01:10:57,300 אתה רוצה להשתמש בזה רק על אובייקטים. 1068 01:10:57,300 --> 01:11:01,030 יש כמה בעיות שעלולות להתעורר אם אתה משתמש בזה על מערכים. 1069 01:11:01,030 --> 01:11:03,750 זה בדרך כלל הוא אחד מאותם דברים, אם כי, כי הוא מאוד שימושי, 1070 01:11:03,750 --> 01:11:06,590 כי אתה מבטל הרבה תקורה 1071 01:11:06,590 --> 01:11:10,270 כי אתה לא צריך למשוך את הכל באובייקט שלך בכוחות עצמך. 1072 01:11:10,270 --> 01:11:12,300 אתה לא צריך לזכור את כל שמות המפתח. 1073 01:11:12,300 --> 01:11:18,270 אתה פשוט סוג של להחזיר אותם בתחביר זה. 1074 01:11:18,270 --> 01:11:21,500 בחודש זה, עם ל, אתה רק רוצה לזכור 1075 01:11:21,500 --> 01:11:27,180 שאתה מקבל בחזרה את כל המפתחות, באופן דומה מאוד לחשיש שולחן. 1076 01:11:27,180 --> 01:11:30,880 אם אתה זוכר מזה, כשאתה הייתי שם במחרוזת אתה יכול להוציא משהו 1077 01:11:30,880 --> 01:11:33,840 שיהיה לי ערך הקשורים אליו. 1078 01:11:33,840 --> 01:11:36,360 מה אתה יכול לעשות עם זה הוא שאתה יכול להגיד, בסדר, 1079 01:11:36,360 --> 01:11:42,120 אני שם במכונית, ואני קראתי לזה פרארי. 1080 01:11:42,120 --> 01:11:45,290 אז אתה יכול לשים במחרוזת פרארי שוב מאוחר יותר, ואתה יכול לקבל את זה. 1081 01:11:45,290 --> 01:11:50,000 ואתה יכול לעשות את זה בלולאה, עם בלולאה. 1082 01:11:50,000 --> 01:11:53,320 אז פשוט יותר על אובייקטים. דבר מפתח מזה שאתה צריך לזכור 1083 01:11:53,320 --> 01:12:00,340 הוא שאתה יכול להשתמש בstruct האובייקט כמו תחביר בכל פעם שאתה רוצה עם אלה, 1084 01:12:00,340 --> 01:12:04,590 אלא אם מה שלך הולך להשתמש כמחרוזת אינו שם משתנה חוקי. 1085 01:12:04,590 --> 01:12:07,650 אז אם אתה מסתכל על שיש, יש לנו מפתח עם רווחים. 1086 01:12:07,650 --> 01:12:12,500 ובכן, אם היית לשים object.key, מרחב, עם, מרחב, מרחב, 1087 01:12:12,500 --> 01:12:15,320 כי פשוט לא יהיה הגיוני מבחינה תחבירית. 1088 01:12:15,320 --> 01:12:22,730 אז אתה יכול רק לעשות את זה עם סוג כזה של תחביר סוגר. 1089 01:12:22,730 --> 01:12:26,520 >> כמו כן, JavaScript היא מאוד היקף חכם ל-PHP. 1090 01:12:26,520 --> 01:12:29,050 יש לך 2 דרכים להתמודדות עם היקפה. 1091 01:12:29,050 --> 01:12:31,960 אתה לא יכול להיות var מול משתנה, 1092 01:12:31,960 --> 01:12:34,060 וזה רק אומר שזה גלובלי. 1093 01:12:34,060 --> 01:12:37,050 אתה יכול לראות אותו מכל מקום. גם אם היית לשים את זה באם הצהרה, 1094 01:12:37,050 --> 01:12:42,430 בכל מקום אחר בקוד שלך אחרי נקודה שאתה יכול לראות שמשתנה. 1095 01:12:42,430 --> 01:12:46,730 דבר נוסף, אם כי, הוא עם var, זה מוגבל לכל מה פונקציה שאתה נמצא בו 1096 01:12:46,730 --> 01:12:48,870 אם אתה לא בתפקיד, טוב, זה גלובלי. 1097 01:12:48,870 --> 01:12:53,900 אבל אם אתה נמצא בתפקיד זה רק נראה לעין בתוך הפונקציה. 1098 01:12:53,900 --> 01:12:56,420 אין לי דוגמא, אבל, כן. זה אחד מאותם דברים שבו 1099 01:12:56,420 --> 01:12:59,900 אתה יכול לנהל את מה שמשתנים שאתה רוצה להיות גלובלי, 1100 01:12:59,900 --> 01:13:03,810 מה משתנה אתה רוצה להיות מקומי, אבל אתה צריך להיות זהיר לגבי זה, 1101 01:13:03,810 --> 01:13:06,890 כי אין לך את הסוג של שליטת תבואה בסדר שאתה עושה ב-C, 1102 01:13:06,890 --> 01:13:15,820 שבו אם הוא הכריז משהו ללולאה, שזה הולך להישאר בכי ללולאה. 1103 01:13:15,820 --> 01:13:18,790 הדבר שאנחנו באמת אכפת להם באמצעות JavaScript להוא מניפולציה דפי אינטרנט, נכון? 1104 01:13:18,790 --> 01:13:21,800 אני מתכוון, זה למה אנחנו עושים את זה. 1105 01:13:21,800 --> 01:13:23,840 >> כדי לעשות זאת, אנו משתמשים במשהו שנקרא ה-DOM. 1106 01:13:23,840 --> 01:13:25,850 סוג Document Object Model. 1107 01:13:25,850 --> 01:13:29,430 בעיקרון, מה שהיא עושה זה לוקח את כל HTML שלך 1108 01:13:29,430 --> 01:13:34,110 ומודלים אותה לתוך חבורה של אובייקטים שמקוננים בתוך אחד את השני. 1109 01:13:34,110 --> 01:13:37,080 אתה מתחיל לצאת עם משהו כזה. 1110 01:13:37,080 --> 01:13:44,770 יש לך, על הזכות בשבילי, חבורה של קוד שם בחוץ, כי זה סוג של - 1111 01:13:44,770 --> 01:13:46,640 היית חושב שאהיה קשה מאוד לתמרן, 1112 01:13:46,640 --> 01:13:48,700 כי אתה רוצה להיות בניתוח דרך חבורה של טקסט 1113 01:13:48,700 --> 01:13:52,080 ויש להם חתיכת דברים בנפרד. ומה אם זה לא היה מעוצב בצורה נכונה? 1114 01:13:52,080 --> 01:13:54,880 דברים רעים לא יקרה. 1115 01:13:54,880 --> 01:13:58,140 אז JavaScript מטפל בזה בשבילך, ואתה מקבל מבנה נתונים נחמד, 1116 01:13:58,140 --> 01:14:01,390 כמו אחד משמאלי, שבו אתה רק צריך מסמך, 1117 01:14:01,390 --> 01:14:03,530 ובתוך שיש לך משהו שנקרא HTML, 1118 01:14:03,530 --> 01:14:05,600 ובתוך שיש לך בראש וגוף, 1119 01:14:05,600 --> 01:14:08,420 ובתוך הראש שיש לך כותרת, וכו ', וכו', וכו '. 1120 01:14:08,420 --> 01:14:11,810 זה מפשט מניפולציה דף אינטרנט, כך שזה פשוט, 1121 01:14:11,810 --> 01:14:14,190 הו, אני רק רוצה לדבר איתי אובייקט זה. 1122 01:14:14,190 --> 01:14:21,340 סוג של דרך דומה מאוד שהיית מדבר אל אובייקט אחר שעשית בעצמך. 1123 01:14:21,340 --> 01:14:25,980 כמו שאמרתי, כל DOM הוא באובייקט המסמך. 1124 01:14:25,980 --> 01:14:29,290 או שזה רק מקום אחד ואז אתה יכול ללכת בתוכו למצוא דברים, 1125 01:14:29,290 --> 01:14:33,880 ואתה יכול לעשות את זה - זה הסגנון הישן של עושה את זה, שם למעלה, 1126 01:14:33,880 --> 01:14:38,130 איפה אתה עושה document.getElementById, ולאחר מכן את השם, 1127 01:14:38,130 --> 01:14:42,420 וכמו שאתם בטח יכולים לספר, זה נהיה מאוד מסורבל אחרי כמה זמן. 1128 01:14:42,420 --> 01:14:44,480 אז אתה כנראה לא רוצה לעשות את זה. זו הסיבה שיש לנו 1129 01:14:44,480 --> 01:14:48,760 הדבר הבא שאנחנו הולכים לדבר עליו אחרי זה. 1130 01:14:48,760 --> 01:14:52,510 הדבר העיקרי כאן הוא ש, בסדר, יש לך את כל המרכיבים האלה, נכון? 1131 01:14:52,510 --> 01:14:56,400 אז אולי אני יכול לשנות את הצבע של משהו כאשר הדף נטען. 1132 01:14:56,400 --> 01:14:58,380 אז מה? מה אם המשתמש שלי לוחץ על משהו? 1133 01:14:58,380 --> 01:15:00,540 אני רוצה שזה יעשה משהו מעניין כאשר הם לוחצים על משהו. 1134 01:15:00,540 --> 01:15:02,600 זו הסיבה שיש לנו אירועים. 1135 01:15:02,600 --> 01:15:05,330 אתה יכול, בעצם, למצוא שום גורם בDOM שלך, 1136 01:15:05,330 --> 01:15:08,560 ואז אומר, היי. כאשר זה טוען או מישהו לוחץ עליו, 1137 01:15:08,560 --> 01:15:11,410 או כאשר הם עכבר מעליו, לעשות משהו עם זה. 1138 01:15:11,410 --> 01:15:15,330 ומה יש לך, יש לך פונקציות שמטפלות בזה בשבילך. 1139 01:15:15,330 --> 01:15:17,980 פונקציות אלה הן מטפלים באירועים. 1140 01:15:17,980 --> 01:15:20,440 מה הוא פזור - זה רק דרך מגונדרת להגיד, 1141 01:15:20,440 --> 01:15:23,500 פונקציה זו מתבצעת רק כאשר אירוע זה מתרחש. 1142 01:15:23,500 --> 01:15:28,070 אז הוא מטפל באירוע שמתרחש. 1143 01:15:28,070 --> 01:15:30,810 זה איך אתה הייתי פורש את מטפל באירועים. 1144 01:15:30,810 --> 01:15:34,750 יש לי איזה כפתור, וכאשר אתה לוחץ עליו, הוא מתפוצץ. 1145 01:15:34,750 --> 01:15:40,560 אז אל תלחץ על הכפתור. 1146 01:15:40,560 --> 01:15:42,910 זוהי דרך אחת שמתקרב לזה, נכון? 1147 01:15:42,910 --> 01:15:46,430 יש לך תגן, ועל לחץ שיש לך מחרוזת שאומרת, 1148 01:15:46,430 --> 01:15:50,460 אה, דרך אגב, אני עושה את הדבר מתפוצץ לי את זה. 1149 01:15:50,460 --> 01:15:53,990 אחרת, זה בדיוק כמו כפתור רגיל אתה פשוט עשה. 1150 01:15:53,990 --> 01:15:56,550 אתה יכול גם לעשות את זה בדרך אחרת, 1151 01:15:56,550 --> 01:16:02,770 על ידי גרירת אלמנט DOM, אבל אנחנו נשמור את זה אחרי שאנחנו מדברים על jQuery. 1152 01:16:02,770 --> 01:16:07,580 >> JQuery: זוהי ספרייה שהיא דפדפן צולב. 1153 01:16:07,580 --> 01:16:09,580 אתה יכול להשתמש בו בכמעט כל דבר. 1154 01:16:09,580 --> 01:16:12,090 וזה רק נותן לך הרבה כלים לעבוד איתו. 1155 01:16:12,090 --> 01:16:15,850 בגלל JavaScript, תוך עוצמה, אין את כל הכלים הדרושים לך 1156 01:16:15,850 --> 01:16:20,550 מחוץ לקופסה באמת להתמודד עם יישום אינטרנט, ייתכן שתרצה לעשות. 1157 01:16:20,550 --> 01:16:24,650 אז זה מפשט הרבה דברים, נותן לך הרבה פונקציות 1158 01:16:24,650 --> 01:16:28,760 מחוץ לקופסה כי אתה בדרך כלל צריך לכתוב בעצמך, שוב ושוב ושוב. 1159 01:16:28,760 --> 01:16:31,600 ופשוט עושה דברים פשוטים מאוד. 1160 01:16:31,600 --> 01:16:35,780 יש לך גם בוררים, אשר מאפשרים לך לקחת את כל אותם האלמנטים 1161 01:16:35,780 --> 01:16:42,800 מDOM שלך הרבה יותר פשוט, במקום שיש להשתמש בקריאות פונקציה ארוכות מאוד אלה. 1162 01:16:42,800 --> 01:16:46,630 נוסף על בוררים אלה. יש לך, שם למעלה שיש לך, בואו נגיד 1163 01:16:46,630 --> 01:16:49,800 אני רוצה לקבל את אלמנט עם המזהה "הסלע". 1164 01:16:49,800 --> 01:16:56,450 ובכן, בjQuery, זה רק $ ולאחר מכן מחרוזת שיש לו קילו, ולאחר מכן "סלע". 1165 01:16:56,450 --> 01:17:01,960 זה פשוט מאוד והרבה יותר מהר מאשר בדרך המסורתית של JavaScript התמודדות עם בעיה זו. 1166 01:17:01,960 --> 01:17:06,120 ויש לך דברים דומים לשיעורים וסוגי אלמנט. 1167 01:17:06,120 --> 01:17:08,140 jQuery היא - אחת התכונות מגניבים הוא סוג של אתה יכול לדחוס 1168 01:17:08,140 --> 01:17:14,350 את השאילתות שלך על DOM שלך מאוד, מהר מאוד. 1169 01:17:14,350 --> 01:17:18,980 עכשיו אנחנו חוזרים לטיפול באירוע, וזה איך היית להתמודד עם אירוע אחד בjQuery. 1170 01:17:18,980 --> 01:17:23,090 אז מה אנחנו הולכים כאן הוא שאנחנו אומרים, הכל בסדר. יש לי תג סקריפט, נכון? 1171 01:17:23,090 --> 01:17:25,400 אז יש לי בשורה זו ב-JavaScript. 1172 01:17:25,400 --> 01:17:27,750 מה שאנחנו הולכים לעשות הוא שאנחנו הולכים לומר, הכל בסדר. 1173 01:17:27,750 --> 01:17:30,860 כאשר המסמך מוכן, מה שאומר שהמסמך שנטען, 1174 01:17:30,860 --> 01:17:34,660 אנחנו הולכים ללכת לתפקיד זה, ואנחנו הולכים להגיד, בסדר, 1175 01:17:34,660 --> 01:17:37,060 פונקציה זו בעצם עושה משהו אחר. 1176 01:17:37,060 --> 01:17:42,320 זה בעצם אומר, בסדר, ישיג לי את האלמנט עם המזהה "myid". 1177 01:17:42,320 --> 01:17:47,960 ולאחר מכן לתת את זה מטפל פונקציה שמבצע כאשר אתה לוחץ עליו. 1178 01:17:47,960 --> 01:17:49,820 בעיקרון מה שזה עושה זה, זה אומר, בסדר. 1179 01:17:49,820 --> 01:17:52,630 הדף נטען, ולכן אני הולך ב, למצוא את האלמנט הזה, 1180 01:17:52,630 --> 01:17:56,420 לתת לו מטפל אירוע זה, וזה בעצם מגדיר את הדף שלך בשבילך. 1181 01:17:56,420 --> 01:18:00,520 וזה איך שאתה רוצה לחשוב על טיפול באירוע. 1182 01:18:00,520 --> 01:18:06,310 אתה רק רוצה לחשוב על זה, בסדר, כשמשהו מתרחש, מה אני רוצה שקורה? 1183 01:18:06,310 --> 01:18:10,520 אתה לא רוצה לחשוב על זה, בסדר, אני צריך לעשות שיחות הדבר הזה בטוחים לדבר הזה, 1184 01:18:10,520 --> 01:18:14,660 הדבר הזה בלה בלה בלה, כי אתה רק רוצה לדבר דבר במונחים של אירועים. 1185 01:18:14,660 --> 01:18:17,650 כאשר זה קורה, זה קורה. כאשר זה קורה, זה קורה. 1186 01:18:17,650 --> 01:18:20,240 ואם דברים לעורר דברים אחרים, זה נהדר. 1187 01:18:20,240 --> 01:18:22,150 אבל אתה לא רוצה לנסות ולעשות קוד מסובך 1188 01:18:22,150 --> 01:18:24,130 לאן אתה מפעילה דברים מרובים באותו הזמן, 1189 01:18:24,130 --> 01:18:28,860 כי אתה פשוט הולך לתת לעצמך כאב ראש. 1190 01:18:28,860 --> 01:18:32,340 >> בסדר. עכשיו אנחנו יכולים להגיע לדף שלנו לטפל באירועים, 1191 01:18:32,340 --> 01:18:35,640 אבל בואו נגיד שהמשתמש שלי לוחץ על כפתור. 1192 01:18:35,640 --> 01:18:38,040 מה אם אני רוצה לשלוח את הבקשה שבחזרה לשרת, 1193 01:18:38,040 --> 01:18:41,100 אבל אני לא רוצה לטעון מחדש את הדף, כי צורך לטעון מחדש דף חדש 1194 01:18:41,100 --> 01:18:44,390 בכל פעם שמקבלת סוג של מייגע, ולמה אני צריך 1195 01:18:44,390 --> 01:18:47,430 לניתץ את הכותרת שוב, ושוב תחתונה, 1196 01:18:47,430 --> 01:18:49,670 ואת כל האלמנטים של הדף שוב 1197 01:18:49,670 --> 01:18:53,180 רק כדי לרענן את ברכה או את הזמן? 1198 01:18:53,180 --> 01:18:55,290 אז זאת הסיבה שיש לנו משהו כמו אייאקס. 1199 01:18:55,290 --> 01:18:59,150 מה אנחנו יכולים לעשות כאן עם אייאקס הוא שאנחנו יכולים לומר, בסדר, 1200 01:18:59,150 --> 01:19:01,290 אני רוצה לשלוח כמה נתונים לשרת, 1201 01:19:01,290 --> 01:19:04,010 ואני רוצה לקבל תגובה בחזרה כדי שאוכל לעדכן את הדף שלי, 1202 01:19:04,010 --> 01:19:12,120 או אולי רק לעשות קצת חישוב אלגוריתמי שלא בהכרח מראה שום דבר למשתמש. 1203 01:19:12,120 --> 01:19:15,500 מה אתה צריך לעשות את זה? ובכן, אתה צריך כתובת אתר שאתה צריך לדבר איתו. 1204 01:19:15,500 --> 01:19:18,650 השרת שלך לא יכול פשוט קסם להקשיב במשום מקום. 1205 01:19:18,650 --> 01:19:21,960 אתה צריך מקום מסוים אתה שולח את הנתונים ל. 1206 01:19:21,960 --> 01:19:26,240 ואתה גם צריך קצת נתונים כדי לשלוח, או אולי זה שאילתת dataless. 1207 01:19:26,240 --> 01:19:31,380 אתה רק רוצה לאותת בחזרה לשרת ואומר, היי, אני בחיים, או משהו כזה. 1208 01:19:31,380 --> 01:19:35,150 ואז אתה רוצה פונקציה שבעצם מטפלת בהצלחה. 1209 01:19:35,150 --> 01:19:38,250 בואו נגיד לך לחזור קצת מידע מהשרת שלך, 1210 01:19:38,250 --> 01:19:42,960 ואתה רוצה לשנות את הכותרת של המשתמש בדף שלהם. 1211 01:19:42,960 --> 01:19:44,930 אז היית מקבל את המידע בחזרה, 1212 01:19:44,930 --> 01:19:48,860 והיית לדחוף את זה על המסך. 1213 01:19:48,860 --> 01:19:51,170 מה שקורה הוא, כאשר הדף מוכן, 1214 01:19:51,170 --> 01:19:56,500 אתה יוצר בפונקציה לחץ על הכפתור הזה שנקרא מברך. 1215 01:19:56,500 --> 01:19:58,810 מה זה אז עושה הוא, כאשר הכפתור שנדחף, 1216 01:19:58,810 --> 01:20:03,700 אתה מדבר עם greetings.php, שתבצע בקשת POST, 1217 01:20:03,700 --> 01:20:07,290 ואתה אומר, היי, תשיג לי משהו מהדף שלך. 1218 01:20:07,290 --> 01:20:09,890 אנחנו לא באמת צריכים לתאר את זה, אבל greetings.php, 1219 01:20:09,890 --> 01:20:12,480 בואו רק נאמר, נותן בחזרה "שלום עולם". 1220 01:20:12,480 --> 01:20:15,650 אז אנחנו מקבלים בחזרה "שלום עולם", ועל הצלחתו של זה, 1221 01:20:15,650 --> 01:20:20,730 בהנחה ששום דבר לא ישתבש, אז אנחנו פשוט הולכים למקום יעד זה 1222 01:20:20,730 --> 01:20:25,720 שצוינו ואנחנו רק מקל את התגובה שם. 1223 01:20:25,720 --> 01:20:31,560 וזו היא דרך פשוטה מאוד של הקמת שאילתת אייאקס. 1224 01:20:31,560 --> 01:20:34,340 >> מהר מאוד, רוב הזכיר את זה כבר סוג של, 1225 01:20:34,340 --> 01:20:37,170 דברים יכולים להשתבש, דברים רעים יכולים לקרות, 1226 01:20:37,170 --> 01:20:42,660 אז אתה רוצה להכיר את עצמך עם קודי תגובת HTTP אלה. 1227 01:20:42,660 --> 01:20:46,030 מה אלה הם רק, כאילו, 200, הכל הלך בסדר. 1228 01:20:46,030 --> 01:20:48,670 משהו אחר, דברים רעים קרו. 1229 01:20:48,670 --> 01:20:50,790 זה בדרך כלל הדבר שאתה רוצה לזכור. 1230 01:20:50,790 --> 01:20:53,440 אבל זה נחמד לדעת את כל אלה. 1231 01:20:53,440 --> 01:20:55,970 ולבסוף, ברגע שאנחנו כבר עברנו את כל זה, 1232 01:20:55,970 --> 01:20:58,680 אנחנו צריכים לדבר מהר מאוד על עיצוב, 1233 01:20:58,680 --> 01:21:00,620 ואז אנחנו יכולים לתת את כל שאתה עוזב. 1234 01:21:00,620 --> 01:21:03,410 עיצוב. דברים שאתה רוצה לזכור. 1235 01:21:03,410 --> 01:21:06,950 שאל את עצמך את השאלות הבאות: מי אהיה באמצעות זה? 1236 01:21:06,950 --> 01:21:09,580 יהיו מה שהם משתמשים בו ל? מה המשתמשים שלי אכפת? 1237 01:21:09,580 --> 01:21:11,750 מה לא אכפת להם? 1238 01:21:11,750 --> 01:21:14,500 אתה פשוט לא רוצה להפוך את האפליקציה ולתת לו רק לגדול 1239 01:21:14,500 --> 01:21:18,270 ולהפוך לענק זה, דבר כל רב שאתה אפילו לא יכול לסיים. 1240 01:21:18,270 --> 01:21:23,900 אתה רוצה להיות מטרות דיסקרטיות ותוכניות ודברים שאתה רוצה להתייחס. 1241 01:21:23,900 --> 01:21:29,000 להפוך אותו ללא מאמץ. כל זה אומר, בעצם, 1242 01:21:29,000 --> 01:21:34,950 לעשות את זה קל עבור המשתמש על מנת להשתמש בו, אל תעשה את זה כתם ענק של טקסט כמו שקופית זו היא, למעשה. 1243 01:21:34,950 --> 01:21:38,020 אתה רק רוצה שזה יהיה משהו שבו זה קל מאוד עבור מישהו ללכת ב 1244 01:21:38,020 --> 01:21:40,800 ולעשות מה שהם רוצים לעשות. 1245 01:21:40,800 --> 01:21:42,920 אתה לא רוצה שהם צריכים לנווט 5 דפים 1246 01:21:42,920 --> 01:21:45,460 כדי להגיע לתפקוד הממשלה שלך באתר שלך. 1247 01:21:45,460 --> 01:21:49,290 אם גוגל היו 5 דפים עוד לפני שאתה יכול לחפש משהו, 1248 01:21:49,290 --> 01:21:53,080 אף אחד לא היה משתמש בו. 1249 01:21:53,080 --> 01:21:55,890 ולבסוף, אב טיפוס נייר, קבוצת מיקוד. 1250 01:21:55,890 --> 01:21:59,220 יש עיצוב טוב ושיטות בדיקה. 1251 01:21:59,220 --> 01:22:00,730 רק בגלל שאתה חושב שזה עובד בשבילך, 1252 01:22:00,730 --> 01:22:04,860 זה לא אומר שמישהו אחר חושב שזה עובד. 1253 01:22:04,860 --> 01:22:14,490 אבל כן, זה הכל. 1254 01:22:14,490 --> 01:22:17,490 [CS50.TV]