חמש מפתחות הטעויות המובילות עושות

הצומת הוא פלטפורמה פנטסטית לכתיבת backends. למעט כשאתה לא מתקין את הדברים.


תלוי באיזה צד של הגדר אתה במקרה, צומת הוא הדבר הטוב ביותר או הגרוע ביותר שקורה לעולם פיתוח האינטרנט. עם זאת, למרות הדעות, אין שום טענה לפופולריות של Node. זה התגבר בצורה פופולרית מהר יותר ממה שציפו, אפילו היוצר שלה (הוא אמר זאת בפסימיות אחרת ראיון)!

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

זה הגיע לנקודה, למרבה הצער, שכשמישהו מבקש ממני להמליץ ​​להם על ערימת התחלה לפיתוח אתרים או מוצרי הפעלה חדשים, צומת היא ההמלצה מספר 1 שלי למרות שאני בקי ב PHP וב- Laravel.

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

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

לכן, אם אתה מפתח Node (מתחיל או מוכר), סביר להניח שאתה מבצע אחת מהטעויות הגדולות הללו שמשפיעות לרעה על היישום שלך. יכול להיות שזה בגלל שאתה לא מכיר דרך מסוימת לעשות דברים טובים יותר ב- Node, או אולי פשוט הרגלים שהעברת ממערכת אקולוגית אחרת.

לא מכבד את לולאת האירועים

כשאדם עובר לצומת, זה נובע גם בגלל ששמעו סיפורים על מידות הלינקדאין באמצעות Node, או שהם ראו מדדים המראים את הצומת פועל במעגלים סביב PHP, רובי וכו ‘בכל מה שקשור לבקשות הגשה בשנייה או טיפול חיבורי שקע פתוחים.

אז הם בונים את האפליקציה שלהם, מצפים לאותם זמני תגובה נפיצים עליהם חלמו – אלא ששום דבר קרוב לזה לא קורה.

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

db.Library.get (LibraryId, פונקציה (שגיאה, ספריה) {
תן לספרים = ספרייה. ספרים;
books.sort (פונקציה (א, ב) {
להחזיר דפים < דפים? -1: 1
});
});

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

הסיבה היא שלולאת האירועים נועדה לבצע קלט / פלט לא חסימת. דוגמה טובה היא של אריזת פיצה במפרק פיצה – האדם מתמחה בחיתוך הפיצה, קיפול כיסויים לארגזי משלוח, הכנת הפיצה, הצמדת התוויות הנכונות ודחיפתו לאיש המסירה.

מדהים, נכון? בדיוק כמו צומת!

מקור: stackoverflow.com

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

לזה אנו מתכוונים במשימות ש”חוסמות “- כל עוד Node פשוט צריך להעביר מידע מסביב, זה מהיר מאוד ואידיאלי האפשרות הטובה ביותר, אבל ברגע שהוא צריך לבצע כמה חישובים נרחבים הוא מפסיק, והכל אחר צריך לחכות. זה קורה מכיוון שלולאת האירועים היא חד-הברגה (פרטים נוספים כאן.)

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

בתקווה שקוד אסינק ישתף פעולה

קחו למשל את דוגמת הצומת הפשוטה ביותר שקוראת נתונים מקובץ ומציגה אותם:

const fs = לדרוש (‘fs’);

תן לתוכן = fs.readFile (‘secret.txt’, (שגיאה, נתונים) => {
נתוני החזרה;
});

console.log (‘תוכן הקובץ הוא:’);
console.log (תוכן);

חשיפה לשפות קלאסיות (כמו PHP, Python, Perl, Ruby, C ++ וכו ‘) תגרום לך ליישם את השכל הישר כי לאחר הפעלת קוד זה, לתוכן המשתנה יהיה תוכן הקובץ. אבל הנה מה שקורה כשאתה מבצע בפועל את הקוד:

אנו לא מוגדרים (). הסיבה לכך היא שאמנם אכפת לך עמוקות מה- Node, אך אופי האסינקציות שלה לא אכפת לך (זה אמור להיות בדיחה! אנא אל תספוג כאן תגובות לשנוא ��). התפקיד שלנו הוא להבין את אופיו האסינכרוני ולעבוד איתו. readFile () היא פונקציה אסינכרונית, שמשמעותה ברגע שהיא נקראת, לולאת האירועים Node מעבירה את העבודה לרכיב מערכת הקבצים וממשיכה הלאה.

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

התקשרות חוזרת הקוראת להתקשר שוב הקוראת להתקשר שוב . . .

JavaScript קרוב יותר לתכנות פונקציונאליות מכל שפה ותיקה אחרת, מיינסטרימית (למעשה, הכל נאמר ונעשה. זה המועדף עלי בכל הקשור לעיצוב מונחה עצמים ויכולות פונקציונליות – הנחתי אותו מעל Python, PHP, Perl, Java, אפילו רובי כשמדובר בכתיבת קוד “מהנה”).

כלומר, פונקציות משיגות יותר זכויות אזרח מאשר בשפות אחרות. קשר זה עם העובדה שקוד אסינכרוני פועל על ידי מתן פונקציית התקשרות חזרה ובסופו של דבר מתכון לאסון המכונה Callback Hell.

הנה כמה קוד אלקטרונים לדוגמא שנתקלתי בהם בקווורה. מה אתה חושב שזה עושה?

אפשרויות var;

דורשים (‘אלקטרונים’). app.once (
‘מוכן’,

פונקציה () {

אפשרויות = {
מסגרת: שקרית,
גובה: 768,
רוחב: 1024,
x: 0,
y: 0
};

options.BrowserWindow = דורש (‘אלקטרון’). BrowserWindow;
options.browserWindow = אפשרויות חדשות. BrowserWindow (אפשרויות);
options.browserWindow.loadURL (‘http://electron.atom.io’);
options.browserWindow.webContents.once (
‘עשה-עצור-טוען’,

פונקציה () {
options.browserWindow.capturePage (
אפשרויות,

פונקציה (נתונים) {
דורשים (‘fs’). writeFileSync (
‘/tmp/screenCapture.testExampleJs.browser..png’,
data.toPng ()
);

process.exit (0);
}
);
}
);
}
);

אם אתה מתקשה, הצטרף למועדון!

פונקציות בפונקציות בפונקציות הן קשות לקריאה וקשה מאוד להסביר עליהם, וזו הסיבה שהיא מכונה “גיהנום של התקשרות” (אני מניחה שהגיהינום הוא מקום מבלבל לצאת ממנו!). בעוד שזה עובד טכנית, אתה עושה את הקוד שלך הוכחה עתידית מכל ניסיונות הבנה ותחזוקה.

ישנן דרכים רבות להימנע מגיהנום של התקשרות חוזרת, כולל הבטחות ו הרחבות תגובתי.

לא משתמש בכל ליבות המעבד

למעבדים מודרניים מספר ליבות – 2, 4, 8, 16, 32. . . המספר ממשיך לטפס.

אבל זה לא מה שיוצר הצמתים חשב לו כששחרר את Node. כתוצאה מכך הצומת הוא חד-הברגה, מה שאומר שהוא פועל בתוך פתיל יחיד (או תהליך, אם אתה רוצה לקרוא לו, אם כי הם אינם זהים), תוך שימוש רק בליבה מעבד אחת.

המשמעות היא שאם למדת את הצומת מהמדריכים וחברים וקטעי קוד שצפים סביבם, ויישמת את האפליקציה שלך בשרת בן 8 ליבות, תבזבז 7/8 מכוח העיבוד הזמין!

למותר לציין שזה בזבוז אדיר. אם תלך בדרך זו, בסופו של דבר תשלם עבור שמונה שרתים כשאתה רק צריך אחד. כלומר, הוציאו 16,000 דולר לחודש כאשר 2,000 $ יעשו (אובדן כסף תמיד כואב, נכון??). כל זאת, כאשר הפיתרון די פשוט: שימוש ב- אשכול מודול.

אני לא יכול להיכנס לכל הפרטים כאן, אבל זו טכניקה פשוטה לגלות כמה ליבות יש למכונה הנוכחית ואז להפעיל את אותם מקרים רבים של Node. כאשר מתגלים שגיאות, מופע מופעל מחדש. הנה כמה פשוט ליישם (הדרכה כאן):

var אשכול = דורש (‘אשכול’);

אם (cluster.isMaster) {
var numWorkers = דורשים (‘os’). cpus (). אורך;

console.log (‘הגדרת אשכול מאסטר’ + numWorkers + ‘עובדים …’);

עבור (var i = 0; i < מספר עובדים; אני ++) {
cluster.fork ();
}

cluster.on (‘מקוון’, פונקציה (עובד) {
console.log (‘עובד’ + עובד. process.pid + ‘מקוון’);
});

cluster.on (‘יציאה’, פונקציה (עובד, קוד, אות) {
console.log (‘עובד’ + עובד. process.pid + ‘נפטר עם קוד:’ + קוד + ‘, ואות:’ + אות);
console.log (‘פתיחת עובד חדש’);
cluster.fork ();
});
} אחרת {
var app = demand (‘express’) ();
app.all (‘/ *’, פונקציה (req, res) {res.send (‘תהליך’ + process.pid + ‘אומר שלום!’). end ();})

var server = app.listen (8000, פונקציה () {
console.log (‘תהליך’ + process.pid + ‘מקשיב לכל הבקשות הנכנסות’);
});
}

כפי שאתה יכול לראות, cluster.fork () עושה את הקסם, והשאר פשוט מקשיב לכמה אירועי אשכול חיוניים ועושה את הניקוי הדרוש..

לא משתמש ב- TypeScript

אוקיי, זו לא טעות, ככזו, והרבה יישומי Node נכתבו ונכתבים ללא TypeScript.

עם זאת, TypeScript מציע את ההבטחות ואת השקט הנפשי ש- Node תמיד היה זקוק לו, ובעיניי זו טעות אם אתה מפתח ל- Node בשנת 2019 ולא משתמש ב- TypeScript (במיוחד כאשר ה- A (זוויתי) בערימת ה- MEAN הועבר ל- TypeScript מזמן).

המעבר עדין, ו- TypeScript דומה כמעט ל- JavaScript שאתה מכיר, עם ערבות הסוגים, ES6, ועוד כמה צ’קים נוספים שנזרקים:

// /lib/controllers/crmController.ts
ייבא * כמונגוס מ’מונגוז ‘;
ייבא {ContactSchema} מ- ‘../models/crmModel’;
ייבא את {בקשה, תגובה} מ’אקספרס ‘;

const Contact = mongoose.model (‘איש קשר’, ContactSchema);
Contactcontroller בכיתת הייצוא {

public addNewContact (בקשה, מילואים: תגובה) {
תן ל- newContact = איש קשר חדש (req.body);

newContact.save ((שגיאה, קשר) => {
אם (לטעות) {
res.send (שגיאה);
}
res.json (איש קשר);
});
}

אני ממליץ לבדוק את זה נחמד וידידותי הדרכת TypeScript.

סיכום

הצומת מרשים, אבל הוא לא בלי הבעיות (הרבות?) שלו. עם זאת, זה חל על כל הטכנולוגיות שם, חדשות וישנות, ואנחנו נעשה טוב יותר להבין את הצומת ולעבוד איתו..

אני מקווה כי חמשת הטיפים האלה ימנעו ממך להישאב לבור הזפת של באגים רב שנתיים ובעיות ביצועים. אם התגעגעתי למשהו מעניין, אנא הודע לי ואשמח יותר (למען האמת אסיר תודה!) לכלול אותם במאמר. ��

Jeffrey Wilson Administrator
Sorry! The Author has not filled his profile.
follow me
    Like this post? Please share to your friends:
    Adblock
    detector
    map