>> בסדר.
אז הסחרור המסוכן היה, מה הוא node.js כפי שאתה מכיר אותו היום?
שום דבר? כן?
>> זה היה כמו JavaScript מסגרת כתיבה
יישומים רחב -
>> בסדר, זה עובד.
>> - אני יודע כמו שימושים נפוצים כמו -
או משהו שאתה יכול לעשות את זה כמו -
[הערה לא נשמע]
>> טוב על אישור.
כן, כך שזה מסגרת.
זה מנוע שבו אתה יכול לבצע קוד JavaScript
אתר שרת.
זה יכול להיות הפשוט ביותר של דברים
כמו כתיבת שורת הפקודה תסריט לא בפייתון או Bash
או רובי או PHP, אבל רק ב-JavaScript עצמו
וההרצה ב מהבהב שורת הפקודה.
או שאתה באמת יכול לרוץ זה בתוך שרת אינטרנט.
ואכן בתוך node.js עצמו,
מסגרת זו היא כל חבורה של ספריות ובהן
בשרת HTTP מובנה.
אז, למעשה אתה יכול לכתוב שרת כפי שנראה
ברגע, סופר בקלות רק על ידי הבנה קצת
של HTTP ו-TCP ויציאות.
ואתה יכול להשריץ האזנה שרת אינטרנט מבלי Apache,
ללא IIS של מיקרוסופט.
בלי שום אחר התקין את התוכנה,
רק אתה יכול להשריץ זו ולהקשיב לכל יציאה ביותר
במערכת ש מותר לך.
אז במקרה ונקודות, תן לי ללכת ולפתוח
עד דוגמא זו, שרת 0.js.
אז שם לב שהחלק העליון של בקובץ זה, פשוט חבורה
הערות לא מעניינות, ואז יש כמה
קווי נציג של קוד שאנחנו תראו recurringly.
אז, HTTP var מקבל דורש "HTTP".
אז מובנה לnode.js ' תשתית היא כל חבורה
מודולים שהם באמת רק ספריות וכל מה שהן סוג
משם חלל עם המזהה הייחודי
כמו זה הוא "HTTP".
אז זה כמו בהרבה שפות כמו Java ו-C + +
ו-C, רק כאשר אתה לייבא או כוללים
או בצומת לדבר דורשים מודול עושה ביטים שלו.
וכל הזיכרון דורש לקבל טעון
לזכרון RAM ולכן בשימוש.
אז, אתה סוג של העומס הזה ספריות או מודולים על פי דרישה.
משמעות דבר היא ללכת קדימה ודורש
לתכנית זו ספריית HTTP,
ולהתייחס לספרייה שעל ידי דרך של משתנה בשם HTTP.
אבל שמאלי סמל זה יכול כבר קרא כל דבר, foo,
בר, באז, זה לא משנה.
אז שלא כמו C + + ו-Java ו C שבו מתי שאתה צריך
או לייבא את ספרייה, זה פשוט סוג
מהופך גלובלי נגיש,
מודולים node.js הם חזק יותר מרחב.
אז זה עצמו - פונקציונלי ה הוא נגיש רק ברגע
בדרך של השם המשתנה הזה.
אתה לא יכול פשוט להתחיל שיטות הקלדה שקיימות
בזה כמו שצריך בדרך שהוא כנראה טוב,
כי אז המרחב שלך לא מקבל מבולגן כמעט כמו
כמו בהרבה שפות.
בסדר, אז עכשיו כנפוץ מציע, ליצירת שרת HTTP
כמו יונתן [להניח כתיב] היה אפשרי הוא, פשוטו כמשמעו,
פשוט כמו שקרא ליצור שיטת שרת בתוך
של מודול HTTP.
אז, זה חוזר ההתייחסות
לסוג מסוים של שרת אינטרנט.
זה הגיע לאפצ'י, לא משקל בהכרח כבד.
זה אחד זה קצת יותר פשוט.
ועכשיו, יש לי רק פשוט לעשות כמה דברים.
אז קודם כל, תן לי לגלול עד לתחתית כאן
ולדלג על המטפל שיטה לרגע.
ושים לב את הקו הזה של קוד,
server.on שהוא בעצם אומר שרת -
להקשיב כמו בקוד jQuery,
להקשיב לאירוע נקרא בקשה
ופשוט לקחת ניחוש מה אני צריך לעשות
כאשר אירוע בקשה שריפות בשרת.
כן?
>> התקשר מטפל הפונקציה.
אז, ממש לבצע את קוד שהפניה
במשתנה זה ולמעשה לא משתנה לסמל כאן,
מה הוא הסמל מתכוון?
ובכן, זה שם של לתפקד עד כאן
ומטפל, ככל הנראה, לוקח שני טיעונים.
למה שתיים? ובכן, אם אתה רק לקרוא את כל תיעוד
למודול הספציפי הזה, אתה יהיה אמר כי המטפל
שתופעל יהיה לפחות שני טיעונים עברו,
התייחסות לבקשה,
ופנימי שלנו הבקשה ממש מתכוון בקשת HTTP.
לכן, כל כותרות HTTP אלה שאולי אתה זוכר
מראשית סמסטר או בכיתה לפני
או ניסיון כמו לקבל קו וקו המארח
ושורת User-Agent, כל זה הוא כמוס ויותר בתוך
של אובייקט בקשה זו.
ואובייקט התגובה הוא מסודרים לנתונים יוצאים.
אז, יש לך התייחסות ל להתנגד זה הולך כדי לאפשר לך
כדי לשלוח מידע חזרה ל הדפדפן על ידי קוראים שיטות
שבטיעון האחרון נקרא Res לתגובה.
אבל זה יכול להיקרא foo או בר, זה הוא רק מוסכמות.
אז עכשיו, מה אני עושה?
ובכן, נראה כי בתוך של שרת האינטרנט של הסופר הזה פשוט
שאני מיישם, אני הולך לעשות את הדברים הבאים.
אני הולך לכתוב HTTP כותרת עם קוד מצב 200,
200 משמעות בסדר, הכל טוב.
ואז, אני הולך להעביר הלאה ככל הנראה.
מה סוג הנתונים של טענה שנייה לימין הראש?
>> זה אובייקט?
>> זה אובייקט עם כמה מפתחות וערכים?
רק אחד מכל אחד, נכון, ערך מפתח אחד מזוג.
אז, 'סוג התוכן'.
והסיבה היחידה אני מצטט אותו כאן היא
בגלל המקף יכול להיות conflated לסימן מינוס
או משהו כזה.
אז, אני חייב לצטט אותו כאן, לחרוך או במרכאות כפולות.
אבל הפרדיגמה שוב נפוצה
בקוד JavaScript הוא לעתים קרובות ציטוטים בודדים בימים אלה,
מעי גס ולאחר מכן את הערך.
אז, זה רק מה שנקרא סוג חשבון.
זוהי כותרת HTTP זה הולך ממש
להיות מעי גס תכנים מסוג המקף מישור נטוי טקסט שקורה
להישלח מ שרת לדפדפן
כך שהדפדפן יודע אם לרוץ טקסט גלם כמו זה
או HTML או כ תמונה או סרט
או קובץ או הבזק כל דבר אחר.
עכשיו, איפה שאני באמת רוצה לשלוח בגוף של הדף?
ובכן, רק על ידי קריאה התיעוד
לאובייקט התגובה בתוך ספרייה זו.
אני רואה שיש נכון שיטה ושלוקחת מחרוזת,
אולי דברים, אבל אחרים מינימאלי מחרוזת.
והמחרוזת היא מה לירוק לדפדפן.
במקרה זה סופרה פשוט, עולם שלום שלו,
אבל זה יכול להיות opne סוגר, HTML, קרוב סוגר,
ראש סוגר פתוח, קרוב סוגר וכן הלאה,
זה יכול להיות html גלם.
אבל אנחנו שומרים על ירושלים פשוט רק על ידי יריקה
מתוך הפשוט ביותר של סוגי המוח שהוא ללא ספק טקסט / רגיל.
ולאחר מכן response.end רק פירושו לסגור את החיבור
ולשלוח את כל מה שיש לי סוג של נאגר בתוך
של אובייקט זה בחזרה לדפדפן.
אני סיימתי. בסדר.
לכן, הדבר האחרון אני עושה כאן למטה
וזה במידה מסוימת שרירותי ואמור להיות מגניב,
הוא אני אומר לי שרת סוף סוף להקשיב
על TCP מסוים ביציאת ברירת מחדל.
כזכור, מהתחלה מאותו סוג שירותים -
או שאתה בדרך כלל באופן ייחודי לזהות אותו על ידי מספרים,
הספירה היא באינטרנט, 443 מבוסס HTTP אתרי אינטרנט, 22 הוא SSH, 21 הוא FTP
ו1337 הוא רק שרירותיים אבל זה גבוה יותר מ 1024
מה שאומר שעל רוב מערכות, אני יכול להשתמש בו
ללא צורך בסופר הרשאות משתמש.
אז זה פשוט נוח.
אבל 8080 הוא באת - נפוצה אחד, 8088, באמת משהו גדול
באלפי כנפוצים אבל זה רק יותר מובחר.
בסדר, אז מה שקורה כשאני בעצם מפעיל את זה?
ובכן, אני לא רק לבקר הדף בדפדפן.
קובץ זה נקרא שרת 0.js.
כי שוב, האפצ'י הוא עכשיו מחוץ לתמונה
למחצית השנייה של הקורס.
אם אני רוצה אינטרנט שרת, אני צריך לכתוב
ולאחר מכן להפעיל את שרת האינטרנט הזה.
אבל מתברר כי JavaScript גם בצד הלקוח
וצד השרת הוא שפה לפרש.
לכן, כל מה שאני צריך זה מתורגמן.
אז שלמענם - אם מתעקשים לרוץ צומת ולאחר מכן שרת 0.js,
אני יכול או לא יכול לראות כמה פלט בהתאם
על מה ספריות צירפתי, שום דבר לא נראה שזה קורה.
אבל הרשית לי ללכת ל הדפדפן ותנו לי ללכת
לאותה כתובת IP לקוחות CS50 שלי.
אבל זה רק יכול כמו גם להיות Mac שלי
או במחשב האישי שלי ואז מקיש על Enter.
זה באמת נראה כמו אפצ'י.
זה כמו הספרייה רישום בדקנו
במחצית הראשונה.
אז, מה עשיתי לא בסדר?
כן.
[הערה לא נשמע]
בדיוק, נכון?
אז, האפצ'י הוא עדיין מקשיב ביציאת ברירת מחדל 80.
למרות שאני יכול לשנות את זה, אני יכול לכבות אותו כולם ביחד
אבל זה עדיין פועל.
אבל החבר 'ה האלה יכולים בהחלט לדור בכפיפה אחת.
אני פשוט צריך לשים את מעי גס 1337 ואז אולי
או אולי לא בקו נטוי הקצה לגשת ליציאה זו
כי השרת הזה הוא פועל.
ועכשיו אני רואה ש שלום, העולם חזר.
ואני יכול להכות רענן כמו פעמים רבות כמו שאני רוצה,
זה עדיין משרת את דף.
ואכן, אם אני פותח את הכרום של מפקח, ללכת לרשת
ולאחר מכן לטעון מחדש את הדף כולו,
שם לב שאכן זה היה הבקשה שנשלחה.
אם אני מסתכל על מקור הגלם,
תבחין הדפדפן שלי שולח את כל הדברים האלה.
ואז התגובה של השרת היה סופר פשוט.
יש 200.
אם זה לא נמוך מדי על המסך,
יש את סוג התוכן.
ולאחר מכן node.js סוג של באופן אוטומטי
לי הוסיף את התאריך ו כל הדברים האחרים
שדפדפנים בדרך כלל לצפות.
אז, בואו פשוט לראות בדיקת שפיות קטנה.
תן לי לחזור לקוד בשרת 0.js ותנו לי -
בכל פעם שאני נכנסתי המטפל,
תן לי רק לומר console.log.
("היו לנו אורח!").
אני לא צריך להדר מחדש או משהו כזה,
זה שפה לפרש.
אז עכשיו, תן לי לחזור אל הדף, טען אחד, שתיים,
שלוש פעמים וללכת לגבות לחלון שלי.
ועכשיו אני רואה את זה.
טוב, זה מוזר, אני רואה שש שורות.
טריוויה אינטרנט מעניינת, למה עשה אני מקבל שש בקשה לא שלוש?
כן?
[הערה לא נשמע]
כן. אז, כפי שאתה ודאי יודע סמל טיפש קטן בחלק העליון
על הבר הדפדפן שהרבה
של עוצמה המשמשת אתרים להיות פסגה של הרווארד,
זה יכול להיות לוגו של חברה או משהו כזה.
אז, בימים אלה דפדפנים מסוג
של תעוזה לעשות בקשת HTTP נוספת
כמעט לכל אתר אינטרנט ש אתה מבקר בודק אם יש
כברירת מחדל קובץ בשם favicon.ico
באותה הספרייה כמו את הקובץ שביקשת.
ואם כן, זה מכניס הסמל שם.
אז כל מה שאנחנו רואים הוא בדיוק זה.
ולמעשה, בואו נראה אם ​​אנחנו יכול לראות את זה ולא סוג
את פשוט, "היו לנו מבקר".
תן לי ללכת קדימה ופלט.
ואני רק יודע שזה מ מסתכל על התיעוד.
יש רכוש בתוך אובייקט הבקשה נקרא URL
אשר קורה להיות הדרך
שהתבקש בכתובת האתר בפועל.
לכן, אם אני מחדש את השרת פשוט על ידי rerunning צומת
על שרת 0.js ו עכשיו תעשה את זה, שתיים,
שלוש ולחזור לכאן.
זה מה שיש.
סלאש הוא מה שאני - האדם ביקש
בfavicon.ico הוא מה הדפדפן הוא
יומרנות המבקשת.
אבל הנקודה היא לא כל כך הרבה דברים favicon
אבל איך השרת מופעל.
כן?
>> למה זה יש לי להיות חלק מהבקשה?
>> למה זה צריך - על ידי הטבע של איך HTTP עובד.
אז, HTTP יכול רק לבקש קובץ אחד בכל פעם.
דפדפנים יכולים להיות חכמים בימים אלה
ולשמור על TCP חיבור פתוח.
אם לקח CS143 או בדרך כלל מכיר את רשת,
כך שאתה יכול לקבל רווחי יעילות
על ידי שמירה על הרשת שקע פתוח
בקבלת HTTP מרובה בקשות סדרתי על זה
אבל הם קובץ אחד לבקשה.
לכן, אם אתה מבקר משהו כמו -
אני אומר שאנחנו יכולים ללכת ביותר בכל אתרי האינטרנט.
אם אתה הולך ל-- בוא להרים את המפקח של Chrome כאן.
הוא עשוי לקבל למלא את רוב של הדף.
עבור לכרטיסיית הרשת וללכת לwww.cnn.com.
וכאשר אתה מבקר cnn.com, בדף הבית שלה -
הדפדפן שלך ולא אכזרי עושה - עדיין נטוי.
על אישור. לפחות 289 HTTP בקשות שוב ושוב.
וזו הסיבה מדוע כאשר אתה מבקר אתרים בעיקר נפוחים,
הם איטיים לטעון בגלל כל
של הנכסים שהם טוענים.
אז, זה נראה כמו 298.
אולי יש כמה אייאקס קורה בשלב זה או
של הנכסים הם רק נמוכים.
אז, כל אחד מאלה הוא בקשת פרט חוזרת
ושוב, הלוך ושוב.
וזו הסיבה שקודם לכן, אפילו למרות שאנחנו סוג של דיברנו
על זה רוב הדמיון במקצת איפה אתה שם את תג סקריפט,
עושה בהחלט הבדל כאשר יש לך -
זה מתחיל יש לי הרבה של תנועה והרבה
של קבצים המבוקשים.
וכל זה מייצג כנראה תמונה, קובץ מדיה,
קובץ JavaScript, קובץ CSS או משהו הדומה.
אז, אנחנו כבר זוממים חלק 4 מגה בייט בלבד
להסתכל על החדשות של היום.
שאלה טובה.
בסדר.
אז, מה הם כמה upsides אף?
נכון, אנחנו יודעים איך לעשות דפי אינטרנט כבר עם PHP.
ורבים מכם הגיעו ל הכיתה בידיעה ג'נגו
ופייתון או מסילות עם רובי.
אז, למה אנחנו צריכים עוד שפה ותשתיות?
מהו node.js במיוחד טוב אם אתה יודע?
[הפסקה]
דבר מסוים?
לא? כן?
>> העברת מסרים.
>> אז, העברת מסרים.
אז זה נכון וזה נכון מסיבה טכנית יותר
ושnode.js ובאמת JavaScript היא במיוחד
מתאים היטב לאסינכרוני קוד,
אם לפיה אתה יוצר האשליה
של עשייה מרובה דברים בבת אחת.
לכן, למרות שהם באמת קורה באופן סדרתי,
אכן, ברוב המקרים, JavaScript הן בצד הלקוח
וצד השרת הוא הליכי משנה בודדים.
שאם אתה לוקח 161 או אפילו 61 אומר ש--
של תכנית זו יודע,
הפרשן יכול, פשוטו כמשמעו, לעשות רק דבר אחד בו זמנית.
אבל זה לא מצוין עבור משהו כמו שרת אינטרנט
שבו אתה יכול להיות עשרות או מאות או אולי אפילו אלפים
של משתמשים בכל ניסיון כדי לגשת לדף האינטרנט שלך
בדיוק באותו הזמן.
ובכל זאת, שמציע כי אחד הטיפול בהם
בזה אחר זה לאחר אחר במיוחד אם חלק
מאותם בקשה כפי שראינו ב-CNN עשוי לדרוש הגשה
עד 300 קבצים לפני שאתה אפילו לקבל למשתמש הבא
מי שרוצה לראות אומרת חדשות.
Node.js מתאים יותר עבור סביבות ככה.
כי מה שקורה הוא כל תהליך איטי בריצה
כמו קריאת קובץ מדיסק או חיפוש במאגר נתונים או מדבר
כמה שרת אחר ברשת,
שנוטה להיות חביון, נכון?
אם אתה לא לוקח 61 או 161 כל במיוחד מסוג זה
שירותים היקפיים נוטה להיות הרבה יותר איטי
מאשר לעשות כל דבר בתוך את אותו זיכרון RAM ואותו מעבד
שאומר במקרה זה שרת הוא למעשה פועל.
אבל מה שיפה node.js הוא שאתה יכול -
ו-JavaScript, בדרך כלל יותר הוא שאתה יכול לעשות משהו
ואז אומר, "הממ, זה הולך
לקחת אותי כמה אלפיות או אפילו כמה שניות.
תן לי סוג של מזלג שאת, " אבל זה לא תהליך נכון.
ולאחר מכן כאשר זה נעשה עושה תהליך ריצה שאיטי
כמו תופס שורות מ מסד הנתונים או קריאת קובץ. html
מדיסק, זה יהיה לחזור אליי ולא
ממני לחכות לזה.
לכן, כדי להפוך את זה יותר ברור.
זהו האמצעי שלי מה שהופך את זה מוכר יותר.
בסדר, אז זה Shake Shack בכיכר.
זהו סוג של הפרדיגמה נפוצה
להסברת אסינכרונית.
זהו למעשה טוב דוגמא משום שייק שאק
ובורגר טעים להפליא להאט למה שהם עושים.
אבל הנקודה היא שהם ממש טוב בקבלת הזמנות
ולקחת את הכסף שלך לאחר שבו אתה מחכה לאוכל שלך.
אז, זה בעצם יותר טוב עיצוב יותר מהאלטרנטיבה.
מכיוון שתניח שאתה נכנס חנות כמו זה ויש לך
לחזית של הקו ולך את ההזמנה שלך ואתה רוצה
להמבורגר, כמיטב יכולתי תגיד, זה לוקח לפחות חמש
דקות או יותר למעשה לקבל המבורגר.
אז, זה יהיה סוג של מודל עסקי רע
אם בזמן שאתה מחכה לך המבורגר, [איות להניח] אליס
ובוב [להניח כתיב] וצ'רלי [איות להניח]
וכל השאר תורים מאחוריך
ואתה ממש חוסם הקו מחכה לאוכל שלך.
אז ברור, שבייק שאק
ומזון מהיר אחר מקומות לא עושים את זה,
הם עושים משהו כזה.
הם נותנים לך זמזם.
והם סוג של לשלוח לך בדרך שלך.
והם קוראים לך בחזרה על ידי מה שהופך את לרטוט דבר הקטן הזה
או פלאש כדי לקבל את תשומת הלב שלך.
אז, זה הוא, פשוטו כמשמעו, מה?
משהו כמו node.js עושה.
אם node.js או JavaScript באופן כללי יותר נמצא בשימוש
והמתכנת הוא חכם מספיק
כדי להבין, "אתה יודע מה?
לא משנה מה אני צריך לעשות את הדבר נכון כאן יכול לקחת קצת מספר
של אלפיות שנייה או שניות.
אתה יודע מה?
תן לי ללכת קדימה ולא קורא לזה באופן סינכרוני -
"כי הוא חוסם את הבחור כולם בקו אחד "-
תן לי ללכת קדימה ו סוג של לזוז הצידה
ופשוט קורא לעצמי בחזרה
כאשר שריצה ארוכה פעולה תושלם ".
וקורא לראש כמובן רומז במקרה זה
לפונקציה של קריאה חוזרת, התייחסות לצ'אק של קוד
כי יקבל להורג כאשר ההמבורגר שלך מוכן,
ממש כמו הדבר הזה יש לי כמה סוג של פונקציונלי מובנה
כי זה מתחיל לרטוט או זמזום מתי זה זמן בשבילך
להיקרא חזרה ל חלק הקדמי של הקו.
אז, מה עושה את זה כלומר במונחים ריאליים?
ובכן, יש לנו לעבוד בדרך שלנו למעלה.
אז, תן לי ללכת קדימה ולעשות את זה ראשון.
בשרת 1.js, תן לי לפשט את הקוד ראשון
כדי שנוכל לנקוט בצעדי תינוק לכיוון בעיה משכנעת יותר.
זה אותו הדבר בדיוק תכנית שכתבתי בעבר.
אבל מה השתנה?
יש סוג של קל הבדל תחבירי
בין זה לבין גרסה 0 לפני רגע.
מה קופץ על שלך אם זוכר אותך?
כן סינתיה [להניח כתיב]?
[הערה לא נשמע]
כן. אז עכשיו, יש לנו קו של פונקציה מועברת פנימה
אנחנו כבר הצלחנו להיפטר מהסוג
של שם לשווא פונקצית מטפל.
תועלת היחידה שבלפני אפילו קורא לזה במקום אחד,
אני לא באמת צריך לבזבז את הזמן לתת לו שם
ומה שהופך אותו קשה יותר לקרוא את הקוד העליון לתחתון.
אז, בואו פשוט להכריז מוטבע הוא פונקציה בעילום שם.
ואני עושה את שני דברים אחרים.
אני עושה יותר טוב שימוש בסימון נקודה.
אז כמו בjQuery, הרבה צומת יכולות להיות כבול שיטות יחד.
כך שברגע שתסיים קוראים משהו, אין לך
לחכות לקו חדש וקורא לשיטה אחרת,
אתה יכול פשוט שרשרת אותם יחד.
וכך, בדרך זו, אנו יכולים באמת להדק את זה.
אז, זה פשוטו כמשמעו שרת אינטרנט בחמש שורות
בסך הכל קוד בניגוד -
שלא כמו מה שבדרך כלל אתה עלול צריך לעשות כדי להגדיר משהו.
אם אני נכנסתי לשרת 2 עכשיו, בואו נעשיתי את זה.
בשרת 2 - בעצם בואו אחזור לאותו השרת 2.
בואו עכשיו להיפתח סינכרוני-0.js ו לטפל בבעיה שעל פרק.
אז קודם כל, בואו נלך קדימה ופתוח
עד סינכרוני-0.js בדפדפן.
אז סינכרוני-0, תן לי ללכת בחזרה לדפדפן.
הכה רענן.
ועכשיו, זה סוג של הודעת שגיאה.
ואכן אני רואה 500 במפקח של הכרום.
אבל תן לי באופן מדויק יותר לבקש hello.txt.
על אישור. לכן, נראה שזה יעבוד.
אז סינכרוני-0.js לא נראה לשרת את משהו ללוכסן.
אין לו תמיכת קובץ ברירת מחדל.
אבל אם אני באופן מפורש לבקש hello.txt,
שנראה שהיא תומכת.
מדוע זה כך?
ובכן, מה אני כבר הלכתי כאן
ונעשה מיושם שרת אינטרנט פשוט סופר
שמדגים שבו אסינכרונית יכולה להיות שימושית.
וכי הוא מיושם באופן הבא.
ראשית, אני משתמש מודול HTTP שוב,
אלא גם FS אשר כנראה מייצג?
באופן כללי במדעי מחשב, במערכת קבצים.
מערכת קבצים על אישור.
מכאן הלאה FS, מערכת קבצים.
בסדר, אז מה האם זה נותן לי?
פונקציונלי הקשורות ל קבצים כמו לקבל חלף,
פתיחת קבצים, כתיבה ספריות, ספריות קריאה
וכל דברים מהסוג הזה.
אז עכשיו שמת לב, את הקוד הזה הוא אותו הדבר כמו קודם,
ליצור השרת, עובר בפונקציה אנונימית.
זה סוג של שרירותי.
זה לא מאוד שרת אינטרנט מאובטח.
למעשה, אתה יכול לגשת רוב כל קובץ בכונן הקשיח שלי
או בשרת של קשה כונן על ידי הפעלת הקוד הזה
בגלל שאני רק בעיוורון בהנחה שאני הולך
כדי לתפוס את כל מה שהמשתמש ביקש ב-URL.
ואני הולך קידומת אותו עם נקודה
כך שאני באופן שולי להיות בטוח
באמירה כל קובץ שהם יכולים יש בקשה לפחות להתחלה
בספרייה הנוכחית.
כמובן שיש איום כאן.
"כי אם הם במקום כולל מה?
בדרכם, הם סוג שהוא יכולים של לעקוף גם את זה.
הנקודה, נקודה, נכון?
לכן, אם המשתמש פשוט לשים נקודה, נקודה בכתובת האתר, בתאוריה,
הם יכולים להתחיל שלי - ואומר קובץ סיסמות.
אז, זה לא נועד להיות מאובטח,
זה אמור להיות פשוט.
אז הנה, יש לי משתנים ה הוא השרשור של נקודה
אשר שוהה בספרייה ואת כתובת אתר הבקשה
שראינו לפני הוא כמו לחתוך או / hello.txt.
אז עכשיו, הוא מקבל קצת יותר מעניין.
ראשית, שים לב לחלק התחתון.
אני מקשיב ב אותה יציאה כמו בעבר.
אז מעניין האמיתי עבודה היא בתוך כאן.
בכל פעם שבקשה מגיע במטבע
של קוד זה, מה אני עושה?
אני מתקשר קובץ שיטת קובץ קריאה של המערכת,
עובר בדרך שאני רוצה לקרוא.
ועכשיו, זה הוא מה שמעניין כאן,
זאת היא על ידי יישום בשיטת אסינכרוני.
אתה לא יכול לקבל החזר ערך מקובץ שנקרא.
בהודעה למעשה, יש לא עזבתי את יד ביטוי
מהשמאל לקובץ שנקרא.
זה לא מחזיר ערך.
במקום זאת, הוא קורא קריאה חוזרת לתפקד כאשר הוא מוכן
כדי לתת לך חזרה תשובה.
אז שוב שיהיה ברור, ואילו בפעם,
בהרבה תכנות שפות, אם אתה רוצה
לקרוא את תיק ב-PHP נקודה,
תחתון קובץ תקבל מדגיש את תוכן,
יש לך ביד שמאל ביטוי בכל הערך לאחר -
לפני סימן השוויון, זה אומר שאתה מקצה
למשתנה שהתשואה ערך של הפונקציה.
אתה יכול לעשות את זה בnode.js, אבל בדרך כלל יש לך
לקרוא באופן מפורש סינכרוני גרסאות של פונקציות אוהבים,
אני חושב שזה קורא סנכרון קובץ או סנכרון לקרוא את הקובץ.
שכחתי איך הם קראו לה.
ושאתן לי שלך ערך החזרה.
אבל אם הקובץ שנמצא על כמה מערכת קבצים מרוחקת
או דיסק הוא רק באופן טבעי איטי, זה יכול לקחת 10 אלפיות שנייה
או 2 שניות לקובץ ש לבוא למעשה חזרה.
בינתיים, אין אינטרנט אחר מבקרים מקבלים שירות
על ידי websit שלך.
אתה חוסם.
זה מה שנקרא חסימת IO, קלט / פלט.
אז הנה, זה הרבה יותר חכם.
כי מה node.js הולך
לעשות על פרשנות הוא הבא,
זה הולך לקרוא שיטת קובץ לקריאה,
אנסה לאחד את הקובץ שיש לו נתיב שצוין על ידי הערך פ
ולאחר מכן, אם וכאשר הוא מוכן כדי לתת לך בחזרה את התוכן
של P הקובץ, הוא קורא פונקציה שחתימתו היא
בכנס הבא.
שתי טענות, הראשונה של אשר הוא אולי אובייקט שגיאה,
E הון, זה אובייקט נקרא שגיאה או Null
אם אין שגיאה כזו.
והטענה השנייה - לקחת ניחוש - הוא הולך להיות מה?
זה נקרא נתונים ברור, אבל מה הוא נתונים יותר קונקרטי?
>> תוכן עניינים?
>> תוכן hello.txt בדוגמא שלפתי
בדפדפן שלי לפני רגע.
אז במילים אחרות ניתן לקרוא את הקובץ ורבים node.js פונקציות
כמו באינו מחזיר ערכים.
הם קוראים לשיחות טלפון ולהעביר
לשיחות הטלפון האלה מה היית עושה היה באופן מסורתי
להחזיר ערך.
היתרון של גישה זו הוא
שאפשר לכנות לקרוא קובץ T0.
אולי הפונקציה של קריאה חוזרת לא ייקרא בהקפה אחת מאוחר יותר
כביכול ב-T, זה עשוי להיקרא T1000,
אלף קרציות מאוחר יותר.
אבל הנקודה היא ש שאר הקוד בקובץ זה,
אם בכלל היית מייד תתבצע תוך node.js
ואילו מערכת הקבצים דמויות איך לקרוא
שהקובץ ולקבל זה יחזור אליך.
אז אתה יוצר את זה -
כל כך ביעילות את האשליה
של מקביליות בעת נותן תהליכי ריצה איטיים יותר הוא לא
לחסום את הדברים החשובים, החלק ששירות למשתמשים.
אז, איך אנחנו מטפלים בזה?
זה נפוץ מאוד הפרדיגמה node.js.
ויש דרך רק כדי לפשט זה שנראה לפני זמן.
בדקתי קודם אם השגיאה היא לא ריקה.
לכן, אם זה לא מזויף אז הייתה שגיאה.
אני לא יודע מה זה, אולי הקובץ אינו קיים.
לא היו לי הרשאות.
שם הנתיב שגוי.
כל מספר של דברים יכול להשתבש.
לעת עתה, אני הולך באופן שרירותי להחזיר את 500
אשר היא שגיאת שרת פנימית.
משהו השתבש.
באמת לא אכפת לי כדי לאבחן אותו.
אז, בואו פשוט נגיד לי המשתמש זה שבור.
ואז, אני הולך לעשות res.end,
ואת זה הוא סימון מקוצר.
נזכיר כי אחרון זמן עשיתי res.write
ואז עשיתי res.end.
אם אתה רק רוצה לשלוח שורה אחת של תפוקה,
אתה פשוט יכול לעשות את זה בבת אחת עם res.end עם טיעון,
וזה הולך לשלוח מה הודעת השגיאה היא
חלק פנימי של האובייקט הזה לדפדפן.
זה די היה קשתי זוכר לפני רגע.
אין לי מושג מה זה התכוון במבט ראשון.
אבל כאשר בקשתי קובץ שלא היה קיים -
אופס, אנחנו צריכים לרוץ השרת שוב.
כשבקשתי קובץ שלא היה קיים, EISDIR,
כך משהו על זה להיות מדריך,
אם אני עושה את חלק אקראי מחרוזת שם,
ככל הנראה זה אומר קובץ אפילו לא קיים.
וזה בגלל שהקוד שלי הוא פשוט אומר לכתוב
את מה הגלם הודעת שגיאה היא,
כל כך לא מאוד ידידותי למשתמש אבל לפחות אני מטפל בזה.
דבר אחר, אם זה לא היה שגיאה מה אני עושה?
אותו דבר כמו לפני השיפוד את אישור 200, רגיל -
טקסט / סוג המוח רגיל ו אז לירוק את הנתונים.
ובגלל זה אני מקבל את תוכן של hello.txt אשר רק
כדי לאשר אם אני נראה בhello.txt,
זה ממש פשוט שלום, עולם.
ואם שיניתי את זה שלום, עולם, שמור את הקובץ,
להפעיל מחדש את השרת, לטעון מחדש את הדף.
עכשיו, אני מקבל גרסה זו.
אז, יש לי באמת רק reimplemented שרת אינטרנט
כפי שהיה קיימת עבור רבים שנים, אבל באמצעות node.js.
אבל אנחנו יכולים לעשות את זה אפילו יותר נקי.
תן לי לפתוח את סינכרוני-1.js.
עכשיו, שים לב שאני מוסיף מודול אחר הפעם,
כנראה מודול הנתיב.
עכשיו, זה טוב הזדמנות להביט
על מה התיעוד נראה.
Node.js הוא תיעוד.
כמו PHP אני חושב שהוא בעצם די טוב
ישר קדימה.
אם אני הולך לnode.js וגוגל ולחפש את נתיב node.js,
מה שתראה בדרך כלל קשר ישיר לכתובת URL
ששמתי כאן לפני רגע.
אז / API הוא המקום הרשמי ללכת על תיעוד.
ומה שתראה בחלק העליון
התיעוד הרשמי של הצומת הוא את כל השיטות ו
או מאפיינים פנימיים של מודול הספציפי הזה,
אחד מהם נקרא להצטרף.
ולהצטרף הוא פונקצית העוזר זה הולך כדי לאפשר לי
לא לטרוח כל הפלוסים.
והוא הוסיף בונוס כפי שתראה
מהרציפים גם זה מנרמל את הדרך וכתוצאה מכך.
לכן, אם המשתמש או שיש לך נקודות או נקודות נקודה או כל שילוב
מאותם סוגים של קרוב משפחה שבילים בין upsides,
של השיטה הוא שהצטרפה זה הולך לנקות את כל מה ש
ואתן לך הקנונית דרך ללא כל
מאותם נקודות או נקודות נקודה.
אז, זה דבר טוב ב כללי לביטחון לפחות
אם אתה בודק להחזיר ערך שאני לא
במקרה הפשוט הזה בפרט.
אבל אני לא רוצה להשתמש בו.
אז, עכשיו אני יוצר את הנתיב קצת יותר באמצעות תכנות
עם path.join במקום של שרשור גלם.
אז, זה קצת נקי יותר מבעבר.
ועכשיו שמתי לב שאני מתנהג קצת יותר אינטליגנטי ולא
לא רק בעיוורון אנסה לקרוא את הקובץ,
אני הולך ממש קורא fs.stat.
לכן, אם אתה מכיר
עם הרמה הנמוכה C פונקציות ו-C, גם PHP.
הרבה ספריות יש לי חוזרת Stat פונקציה זו
למעשה סטטיסטיקה בקובץ, גודל הקובץ,
ההרשאות, שם ודברים כאלה,
ומשתמע מכך גם אם הקובץ קיים או לא,
ואם זה קובץ או ספרייה
או קישור סמלי או משהו אחר.
אז עכשיו שמת לב, אני קורא fs.stat.
ולאחר מכן, ככל הנראה, על פי בתיעוד,
אני צריך לחזור באובייקט שגיאה
או Null ואחרי על ידי אובייקט נתונים סטטיסטיים.
אבל בואו נבדוק את זה, node.js.fs.
הנה הקובץ תיעוד מערכת.
תן לי להסתכל לנתונים סטטיסטיים.
יש בזה הרבה יותר של פונקציות כאן.
אופס, זה סנכרון Stat, fs.stat.
אז הנה, זה אסינכרוני סטטיסטיקה (2).
זה כלומר אם אתה זוכר מדפים ראשיים,
פרק 2 של הדף הראשי,
זה אומר שזה הוא, פשוטו כמשמעו, רק יישום צומת
של ברמה הנמוכה Stat תפקוד מערכת.
לכן, ההתקשרות מקבלת שני ויכוחים, שגיאה וstat
בי Stat הוא fs.stats להתנגד.
אז בואו לראות מה החפץ הזה הוא אמורה להיראות.
בואו לחצו על קישור ואני רואה את זה.
האובייקט מכיל נתונים סטטיסטיים ככל הנראה כמה שיטה עוזר,
הוא קובץ, הוא מדריך, הוא חבורה של דברים אחרים.
זה הקובץ "הוא" כי אכפת לי כ במקרה המסוים הזה.
אז הנה אני הולך.
אם הייתה טעות, אז תן לי רק לחלץ הפעם
ותניח.
אם יש שגיאה, זה היה כנראה קובץ 404 לא נמצא.
זה יכול להיות משהו אחר
אבל אני להיות קצת עצלן לכאן רק כדי להתמקד
על הפרטים מעניינים יותר.
אבל למשתמש של מטרות, קובץ לא נמצאו,
אם לא הייתה כל טעות לפי הקובץ.
אחרת, תן לי לבדוק אם קובץ הוא אכן קובץ עצמו.
אז אם זה לא קובץ, שהוא קיים.
יש שם משהו אבל זה כנראה ספרייה
או אולי קישור סמלי
או משהו אחר זה פאנקי במערכת הקבצים.
כך או כך, המשתמש לא צריך לראות את זה.
אז עכשיו, אני רק הולך לירוק
מתוך כמקובל לא מורשה 403.
אבל שוב רק אמנה,
אני היה יכול להשתמש משהו אחר בתאוריה.
ואז לבסוף, הרשה לי תנסה לקרוא את הקובץ.
אז, תן לי לגלול למטה.
ועכשיו שם לב זה המקום שבו הקוד יכול להיות קצת מבולגן,
שם לב שאני מתקשר פטירת fs.readFile
באותה הדרך, באותה איתות פעם שעברה,
כך בגרסה הקודמת.
ואז אם הייתי מוצא -
אם אני לא מוצא את זה, אני יורק מתוך 500.
ואם אני מוצא אותו, מה שורה אנחנו הולכים לראות כאן?
אנחנו הולכים לראות את FS לכתוב כותרת 200 כנראה
וres.end שליחה הנתונים בפועל.
אבל שם לב זה.
וזה לא הפגנתי של התרחיש הגרוע ביותר.
אבל יש לי שיחת stat זה כאן מאשר יש לי כמה דברים.
לאחר מכן, יש לי עוד שיחת אסינכרוני כאן,
כך יותר כניסה.
אז, פשוט סוג של אקסטרפולציה אם אתה יכול מכאן.
מה בעיה נוטה להתעורר עם השפה כמו JavaScript
בסביבה זו בי אין לך ערכי תמורה
אלא שיש לך שיחות הטלפון הללו.
וכמובן, זה רק דבר סגנוני העובדה
כי אני כל זמן זחה.
אבל לקחת את זה ל הצעד הגיוני הבא.
נניח שהיה אחד או שתיים או שלוש פונקציות אחרות
שאני צריך לבצע כי היו על ידי אסינכרוני הטבע,
ולכן אתה פשוט סוג של לשמור על הזחה לטפל בהם,
כדי לטפל בהם, לטפל בהם.
אתה מקבל סוג של התקשרות לעזאזל אנשים קוראים לזה
שם הקוד שלך מתחיל כדי לקבל רחב מאוד
ולמען אמת באמת קשה לקריאה.
כפי שהוא, אני יכול סוג של בקושי תגיד שזה סוג של זרימה
שיש לו סוג זה
מבחינת סגנונית בזווית דבר קורה כאן.
אז, זה לא אידיאלי כי יכול להיות זה מהר מאוד
מסורבל, למרות ששני אסינכרוני קורא לא
כזה ביג דיל.
לכן, אנחנו יכולים למנוע את זה, נכון?
ייתכן שהבחנת כי אני misclicked לפני רגע.
בתיעוד, אתה יודע, זה נראה כאילו יש statSync.
וstatSync לא לוקח התקשרות כטיעון.
זה לוקח רק את הדרך כי זה כנראה עושה מה?
זה מחזיר את מופע של fs.stats.
אז זה יכול להיות שלך אינסטינקט ראשון, נכון?
במיוחד אם פונקציות של קריאה חוזרת
ואסינכרונית היא חדש קטן אליך, בכנות,
הגישה הקלה ביותר היא כנראה רק למנוע את הבעיה כל
יחד, לחזור למיין של תכנות בסגנון CS101
שבו אתה קורא לפונקציה או שיטה, מחזירה את הערך,
לקרוא לפונקציה, חוזר הערך,
פונקציה, מחזירה את הערך.
ואני יכול להשתמש ולכן fs.statSync
שהוא, פשוטו כמשמעו, את אותו אבל זה גרסה סינכרוני
מה שאומר שהוא חוזר הערך.
זה לא עובר ערך לקריאה חוזרת.
אבל למה שכנראה יהיה לעקיפת הבעיה הכי מוצלח להיזקק
לפונקציות סינכרוני?
כן?
[הערה לא נשמע]
בדיוק, זה לוקח זמן רב.
אתה פשוט האטה כל מה שלמטה.
בגלל הרבה כמו Shake Shack או בורגר טעים, אם הם נפטרו
מזמזמים אותם וגרם לך, הלקוח לעמוד בחזית
של קו עד לאוכל שלך מוכן עוד לפני שלוקח את הסדר
של האדם שמאחורי ברור שאתה
דרך מכר שמאט.
אנשים מתחילים לעזוב, אתה סוג של לצייר מנות.
אתה יכול לעשות כל מספר של האנלוגיות כאן.
אבל בקיצור, זה כנראה לא דבר טוב
לעסקים או לשרת.
קוד אז אסינכרוני הוא בדרך כלל טוב לפחות
במקרה הזה, אבל זה בהחלט מתחיל לגרום לחרדה.
ולמעשה אני מעז לומר מתי ראשון כותב את הדברים האלה,
זה ייקח קצת קצת הזמן להתרגל אליו.
אז, בואו נתחיל לצייד לך עם כמה ספריות
וטכניקות לעשות זה קצת יותר קל.
לכן, אחד הנפוץ ביותר ספריות הן ספריות הפופולריות
בימים אלה, זה אחד בשם async.js.
וכמו הרבה node.js ספריות או מודולים,
כל אלה הם קוד פתוח.
הם כמעט כולם חיים ולקבל מאגרי רכזת שהוא סוג
מהפכתי דה פקטו מקום לאחסן את הדברים האלה.
ואז יש כל תשתית
להתקנת הדברים האלה קרא NPM, צומת מנהל חבילות
שאם אתה מכיר עם EvanTube הוא סוג
של יישום או אפליקציה כמו לקבל.
אם אתה מכיר עם Red Hat ופדורה
כמו במכשיר, זה כמו יאם.
אבל זה צומת - זה מנהל חבילות פשוט
לסביבה המסוימת הזה.
לכן, אנו יכולים להוריד ולהתקין דברים כמו ספריית סינכרוני
וגם עוד אחד בשם מדגיש ספרייה או מודול.
אבל FS ככל אלה, HTTP, נתיב,
אלה הם כולם באים נבנה לצומת.
אז אם אנחנו הולכים למסמכי ה-API, אתה באמת תראה שנבנה
לצומת אתה מקבל בחינם חבורה שלמה של מודולים.
אבל הרבה אנשים נחמדים על האינטרנט הפך עשרות
אם לא מאות ספריות אחרות
לעשות דברים טובים יותר או בצורה שונה.
אז, בואו נסתכל על איך זה עובד ספרייה.
לכן, רוב הקוד הזה הוא זהה לרגע.
יש לי נתיב להיות נוצר למעלה.
ועכשיו אני מתקשר async.series.
אז ספריית סינכרוני, זה רק ספרייה המאפשרת לך
להעביר או להעלות בדרך כלל של פונקציות כדי לקבל בשם אחד
בזה אחר זה רק כדי סוג של להימנע מזה עניין כניסה,
ובאמת רק הנפשי חרדה כי תמיד תקום
לפחות כאשר אתה ראשון לצלול לזה בעצמך
עם תכנות אסינכרוני.
כמו בצד, אם יש לך לקחת 161 ושהתמודדת עם מנעולים
ולהעלות את התנאים ואת כל שמקוד, אסינכרוני
וסביבה כמו node.js הוא למעשה הרבה,
ללא ספק הרבה יותר פשוט
מאשר למעשה כתיבה קוד מרובה הליכי.
בכל פעם שיש לך קוד מרובה הליכי,
יש לך תנאי העלאה.
אתה צריך לדאוג שני אשכולות המכילים
על אותם המשאבים דיסק או זיכרון.
היופי של JavaScript
בnode.js הוא שיש פשוטו כמשמעו רק חוט אחד,
מה שאומר שהדפדפן
או השרת רק יכול לעשות דבר אחד בכל פעם.
זה רק תלוי בך, מתכנת
כדי לשמור על מודל המנטלי ל איך אתה סוג של תור דברים
ולהבין איך להורות את הקוד שלך.
אבל אתה לא צריך לדאוג כ להעלות תנאים
בדיוק באותה הדרך ב לפחות עם קוד גלם כמו זה.
אז, זה קצת קשה grack כאן.
אבל - אז תן לי לפתוח את המסמכים רק לרגע.
ספריית async.js בי באופן דומה מאוד googleable,
הוא חי בGitHub repot כמו הרבה מהם.
לא חושב שזה גס, זה לא.
תן לי לגלול למטה לקרא אותי כאן.
אז, ספריית סינכרוני מספק כל חבורה
שיטות הפנימיים שלו.
לדוגמא, יש שיטה הנקראת כל אחד,
שאם אני לוחץ על זה פשוט לראות מסמכים שלה לרגע,
זו היא פונקציה או שיטה זה מאפשר לך לעשות משהו
כמו ארבעה בכל אבל במקביל.
הם כולם הולכים לקרות פוטנציאל במקביל.
והשיטה כל אחד היא רק הולך להחזיר לך כאשר כל
של החזרות הושלמו.
אז אולי הם קורים אחד אחרי השני.
באופן אידיאלי, הם קורים למעשה במקביל.
אבל השיטה אינה להתקשר אליך בחזרה.
זה לא זמזמך זמזם, עד שכל
של האלמנטים שיש לך iterated על השלים.
אז, זה פשוט דרך נחמדה
של הימנעות משימוש ארבע לולאה פשוטה
אבל בעצם עושה משהו באופן אסינכרוני.
אבל עכשיו באופן ישיר יותר הקשורים לדוגמא זו,
שימו לב שיש את זה שיטת סדרה.
ותן לי רק להרים דוגמא הקנונית פשוט.
אז ספריות סינכרוני, סדרה השיטה לוקחת בכפי שמשתמע
בסוגריים מרובעים במערך.
מה הם הנתונים סוגי האלמנטים
במערך זה, המבוסס בדוגמה פשוטה?
זהו מערך של פונקציות.
אז ב-C, היית קורא שלהם לתפקד מצביעים.
ב-JavaScript, יש יותר מתייחס כראוי לפונקציות
או פונקציות בעילום שם.
וזה רק אומר, מערכים
כמובן מסודרים מאפס בעד.
אז, הם שמרו כדי שהוא טוב
לסדרה, סדרה 'סיבה כמובן אמצעים לעשות משהו
על מנת שלא במקביל.
אז, זה רק אומר שזה פונקציה תקבל להורג,
אז זה אחד, אז זה אחד, זה אחד, אז זה אחד,
אולם רב יש
עד שלבסוף אופציונלי התקשרות נקראת.
אז, שים לב הפרדיגמה כאן.
ואף על פי שזה היא הספרייה של בחור אחד,
זה נציג הפרדיגמה JavaScript נפוצה מאוד
של שוב באמצעות שיחות טלפון.
אז, שים לב מה שאתה עושה כאן.
בהיותו הפונקציה הראשונה עבר בבאמצעות מערך זה,
שהגדרת בעילום שם פונקציה רק ​​עם פונקציה.
אבל שים לב שככל הנראה על פי תיעוד זה,
צריכה שפונקציה אנונימית תיקח התקשרות ויכוח.
כי הוא הולך להיות מצביע או הפניה לפונקציה
כי אתה צריך להתקשר כאשר הקוד מוכן להחזיר ערך.
אז שוב, בניגוד לרק תכנות בדרך כלל פרוצדורלי
שבו אתה רגיל חוזר ערכים באופן מיידי
כי הבדל אחד עם באמצעות ספרייה כזאת
בתכנות אסינכרוני יותר בדרך כלל, הוא כאשר אתה מוכן
כדי להחזיר ערך מ מסד הנתונים, מתוך קובץ,
מחשבון ביטוי, זה תלוי בך
לקרוא לפונקציה של קריאה חוזרת.
והדבר נחמד על ספרייה זו
אם אנו קוראים את המסמכים הוא בזהירות רבה יותר כי,
אם ורק אם כל אזור callbacks נקרא
ללא אובייקט שגיאה, יצליח כל העניין?
אז במילים אחרות, אם יש 2,
אם יש 10 אנונימי פונקציות
במערך זה ולכן בסדרה זו,
רק אם כולם יצליחו,
תהיה ההתקשרות אופציונלית הסופית להיחשב מוצלח?
אם מישהו מהם נכשל, כל פונקציה
לאחר שזה לא יקרה אפילו להיות מוצא להורג.
אז, זה דרך נחמדה מסוג שיש לו שרשרת דייזי
שביטולים בטרם עת אם משהו משתבש.
אז לראות את זה בהקשר, כאן הוא כיצד תוכל ליישם מחדש
כי התכנית קודמת.
אני מקבל את הדרך כמו קודם, אז זה חלק קל.
אני להעתיק ולהדביק קוד השלד הזה
מהתיעוד שיש async.series סוגריים פתוחים,
לפתוח סוגריים מרובעים.
ועכשיו שמתי לב שיש לי אחד פונקציה בתחילת זה
של שנייה, נראים לאן אנחנו הולכים מכאן.
ועכשיו שם לב, זה מורכב קצת בהתחלה
אבל להתמקד רק על זה שורה אחרת שורה.
Fs.stat פירושו לקבל את הנתונים הסטטיסטיים או מה שלא של הנתיב.
התקשר התקשרות זו כאשר מוכן.
קוד זה אותו הדבר כמו קודם.
אם יש שגיאה, יש הבדל אחד עכשיו.
שוב, את הפרדיגמה נפוצה מאוד בתכנות node.js הוא
אם משהו משתבש ו התקשרות צריכה לדעת
כי על ידי אמנה, הראשון טיעון להתקשרות הולך
להיות שלא, אם הכל טוב או הפניה לאובייקט שגיאה,
הון א 'זה כמו שגיאה כיתה שקיימות בעולם
אבל עוד על כך בפעם אחרת.
אז עושה את זה, אם יש שגיאה, מה המשמעות?
גם על הסמך מה שאני אמר הסדרה עושה,
הוא אם הכל הולך לא נכון, אנחנו פשוט סוג של הרצון
להפיל את כל הסדרה פונקציה של אנונימי קוראת.
אז, די לי רק לחזור חולף התקשרות
באובייקט השגיאה.
כי אם Stat נתן אותי בחזרה שגיאה,
אני יכול ליצור חדש אובייקט שגיאה משלי,
אבל לא ממש אכפת לי,
אני רק רוצה לעבור את כל מה שגיאה היא שבאמת יקרה
אז אני יכול להעביר את זה להתקשרות זו.
ורק שיהיה ברור, השיבה היא לא הכרחי.
אני בעצם רוצה לעשות את זה אבל רציתי עכשיו אין "לחזור;
/ / כדי שלא יותר קוד כאן מבצע ".
אז שוב אחר נפוץ כנס ב-JavaScript,
למרות שאתה לא חוזר ערך כשלעצמו,
אתה רוצה להעביר את הערך לפונקציה של קריאה חוזרת
אבל אז אתה רוצה כדי לעצור את הביצוע
של הפונקציה אתה ב, הדרך של מה בכך
כדי לעשות את זה הוא רק לקרוא לחזור לכאן.
אבל אין שום דבר רע,
אנחנו פשוט עושים את התקשרות תמורה שגיאה למרות שזה הולך
לחזור בערך לא מוגדר.
בסדר, זה לא להחזיר ערך הסביר ביותר.
כל מה שאכפת לי ממנו עליית ביצוע נוסף.
לכן, הצירוף של אלה שני קווים הוא רק הסטייליסטית
לועידה רק כדי יש את המספר של קו
קוד פשוט כתבתי 2-1.
אז מה עוד?
אם אין שגיאה -
למעשה להיות ברור גם אני יכול להימנע
כי על ידי עושה אם אחר.
אבל שוב, אחר הפרדיגמה נפוצה היא בדיקה
על הטעויות שלך למעלה ולאחר מכן רק לחזור ולא להמשיך
כדי לשנן את הקוד שלך עם elses וelses וelses.
אז אם זה לא קובץ, עכשיו, אתה יודע,
אני רוצה לטפל בזה קטן במיוחד.
אז הנה כמו בג'אווה או C + + או כמה שפות אחרות,
הנה איך יכול מופע מתנגד להקלד חולף שגיאה
בברירת מחדל של הודעה של לא קובץ
וזו רק שרירותי במידה מה.
אבל אני איתות טעות שלי.
ומה עושה את זה אחרון השורה מסמנת ככל הנראה?
הכל טוב.
אם אתה עובר באפס עבור פרמטר שגיאה, שמתכוון רק
בכנס הכל טוב.
אז, זה אומר מה יקרה באופן הגיוני?
אם null מועבר להתקשרות
זה אומר שזה בעילום שם פונקציה הצליחה
אם אפשר לומר כך.
אז מה צריך הסדרה שיטה קודמת ולחברה אין בסיס
בהגדרה הקודמת המילולית שלי?
[הערה לא נשמע]
לעבור לבא אחריו, נכון?
אם זה חזר שאינו ריק ערך, זה יהיה להפיל רק
ולא יותר אנונימי פונקציה היית מקבלת בשם.
אבל בגלל שיש לו לא, אז זה יקבל בשם הבא.
לכן, ההיגיון כאן הוא פחות או יותר אותו הדבר כמו קודם
ואנו רואים איך לנקות את זה עוד יותר ברגע.
אני מבין שזה סוג של הרבה
כדי לקלוט את כל מילולי מבחינה חזותית.
אבל עכשיו שם לב, השני פונקציה אנונימית שאני רוצה
לביצוע בסדרה הוא כדי לנסות לקרוא את הקובץ.
התקשר התקשרות זו כשאתה מוכן.
אם יש שגיאה, פשוט אות זה בדרך של ההתקשרות
כך ששאר החומר הזה ביטולים.
null תמורה אחר.
אבל למה אני עובר בשתי טענות?
ובכן, זה זמן אם אני קורא את הקובץ ולקבל בחזרה
כמשתנה הנקראת נתונים,
אני רוצה לסמן לא רק הכל טוב על ידי החזרת null
לטענה הראשונה.
אני רוצה לחזור בפועל הנתונים כטענה השנייה.
כי אם אני לקרוא עוד בתיעוד,
תבחין הנתח האחרון של קוד סוגר מרובע פירוש זה
הסוף של הסדרה.
היו רק שתי אנונימי פונקציות בסדרה זו.
אם הייתה שגיאה כאן, ולאחר מכן אני יודע שאחד הקישורים
בשרשרת הזאת כל כך לדבר נכשל.
אז במילים אחרות, שגיאה זו הולך להיות אובייקט שגיאה
שהוא ריק אם בכלל החבר 'ה האלה נכשל.
ואם זה המקרה, אני רק הולך לחלץ את ואני הולך
לומר ש400 משמעות בקשה להיכשל,
זה מאוד גנרי הודעת שגיאה.
ואז, אני הולך להדפיס את הודעת השגיאה.
אז, אני לא טורח להיות סופר אנאלי הפעם,
אני לא מתכוון להבחין בין 500 404 ו403,
אני פשוט סוג של עיוורון לנופף את היד שלי
ואומר שמשהו השתבש.
אבל אם לא עשה להשתבש,
אני הולך לשלוח את זה res.end העברת נתונים זה.
עכשיו זה נראה קצת לא ברור מאליהם.
אבל שוב, אם אני קורא התיעוד,
הארגומנט השני התקשרות זו סופית, סופית,
הבחור שמבוצע רק ברגע שהסדרה נעשה
ביצוע או חלק שם של, זה הולך להיות מערך
מכל הטיעונים שני
שעברו להתקשרות.
כעת, מתברר כי לקשר רק בסדרה זו
כי בעצם לחזור לשני טיעון הוא זה כאן.
אז אני הולך למיון של על הקפיצה של אמונה פשוט להשתמש נניח
לרגע ש האחרון היא שיטה
זה נותן לך אחרון אלמנטים של מערך.
מכיוון שמערך זה שמועבר
לי יש שני: מדדים, אפס ואחד.
זה פשוט אפס אין לו ערך בגלל הבחור הזה חוזר -
לא עובר בשנייה ויכוח אבל הבחור הזה עושה.
אז תוצאות סוגר אפס שום דבר,
סוגר תוצאות אחד מכיל מה,
אם אתה עוקב אחרי יחד עד לנקודה זו?
הקובץ, שלום, תוכן בעולם ככל הנראה,
אז ככה אני ממש להדפיס אותו.
ותן לי לסיים פרט אחד כאן.
אם אני עושה את זה סוג של ישן בית הספר, אם אני רוצה להגיע
באלמנטים שעבר, אם הייתי יכול לעשות תוצאות [results.length-1],
זה סוג של דרך בית ספר ישנה
לגישה לאלמנטים שעבר ב-- או אפס מערך מדד.
אבל כמו בצד, זוכר שיש לי בספרייה זו
עד כאן תחתון שעל ידי כנס הוא רק בשם
פשוטו כמשמעו תחתון דמות שהיא לא מיוחדת,
זה פשוט נראה מגניב כמו סימן דולר עושה עבור jQuery.
זה רק עוזר שיטה מדגישה נקודה האחרונה
שעושה בדיוק את אותו הדבר.
ואם אף פעם לא השתמשו בו לפני מדגיש JS שני
עבור קידוד בצד הלקוח
וצד השרת הוא ספרייה שימושית להפליא
שאנשים רבים תיארו זה כמו jQuery מכיל את כל
מהשיטות, אנשים איחלו הגיע עם JavaScript עצמו.
על אישור.
>> אז, כמו די לי ו אני צופה בסדרה,
יש לך כמו התקשרות כטיעון?
>> כן.
>> כמו כל כך כאשר אתה כמו בעצם לדחוף כי ב,
וכמו מה שעושה את זה מתכוון כשאתה רק צריך
כמו איתות ולאחר מכן בצע כמו -
[הערה לא נשמע]
>> אוקיי, שאלה טובה.
אז, תן לי למשוך את הדף הראשי סינכרוני כאן
או התיעוד על GetHub.
אז זה הקנונית מבנה.
לך אם שיחה משתמש בזה סדרת שיטה מסוימת,
יש שני חלקים גדולים אליו.
אחד מהם הוא מערך של פונקציות בעילום שם
ושני הוא התקשרות סופית פונקציה שבעצם
להורג במאוד הסוף של הסדרה.
עכשיו, אם אנחנו להתקרב קצת יותר קרוב בראשון
הדברים הגדולים האלה, מערך של פונקציות בעילום שם
על ידי דרישה של זה יש התיעוד של הבחור
להיות אנונימי פונקציה שלוקחת
בקריאה חוזרת בשם טיעון אחד או foo או בבר, זה לא משנה
אבל הוא קורא לזה איתות.
וזה סוג של זמזמך שייק שאק מושיט לך.
זה הוא הכלי שבאמצעותו אתה יכול להחזיר את ערך
ללקוח כי אתה לא יכול פשוט, פשוטו כמשמעו, לחזור.
אתה צריך לעשות את זה על ידי דרך של התקשרות זו.
כי אם בתוך זה פונקציה היא קצת איטית בריצה
קוד כמו מסד הנתונים שאילתה, לקרוא את הקובץ ממערכת הקבצים,
אתה לא רוצה לחכות שם ולחסום את כולם,
אתה רוצה לקרוא לאיתות.
אז, זה פשוטו כמשמעו שמו של הוויכוח.
אבל אוהב ב-C, אתה יש מצביעי פונקציה.
ב-Java יש לך שיטות מערכת התייחסות
ואותו הדבר כאן ב-JavaScript.
זה משתנה אבל הסוג שלה הוא פונקציה.
אז פשוט על ידי כתיבת שמו אם התקשרות או foo
או בבר, ואז סוגריים פתוחים וקרובים סוגריים,
אתה ביצוע כי בפונקציה זו.
ועובר null אשר משמעות שגיאה ואחד null
מה שאומר שזה הוא הנתונים שאני רוצה לעבור פנימה
ולאחר מכן הנתח שיהיה ברור, זה הוא התקשרות אחרת.
וזה לא נקרא איתות,
זה פשוט מושגית הוא פונקצית שיטת התקשרות
כי זה נקרא על ידי הגדרה
מספרייתו של יוצר זה כש הסדרה כולה השלימה
או משנו אם השגיאה שקרה מוקדם יותר.
לכן, שם של פונקציה של קריאה חוזרת, קורא פונקציה של קריאה חוזרת,
שם של פונקציה של קריאה חוזרת, קורא פונקציה של קריאה חוזרת,
התקשרות שונה לתפקד כולם יחד.
>> עכשיו יש לנו כמו מגדיר את ההתקשרות?
>> לא, כי הבחור הזה יעבור למערך שלך
פונקציות של בעילום שם,
מצביע לקוד הוא רוצה להוציא לפועל.
בדיוק, הכל בסדר.
אז, בבקשה לומר כי קוד מקבל קצת יותר פשוט.
אז, זה יכול.
ואם אתה אוהב אותי, קח את נוחות לפחות בידיעה,
זה לוקח זמן להתרגל לזה.
אבל אנחנו יכולים לנקות זה קצת למעלה,
לא לזרוק יותר מדי באליך אבל הנה עוד וריאציה
ו בשיטה אחרת
באותה הספרייה נקרא מפל.
ההפוך שבם הוא בניגוד לסדרה שבה כל
של אנונימי אלה פונקציות להורג במהות
באופן בלתי תלוי כל אחד מהאחרים.
מפל כמו השם מציע מאפשר פונקציות העליונות
לעבור סוג של בערכים לתפקוד נמוך יותר,
כמו סוג של מפל מים.
אז היתרון של זה הוא שסוג שאני יכול
הבהרה זו לטובתי.
בasync.waterfall, שים לב לדברים הבאים.
אני רק יכול לקרוא fs.stat עובר בדרך
כי אני רוצה להגיע נתונים סטטיסטיים על.
ואז לפני שאני זוכר הייתה פונקציה אנונימית
שהיה לו שתי טענות לטעות,
esults ולאחר מכן התקשרתי פונקציה של קריאה חוזרת באופן ידני?
במילה אחרת הוא רק כדי להיות ברור, זוכר שקודם לכן
בסינכרוני 2, אני עשיתי את כל העבודה מגעיל הזה.
התקשרתי עבר fs.stat בP,
הכריז אנונימי שלי פונקציה.
אז אני בדקתי אם שגיאה היא לא ריק ואז עשיתי את זה,
אחר שעשיתי את זה, את כל יופי של מוסכמות הבאות
כמו בnode.js היא התקשרות ש פונקציות באופן כללי נועדו
לקחת טענה אחת לפחות, אובייקט שגיאה ואחריו אפס
או ערכים שימושיים יותר.
אז שם לב הפרדיגמה כאן,
פונקציה של קריאה חוזרת זה אני ההכרזה הבאה בדיוק
הפרדיגמה שהבחור הזה ספריית סינכרוני עושה.
איזו הוא להגיד את זה, למה אני אני יישום ההתקשרות שלי
שיטה כאשר המחבר זה ספרייה היא, פשוטו כמשמעו, והושיטה לי
על מגש של כביכול, פונקציה של קריאה חוזרת אני יכול להשתמש?
אז, אני יכול פשוט לעבור ב הפניה שהוא נתן לי
כך שמייד, כמה שורות שלי
הקוד להיות שורה אחת של קוד.
עכשיו, לאן אנחנו הולכים עם זה?
הפונקציה הבאה ש אני רוצה להוציא לפועל,
אנונימי הבא פונקציה במערך זה
של פונקציות עושים את הדברים הבאים.
Stat הראשון הוא ההודעה הטענה הראשונה.
אז משהו יש השתנה כבר.
עכשיו, מי הבחור הזה כתב את הספרייה -
ואני אומר בחור כי זה בחור.
הבחור הזה שכתב את ספרייה זו היא ערבויות תיעוד
שאם פונקציה זו כאן עובר לי בחזרה אובייקט שגיאה
או אחרי null ידי תרדמת רשימה מופרדת של ערכים אחרים,
הוא יהיה לוודא כי אלה ערכים אחרים הם בידיים
לפונקציה אנונימית זה לפי הסדר משמאל לימין.
ומה היו אמור להיות רק פונקציה של קריאה חוזרת לבד פשוט
הופך הטיעון כזה שעבר.
עכשיו, אני לא יודע מי אני התמקדות רק אתה יודע.
אבל עכשיו, מה לקחת כאן?
אז, אנו יודעים מן התיעוד
או כמה דוגמאות לפני
fs.stat שסופו של דבר מצפה התקשרות עם שני ארגומנטים,
אובייקט השגיאה שהוא אובייקט שגיאה או null ואחרי
על ידי התייחסות לנתונים סטטיסטיים להתנגד.
אז אם אני חושב על זה, סטטיסטיקות תרדמת אובייקט שגיאה מתנגדות,
שמתאים בפרדיגמה מספרייתו של אדם זה.
אז, אני יכול לומר בפשטות כי שלי שום טענה השנייה
שזה - זה הולך יועבר על ידי fs.stat
להתקשרות היא לטעות, סטטיסטיקה על ידי הגדרה של ספרייה זו,
אני יכול לשים שני שמו של הוויכוח כאן
או מה שאני יכול לשנות את זה
אם אני רוצה ואחרי על ידי ההתקשרות כאן.
אז, אני יכול לעבור אחד ערך מכאן לכאן.
עכשיו, את כל הקוד הזה אם כי אמנם מעט נסתר הוא
לפחות להעתיק ולהדביק על ברוב המקרים מהעבר.
ההבדל היחיד הוא הודעה כאן אני מכריז שגיאה
מתנגד ועכשיו אני רוצה כדי לקבל קצת להשתכלל.
אני באמת רוצה לדעת מה הטעות, אז אני הולך
לתחוב פנימי של האובייקט הזה נכס בשם קוד שרירותי
כך שאני יודע ש זה לא קובץ
שצריך להיות לא מורשה, זה HTTP 403.
תן לי לזכור שלפני אני עובר את אובייקט השגיאה
להתקשרות.
ואז לבסוף תנסה לקרוא את הקובץ, ולכן במקרה זה,
המפל, אני כבר נשבר הקוד משני צעדים גדולים
לשלושה צעדים קטנים יותר.
שים לב ליופי כאן,
אני יכול לקרוא fs.readFile עובר בנתיב.
ולאחר מכן חלק הקשה מבחינה נפשית, הוא פשוט עובר
בקריאה החוזרת של הבחור.
הדבר שהוא הושיט לי, אני הולך לעבור לfs.readFile.
בגלל שאנחנו כל דבקות לאותו מוסכמות,
הטענה הראשונה להתקשרות היא אובייקט שגיאה או null ואחרי
בתרדמת או פרוד רשימה של דברים שימושיים.
אז, מה זה אומר עכשיו ואם אני קרא את התיעוד אני אדע
זה, ההתקשרות האחרון, הבחור הזה כאן מחוץ
של סוגריים מרובעים הולך שעבר באובייקט שגיאה
או null שאני צריך לבדוק כמו תמיד עם הקוד הזה כאן.
ולאחר מכן על ידי הגדרה של שיטה זו
בתיעוד של הבחור, הערך האחרון חזר
מהשיטה האחרונה במערך אנונימי שלי -
המערך שלי של פונקציות בעילום שם.
אז, מה לקרוא תמורת קובץ
ואני משתמש בתשואה באופן רופף עכשיו.
אני מתכוון למה שאין לקרוא לעבור קובץ כפי טיעונים
לשיטת ההתקשרות שלה בידיים?
שני טיעונים, הוא ראשון אובייקט שגיאה או null,
זה כמעט תמיד הולך להיות התשובה.
והדבר השני הוא הולך להיות מה לקובץ לקריאה?
את תוכנו של הקובץ, הנתונים, כפי שכינינו אותו קודם לכן.
אז, פשוט על ידי הכרזה לטעות, לגרום,
ולבדוק לשגיאה זו הוא סוג של משעמם עכשיו.
דבר אחר, אני עושה res.end עובר בתוצאה זו.
ללא ספק זה יהיה לא לסנכרן באופן מושלם
עד שאתה בעצם לכתוב את זה בעצמך.
אבל לעת עתה, לקחת משם לפחות את העובדה
שיש, ככל הנראה, זה הפרדיגמה נפוצה, לפיה אם
ומחברים של ספריות כל הסוג של מקל
לאמנה זו שיטות התקשרות.
והטענה הראשונה היא אובייקט שגיאה או null.
והשני ושלישית
ואובייקטים רביעי הם דברים אכפת לנו ואנחנו סוג
מלעקוב אחר כללים ו תיעוד.
התחלנו עם קוד ש כנות היא די מכוערת.
ואף על פי האחרון דוגמה לכך היא בכנות קצת קשה
לעטוף את דעתך בסביבה, זה לפחות מבחינה ויזואלית,
נראה שזה הרבה יותר הדוק.
וברגע שאתה מקבל בנוח עם זה, זה כל כך הרבה יותר קל
וזה כל כך הרבה פחות נוטה באגים מזה דוגמא קודמת.
אז, תן לי להדגים הדבר האחרון כאן.
זוהי גרסה שלוש.
ו-- לא, בואו נשאיר זה אחד לבד.
תן לי להיכנס לכמה הדברים האחרונים אחרים כמו טיזרים.
בסדר, אז בשרת 2.
על אישור. ראשית, שאלות, אני יודע שזה הרבה
אבל אתה רצית יותר הוראות, כל כך?
לא אמרו טוב הוראה בהכרח.
כן?
[הערה לא נשמע]
נכון, אתה בעצם סלחני למערכת הפעלה
כדי להבין איך ללהטט כל הכדורים האלה בבת אחת,
קריאה מקובץ, קריאה מבסיס נתונים.
וזה שרת JavaScript זו עצמו זה של הליכי משנה בודדים.
ובעצם ולמעשה,
יש תמונה אחת לא להקיא,
וזה לא בהכרח כל מאיר עיניים כי
אבל אולי ייתנו לי אתה מודל המנטלי.
JavaScript עצמה וצומת
בפרט יש את זה מה שנקרא אירוע לולאה.
לפיה, אתה יכול לחשוב של node.js, התכנית,
הוא ממש כמו לולאה אינסופית.
זה פשוט לולאה פראית, מחכה וחיכיתי וחיכה,
מחפש משימות להשלים.
והמשימה עשויה להיות, עבור להביא משהו מבסיס נתונים
או הנה ערך מ מסד נתונים או ללכת לקבל קובץ זה
מדיסק או הנה לבקש ממשתמש.
כל סוג של אירוע, בדיוק כמו אירוע הדפדפנים מונע,
כך כשרת אירוע צד מונע.
וכל הדברים האלה מהווה אירועים.
אז מישהו בnode.js, רק כתב לולאה אינסופית,
לולאה פראית גדולה, מחכה לדברים לקרות.
וכפי שהדברים קורה, זה בסופו של תור, נכון?
אין ספק, בסיס הנתונים עלול להחזיר ערך.
ומערכת קבצים, ההפעלה מערכת עשויה להחזיר ערך
בערך באותו הזמן אבל יש כנראה הולך
להיות חלק מסדר להם.
וnode.js הולך יש בעצם תור
כמו מערך גדול או וקטור, כמה מבנה נתונים
שאוגר את כל מהדברים האלה.
כי זה יכול, פשוטו כמשמעו, רק להתמודד עם אחד מהם בכל פעם.
לכן, כאשר אתה, היזם,
כתיבת JavaScript אסינכרוני קוד באמצעות אסינכרוני
פונקציה, אתה מאפשר את זה מה שנקרא אירוע הלולאה ללכת
לתקתק הבא, נכון?
לכן, כל עוד אתה באופן מיידי תחזור כמו כל
שיטות אלה אסינכרוני לעשות כמו קובץ קריאה וstat,
הם חוזרים באופן מיידי כי התקשרות סופו של דבר
מקבל בחזרה.
ברגע שאתה חוזר,
זה אומר שמישהו אחר יכול לחטוף את המניה כאן
או שהוא יכול לחטוף את בראש התור כאן.
וכך, יש ב עובדה בהמשכים
מכל מה שקורה,
למרות כל הדברים האלה יכול להיות שזה קורה במקביל
במערכת מרובה הליכי.
אבל node.js עצמו ו השרת רצו
כחוט אחד.
ולמטה בצד של זה t אתה לא בהכרח מקסימום
את המחשב שלך היכולת היא כבמיוחד
אם יש לך ליבה או 16 אפילו מחשב 2 ליבה
ואתה פשוט רץ מופע של צומת אחד.
אבל אם יש לך שוב לקח משהו כמו 161,
לך להימנע מסיוט ענק כאבי הראש כשמדובר
לתנאים של מרוץ ו מנעולים וסמפור
וכתיבה באמת קוד מרובה הליכי,
כך upsides וחסרונות.
על אישור. אז, בחזרה לקוד כאן, הרשה לי להציע שאנחנו מתחילים
כדי לפשט את דברים קצת.
ראינו שרת אחד קצת לפני שנראה כמו זה.
אז, זה ללא ספק די פשוט.
אבל בדיוק כמו בעולם של PHP, יש מסגרות
כמו Laravel ויש דברים כמו Rails וג'נגו,
אותו דבר בעולם node.js.
ואנו מבלים יותר זמן על זה ביום רביעי
ובפרויקט הבא.
אבל אם אני נכנסתי שרת 2 ספרייה,
שם לב כמה פרדיגמות כאן.
אז זה - יש הולך להיות דוגמא מקבילה
אבל זה באמצעות מסגרת נקראת express.js,
שהוא קוד פתוח בחינם תוכנה כמו Rails וג'נגו,
כמו Laravel, זה רק סופו של דבר הולך
להיות שלא מעריכים היום כי אנחנו כבר כותבים
דוגמאות פשוטות כאלה.
אבל תאמין לנו.
זה יהיה מהר מאוד להיות חבר שלך
כי זה יחסוך לך הרבה קוד TDS.
והפרדיגמה נפוצה יישום express.js הוא
יש app.js או server.js קובץ המכיל את הלוגיקה
התכנית שלך או ב לפחות נקודת הכניסה.
אתה יכול לקבל קבצים מרובים.
תיקיית מודול צומת שבו יש ספריות
שהורדת כמו סינכרוני
ולבטא את עצמו באחרים.
ולאחר מכן package.json, package.json נראה כך,
ואתה יכול ליצור אותו באופן ידני או כלים ליצור את זה בשבילך
וזה ממש קובץ json
וחלק המעניין היא התלות כאן.
בדיוק כמו בLaravel, אתה היה שספריית ספק
והיה לך מה לדאוג על חבילות ועושים -
למעשה עדכון עם Artisan או פקודות דומות,
ספריותיך התקנתי,
באופן דומה עם package.json כאן ולך לנהל את הספריות
והגרסות שאכפת לך.
לכן, אם יש לי package.json, אני יכול פשוט לעשות NPM,
צומת החבילה מאנגר להתקין, זה הולך להיראות באופן אוטומטי
באותו קובץ package.json.
תסתכל ותראה, יש לי יש את הגרסה האחרונה
של כל המודולים ספקים
בצומת מדגישים מודולים ספרייה כאן או אולי
בחלק ההורה או ספריית אב קדמון.
ואם לא, זה הולך להוריד אותם
ותראה כל חבורה
דברים HTTP הולכים מעבר לגדר.
כך למשל, תן לי להראות לך את התוכן
מודולים צומת רק כדי להביע.
תן לי ללכת קדימה ו באומץ למחוק מודולים צומת
כך שכל שיש לי כרגע הוא זה.
ואם אני NPM ניתן להתקין, תוכל רואה שזה הולך לקרוא
שקובץ וpackage.json ראינו פלט דומה
לזה בעולם Laravel.
זה הורדה שלמה חבורה של דברים וזה
בגלל מפורש בתורו תלוי כל חבורה
ספריות עמים אחרות.
לכן, כל אלה הם סוג של הורדת באופן רקורסיבי.
עד עכשיו, אם אני עושה בLS שוב,
יש מודולים צומתי בחזרה ספרייה
ולהביע כבחזרה.
אז זה רק דרך ניהול חבילות לפשט.
עכשיו, אם אנחנו מסתכלים על קובץ app.js, זה הולך
להיות חזרה ל שרת האינטרנט הראשון שלנו
שבו אנחנו פשוט לירוק מתוך "שלום, עולם".
אבל שים לב לפרדיגמות כאן,
ראשון אנו דורשים מפורשים המודול, אז יש לנו את הקו הזה
של קוד שבו אתה יודע מהתיעוד.
אתה ממש טיפול ש משתנה של מודול כפונקציה,
קרוב סוגריים כל כך פתוח סוגריים פירושו לבצע את זה.
זה הולך ככל הנראה להחזיר משהו שאנחנו הולכים
בדרך כלל קורא לאפליקציה.
איך זה עובד?
אני לא ממש יודע.
אני אתן למישהו אחר, אתה יודע, בעולם המפורש לכתוב את זה.
אני מתכוון לעמוד כעת על כתפיים שלו או שלה כדי
כדי להפוך את הבקשה שלי פועל קצת יותר פשוט.
הנה, אני הולך להקשיב ביציאה מסוימת
זה יכול להיות כל דבר ביותר.
והנה קוד זה אולי מזכיר יותר עכשיו
של Laravel וroutes.php.
אז זו ארוחת ערב פשוטה, אני רק הולך לציין מסלול
לכוכב קו נטוי, כך שהכילו הולך להיספג
על ידי מטפל בקשה זו.
הפרדיגמה למטפל בקשה היא הפונקציה אנונימית
עם טיעון בקשה
ואובייקט תגובה בדיוק כמו קודם.
וres.send באמצעים מפורשים אתה שולח את הקוד ואחרי
על ידי מה שאתה רוצה לשלוח.
וכמובן, שאתה יכול לעשות משהו מהודר
על ידי שליחה למעשה קבצים או HTML
או שנוצר באופן דינמי תוכן.
אבל לעת עתה, כל מה שעשינו היה לירוק את שלום, עולם.
אם תלכו לשרת שלושה, זה אפילו מהודר יותר פשוט
כדי להראות לך חלק מהפונקציונליות.
ואנחנו אראה לך גרסה אפילו יותר סקסית
זה ביום רביעי.
אבל אם אי פעם שמעו של Socket IO אולי,
אז כמו שאני חושב יונתן או מישהו שאמר קודם לכן,
אחד הדברים הצומת היא באמת ידועה
לזמן האמיתי שלה התנהגות, נכון?
תחשוב על PHP ב-MySQL, אם אתה היו ליישם שרת צ'אט
ב-PHP לפיה שני אנשים יכולים לפתוח חלון דפדפן לfoo.com
ולאחר מכן להתחיל בהתכתבות במסרים מיידי כל אחרת, אליס בחלון אחד,
בוב באחר כך כל אחד מהם רואה אותו
או הודעותיה ב החלון האחר.
איך היית עושה את זה ב-PHP ו-MySQL?
שימוש או אי שימוש מסוג Laravel של לא מהותי, אתה יכול לקבל
כמו קובץ index.php.
ואתה חייב להיות - ב חלק ממקרים זה חייב לירוק
מתוך טופס, כך שאין הולך להיות טופס HTML
שכנראה לא יגיש באמצעות הגשת טופס רגילה
אבל אייאקס כנראה, נכון?
אז, על להגיש מטפל, ולכן אתה מקליד לתוך שדה טקסט,
אתה הקש על Enter ולאחר מכן הוא מקבל נשלח לשרת באמצעות Ajax.
מה אתה עושה אז לעשות בשרת?
אז, יש לך index.php
או PHP נקודת משהו שהוא קיבל בפרמטר HTTP
מהמשתמש, אליס או בוב הודעה מיידית, מה אתה עושה
עם זה על מנת להפיץ אותו לבוב או אליס, בהתאמה?
אני אומר לך, פשוטו כמשמעו, יש כלים שבאמצעותם
לעשות את זה בדקות שלך.
אז כמו מה היית עושה?
יש לך דקה אחת כדי ליישם תכנית זו.
כן?
[הערה לא נשמע]
מושלם. נכון, אז יש לך מסד נתונים.
אנחנו יודעים קצת קצת על MySQL.
אז, יש לך טבלה זה הודעות,
אולי יש פעמים חותמת, זיהוי משתמש,
גוף ההודעה עצמו יצר את זה,
מעודכן וכל זה.
אז, אתה לאחסן במסד נתונים.
ונניח שאליס שולחת את הודעה ראשונה, איך בוב יקבל
כי הודעת החברה מבסיס הנתונים?
>> זה יכול להיות חלק מאייאקס תגובה שקורה כל הזמן
חזרה לאתר עליון לקבל את [לא ברור].
>> בדיוק.
אז הקוד של בוב מי קוד אותו הדבר כמו אליס הוא רק סוג
של מערכת יחסים סימטריים,
יש הדפדפן של בוב קצת קוד אייאקס זה כנראה אולי כל 30
שניות מושכות שרת באמצעות סנכרון אייאקס,
יש הודעות חדשות?
האם יש הודעות חדשות?
כל 30 שניות הולכת להיות סוג של תת אופטימלי
כי הוא צריך לחכות עוד
אם אליס, פשוטו כמשמעו, פשוט שלח את ההודעה.
אז, יכל הדפדפן של בוב כל שנייה פגע בשרת.
אבל זה אומר אליס דפדפן הוא להכות את השרת
בכל שנייה.
ומה עם צ'רלי [איות להניח]
ודוד [להניח כתיב] ואדוארד [להניח כתיב]
וכל אות אחרת של האלפבית?
מה הבעיה בגישה זו?
הרבה להיטים מוגזמים -
אני אומר שאתה פשוט בצורה יעילה מינון המראה שלך
או DDOSing, Distributed התקפות מסוג מניעת שירות
באתר שלך, על ידי כך את כל
של משתמשים אלה להפעיל JavaScript קוד זה רק פינג
לעזאזל מתוך השרת שלך גם אם מספר שרירותי,
80 אחוז מזמן אף אחד לא אמר שום דבר
בחדר הצ'אט.
אבל אתה רק בודק לוודא של כאלה.
אז PHP בהרבה שפות הן פשוט לא טובות
לתקשורת בזמן אמת.
משום שבזוכר PHP יש אין זיכרון מרכזי, נכון?
יש לך אובייקטי מושב אשר יוצר את האשליה
של אחסון אבל מרכזיים זה על כל משתמש בפרט.
אין לך זיכרון הגלובלי כמו שאתה עושה בServlet Java
במכיר או באחרים מסגרת עובדת ככה.
Node.js אם כי, יש לך זיכרון הגלובלי בגלל שיש לך
שרת אחד וזה יכול זוכר שום דבר שהיא רוצה
על כל משתמשים.
ואתה עדיין יכול יש מסד נתונים.
אבל הדבר נחמד על node.js גם הוא שזה הרבה יותר טוב
מאשר משהו כמו PHP ויצירת האשליה
טיפול במספר רב של דברים בבת אחת.
ולמעשה כמו בצד, אתה יכול ליישם שרתי צ'אט ב-PHP,
אבל אתה בדרך כלל הייתי עושה משהו שנקרא תשאול ארוך
לפיה אתה לא לאותת השרת כל שנייה.
אתה לאותת לשרת, שרת אינו מגיב אליך
ללמעלה מ 30 שניות, זה ממש יושב
בלולאה מחכה וחיכה.
והמחאות השרת אם יש נתונים חדשים באתר
ורק ברגע שהוא רואה אותך, "אה, הנה הודעה מבוב, "
זה להגיב לשרת HTP?
כך שהאפקט בדפדפן שלך הוא שעל הסמל של IE או מוזילה
או מה שרק הולכים וספינינג ל30 שניות בכל פעם.
אבל היתרון הוא, שאתה לא יודע יש 30 בקשות חיבור
ב30 שניות, יש לך אחד.
אז זה נקרא תשאול ארוך.
אבל אפילו טוב יותר באינטרנט מודרני דפדפנים הוא משהו שנקרא
WebSocket, אשר אתה לוקח את CS143,
אתה יכול למעשה לעשות חיבור TCP מלקוחות
כמו דפדפן לשרת ולאחר מכן להיאחז בו
ללא שימוש כמעט משאבים רבים
כמו HTTP יכול לעשות באופן מסורתי.
וSocket IO הוא ספריית node.js
זה עושה את זה הרבה יותר קל להפוך את חיבורי השקע
או אשליות יש לדפדפנים ישנים
כך שאתה יכול ליישם את זה של פונקציונלי בזמן אמת.
אז, הנה דוגמא.
החומר הזה למעלה מקבל קצת יותר מסובך
אבל זה בעיקר להעתיק ולהדביק מתיעוד של socket.io.
הנה עכשיו יותר מטפל בקשה מדויק.
אם בקשת המשתמש לוכסן, מה קובץ אני הולך
להיות, ככל הנראה, לשרת אותם?
Index.html.
ויש כמה חדש זרם דברים כאן
שאני אראה לך ברגע.
אבל זה רק בדרך אחרת
של גרירת קובץ קצת יותר ביעילות
מאשר רק עושה fs.readFile.
זה קצת יותר חכם במיוחד עבור קבצים גדולים.
סיפור כל כך הרבה זמן קצר, את השורות האלה רק כדי לשרת
עד קובץ בשם index.html
אשר לעת עתה להניח מכילה טופס ה-HTML שבו אליס
ובוב אולי intercommunicate.
לבסוף, io.sockets.on, אז זה מגיע מהקו הזה עד כאן.
אז, אני רק קורא io.socket התיעוד נותן לי
גישה למה שנקרא WebSocket עם דפדפן,
בין הדפדפן והשרת.
אני מקשיב למיוחד חיבור אירוע שאמצעים
כאשר המשתמש הראשון פוגע בשרת מנסה
כדי לפתוח את הקשר הזה, אני הולך לקרוא קריאה זו חזרה.
ועכשיו, אני הולך לעשות את הדברים הבאים.
כל חמש שניות, מה אני הולך לעשות?
אני הולך לפלוט או לשדר אם אתה זוכר את התחלה,
השפה גרפית היית שחוסם את שידור?
אז, אתה הולך לפלוט
או לעורר אירוע שנקרא באופן שרירותי מהשרת.
וזה הולך מכיל פינג הודעה
ואת התאריך הנוכחי.
אז, זה בפועל שרת הצ'אט שאליס
ובוב יכול להשתמש בו, אבל זה מסוג של שרת צ'אט אוטומטי
שבו ההודעות הן pings פשוט סוג של סונאר.
זה פשוט לצאת בזמנים שהם נשלח כל חמש שניות.
לכן, אם אני ממש להפעיל את זה דבר - וזהו זה.
כדי להיות ברור כאן למטה, הודעה זה פשוט להיכנס לכאן.
לכן, הרשה לי לפנות עין זה.
תן לי לעשות צומת של app.js.
תן לי ללכת לדפדפן שלי.
רענן בדף הבית כאן.
[הפסקה]
ותן לי לסגור את המפקח.
כל חמש שניות, יש לי הפגנה אף שלא
אינטראקטיבי לאדם
של משהו שהוא קורה באופן אסינכרוני.
בהודעה של הדפדפן, אין סמל ספינינג.
זה באמצעות תכונת מגדלת של כרום בדפדפנים מודרניים
של שמירה על שקע חיבור מתחת למכסת המנוע
וזה מה שנקרא בדרך כלל מודל פאב / sub,
לפרסם / להירשם מודל, שבו אנחנו לא עשינו
כי די במפורש כאן.
אבל מה שיפה זה הפרדיגמה פאב כללי / sub היא
כי אתה יכול להיות שותף אחד.
במקרה זה שרת מרכזי וכל
של הפרט דפדפנים הם לקוחות.
אליס ובוב של עולם יכול להירשם אליו,
כך שאתה יכול להעביר מסרים בין כל מספר של משתמשים.
ולמרות ששוב אנחנו לא רואה אינטראקטיביות,
היו לנו אולי 12 קווים הקוד רק כדי לעשות את זה.
וזה כנראה לא קפיצה לדמיין איך ייתכן שהשוט
את קובץ index.html שיש לו טופס HTML נכון,
קצת קוד jQuery עם אייאקס שאינו שולח בשעות היום
אבל פשוט שולח מה שאליס או סוג בוב לשרת
ולאחר מכן השרת יהיה להעביר אותו החוצה.
ואני מבטיח להציץ בדבר אחד אחרון רק
כדי להקניט אותך עם זה.
אם נלך לתוך זרם אפס ואחד,
תראה קוד זה רק קצת שונה כאן.
רק שראית את זה, זו היא חלופה
למה קראתי לי fs.readFile שיטה קודם לכן, לפיה,
אתה יכול לספר לי node.js, "לך לקרוא קובץ זה לזיכרון.
אבל אם זה גדול פשוט לתת לי שלי נתח בכל פעם. "
ואתה אולי יודע מCS165
או 161 מערכות הקבצים יש שונה
מאפייני ביצועים.
אולי כדאי לך לקרוא בלוקים של 512 בתים
או 2 קילו או משהו כזה.
זוהי דרך לייעל של מקבל בחזרה קובץ איטרטיבי
כך שאתה יכול לירוק את זה קצת יותר מהר
לדפדפן או ל מי הלקוח הסופי הוא.
כמות עצומה כל כך של תוכן היום ואנחנו הולכים לצלול
לפרטים נוספים ביום רביעי עם טים [איות להניח]
בפרט מסתכל איך אנחנו יכול לתרגם חלק מהרעיונות
מהמחצית הראשונה של כמובן Laravel ומודלים
לספרייה שהוא עצמו כתבתי בשם Bookshelf.js
אשר הופך יותר ויותר פופולרי בקהילה
כי זה נותן לך את רובו,
אם לא יותר הפונקציונליות של רהוט
שזוכר הוא כי תובנה ספרייה של Laravel,
אז עוד על כך ועוד איך
לפתח מלא לכל דבר אפליקציות ביום רביעי.
אנחנו תראו אז.