>> קווין שמידט: שלום לכולם.
ברוכים הבאים לסמינר CS50 על Node.js.
השם שלי הוא קווין.
אני TF CS50.
ואני כמו סוג של ממש נרגש על הסמינר הזה.
אני חושב Node.js הוא מאוד מגניב.
אני מקווה שהסמינר הזה יכול לשמש כמו, אני מניח, קרש קפיצה טובה ל
חלק מפרויקטי הגמר שלך אם אתה מעוניין בשימוש
משהו כמו Node.js.
>> אנחנו סוג של נתחיל את הסמינר על ידי מדבר רק על קצת
סוג של יכולת הרחבה רקע פרספקטיבות של Node.js, ולאחר מכן
נעבור לכמה דוגמאות קוד.
ויהיה לי את הקוד באתר אינטרנט, ואתה יכול להסתכל על הקוד.
ואחרי הסמינר, אני אטפל דיבורים על איך אתה יכול להגדיר Node.js
במחשב שלך.
>> על אישור.
אז בואו נתחיל.
אז אני מניח שאני רק רוצה לדבר על שרתי אינטרנט, באמת, ראשון.
וכדי להתחיל את הדיון הזה, אני בעצם יש תרשים שהוא מ
ספר הלימוד המשמש לCS61, אשר בעצם מציגה את האינטראקציה
בין תהליך לקוח, כמו האינטרנט שלך דפדפן או כמו הלקוח או המטרה שלך
משהו כזה, ושרת אינטרנט.
אז זה סוג של נראה דומה תמונה שראית בהרצאה על
יום רביעי שבו בעצם יש לנו כמה תהליך כמו Google Chrome לקוח.
>> ולאחר מכן צעד אחד הוא לקוח שולח בקשה.
אז זה יכול להיות משהו כמו גם בואו לבקר, אני לא יודע, CS50.net.
אז אנו מנפיקים את הבקשה.
והאם מישהו זוכר את שמו של הפרוטוקול המפרט איך זה
בקשה צריכה להיות בנויה?
כן.
>> קהל: [לא ברור].
>> קווין שמידט: בדיוק.
אז זה כמו HTTP, נכון?
אז בעצם מפרט כיצד בקשה שבעצם צריכה להיות מונחת
החוצה, כי בסופו של היום, בקשה שבאמת רק הוא אוהבת
מחרוזת שבעצם אומר שאני רוצה את זה.
והמפרט בשביל זה הוא הפרוטוקול HTTP.
אז זה כמו פרוטוקול.
>> אז השרת מקבל בקשה ש.
אז החבר 'ה יש לי מותקן בשרת אינטרנט במכשיר CS50.
זה אפצ'י.
וזה שבוע שבו אתה עובד על בעיה להגדיר שבע, אתה בעצם עובד
עם זה שרת האינטרנט.
אז השרת מקבל את הבקשה, ו אז זה חייב לגרד את סוג שלה
ראש ואומר כמו גם מה אני עושה עם זה?
>> אז על סמך מה יחליט לעשות, ולאחר מכן זה ייתכן כי יצטרך לפנות איזה
של משאבים.
ומשאבים שיכולים להיות הרבה דברים שונים.
עבור אחד, זה יכול להיות רק כמו קובץ HTML סטטי.
אז זה יכול להיות רק כמו HTML שהוא כמו ל
האתר האישי שלך.
זה יכול להיות קובץ סטטי כמו תמונה או כמו בסרט שיש לך.
זה אפילו יכול להיות לדבר לסוג מסוים של מסד נתונים
כמו מסד נתונים MySQL.
אז זה לא תמיד צריך לתקשר עם משאבים, אבל ב
מקרים מסוימים, זה יכול.
>> אז מה זה הולך לעשות אחרי זה הוא שזה הולך
לשלוח בחזרה את התגובה.
והתשובה לכך היא גם צוין על ידי HTTP.
אז הלקוח יכול לקבל אותו.
זה יכול לקרוע אותו לגזרים ולעבד אותו.
ואז אתה מקבל דף אינטרנט כמו גוגל או CS50.net או
כל מה שאתה הלך.
בסדר?
>> אז זו האינטראקציה הבסיסית ש אנחנו הולכים להיות התמודדות עם.
ואנחנו הולכים להיות פחות או יותר התמקדות בחלק זה של
אינטראקציה, השרת.
על אישור.
מגניב.
למישהו יש שאלות עד כה?
על אישור.
>> אז כמו שאמרנו, שרת האינטרנט מקבל בקשת HTTP זה ולאחר מכן מוציאה את זה
תגובת HTTP.
וכמו שדיברנו בעבר, שרת אינטרנט של מכשיר CS50 הוא אפצ'י.
לכן, כאשר אתם עובדים על P להגדיר שבע, אתה הולך לעבוד עם
שרת האינטרנט Apache.
אתה לעולם לא צריך באמת לעבוד עם אפצ'י ישירות יותר מדי.
אתה סוג של להגדיר אפצ'י קטן כשאתה מציין את המארחים או וירטואליים
המארחים v, ונקבל לזה בקצת.
>> אבל בעיקרון, שרת האינטרנט Apache להגדיר לעבוד עם סוג PHP
של מחוץ לקופסה.
אז מה באמת קורה הוא כשאתה הולך לאחד מאתרי האינטרנט שלך כמו, למשל,
index.php המקומי מארח קו נטוי או משהו כזה, הוא הדפדפן שלך שולח כי
בקשה, ולאחר מכן האפצ'י יושב יש ודמויות לעשות עם זה.
והפעולה היא לבצע קוד שבindex.php ו
לאחר מכן לשלוח אותו בחזרה.
אז יש את זה.
אז אנחנו סוג של דיברו על זה.
אז זה רק יכול לשרת קובץ סטטי או להריץ כמה קוד PHP ולאחר מכן נושא
התגובה.
>> אז שאלה נפוצה שיכול לבוא למעלה הוא גם, איך אנחנו באמת להתמודד
עם בעל מספר משתמשים באותו הזמן?
אז דמיין אם היית כותב אינטרנט שרת, אם היה לך שרת אינטרנט ש
אתה מנסה לכתוב במשהו כמו C או משהו כזה,
בעצם אתה יכול לחשוב על איך יש יכול להיות איזשהו קוד ש
אקבל את הבקשה, אבל אז יש לו לעשות את כל העבודה הזו עליו.
זה יכול להיות, למשל, פנה מסד נתונים או משהו כזה.
נכון?
ואז זה יהיה לעשות את זה סוג של עיבוד ולאחר מכן
נשלח בחזרה התגובה.
אז זה כמו גבוה סקירה ברמה.
>> אבל זה לא ברור מייד איך אתה יכול לעשות את זה, כך ששני אנשים או
אפילו 1,000 בני אדם יכולים לעבוד איתך שרת אינטרנט באותו הזמן.
אז הפתרון שהאפצ'י משתמש נקרא אשכולות או תהליכים.
אז אתה אולי שמעת על תנאים אלה בעבר.
זה בסדר אם יש לך שלא, אבל פשוט חושב על חוטים או תהליכים כדרכים ל
מערכת הפעלה או תכנית משתמש או משהו כזה או שרת אינטרנט
לביצוע מספר רב של סוג של דברים בבת אחת.
אז אתה אולי שמעת את המונח כמו חוטים של הוצאה להורג.
אז זה כמו סוג של אתה סוג של ריבוי משימות.
>> ואם ראו בתיבה שלך מחשב נייד, או משהו כזה,
ריבוי הליבות, מה שאתה יכול לעשות הוא שאתה יכול להפעיל שני אשכולות שונים על שונה
חלקים של המעבד, כך שהם יכולים בעצם יקרה באותו הזמן.
אז זה ממש חזק.
וזה סוג של האפצ'י פתרון לבעיה זו.
>> אז יש סוג של כמו כל נושאים עם גישה זו אף?
אז אני מניח שאני סוג של כתבתי אותם שם.
אבל שניהם סוג של משתמש הרבה זיכרון.
זה יקר מאוד כדי ליצור חוט או תהליך.
>> וחלק מהסיבה הוא שפשוט כמו כשאתה מפעיל תכנית C
כמו העיקרי שלך ולאחר מכן ששיחות פונקציה אחרת, שיש לו
סוג כלשהו של ערימה.
אז אשכולות גם דורשים לגמרי ערימה נפרדת אשר
יכול להיות די גדול.
ואם אתה יכול לדמיין שיש טונות של משתמשים באתר שלך, האם יש לך
הרבה נושאים שונים.
זה הרבה ערימות כדי לנהל ולתחזק.
אז זה צריכת זיכרון גדולה.
>> ואז, גם, נניח שיש לך רק מעבד אחד, או נניח שיש לך
יותר ממה שיש לך אשכולות אלה multicores.
נכון?
אז בואו נגיד שהיה לך 10 אשכולות והיה לך רק חמישה מעבדים.
אתה סוג של לעשות את הדבר הזה שבו אתה עובר בין הזרם
אחד שפועל בגלל שאתה לא יכול להפעיל את כל 10 בבת אחת.
וזה נקרא מתג הקשר.
ויש לו טווח שבעצם כמה הקשרים שונים, אבל בואו רק
לחשוב על זה כמיתוג בין שני נושאים.
זה יכול להיות די יקר בגלל בעצם מה שאתה צריך לעשות זה אתה
צריך להפסיק את מה שאתה עושה, לשמור את מצב שחוט הריצה, ו
לאחר מכן לעבור למקום אחר.
>> אז האם כל סוג של לראות את מוטיבציה של מה אשכולות ו
תהליכים יכולים להיות קצת מגושמים?
והאם יש לך שאלה?
על אישור.
מגניב.
למישהו יש שאלות?
על אישור.
>> אז אם אנחנו לוקחים צעד אחורה לרגע, יש כמו סוג של
תצפית שאנו יכולים לעשות על הרבה של יישומי אינטרנט.
וזה באמת כל כך הרבה מהם למעשה לא עושה את זה הרבה יותר שימושי
עבודה פנימית של חוט.
אז יש מישהו שנפתחו על P להגדיר שבע בכלל?
אז אתה רוצה אולי לתאר כמה החלקים?
האם עבד בעת כניסה או משהו כזה?
>> קהל: לא.
>> קווין שמידט: אישור.
אין דבר.
סליחה.
אבל בעיקרון, בערכת P, אתה הולך להיות עושה הרבה סוג של
שאילתות למסד נתונים כדי לקבל קצת מידע ממסד נתונים זה.
ומה הקוד שלך הולך לעשות, מה זה תהליך האפצ'י או
שחוט האפצ'י הוא הולך לעשות בזמן זה יש ליצור קשר עם
מסד הנתונים הוא שזה סוג של הולך להיות יושב שם וזה הולך להיות
מחכה למסד הנתונים כדי לענות.
>> עכשיו שאולי לא נשמע כמו שגדול להתמודד משום שמסד הנתונים הוא עליך
מכשיר CS50, נכון?
אבל יש סוג כלשהו של רשת חביון שם כי החברה האינטרנט
שרת יש להוציא בקשה משלו כדי מסד הנתונים כדי לתקשר עם
מסד הנתונים ולאחר מכן לקבל את זה מידע בחזרה.
אז עכשיו זה כמו גם חכה לי, אני הולך לקבל משהו מ
מסד הנתונים ולאחר מכן יש הרבה מחכה קורה.
האם זה הגיוני?
>> ולכמה דברים שזה לא כל כך רע.
אם זה פשוט חייב, למשל, זיכרון גישה, שלא כמו
חביון I / O הנורא.
וכאשר אני אומר, אני / מיסות O, מה אני מתייחס לזה כמו כל סוג של כמו
קלט פלט.
אבל כדי לגשת לקבצים בדיסק, כמו אם אני רוצה לשרת את HTML סטטי
קובץ שהיה באתר שלי או משהו כזה, אני די צריך
לעצור לרגע, לקרוא קובץ ש מהדיסק, ולאחר מכן ב
תהליך שאני מחכה.
אני לא עושה את העבודה מועילה.
>> זה לא נכון מכל דבר, אבל זה הוא נפוץ ביישומים כמו סט P
שבע והרבה יישומים שאתה לא
בעצם עושה הרבה חשיבה.
וכשאני אומר חשיבה, אני מתכוון כמו עבודה חישובית.
עבודה אז חישובית יכולה להיות משהו כמו, נניח, שאתה רוצה
לכתוב שרת אינטרנט שפשוט מחושב מספר פיבונאצ'י המי יודע כמה.
זה לא נשמע כמו במיוחד שרת אינטרנט של כיף.
כמו שלא הייתי מצפה שאתר יהיה פייסבוק הבא, אבל זה חלק
סוג של עבודה חישובית.
>> ואתה יכול לדמיין את זה עם החלפה איזה מעניין אחרים
עבודה חישובית.
בואו נגיד שאתה כותב משהו שחשב את דרגות
הפרדה בין שני אנשים או משהו כזה.
כך שאינו כרוך סוג כלשהו חישוב, נכון?
וגם אז, לעשות כדי שעדיין יש לך לעשות הרבה ההמתנה לאולי
אתה צריך שאילתת מסד נתונים להסתכל עד שזה חברים עם מי או
משהו כזה.
אז יש סוג כזה של רעיון עבודה של חישובית.
האם זה הגיוני?
האם יש למישהו שאלות?
>> אה, ואני מניח ששמתי את שרתי צ'אט יש בגלל שרתי צ'אט הם סוג של
עוד דוגמא טובה לכך.
שרת צ'אט אין לעשות הרבה חשיבה.
זה פשוט צריך לחכות לאנשים לשלוח הודעות ולאחר מכן כאשר
הם, לשלוח אותם.
בסדר?
>> אז רק כדי לסכם שוב, Apache ו שרתי אינטרנט דומים כמו שמזלג
הרבה נושאים ותהליכים אשר יכול להיות סוג של הבזבוז.
אז אני מניח שהשאלה שעלולה לבוא שמאנחנו צריכים
נושאים מרובים ותהליכים?
מה אם רק היו לנו אחד?
>> אז בואו סוג של לצייר תמונה ממה שזה ייראה.
אז בואו להשתמש רק באחד חוטים.
בסדר?
אז רק לדמיין את זה עם חוט אחד.
>> בואו נניח שאנו לא ממש עושים כל כך הרבה שימושי - וכשאני אומר
שימושי, אני מתכוון לעבודה חישובית -
בנושאים מרובים אלו בעבר.
אז בואו סוג של לאחד הכל לחוט אחד.
אז מה אם היו לנו חוט אחד מסוג זה רק מסתובב בלולאה ו
כל הזמן בדיקות עשו משהו חדשים לקרות.
כך למשל, קרה משהו חדש יכול להיות יש לי משהו בחזרה מ
בסיס הנתונים, או שמישהו שלח שלי בקשת HTTP חדשה.
אז אלה הם סוג של אירועים לזה לקרות, נכון?
>> ואז מה אני יכול לעשות בעת חדשה אלה לדברים לקרות הוא באותו אשכול זה
ביצוע, חוט אחד של הוצאה לפועל, אני יכול לקרוא קצת קוד ש
יטפל דבר מסוים הזה.
כך למשל, אם יש לי משהו בחזרה ממסד הנתונים, אני יכול לרוץ שלי
חלק חישובית קטן ממנו כי למעשה רק מכין את הדבר
לשלוח בחזרה למשתמש.
אז עושה את זה סוג של הגיוני?
>> אבל מה הם באמת השלכות של זה?
נכון?
מכיוון שאנחנו כתבתי הרבה קוד ש--
ואני רק הולך לקפוץ קדימה בשקופיות, אם זה בסדר.
אז אם לא אכפת לך, אני רק הולך לקחת צעד אחורה.
אז זה סוג של דבר הוא בשם לולאת אירוע.
בסדר?
וזה סוג של היסוד רעיון מאחורי Node.js.
>> אז מה Node.js הוא באמת עושה כאינטרנט השרת הוא שיש חוט אחד
כי הוא בעצם מסתובב בלולאה כמו סוג ואילו אחד מתחת
מכסה המנוע של Node.js זה כל הזמן בדיקה, האם אנו מקבלים דברים חדשים?
ואז הוא יתמודד מפעילים שאתה מגדיר.
אבל שאלה טובה לשאול היא, איך אנחנו יכולים לגרום לזה לקרות
עם דברים קיימים?
>> אז שמתי את שורת קוד C כאן כי בעצם נראה כאילו זה פתיחה
להגיש, נכון?
אני היא יצאתי רק עם אלבום.
אז הייתי צריך לפתוח אותה בקובץ חדש.
לכן דרך קוד C שלנו להפעלה -
ואני מניח שהסיבה שבחרתי קבצים הייתה בגלל זה הוא סוג של המידה
עבודת I / O שעשינו ב-C ב מובן שיש פלט קלט.
אז אנחנו קוראים את הקוד הזה כי עושה F זה פתוח.
ולאחר מכן בשורה הבאה שלנו תכנית, עכשיו אנחנו יכולים לעבוד עם f.
>> אז זו תהיה דוגמא למשהו זה כמו סינכרוני או
חסימה משום שבשורה ראשונה שם אנחנו מחכים עד ש
לקבל את הקובץ פתוח.
אז בשורה השנייה, אנחנו יודעים שאנחנו יכול לעבוד עם F, אבל זה אומר ש
שהשורה שנייה לא באמת יכולה לרוץ עד השורה הראשונה נעשה.
האם זה הגיוני?
>> אז זה יהיה רע לשים במטפל באירועים.
והסיבה לכך היא כי סוג זה של מחכה, נכון?
אז זה יחזור אלינו בחזרה לאותו הדבר.
ועכשיו אנחנו אפילו לא צריכים יתרון של אשכולות מרובים או
תהליכים בגלל שיש לנו חוט אחד בNode.js.
האם זה הגיוני לכולם?
>> קהל: חכה.
אז מה התחליף?
>> קווין שמידט: אה, אז כן.
אז אני הולך להגיע ל ההחלפה.
על אישור.
אז מה אם היו לנו משהו שנראה כמו זה?
אז מה אם עכשיו אני בעריכה ו לפתוח קצת?
אז אני עובר באותו שני טיעונים כמו קודם.
אני עדיין אוהב את השיר החדש שהיא יצאה איתו.
אבל אני עובר דבר שלישי ש נקרא משתנה זה קוד.
>> אבל מה הוא בעצם קוד בהקשר הזה?
האם זה כמו משתנה C רגילה?
זה פונקציה, נכון?
וזה עשוי להיות קצת מוזר כי אני בעצם כמו עכשיו עובר
פונקציה לפונקציה אחרת.
>> אז כמה דברים שחשוב לציין בעניין זה.
אחד, אני לא ממש קורא פונקצית הקוד.
אז אתה לא רואה את קוד עם paren שמאל, סוגריים הנכונים.
אני רק עובר בקוד.
ובC, מה זה בעצם לעשות הוא נותן לי מצביע שלבפועל
קוד, ואז זה יכול להפעיל אותו.
אבל רק לחשוב על זה כמו שאתה נמצא עובר את הקוד לפעול בעת
הקובץ שנפתח.
>> אבל מה שזה אומר זה שעכשיו שאר התכנית שלי שיכול לעשות
דברים אחרים, יכולים להמשיך לעשות אחרים דברים בזמן שאנחנו, לא ממש לחכות, אבל
פשוט יש בחלק האחורי של הראש שלנו, כי כאשר קובץ שהפתוח, ריצה ש
קוד בחלק העליון.
האם זה הגיוני?
>> ועכשיו הרעיון מאחורי Node.js הוא כי הקוד בדברים לעשות עם f
חלק צריך להיות די קצר ופשוט וברור ולא ממש להיות
מאוד אינטנסיבי המחשוב.
זה אולי צריך לפתוח קובץ אחר, אבל שצריך להיות גם די מהר
כי זה רק צריך לומר לעשות f אחר לפתוח ולאחר מכן קורא לקוד אחר זה.
>> אז רק כדי להיות ברור לחלוטין, ו פתיחה שעושה את שיר Katy Perry החדש
mp3 לעשות, זה הולך די הרבה לחזור באופן מיידי.
ואז אנחנו יכולים רק להמשיך לעשות דברים אחרים, כי כל מה שהחברה ו
שיחה פתוחה אין הוא אומר לי בעצם קוד פתוח ו בסיסי לפתוח קובץ זה
וכשתסיים פתיחה זה קובץ או כאשר אתה מקבל אותו בחזרה,
לאחר מכן להפעיל את הקוד הזה.
אבל זה לא ממש להפעיל קוד זה.
והיה לך שאלה?
>> קהל: אתה נראה לרמוז כמה פעמים כי הוספת המחשוב
קוד אינטנסיבי סוג של לשבור את מערכת מונעת [לא ברור].
[לא ברור]?
>> קווין שמידט: זו שאלה גדולה.
אז יש לי בעצם דוגמא לאופן אתה יכול לשלב את המחשוב
קוד אינטנסיבי בקצת.
לכן, כאשר אנחנו מגיעים לדוגמאות הקוד, אני אהיה בטוח כדי למשוך את זה.
האם זה בסדר?
תודה.
>> מה השם שלך?
>> קהל: אהרון.
>> קווין שמידט: אהרון מעלה מאוד נקודה טובה, וזה שאם היה לי
קצת קוד אינטנסיבי המחשוב ב הדברים לעשות עם חלק F, שאר
התכנית שלי לא יכולה לרוץ ולא יכולה להקשיב לבקשות או כל דבר חדשים עד שכל
דברים שהוא סיים.
אז אם אני כותב קוד צומת באופן כללי אלא אם אנחנו עושים משהו כמו שאני הולך
להציע מאוחר יותר, כאשר אנו מסתכלים על דוגמאות קוד, אני חייב להיות בטוח כי
הקוד שלי לא לקשור את אירוע לולאה זו.
האם זה הגיוני?
על אישור.
מגניב.
>> אז Node.js מציע מסגרת זו אתה יכול לבנות את אירוע אלה מונעים
שרתים עם.
אז יש לו סוג של אסינכרוני אלה ללא חסימת קלט / פלט ספריות, ואילו
ספריות C סטנדרטיות שאנחנו כבר עבודה עם, כמו אם אתה רק
להשתמש בם באותו אופן שיש לנו כבר משתמש בהם עם F פותח ו
דברים, אלה חוסמים בגלל אתה בעצם צריך לחכות
הקובץ שייפתח.
>> אבל Node.js נותן לך את זה וזה בעצם מתחבר לV8 של גוגל
JavaScript מנוע המהווה את הסיבה כי הכרום הוא כל כך מהר, בעיבוד
JavaScript כי זה יש מנוע V8 הזה.
אז אני יודע שזה נשמע כמו אחד מאותם דבר כנסי מפתחי WWDC
שבו הם פשוט זורקים את חבורה של דברים מספר מכתב למעבדים
ואומר את זה כל כך מגניב.
אבל זה מגניב שהם עשו כי JavaScript זה -
או אולי אם אתה לא מכיר JavaScript עדיין בגלל שלא היו לנו
ההרצאות על זה -
אבל JavaScript היא לפרש שפה.
>> וזו נקודה חשובה יותר מדי.
לכן חשוב לאתר האינטרנט שלנו שרתים להיות מהירים, נכון?
ואם היינו פשוט רצנו JavaScript קוד שהתפרש רק עם
כל פרשן ישן זה יכול להיות איטי.
יתרונות אז צומת מהצורך זה פרשן V8 סופר מהיר.
ואני לא יודע אם הם שמו את זה בגלל סטירת V8 במצח
דבר, אבל בסדר.
>> אז הכנתי כמה דוגמאות בכתובת זו.
לאחר הסמינר, אני סוג של הולך לדבר על איך אתה יכול לקבל סט צומת
למעלה, אך לעת עתה, אני פשוט סוג של רצון ללכת דרך כמה דוגמאות קוד.
כך שאם אתה רוצה לבצע יחד, כל קוד המקור זמין שם.
בסדר?
>> אז אני אשאיר את כתובת אתר זו עד לקצת.
ואז אני פשוט הולך לעבור למסוף.
האם כולם טוב עם כתובת אתר זו?
אז אני הולך לעבור למסוף שלי כאן.
>> אז הנה הקוד ש יש לי להיום.
למה שלא נתחיל עם simpler.js להגיש?
הדבר השני הוא שכל זה קוד הולך להיות כתוב ב
JavaScript שבו אתה יכול או לא יכול להיות מוכר.
אני מניח שכמה דברים הוא שהרבה של קוד JavaScript הוא הסוג של
תחביר ומבנה דומה מאוד C, ולכן סוג של אתה יכול להרים את זה כמו
אתה הולך יחד.
אני כבר ניסיתי לכתוב הרבה קוד מתחיל לכך באופן זה
דומה ל-C, כך שזה קצת יותר קריא.
אבל ככל שנתקדם, אני אהיה מפגין כמה נוסף
תכונות של JavaScript ש הם די מגניב.
>> אבל בואו נסתכל על תכנית לדוגמה זו.
אני מניח שכל מה שהוא מנותק שם.
אני רק הולך לתקן אמיתי ש מהר אם זה בסדר או לא.
אני לא יודע מה זה הולך לעשות.
האם זה קצת יותר טוב?
אתה יכול לראות את var וכאלה?
על אישור.
>> אז השורה הראשונה היא כמו JavaScript גרסה של משתנה
הכרזה.
אז רק כדי להדגיש את מה שהיית עושה את זה נראה כמו בג אז זה בדיוק כמו
מדדי אומר שווה שלושה או משהו כזה.
אז לא לציין את הסוג.
JavaScript אכן יש סוגים, אבל זה הקלדה מאוד דינמי בטבע, ולכן
לא ספק כל סוג שהוא מהסוג עליו.
אז זה פשוט יש var.
זה כמו משתנה.
בסדר?
>> ואני מתקשר HTTP משתנה זה.
ועל צד ימין שלי, יש לי ביטוי שאני רוצה לשים בפרוטוקול HTTP.
וזה אומר דורש HTTP.
אז זה די דומה לכולל.
זה קצת יותר כמו חזק מאשר כולל, במובן זה כולל
היה להעתיק ולהדביק רק את הכותרת להגיש לאבות טיפוס לפונקציות או
מה עם הגדרות הסוג.
אבל דורש הוא בעצם הולך כדי לגרום לנו הקוד.
>> אז אתה יכול לחשוב על זה כעל יבוא קצת קוד.
אז באיזשהו מקום במודול Node.js מערכת או כל דבר אחר, יש להם את כל זה
קוד שרת HTTP אז אני פשוט להביא אותו לשלי
שימוש אישי בתכנית זו.
בסדר?
>> אז יש לי את התפקיד הזה שאני כתבתי.
ושים לב שאני לא צריך לציין סוג ההחזרה או הסוג של
טיעונים שוב.
אז סוג של הקלדה רופפת ב זה סוג של תחושה.
שני טיעונים שזה לוקח ב, הבקשה ותגובה.
אז זה מושגית כמו סוג של מוכר מהתמונה שהיו לנו
על המסך לפני כי אנחנו מקבלים בקשה זו שאנו
יש לי מהמשתמש.
ואז יש לנו בתגובה כי אנחנו יכולים לכתוב דברים.
>> אז השורה הראשונה של עושה res.writeHead 200 ואז זה
טקסט רגיל לסוג התוכן.
אז בואו זה חתיכה בנפרד קצת.
אז בואו פשוט להתמקד בres.write לקטן.
אז הכתיבה היא בעצם, ולכתוב את הראש, הם רק דרכים לכתוב את הסוג של
דברים לתגובה.
בסדר?
אז לכתוב את הראש, אם מישהו זוכר מהרצאת HTTP, לעשות לך חבר 'ה
זוכר את הכותרות ב העליון של הדבר HTTP?
אז למה אני לא פשוט הדגמה כותרות ממש מהר.
האם זה יהיה מועיל?
או שאנחנו צריכים פשוט סוג של -
על אישור.
בטח.
>> לכן, כאשר הדפדפן שלך הולך ל-google.com או משהו כזה,
אין למעשה קצת יותר -
זה כמו סוד -
יש כמו קצת יותר מידע שמגיע דרך הצינור מסתם
חיפוש וכל דבר הקטן.
אז כדי להראות לך את זה, אני הולך כדי להשתמש בתוכנה בשם קורל.
בסדר?
אז זה משהו שאתה יכול לרוץ ב הקו שלך Mac OSX הפקודה או ב
מכשיר או כל דבר אחר.
ולכן אם אני סלסול HTTP google.com, אני הולך לראות את ה-HTML.
וזה, בהגינות, רק HTML שסוג של אומר לך
להפנות לwww אם הדפדפן שלך לא באופן אוטומטי להתמודד עם
ניתוב מחדש.
>> אז זה רק ה-HTML, אבל אני הולך להוסיף לסלסול מקף זה אני דגל.
בסדר?
וזה הולך להראות לי הכותרות.
אז זה גם מידע שמגיע דרך כאשר אני מקבל את התגובה הזאת.
בסדר?
>> אז בראש, אתה רואה את זה HTTP 301 להעביר באופן קבוע.
וזה סוג של חשוב, כי זה מתייחס לקוד המצב.
אז 301 כאן הוא קוד המצב, שהוא בעצם רק מספר שלם
שאומר לדפדפן או מי שזה קורא את זה, אם אתה מעמידים פנים ש
אתה דפדפן ואתה רואה את זה, בעצם עכשיו, אם אתה מסתכל
ושאתה רואה 301, אתה יודע שיש לי לעשות משהו מיוחד המבוסס על
301, או משהו מיוחד קרה המבוסס על 301.
אז זה אומר שעבר באופן קבוע.
>> ואז, בעצם, יש לנו חבורה של זוגות ערך מפתח.
אז אנחנו מקבלים את המיקום הוא www.google.com.
ואז כל סוג של דברים אחרים זה, אבל בעצם, מהו המיקום
אמרה היא המיקום החדש הוא בwww.google.com.
אז עכשיו אם אתה רוצה ללכת ל-google.com, תוכל סוג של לראות את סוג הדפדפן של מצמוץ
לשנייה ולאחר מכן להפנות אותך זכות חזרה לwww.google.com.
אז התשובות יכולות להכיל כותרות אלה.
>> וכמה דברים כדי להצביע.
אז בואו נגיד שהיינו מוצלח באמת בביקור בדף אינטרנט.
אז תן לי ללכת -
מה אתר טוב?
אני רע בחשיבה של טוב אתרים במקום.
>> קהל: ויקיפדיה.
>> קווין שמידט: אישור.
בואו נעשה את ויקיפדיה.
אז הנה אני התרגשתי.
אה רגע.
הייתי?
כן, הייתי.
על אישור.
אז יש לי לעשות www.
אז אני הולך לעשות www.
וכפי שאתם יכולים לראות, הנה כל HTML שהדפדפן היה תהליך
לויקיפדיה.
>> אבל אם אני אמשיך גלילה עד כאן, מה אני אראה בחלק העליון -
וואו, יש הרבה HTML בוויקיפדיה -
אבל מה שאני יכול לראות בחלק העליון כאן הוא קוד שבניגוד לזו 200 מעמד
301 שראיתי קודם לכן.
ושים לב שיש לו נחמד אישור ידידותי לצד זה.
אז זה כמו קוד מצב הטוב.
>> האם זה מספר 200 נראה מוכר?
כן, כי כשעשיתי simpler.js, כתבתי 200 שם.
אז זה בעצם אומר לספר דפדפן או מי שמנסה להגיע ל
זה שהם היו מצליחים.
או סוג כזה שלנו כמו היו מוצלחים מדי.
>> ויש תחביר מיוחד מסוג זה ב-Javascript להכרזה
המפה של מקשים אלה כמו סוג התוכן והערכים הללו כמו טקסט רגיל.
אז אם אתה מסתכל על התגובה שאנחנו חזרתי מויקיפדיה בעבר, -
אני הולך לנסות כדי לגלול עד קצת יותר מהר -
יש לך את המפתחות האלה כמו שרת והערכים הללו האפצ'י.
אז יש לך את מפתחות וערכים.
ואתה יכול לציין זאת ב צומת מה לשלוח בחזרה.
>> אז זה בעצם סוג של, בכמה דרכים, ובמובנים מסוימים זה לא
באמת, אבל זה ברמה מעט נמוכה יותר מקוד PHP שאתה יכול להיות
כתיבה עבור P להגדיר שבע בגלל PHP ו אפצ'י סוג של לטפל בכמה
הדברים האלה בשבילך.
ב-PHP, אתה יכול לעקוף את ברירת המחדל התנהגות על ידי כתיבת הכותרות שלך.
אבל לצורך זה, אנחנו מקבלים כדי לכתוב את הכותרות שלנו.
>> אז האם קו שהגיוני כולם, בקו הראש לכתוב?
על אישור.
מדהים.
>> אז מה שאני עושה זה לסיים את התגובה על ידי אמירת שלום עולם.
על אישור.
אבל זה רק פונקציה נקרא מטפל בקשה.
אז עכשיו אני באמת צריך לעשות סוג של משהו עם פונקציה זו, נכון?
>> אז הנה מה שאני עושה הוא שיש זה קו שבו עושה שווים שרת var
HTTP.create שרת, ולאחר מכן אני לעבור במטפל הבקשה.
אז זה סוג של הצומת דרך של יצירת שרת.
ושים לב שאני מעביר במטפל הבקשה.
אז זה אומר לי createServer פונקציה שאני רוצה שתעשה אותי
שרת, וכאשר השרת שמקבל תגובה, אני צריך שקורא לזה
לבקש פונקצית מטפל.
בסדר?
>> אז קו שפחות או יותר מסיים מייד.
אז שורת שרת var נעשית ימין אחרי שאתה עושה את זה די הרבה.
אני מתכוון, זה חייב להגדיר כמה פנימי מדינה יודעת שהיית צריך
קורא לזה פונקצית מטפל בקשה, אבל זה לא הולך לשבת שם ו
יש לומר למשתמש שנשלח שלי בקשה עדיין?
יש למשתמש שלח לי בקשה עדיין?
אז זה לא לחסום.
בסדר?
>> אז מה זה יעשה הוא זה בעצם החברה מאחסן את מצביע לקוד הזה,
פונקציה זו בקשת מטפל, ולאחר מכן יהיה להפעיל קוד שכאשר מישהו
גורם בקשה.
ואז אנחנו עושים server.listen.
>> 1337 שם הוא די שרירותיים.
לא היה לי סיבה מיוחדת לקטיף המספר הזה.
זה היה אקראי לחלוטין.
אבל זה רק מציין את הנמל.
אז רוב שרתי האינטרנט אתה תראה שהם להשתמש ביציאה 80 כי זה סוג
כמו האמנה.
אז אם אני הולך למשהו כמו, אני לא יודע, Wikipedia.org,
ושמתי את מעי גס 8 -
וואו, אתה לא יכול לראות את זה.
אני מצטער.
אבל אם אני עושה את ויקיפדיה -
אני כותב את זה כאן רק כדי ש זה ברור שעל המצלמה.
אבל אם אני לוקח את זה לדפדפן עם מעי גס 80, המציין ללכת
Wikipedia.org בנמל 80.
אז זה כמו איך יש לו את ארצות הברית יציאות מרובות כמו שבו אתה יכול לשלוח
דברים לסוג של.
אז זה כמו ללכת לזה בפרט מקום על שרת זה.
על אישור.
>> אז אני פשוט בחרתי 1337.
יש מגוון של מספרים שלם כי אתה יכול לבחור.
זה לא היה מיוחד לחלוטין.
>> אבל מה שאני הולך לעשות עכשיו הוא אני הולך לרוץ צומת.
תנו לי למעשה להיכנס כי בני זוג קווים למטה, כך שאתה יכול לראות את זה.
אני הולך לעשות את הצומת, ואני הולך לרוץ simpler.js.
ונדבר על איך להגיע צומת הוקמה בקצת.
אבל עכשיו זה פשוט רץ בשרת.
>> אז דבר אחד שאנחנו יכולים לנסות שאולי לא להיות שמרגש הוא בעצם שאנחנו יכולים
אנסה לגשת אליו בסלסול.
אז אני יכול לעשות את קורל, ושלי מכונה היא מארח מקומי.
תוכל גם לראות את זה בכתב כמו לפעמים זה.
מארח ו127.0.0.1 מקומיים הם סוג כמו המחשב הביתי שלך.
אז זה כמו לדבר המחשב שלך.
על אישור.
>> ולאחר מכן אני יכול לומר 1337.
אז אם אני מפעיל את הקו הזה של קוד, זה אומר שלום עולם.
ואם אני רוצה לראות את הדברים האלה, כי טקסט של סוג התוכן היה רגיל או
מה, אני יכול אפילו לשים את זה כאן.
ושים לב שזה אומר על אישור.
ויש לי טקסט רגיל.
ויש גם את סוג של כל זה אחר דברים שהצומת תוסיף ב
שם בשבילי.
זה לא סופר חשוב.
>> אני מתכוון, יש כמה סוג של טכני היבטים של בכי הם סוג
מגניב לדבר עליו, אבל רק כדי להראות לך, יש לי גם את הכח
לשנות תנאים אלו בסביבה.
אז רק אני יכול להוסיף חבורה דברים כאלה.
ואז עכשיו, אם אני מסתכל בי פלט, זה יהיה זה.
אז הכותרות הללו אומר דברים מסוימים לדפדפנים ודברים כאלה.
>> וכותרות בעצם יכולות להגיד דפדפן כיצד להגיב למשהו.
אם אי פעם שמעו על עוגיות לפני, או אם אי פעם היה מתעצבן
על ידי דף אינטרנט הגדרת עוגיות, או מופעל בלוק או עוגייה
משהו כזה.
למעשה אתה יכול להגדיר עוגיות בכותרות אלה.
אז הם אומרים לי דפדפן כיצד התנהגות במקרים מסוימים.
על אישור.
>> אז זה היה simpler.js.
האם יש למישהו שאלות באותו קובץ קוד המקור?
על אישור.
מגניב.
>> אז בואו להסיר את r מזה ומסתכל simple.js.
אז זה פחות או יותר אותה תכנית.
אני רק כתבתי את זה קצת אחר כי רציתי למיין של גולת כותרת
כמה תכונות של JavaScript.
>> אז שם לב שמטפל הבקשה פונקציה נעלמה לגמרי.
אה כן, האם יש לך שאלה?
>> קהל: כן, הטיעונים כי הם עברו לזה
פונקציה, מה הם?
>> קווין שמידט: אז אלה הם JavaScript אובייקטים.
בתיעוד Node.js, זה בעצם אומר מה הן שיטות
זמין עליהם.
אנחנו פשוט צריכים הגישה ל שיטה זו נקראת כתיבת ראש והסוף
ודברים כאלה.
אבל יש חבורה שלמה עוד שיטות.
>> ולמשל, כאחד מהם בפרט על rec, אתה יכול לעשות
משהו כמו rec.method אשר יהיה להגיד לך אם זה HTTP או לקבל
הודעה HTTP בקשות ו דברים כאלה.
אז יש כל מיני שונים מאפיינים, אבל הם שניהם
JavaScript אובייקטים, ורק להם פונקציות המצורפות אליהם, כי אתה
יכול לכתוב דברים.
בסדר?
>> אז שם לב שמטפל הבקשה הוא נעלם לחלוטין.
אבל הקוד שיש לי בבקשת מטפל הוא עדיין שם.
עדיין יש לי res.writeHead זה ועדיין יש לי res.end זה.
ומה זה הוא דוגמא ב JavaScript היא הרעיון הזה של
פונקציה אנונימית.
ואנונימי הוא כמו שם הולם לזה כי זה עושה ממש לא
יש לו שם.
אין בקשת פונקציה מטפל שם.
>> אין לו שם, אבל זה עדיין הוא לוקח ויכוח.
אז יש לי עוד rec ומיל.
ועדיין יש לי את הקוד.
זה בסדר גמור קוד JavaScript.
אז אני יכול להכריז על פונקציה ללא באופן מפורש לתת לו שם.
זה קצת מבלבל בהתחלה.
יש כמה דברים שימושיים כמו שאתה יכול לעשות עם
פונקציות אנונימיות אלה.
האם יש למישהו שאלות על זה, או שזה בסדר רק כדי, לעת עתה,
סוג של פשוט לקבל את העובדה שזה יעשה את אותו הדבר?
כן?
>> קהל: האם פונקציות הראשונות בכיתה ב-JavaScript?
>> קווין שמידט: הם ראשון בכיתה ב-JavaScript.
ורק יודע שמושגים אלה עובר בפונקציה אנונימית כמו
זה חלים על JavaScript שאתה יכול לכתוב בפרויקט הגמר שלך ל
דפדפן האינטרנט מדי.
כך למשל, בJavaScript ב הדפדפן שלך, זה גם קצת אירוע
מונע במובן זה מה שאתה יש לי הוא כאשר המשתמש לוחץ על זה
כפתור, אני רוצה לך להפעיל את הקוד הזה.
>> אז זה אותו הסוג של רעיונות של בצד לקוח, כאשר בלחיצת עכבר או שהם
במעבר עכבר על תמונה מסוימת עליך דף האינטרנט, להריץ את הקוד הזה.
זה יכול לחול על שרתים.
אז זה כמו סוג של מרגש הסיבה JavaScript היא באמת
אנשים מתאימים או שחושבים שזה שפה מתאימה מסוג זה
שרת נהג אירוע כי יש לך פונקציות אנונימיות אלה.
יש לך את כל הרעיון של קוד אסינכרוני זה.
על אישור.
למישהו יש שאלות?
>> על אישור.
אז זה היה simple.js.
אז בואו נסתכל על עוד אחד או עוד כמה.
אז זה sleep.js.
אז האם מישהו מכיר שנת פונקצית C?
מאולי אחד מההרצאות הקודמות או משהו כזה?
>> אז בעצם אתה יכול לעבור באני חושב מספר שניות, או אם אתה משתמש ב-U
לישון מספר אלפיות השניה או ננו שניות.
ובעצם התכנית תהיה פשוט להפסיק פועל במשך פרק זמן זה.
נכון?
ואז זה יהיה סופו של דבר יתעורר ו אז זה פשוט ממשיך לרוץ
את התכנית.
>> אז שרת זה סוג של נותן הרושם של שינה.
אז שם לב שיש לנו את אותו res.writeHead 200 עם הכותרת כמו
בעבר, אבל אז אנחנו קוראים את זה פונקציה שנקראת פסק זמן שנקבע.
פסק זמן להגדיר זמין גם ב דפדפן האינטרנט שלך ב-Google Chrome
או ספארי או משהו כזה.
ובעצם מה שהוא עושה כאן הוא זה לוקח בפונקציה.
שימו לב, שוב, שזה פונקציה אנונימית.
אז זה די מגניב בגלל שאנחנו באמצעות פונקציה אנונימית בתוך
פונקציה אנונימית אשר יכול להיות קצת מוזר.
>> אבל זה לוקח פונקציה ש, שהוא בעצם אומר - והדרך זו
עבודות היא ב5,000 אלפיות שנייה, אני רוצה לך לבצע פונקציה שבי
רק מסיימת את התגובה וכותבת היי.
אז זה נותן את הרושם של כאילו ישן, אבל בדרך זו למעשה
עובד הוא שאנחנו נרוץ דרך קו זה מהר מאוד.
אנחנו רק כותבים משהו.
ואז גם להפעיל באמצעות קו זה מהר מאוד.
אז אנחנו לא ממש הולכים לחכות חמש שניות.
אנחנו רק הולכים לרוץ קוד זה באופן מיידי.
>> ויש גם, שוב, זה קצת אירוע לולאה שעכשיו יש את הדבר הזה
אוגרים שבעצם הוא רק כל הזמן מסתובב במעגל
ומסתכל על השעון באחת חוט ואומר, יש לו חמש שניות
עבר עדיין?
ואז כשהוא רואה ששני היד עברה כמו חמש שניות או
מה, אז הוא מתעורר ואומר, הו, מה אני צריך לעשות?
אוי אני חייב לרוץ את הקוד הזה.
ואז זה הולך להפעיל res.end היי.
>> אז שוב, אנחנו לא מחכים כאן.
אז זה לא שהקוד הזה בתוך פונקציה זו הולכת לקחת חמש
שניות לרוץ.
קוד זה יפעל פחות או יותר באופן מיידי, לפחות ביחס ל
שניות חמש שאנחנו מדברים עליו קודם לכן בעבר.
>> אז רק כדי להראות את זה בפעולה, אני יכול לעשות Node.sleep.js.
ועשה לי בלגן משהו?
אולי.
סליחה.
בואו נראה מה אנחנו יכולים לעשות כדי לתקן את זה.
על אישור.
אז בהחלט להשתמש Node.js.
אני רק צוחק.
על אישור.
רק אחד לשנייה.
על אישור.
אני יודע מה זה.
>> אז הבעיה היא שבכרטיסייה אחרת שלי כאן, אני רץ כבר בצומת
שאותה כתובת, 1337.
אז שגיאה שזה זרק, אם אנחנו מסתכלים על זה ממש מקרוב, היא בכתובת
להשתמש, EADDRINUSE.
אז כבר הייתי משתמש 1337 כאן.
אז אם אני סוגר את זה, ואז אני עכשיו אנסה להפעיל את זה, אני מקווה, את כל מה
יהיה בסדר.
על אישור.
אז אתה רק יכול להיות סוג דבר אחד של ההקשבה ביציאה ובעונה אחת.
פתרון נוסף היה בשבילי רק כדי לערוך את התוכנית ולהפוך את
זה יהיה כמו 1338 או משהו ככה.
>> אבל עכשיו שינה פועלת.
אז בואו באמת לנסות את זה ב דפדפן זה זמן כי זה
מרגש קצת לראות זה במסוף.
אז רק אני הולך ללכת לזה 127 כתובת שוב ב1337.
ואם אתה יכול לראות את זה -
אני לא יודע אם אתה יכול - אבל שלי הדפדפן של נטילת מאוד, מאוד ארוך
זמן לטעון או כמו חמש שניות.
>> ואז אחרי זה, זה סוף סוף סיימתי את התגובה.
ואתה לא יכול לראות את זה כי הדבר הוא עבר על פני קטן, אבל אם אני עושה
קצת יותר קטן זה, אתה אפשר לראות את זה, אומר היי.
אז יש לי את היי, אבל לאחר חמש שניות.
וזה יכול להיות קצת נקי יותר לראות זה כאן במסוף, ולכן אני
הולך לעשות -
בואו נעשה כאן -
בואו נעשה את סלסול הכתובת ש שוב עם 1337.
ואני פשוט סוג של צריך לשבת כאן במשך חמש שניות.
אבל שם לב שהשרת יכול לקבל את התגובות חדשות.
אז זה מדפיס היי.
>> וכדי הדגמה זו, בעצם מה אני יכול לעשות בכרטיסייה אחרת זה -
אז בואו נאמרתי שאני עושה את זה בכרטיסייה אחרת, אני הולך לעשות את קורל ואת אותו
דבר שוב.
ואני הולך לנסות לבעוט אלה החבר 'ה יורד באותו הזמן.
אז אני הולך לעשות את זה, ואני הולך להתחרות כאן ואני
הולך לעשות את זה שוב.
>> ובואו נעשיתי את זה, כך שאתה יכול לראות את שניהם.
כי אחד מודפס היי וכי אחד מודפס היי כל הדרך ב--
בואו נעשה ניסוי זה שוב.
בעצם, בואו נשתמש בזה טריק, אם זה בסדר.
>> אז אני הולך להשתמש דבר שפגז מאפשר לי בעצם להפעיל שני עותקים
של תכנית זו במקביל.
אז זה יהיה להפעיל את התכנית הראשונה ו התכנית השנייה במקביל.
אז עכשיו אם אני לוחץ על Enter, זה הולך כדי להפוך את הבקשה שפחות או יותר
באופן מיידי באותו הזמן.
אז בואו אתן לזה צ'אנס.
>> אז עכשיו שם לב לזה, אומר שני תהליכים.
ואם אתם סקרנים, ש27,000 מספר הוא בעצם את תהליך זיהוי.
ואז שם לב, שהם מודפסים היי באותו הזמן.
זה לא היה כמו שהיינו צריך לחכות חמש שניות לאחד ואז אחרי זה,
חמש שניות לאחר מכן לקבל את השנייה.
אז זה סוג של, במובנים מסוימים, זה לא ממש ראיות, אבל זה
ראיות אינטואיטיבי שזה לא רק כמו מחכה חמש שניות וחסימה
כל החוט.
אישור מגניב.
>> אז אהרון שאל שאלה מוקדם יותר באותו היה, אז מה אם אנחנו עושים משהו -
כן?
>> קהל: חכה.
איך זה שונה מ חיץ printf, אם כי?
האם זה לא באופן אוטומטי לעשות את זה?
למה אנחנו צריכים לדאוג בקשר לזה?
>> קווין שמידט: אה, הייתה לך אומרת שעוד פעם אחת?
>> קהל: האם לא אוהב את חיץ printf לעשות את אותו הדבר בדיוק?
>> קווין שמידט: חיץ printf?
>> קהל: כן.
על אישור.
לא היה באחד מהחידונים הם היו מדבר על כך שאם אתה ימני printf
משהו ואז יש לו להשהות אחד שני, ואז יש לך את זה לולאה עשר
פעמים, זה יחכה עשר שניות ו אז printf הכל ביחד?
>> קווין שמידט: אה, אוקיי.
>> קהל: האם זה עושה את אותו הדבר דבר אז במקרה זה?
>> קווין שמידט: אז השאלה הייתה בעצם באחד מהחידונים לשעבר
או משהו, לא הייתה שאלה ש בעצם אם אתה אומר הדפסה ו 10
דברים בו זמנית ולאחר מכן ישנו כמו ב תהליך הדפסה אותם החוצה,
בסופו של הדבר מסיבה כלשהי, זה היה פשוט לזרוק את כל אלה על המסך.
אז יש סוג של שתי שונים מושגים כאן.
>> אז אני מניח שדבר אחד הוא, כי בזה מקרה, שאנחנו עם שתי שונים העוסקים
סוג של אנשים שואלים את השרת לדברים באותו הזמן.
והסיבה לכך שהסוג של printf מחכה כמו ושמרוקן את כל זה
בבת אחת הוא קשור יותר איך סוג של printf -
כך printf הדרך הוא למעשה מיושם הוא זה בעצם יש
לדבר עם מערכת ההפעלה כדי לכתוב דברים שלקונסולה.
אז זה לא רוצה לעשות את כל זה דברים מייד כשאתה אומר printf
כמה מחרוזת משום שיכול לקבל יקר אם יש לו
לעשות את זה בכל פעם.
>> אז אם אתה עושה printf היי, התכנית שלך אולי לא ממש להדפיס כי
מייד למסוף.
זה אולי אומר, אוקיי, אני כתבתי אותו.
ואז לחכות סוג של לך לתת זה קצת יותר לפני למעשה
כותב את זה לקונסולה.
>> אז הסיבה לכך שזה היה המקרה -
וזה סוג של בלתי קשור לשינה -
הוא שהשינה הייתה סוג של רק הזריק לשם כדי להפגין
עובדה שזה לא לכתוב זה באופן סינכרוני.
אבל הסיבה לכך היא פשוט ביצועים, כך שאתה לא צריך
ליצור קשרים שרבים מערכת ההפעלה.
>> אבל כאן, מה שאנחנו באמת מנסים לעשות עם הדבר ישן הזה הוא רק להראות
כי כאשר יש לנו שני אנשים לבקר האתר הזה, זה לא הולך לשים
אותם בשורה שבה הוא הולך להגיד אני חייב לעזור לך, ואז כשאני
לחלוטין סיים לעזור לך אחרי אלה חמש שניות, ואז אני הולך
לעבור על האדם הבא.
אז את בקשתו של האדם הראשון לא לקשור את אירוע לולאה
אם זה נשמע הגיוני.
>> אבל כאן היא למעשה דוגמא של משהו שיקשור
את אירוע הלולאה.
אז הנה פונקציה נורא לחשב את פיבונאצ'י המי יודע כמה.
זה ממש גרוע הדרך שתוכל לחשב את מספר פיבונאצ'י המי יודע כמה.
וזה בעצם רק כדי להכיר איפה זה בא,
אין למעשה -
אני מתכוון, אתה יכול לנסות ללכת למצוא אותו - אבל יש כמו בלוג ארוך מאוד
לפרסם שמישהו כתב.
זה כמו אחד מהדברים Reddit אלה.
אבל מישהו מתח ביקורת Node.js, ו הם השתמשו בזה כדוגמא.
אז אני רוצה סוג של רק להראות לך שני נקודות מבט שונים, רק כדי לקבל
הבנה כללית של המושגים מאחורי שני הדברים האלה.
>> אבל זו נבחרה כפשוט נורא, המחשוב יעיל להחריד
דרך אינטנסיבית כדי לחשב את מספר פיבונאצ'י המי יודע כמה.
אז רק כהערה צדדית, למה הוא זה נורא כמו בדרך זו?
כן?
>> קהל: תגיד שאתה מתחיל עם 1,000.
1,000 מתפצל ל999 ו998.
כל אחד מזה מתפצל לשני דברים.
>> קווין שמידט: נכון.
>> קהל: כל הדרך למטה.
>> קווין שמידט: בדיוק.
אז רק כדי לחזור למצלמה, אם אני קוראים לבלף על כמו 1,000 או משהו
ככה, זה ברור שלא פחות מ או שווה לאחד אז אני הולך ל
תלך למקרה אחר זה, ולאחר מכן אני הולך לקרוא לבלף 999 תוספת לבלף 998.
ואז פחות או יותר את כל זה עבודה שלבלף 999 עושים היא
סוג של ברמה זו.
אם אתה יורד, זה אפילו יותר מיותר יותר מזה, אבל אם אתה רק
חושב לבלף מחשוב 998 מקבל שלנו די קרוב לבלף 999.
אז אנחנו באמת צריכים להיות קצת יותר חכם על איך אנחנו סוג של שימוש חוזר
האלה, אבל אנחנו לא שימוש חוזר את הדברים האלה בכלל.
אז אתה יכול לדמיין את זה ענק, עץ ענק שפשוט נורא.
>> אבל בכל מקרה, על אישור.
אז זה היה לבלף.
זה פשוט לוקח זמן כדי לרוץ.
כן?
>> קהל: [לא ברור].
>> קווין שמידט: אה, הייתה לך לחזור על השאלה?
>> קהל: [לא ברור].
>> קווין שמידט: אה, אז זה רק קוד זה הולך להיות סוג של על
בצד שרת.
אז זה לא הולך ניתן למצוא בדפדפן או משהו כזה.
זה בעצם מה שיש לנו הוא שכאשר המשתמש כאן פחות או יותר עושה
בקשתם שוב, כאשר אנו סוג של להגיש בקשה, אנחנו הולכים לקרוא
פונקציה זו בצד השרת.
ואז מקבלים את התוצאה בחזרה מקריאה לפונקציה זו.
ואז אנחנו פשוט להדפיס אותה למשתמש.
כך שהמשתמש לא ממש להתמודד עם פונקציה זו יותר מדי.
>> הייתה שהשאלה?
האם זה הגיוני?
על אישור.
מגניב.
>> אז שוב, אנחנו עושים את כל זה res.writeHead דבר שבו אנחנו להדפיס
הכותרת.
ואז אני בסופו התגובה על ידי עושה מספר הקסם הוא לבלף 45.
אז בואו פשוט להפעיל את השרת הזה.
אז אני הולך לעשות fib.js. צומת
אז עכשיו השרת לבלף שלי פועל.
>> ואז הנה, אני הולך לעשות אחד מאלה.
בסדר?
אז רק אני הולך לומר, סלסול.
אז זה הולך לקחת קצת זמן, אבל אני מקווה שבקרוב זה יהיה סופו ו
הוא ידפיס 45th כי פיבונאצ'י מספר.
>> קהל: [לא ברור].
>> קווין שמידט: זה צריך להספיק די בקרוב.
כך זה צריך להימשך חמש עד שש שניות.
אני לא יודע זה רק סופר להיות V8 מהר, אבל בכל מקרה, זו היא
דוגמא קצרה מאוד ובכוונה לא אלגנטי של לא טריוויאלית
חישוב.
אז אחרי כמה זמן, זה לקבל את זה.
>> אבל עכשיו, מה אם אני עושה את זה אותו סוג של ניסוי כמו בעבר שבו אני עושה
שתי בקשות באותו הזמן?
אז הנה אני הולך קורל על כתובת זו, ואני הולך
לעשות עוד סלסול.
וזכור, כשעשינו את זה בשביל לישון שרת, כאשר אנו בעצם לא היינו לו
לאחר חמש שניות, הם די הרבה שניהם חזרו תקין
בערך באותו הזמן.
אז זה לא היה במיוחד קשור.
>> אבל בואו ננסה את זה עכשיו.
אוקיי, אז יש לנו שני התהליכים שלנו.
זכור אלה מזהי התהליך.
זה הולך להיות קצת מביך בזמן שאנחנו הדוכן.
אז בואו פשוט להישאר כאן ולחכות.
>> אז אחד מהם צריך לבוא חזרה אחרי כמו -
אוקיי, אז אחת חזר.
אבל אז למה לא עשה את השני אחד חזר עדיין?
כן?
>> קהל: השרת לא יכול לעשות כלום בזמן שהוא החישוב שמספר גדול.
>> קווין שמידט: נכון.
אז התגובה הייתה פשוט כי השרת באמת לא יכול לעשות כלום בזמן
זה חישוב שפיבונאצ'י.
אז עכשיו יש לי רק שני הדברים שלי בחזרה.
אבל אני מניח שרק לחשוב על הקוד קצת יותר, איך זה עובד
והכל.
>> אז פונקציה זו כאן את הקוד ש כבר אמר לי שרת זה לרוץ כאשר הוא
מקבל בקשה נכנסת חדשה.
אז זה פשוט הולך לרוץ דרך זה קוד כולו, ולאחר מכן זה הולך ללכת
לגבות לאירוע הלולאה ולאחר מכן להמשיך בדיקה לאירועים חדשים.
אז בעצם מה שקורים הוא השרת הוא
האזנה לדברים חדשים.
האדם הראשון שואל על מה הוא 45.
אנו מפעילים את הקוד הזה כדי לחשב את זה.
קוד זה לוקח בערך חמש לשש שניות לרוץ.
אחר כך אנחנו חוזרים לאירוע הלולאה ולבדוק בקשות חדשות.
>> אז זו דוגמא לאופן, אם אתם יש דברים שהם מחשוב שנקרא
מחויב, או להשתמש הרבה חישובית, לא כוח, אבל כמוהם
המחשוב עתיר -
אני מניח שדבר אחד להגיד על זה שפונקציה זו עושה לגמרי,
על פי רוב, די ממש עבודה מועילה.
כל הזמן שהתקשרות ש הפונקציה רצה, זה היה די
הרבה מבלה את רוב זמנה רק מספר פיבונאצ'י המי יודע כמה מחשוב.
>> אבל היה לנו רק חוט אחד כדי להתמודד איתו.
במודל האפצ'י, כאשר שני אנשים הגיש את הבקשה כדי לקבל לבלף 45, אנחנו
היו לו שני נושאים שונים.
ולאחר מכן העבודה של מערכת ההפעלה הייתה, או ברמת המשתמש
קוד שמנהל את האשכולות, היה כבר היה לחתוך את זה על
מעבד, או אפילו אם היה לך מעבדים מרובים, להפיץ אותם באופן שווה על פני המעבדים
כך ששניהם היו לסיים בערך באותו הזמן.
>> אז רק כדי להראות לך איך אנחנו יכולים למיין של - ואת זה הוא לא מושלם סך הכל
פתרון, אבל סוג של איך אנחנו יכולים להפוך לחזור לכאן ולעשות
קצת יותר טוב.
אז מה יש לי כאן הוא תכנית בשם לבלף ג וזה בעצם משתמש
עוד אחד מהמודולים של הצומת נקראת מודול תהליך הילד.
אז צירפתי כי בסוג העליון כמו שהייתי עושה קילו כולל
process.h ילד או משהו.
עכשיו יש לי גישה למשתנה CP זה שבו יש את כל הפונקציונליות שלי.
>> אז עכשיו מה שאני עושה בתגובה הזאת מטפל הוא אני מפעיל תכנית זו
נקודה לקצץ לבלף 45.
אז מה שעשיתי - ואני רק הולך כדי לצאת מתכנית זו עבור
קצת -
הוא כתבתי תכנית C כי בעצם מחשב את
מספר פיבונאצ'י המי יודע כמה.
אז הנה רק תכנית שכתבתי ב-C, שמחשב את זה.
אני יכול לאסוף את זה, ואני יכול לרוץ זה בשורת הפקודה.
וזה הולך לחשב את מספר 45th פיבונאצ'י.
>> אז שם לב לזה פשוט לוקח פחות או יותר כל עוד.
אני כנראה היה יכול להשתמש במקף 03 ל לייעל את זה או משהו כזה,
אבל אני פשוט לא אהבתי רגיל הגדרות מהדר.
והיא מדפיסה אותו החוצה.
>> אבל עכשיו, מה אני עושה סוג של?
אה סליחה, קובץ הלא נכון.
אז אני עושה את אותם דברים, עם הכותרת כמו קודם.
ואז אני עושה cp.exec זה.
אז מה זה הולך לעשות הוא זה הולך להפעיל את התכנית.
אבל הדרך שזה עובד היא כי זה לא הולך לחכות
תכנית שכדי לסיים.
זה פשוט בעצם אומר ביצוע תכנית זו.
אז בעצם להקליד את זה לתוך פקודת סוג הפקודה של.
>> ואז, כשתסיים עם אותו, להפעיל פונקציה זו.
אז עכשיו אנחנו סוג של לקבל את זה דבר כולו משוחזר של
כמו שאנחנו לא מחכים.
האם זה סוג של הגיוני?
כן?
>> קהל: [לא ברור]?
>> קווין שמידט: אז זה יהיה ממש לפתוח תהליך חדש לעשות את זה.
אז זה הוא למעשה, במובנים מסוימים, רע, לא סופר רע, אבל זה
חשוב להגיד שזה סוג של חוזר ל, מצד אחד, האפצ'י
מודל שבו אנחנו עושים את הנושאים ותהליכים לכל בקשה או
תהליכים לכל בקשה.
אז זה סוג של אנלוגי למה האפצ'י עושה.
במקרים מסוימים, זה יהיה פשוט להשתמש חדש חוט, שהוא קצת יותר אור
משקל מאשר תהליך, אבל האפצ'י יכול בסופו של שופכי תהליך חדש
שהוא סוג של מה שאנחנו עושים כאן במשתמע על ידי עושה לבלף לוכסן נקודת 45.
>> ואז במקרה כזה, אנחנו סוג של להיגרם אותו הוצאות של תהליכים.
אז זה רק דבר אחד שאתה יכול לעשות.
אבל רק כדי להראות סוג זה של ריצה.
והדיבור הזה הוא פשוט באמת שמטרתה הצגת סוג של תוכניות אלה, כמו
דרך להראות נקודות מבט שונות על כיצד לעצב שרתים כאלה.
אז זה פועל, ואז עכשיו אם אני עושה זה שוב, יש לי שתי תעודות זהות של תהליך.
>> בואו רק לדבר על דברים כדי להצביע.
אז שם לב שהם באופן הדרגתי.
זה מגניב.
כי זה היה 27,122 לפני.
אבל שימו לב עכשיו, הם חזרו בערך באותו הזמן.
>> ועכשיו, שאלה טובה לשאול על מדוע היה כי המקרה הוא, שתפקידם
היה זה עכשיו כדי לעשות סוג של הדברים האלה סוג של משחק הוגן עם כל
, שני מקרים אלה אחרים של לבלף לוכסן נקודת 45 שרצתי
או שרץ צומת?
מי סוג של עושה את זה הוגן ששניהם לקבל מאוזנת סוג של זמן ריצה?
>> קהל: [לא ברור].
>> קווין שמידט: כן.
אז בעצם, כשאני עושה לבלף לוכסן נקודה 45 או משהו כזה, עכשיו זה
סוג של עד מערכת ההפעלה כדי להתמודד עם הריצה של תוכניות אלה.
ועכשיו הוא יכול לתזמן אותם על מעבדים שונים או שזה
ניתן לתזמן אותם.
זה יכול לחתוך את הזמן שאחד מעבד מקבל את זה או שהם מקבלים
לרוץ על מעבד אחד.
אז זה הרעיון שעומד מאחורי זה.
האם זה הגיוני לכולם?
אז עכשיו הצומת היא לא ממש שיחקה חלק בחלוקת משימות אלה.
על אישור.
>> אז זה כמעט זה לדוגמאות.
רק רציתי להראות עוד דבר אחד כי הרבה זה עד כה
לא לגמרי סופר מעשי במקרים מסוימים.
אני יכול לדמיין את מגיע הביתה אחרי זה לדבר ומשהו ואומר כמו,
גם אני סוג של יצאתי מהשיחה כי אני יכול לעשות שרת פיבונצ'י
פרויקט הגמר שלי.
אז הנה רק סוג של דוגמא אחת יותר שאני מקווה שיהיה -
אולי לא, אבל אולי - קצת יותר סוג של רלוונטי לפרויקטי גמר ו
חושב קדימה לדברים כאלה.
>> אז זה chat.js.
אז זה סוג של רוצה קצת מדגם קוד בצד שרת שאתה יכול להשתמש בו כדי
להקים שרת צ'אט קטן כמו אתה יכול לראות על
פייסבוק צ'אט או משהו כזה.
אז אני לא אומר שזה כמו פייסבוק צ'אט, אבל זה סוג של
כמו טוב - אולי לא טוב, אבל אולי נקודה לשיחה מתחילה - טובה
שרת עבור האתר שלך לפרויקט גמר.
אז בואו נסתכל על מה שהוא עושה.
>> אז אנחנו מקבלים את הדבר המיוחד הזה בחלק העליון, זה var SIO
שווה דורש Socket.IO.
אז זה עוד דבר שהיא עושה לא באו בעצם יחד עם
צומת אבל אתה יכול להתקין אותו.
זה מודול צומת.
אז זה בדיוק כמו כמה סיומת לצומת.
>> SocketIO הוא ממש ממש די מגניב.
זה הפשטה שבעצם מה היא עושה הוא שזה מאפשר לך
יש הזרם הזה של תקשורת בין אינטרנט
דפדפן ושרת אינטרנט.
אז ברוב המקרים עד כה, שהיינו לנו שני אלה מהירים מאוד אחד או שתיים
תקשורת שנייה בין אינטרנט דפדפן לבין שרת האינטרנט.
אז זה בעצם ללכת ל-google.com, גט הדברים, לשלוח אותו בחזרה, ולאחר מכן
אנחנו נעשו.
אנחנו אף פעם לא מדברים שוב עד משתמש מקליד במשהו אחר.
>> אבל מה Socket.IO וסוג דומה של דברים - וSocketIO הוא למעשה אחד
מהדברים שהבנויים על כ WebSocket שהוא סוג של זמין
כחלק מHTML5 -
המאפשר לך יש את זה דיאלוג מתמשך.
וזה מאוד שימושי בשרת צ'אט סוג של דבר כי זה
כמו סוג של דיאלוג מתמשך ב מובנים מסוימים, כי אם אתה משוחח
עם מישהו, עכשיו אתה יכול פשוט לשלוח הודעה במורד הצינור, ולאחר מכן
שרת יכול לשלוח הודעה למטה צינור לאדם האחר שאתה
משוחח עם.
ואז אתה יכול לקבל את זה להחליף ככה.
>> אז זה סוג של מה SocketIO הוא טוב.
הסיבה שSocketIO משתמש WebSockets כדבר אחד הוא שב
בנוסף לWebSockets פשוט ישן, זה גם עושה כמה טריקים כדי בעצם
להפוך את הדפדפן שלה תואם.
אז דפדפנים כמו Internet Explorer למרבה הצער אינו תומך WebSockets
היישר מהקופסה.
אז הוא משתמש בסוג כלשהו של מגניב מסודר אחר דברים עם Adobe Flash כדי לאפשר
שיהיה לך תמיכת דפדפנים.
אז זה באמת שימושי.
>> ובעצם, אני יודע שאני סוג של פועל על זמן כאן, אבל CS50
דיון, האם אי פעם ראה משהו כאילו, אני לא יודע, ריק הוא כך וכך
מענה להודעה או משהו זה ככה, תכונה ש?
זה SocketIO.
לכן, כאשר מישהו מתחיל להקליד תיבה לדון לעשות תשובה או
משהו, הדפדפן שלך אינו מה קרא בSocketIO פולט איזה
אירוע שאומר למישהו זה מענה להודעה זו.
>> ואז השרת אומר, אוקיי, מה אני צריך לעשות?
ובכן עכשיו אני חייב לספר לי אלה החבר 'ה אחר שנמצאים על CS50 דיון מחפש
בפוסט הזה שמישהו משיב.
אז זה סוג של מה הוא SocketIO טוב ל, בהמשך מסוג זה
זרם של דיאלוג.
על אישור.
>> אז מה יש לי כאן - ואנחנו רק הולך להתעלם ממערך קשרים
לקצת -
מה שאני עושה הוא שאני עוד אשמע.
אז זה בדיוק כמו בSocket.IO הוא אומר בואו להאזין ביציאה זו.
ואז אני עושה את זה בחיבור.
אז זה רק בעצם Socket IO של הדרך שלי לומר, כאשר אנו מקבלים
חיבור, אני רוצה אותך כדי להפעיל את הקוד הזה.
>> ושים לב שבמקום שיש rec ומיל עבר לשם יש לי שקע.
ורעיון Socket זו הוא בעצם זו דבר שאתה יכול לכתוב ולקרוא
מזה יש למשתמש של הודעות אולי.
וההודעות שאתה שולח יכול לעבור Socket זה.
האם זה הגיוני?
אז זה דבר מתמשך זו.
>> אז מה שאני עושה זה אני קורא Socket.emit.
ופולטים לוקח די הרבה שני טיעונים.
הטענה הראשונה היא מחרוזת רק מייצג את הסוג של
דבר שאתה פולטת.
אז למקרה זה, יש לי שימוש הודעה זו המחרוזת חדשה.
וזה רק אומר שבעצם הסוג של הדבר הזה, מה אני
שליחה, היא הודעה חדשה.
כך שתוכל להאזין לסוגים מסוימים כמו הודעה או מה שלא חדשים
על ידי שימוש בנקודה על.
>> אז חיבור למשתמש נשלחו לשם, אם אתה מסתכל בו אנחנו קוראים לנקודה על,
אלה הם מחרוזות אחרות המייצגות סוגי הודעות משתמש.
אז זה בעצם שאתה יכול להיות לפלוט זה אחד מהסוגים אלה הודעה, ו
אז לעשות משהו בתגובה ל אחד מסוגים אלה הודעה
>> אז אני פולטת הודעה חדשה.
אנחנו הולכים להתעלם connections.push לשנייה אחת.
אבל אז אני אומר, משתמש Socket.on נשלח.
אז עכשיו זה סוג של כמו כאשר משתמש שולח לי הודעה, אני רוצה
לך להפעיל את הקוד הזה.
ושים לב כי פונקציה אנונימית הוא לוקח במשתנה זה
קרא נתונים אשר בעצם הולך כדי שההודעה של המשתמש.
>> סוג אז עכשיו בואו לדבר על מערך חיבורים.
אז זה מיועד ללקוח צ'אט שבו בעצם כל סוג של ב
אותו חדר הצ'אט.
אז בעצם, מה שאנחנו צריכים לשמור על סביב איזה מערך שבעצם
מייצג את כל האנשים מפטפטים ב מבחינות מסוימות, אם זה נשמע הגיוני.
נכון?
כי אנחנו צריכים לדעת שחבר 'ה האלה כל כך אנחנו יכולים לשלוח להם ההודעות
שאנשים אחרים שולחים לנו.
>> אז מה הקוד הזה עושה הוא כאשר משתמש שולח מסר - זה הסוג של
האירוע -
אנחנו הולכים להפעיל את הקוד הזה.
ומה שאנחנו עושים הוא שאנחנו מריצים דרך זה מערך שיש לנו בשם חיבורים.
ופחות או יותר לכל חיבור פרט אחד שהוא שלנו, זה
מה הקוד הזה אומר, אנו שולחים חדשים הודעה עם שהודעה המצורפת
מידע.
>> אז אם אתה שם לב לכאן, מה שעשיתי כש המשתמש בעצם עושה חדש
חיבור הוא אני הוספתי עם שיטת JavaScript.push, זה
בעצם רק אומר כמו להוסיף Socket שכערך לתוך
מערך הקשרים שלנו.
אז עכשיו כאשר קוד זה פועל, זה יהיה לשלוח דברים מסוימים אלה
חיבורים.
אז זו יכולה להיות נקודת התחלה טובה להכנת שרת צ'אט
או משהו דומה.
>> ואת הסוג של דבר מגניב הוא ש קוד שאתה רואה כאן, כמו וב
לפלוט ודברים כאלה הוא זהים סוג של קוד JavaScript שהיית
לכתוב בדפדפן כדי אינטראקציה עם השרת.
אז בגלל זה SocketIO הוא סוג של מסודר ושימושי בדרך זו.
>> אה, ורק דבר אחד יותר מהיר אמיתי.
היה פרויקט גמר CS50 בשנה שעברה כי בעצם מיושם צ'אט
שרת בNode.js.
אני חושב שזה Harvardchats.org אבל אני לא -
על אישור.
אני לא בטוח מה היא כתובת האתר, אבל אני יכול לשלוח את זה אחר כך.
אבל זה די מגניב מה אתה יכול לעשות עם Node.js.
>> אז אני מקווה, באופן כללי, יש לך חבר 'ה תחושה של מה Node.js שימושי טובה
ולאיך אולי אפשר להחיל לפרויקט הגמר שלך.
אני יהיה לשלוח עוד קצת משאבים יחד עם זה.
ותודה לך שבאת.
תודה.
>> [מחיאות כפות]