10 מושגי JavaScript שכל מפתח של Node.js חייב לשלוט בה

ראול מהטר מוביל צוות מפתח בחברת Software AG.

עם JavaScript ומנוע ה- V8 בבסיסו, ארכיטקטורה מונחת אירועים והרחבה מהקופסה, הפך Node.js במהירות לסטנדרט דה-פקטו ליצירת יישומי אינטרנט ומוצרי SaaS. מסגרות Node.js כגון Express, Sails ו- Socket.IO מאפשרות למשתמשים לאתחל במהירות יישומים ולהתמקד רק בהיגיון העסקי.

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

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

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

סרטון קשור: טיפים וטריקים של Node.js

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

JavaScript IIFEs: הופעלו מיד ביטויי פונקציה

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

(פונקציה () {

// כל הקוד שלך כאן

// ...

}) ();

זוג הסוגריים הראשון function(){...}ממיר את הקוד בתוך הסוגריים לביטוי. צמד הסוגריים השני מכנה את הפונקציה הנובעת מהביטוי. ניתן לתאר IIFE גם כפונקציה אנונימית המזמינה את עצמה. השימוש הנפוץ ביותר בו הוא להגביל את היקף המשתנה שנעשה באמצעות varאו להקיף את ההקשר כדי למנוע התנגשויות שם.

סגירת JavaScript

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

ספירת var = (פונקציה () {

    var _counter = 0;

    פונקציית החזרה () {return _counter + = 1;}

}) ();

לספור();

לספור();

לספור();

> // הדלפק עכשיו 3

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

אבות טיפוס של JavaScript

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

מלבן פונקציה (x, y) {

    this._length = x;

    this._breadth = y;

}

Rectangle.prototype.getDimensions = פונקציה () {

    להחזיר {length: this._length, width: this._breadth};

};

Rectangle.prototype.setDimensions = פונקציה (len, bred) {

    this._length = len;

    this._breadth = bred;

};

נכסים פרטיים של JavaScript, באמצעות סגירות

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

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

מלבן פונקציה (_length, _breadth) {

     this.getDimensions = פונקציה () {

     החזר {length: _length, width: _breadth};

     };

     this.setDimension = פונקציה (len, bred) {

     _length = len;

    _ רוחב = גידול

    };

}

תבנית מודול JavaScript

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

כיוון var = (פונקציה () {

  var _direction = 'קדימה'

  var changeDirection = פונקציה (d) {

          _כיוון = ד;

  }

  להחזיר {setDirection: פונקציה (ד) {

          שינוי כיוון (ד);

          console.log (_direction);

          }

  };

}) ();

Direction.setDirection ('אחורה'); // תפוקות: 'אחורה'

console.log (כיוון._כיוון);

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

כיוון var = (פונקציה () {

  var _direction = 'קדימה';

  var _privateChangeDirection = פונקציה (d) {

_כיוון = ד;

  }

  להחזיר {

          setDirection: _privateChangeDirection

  };

}) ();

הרמת JavaScript

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

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

העדיפות ניתנת למטה מגבוה לנמוך:

  • מטלה משתנה
  • הצהרת פונקציה
  • הצהרות משתנות

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

קארי JavaScript

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

var myFirstCurry = פונקציה (מילה) {

  פונקציית החזרה (משתמש) {

            החזר [word, ",", user] .join ("");

  };

};

var HelloUser = myFirstCurry ("שלום");

HelloUser ("Rahul"); // פלט: "שלום, רחול"

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

myFirstCurry ("היי, ווסופ!") ("Rahul"); // פלט: "היי, ווסופ !, ראול"

JavaScript חלות, קוראות ואוגדות

זה הכרחי עבור כל מפתח JavaScript כדי להבין את ההבדל בין call, apply, ו bindשיטות. שלושת הפונקציות דומות בכך שהטיעון הראשון שלהם הוא תמיד הערך "זה", או ההקשר, שאתה רוצה לתת לפונקציה שאתה קורא לה את השיטה.

מבין השלושה, callהוא הקל ביותר. זהה להפעלת פונקציה תוך ציון ההקשר שלה. הנה דוגמה:

משתמש var = {

     שם: "Rahul Mhatre",

     whatIsYourName: function () {

     console.log (this.name);

     }

};

user.whatIsYourName (); // פלט: "ראול מהטר",

var user2 = {

     שם: "Neha Sampat"

};

user.whatIsYourName.call (user2); // פלט: "Neha Sampat"

שים לב שזה applyכמעט כמו call. ההבדל היחיד הוא שאתה מעביר טיעונים כמערך ולא בנפרד. קל יותר לטפל במערכים ב- JavaScript, וכך נפתח מספר גדול יותר של אפשרויות לעבודה עם פונקציות. הנה דוגמא באמצעות applyו call:

משתמש var = {

     לברך: "שלום!",

     greetUser: function (userName) {

     console.log (this.greet + "" + userName);

     }

};

var greet1 = {

     greet: "Hola"

};

user.greetUser.call (greet1, "Rahul") // פלט: "Hola Rahul"

user.greetUser.apply (greet1, ["Rahul"]) // פלט: "Hola Rahul"

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

משתמש var = {

     לברך: "שלום!",

     greetUser: function (userName) {

     console.log (this.greet + "" + userName);

}

};

var greetHola = user.greetUser.bind ({greet: "Hola"});

var greetBonjour = user.greetUser.bind ({greet: "Bonjour"});

greetHola ("Rahul") // פלט: "Hola Rahul"

greetBonjour ("Rahul") // פלט: "Bonjour Rahul"

שינון JavaScript

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

function memoizeFunction (func) {

  מטמון var = {};

  פונקציית החזרה () {

          מקש var = ארגומנטים [0];

          אם (מטמון [מפתח]) {

          החזר מטמון [מפתח];

          }

          אחר {

          var val = func.apply (זה, טיעונים);

          מטמון [מפתח] = val;

          החזרת val;

          }

  };

}

var retracement = memoizeFunction (פונקציה (n)

  החזר (n === 0);

העמסת יתר על שיטת JavaScript

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

function overloadMethod (אובייקט, שם, fn) {

     אם (! object._overload) {

    object._overload = {};

     }

     אם (! object._overload [שם]) {

    object._overload [name] = {};

    }

     אם (! object._overload [שם] [fn.length]) {

object._overload [שם] [fn.length] = fn;

    }

     אובייקט [שם] = פונקציה () {

         if (this._overload [name] [arguments.length])

         להחזיר this._overload [שם] [arguments.length]. להחיל (זה, טיעונים);

     };

פונקציה סטודנטים () {

  overloadMethod (זה, "מצא", פונקציה () {

          // מצא תלמיד בשם

  });

overloadMethod (זה, "מצא", פונקציה (ראשון, אחרון) {

          // מצא תלמיד בשם פרטי ושם משפחה

  });

}

תלמידי var = סטודנטים חדשים ();

students.find (); // מוצא הכל

students.find ("רחול"); // מוצא תלמידים לפי שמם

students.find ("ראול", "מהטר"); // מוצא משתמשים לפי שם פרטי ושם משפחה

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

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

ראול מהטר מוביל צוות מפתח בחברת Software AG. בעבר היה אדריכל טכני ב- Built.io, שנרכשה על ידי Software AG. 

-

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