10 концепции на JavaScript, които всеки разработчик на Node.js трябва да овладее

Rahul Mhatre е ръководител на екипа за разработчици в 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 съвети и трикове

В това обяснително видео научете няколко техники, които могат да подобрят вашия опит за разработка на Node.

JavaScript IIFE: Незабавно извикани функционални изрази

Незабавно извиканият израз на функция (IIFE) е функция, която се изпълнява веднага след като е създадена. Той няма връзка с никакви събития или асинхронно изпълнение. Можете да дефинирате IIFE, както е показано по-долу:

(функция () {

// целият ви код тук

// ...

}) ();

Първата двойка скоби function(){...}преобразува кода вътре в скобите в израз. Втората двойка скоби извиква функцията, получена от израза. IIFE може също да бъде описан като самоизвикваща се анонимна функция. Най-често срещаното му използване е да се ограничи обхватът на променлива, направена чрез varили да се капсулира контекст, за да се избегнат сблъсъци на имена.

Затваряне на JavaScript

Затварянето в JavaScript е вътрешна функция, която има достъп до обхвата на външната си функция, дори след като външната функция е върнала контрола. Затварянето прави променливите на вътрешната функция частни. Прост пример за затваряне е показан по-долу:

var count = (функция () {

    var _counter = 0;

    функция за връщане () {return _counter + = 1;}

}) ();

броя();

броя();

броя();

> // броячът вече е 3

На променливата countсе присвоява външна функция. Външната функция се изпълнява само веднъж, което задава брояча на нула и връща вътрешна функция. В _counterпроменливата може да бъде достъпен само от вътрешната функция, което го прави да се държи като частен променлива.

JavaScript прототипи

Всяка функция на JavaScript има свойство прототип, което се използва за прикачване на свойства и методи. Това свойство не може да се изброи. Той позволява на разработчика да прикачи методи или функции на членове към своите обекти. JavaScript поддържа наследяване само чрез свойството прототип. В случай на наследен обект, свойството прототип сочи към родителя на обекта. Често срещан подход за прикачване на методи към функция е използването на прототипи, както е показано по-долу:

функция Правоъгълник (x, y) {

    this._length = x;

    this._breadth = y;

}

Rectangle.prototype.getDimensions = function () {

    return {length: this._length, width: this._breadth};

};

Rectangle.prototype.setDimensions = функция (len, bred) {

    this._length = len;

    this._breadth = bred;

};

Частни свойства на JavaScript, използващи затваряния

JavaScript ви позволява да дефинирате частни свойства, като използвате префикса за подчертаване, както е показано в горния пример. Това обаче не пречи на потребителя да осъществява директен достъп или да променя свойство, което се предполага, че е частно.

Определянето на частни имоти чрез затваряне ще ви помогне да разрешите този проблем. Функциите-членове, които се нуждаят от достъп до частни свойства, трябва да бъдат дефинирани на самия обект. Можете да направите частни имоти, като използвате затваряне, както е показано по-долу:

функция Правоъгълник (_length, _breadth) {

     this.getDimensions = function () {

     return {length: _length, width: _breadth};

     };

     this.setDimension = функция (len, bred) {

     _length = len;

    _широчина = отглеждана

    };

}

Модул на JavaScript модул

Шаблонът на модула е най-често използваният модел на проектиране в JavaScript за постигане на свободно свързан, добре структуриран код. Тя ви позволява да създавате публични и частни нива на достъп. Един от начините за постигане на модел на модул е ​​показан по-долу:

var Посока = (функция () {

  var _direction = 'напред'

  var changeDirection = функция (d) {

          _насочване = d;

  }

  връщане {setDirection: функция (d) {

          changeDirection (d);

          console.log (_direction);

          }

  };

}) ();

Direction.setDirection ('назад'); // Изходи: 'назад'

console.log (Direction._direction);

Моделът на разкриващия модул е ​​подобен на модела на модула, при който променливите и методите, които трябва да бъдат изложени, се връщат в обектен литерал. Горният пример може да бъде написан с помощта на модела Revealing Module, както следва:

var Посока = (функция () {

  var _direction = 'напред';

  var _privateChangeDirection = функция (d) {

_насочване = d;

  }

  връщане {

          setDirection: _privateChangeDirection

  };

}) ();

JavaScript повдигане

JavaScript премества променливи и декларации за функции в горната част на техния обхват преди изпълнението на кода. Това се нарича повдигане. Независимо къде поставяте декларацията за функции и променливи във вашия код, те се преместват в горната част на техния обхват от интерпретатора. Това може и да не е там, където ги искате. Ако не, тогава вашата програма ще има грешки.

Декларациите на променливи се обработват преди изпълнението на който и да е код. По ирония на съдбата недекларираните променливи не съществуват, докато не им бъде присвоена стойност. Това кара всички недекларирани променливи да станат глобални променливи. Въпреки че декларациите за функции са издигнати, изразите на функции не са издигнати. JavaScript има ред на приоритет, докато повдига променливи и функции.

Приоритетът е даден по-долу от по-висок към по-нисък:

  • Присвояване на променлива
  • Декларация за функция
  • Декларации на променливи

За да избегнете грешки, трябва да декларирате променливите и функциите си в началото на всеки обхват. 

JavaScript currying

Карирането е метод за повишаване на гъвкавостта на функциите. С изкривена функция можете да предадете всички аргументи, които функцията очаква, и да получите резултата, или можете да предадете само подмножество аргументи и да получите функция обратно, която чака останалите аргументи. Прост пример за къри е даден по-долу:

var myFirstCurry = функция (дума) {

  функция за връщане (потребител) {

            return [дума, ",", потребител] .join ("");

  };

};

var HelloUser = myFirstCurry ("Здравей");

HelloUser ("Rahul"); // Изход: "Здравей, Рахул"

Оригиналната извита функция може да бъде извикана директно чрез предаване на всеки от параметрите в отделен набор от скоби един след друг, както е показано по-долу:

myFirstCurry ("Хей, загуба!") ("Рахул"); // Изход: "Хей, загуба! Рахул"

JavaScript прилага, извиква и свързва методи

Това е наложително, за всеки разработчик JavaScript, за да се разбере разликата между call, applyи bindметоди. Трите функции са сходни по това, че първият им аргумент винаги е стойността “this” или контекстът, който искате да присвоите на функцията, към която извиквате метода.

От трите callе най-лесният. Това е същото като извикване на функция, като същевременно се определя нейният контекст. Ето пример:

var потребител = {

     име: "Rahul Mhatre",

     whatIsYourName: function () {

     console.log (this.name);

     }

};

user.whatIsYourName (); // Изход: "Rahul Mhatre",

var user2 = {

     име: "Неха Сампат"

};

user.whatIsYourName.call (user2); // Изход: "Neha Sampat"

Имайте предвид, че applyе почти същото като call. Единствената разлика е, че предавате аргументи като масив, а не отделно. Масивите са по-лесни за манипулиране в JavaScript, отваряйки по-голям брой възможности за работа с функции. Ето пример за използване applyи call:

var потребител = {

     поздрави: "Здравей!",

     greetUser: функция (потребителско име) {

     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: функция (потребителско име) {

     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. Например можем да преобразуваме рекурсивна факториална функция в запомнена факториална функция, както е показано по-долу:

функция memoizeFunction (func) {

  кеш-памет = {};

  функция за връщане () {

          ключ ключ = аргументи [0];

          if (кеш [ключ]) {

          кеш за връщане [ключ];

          }

          друго {

          var val = func.apply (това, аргументи);

          кеш [ключ] = val;

          възвратна клапа;

          }

  };

}

var fibonacci = memoizeFunction (функция (n)

  връщане (n === 0);

Претоварване на JavaScript метода

Претоварването на метода позволява на множество методи да имат едно и също име, но различни аргументи. Компилаторът или интерпретаторът определя коя функция да се извиква въз основа на броя на подадените аргументи. Претоварването на метода не се поддържа директно в JavaScript. Но можете да постигнете нещо много подобно на него, както е показано по-долу:

функция overloadMethod (обект, име, fn) {

     if (! object._overload) {

    object._overload = {};

     }

     if (! object._overload [name]) {

    object._overload [име] = {};

    }

     if (! object._overload [name] [fn.length]) {

object._overload [име] [fn.length] = fn;

    }

     обект [име] = функция () {

         if (this._overload [име] [аргументи.дължина])

         върнете this._overload [име] [аргументи.дължина] .apply (this, аргументи);

     };

функция Студенти () {

  overloadMethod (this, "find", function () {

          // Намерете студент по име

  });

overloadMethod (this, "find", function (first, last) {

          // Намерете ученик по собствено и фамилно име

  });

}

var students = нови Студенти ();

students.find (); // Намира всички

students.find ("Rahul"); // Намира учениците по име

students.find ("Rahul", "Mhatre"); // Намира потребителите по собствено и фамилно име

Когато станете добре запознати с Node.js, ще забележите, че има много начини за решаване на почти всеки проблем. Но вземането на правилния подход е от решаващо значение. Грешният подход ще доведе до множество странични ефекти като неравномерни или бъги приложения или регресии, които ви принуждават да пренапишете цялата логика. От друга страна, правилният подход ще постави основата за стабилно, ефективно и мащабируемо приложение.

10-те концепции на JavaScript, описани в тази статия, са основи, които всеки разработчик на Node.js трябва да знае. Но те са върхът на айсберга. JavaScript е мощен и сложен. Колкото повече го използвате, толкова повече ще разбирате колко голям е JavaScript всъщност. По-доброто разбиране на толкова обширен език със сигурност ще ви помогне да избегнете грешки. Междувременно вземете правилно основите и ще видите страхотни резултати.

Rahul Mhatre е ръководител на екипа за разработчици в Software AG. Преди това той беше технически архитект в Built.io, придобит от Software AG. 

-

Форумът New Tech предоставя място за изследване и обсъждане на нововъзникващите корпоративни технологии в безпрецедентна дълбочина и широчина. Изборът е субективен, базиран на нашия избор на технологиите, които смятаме, че са важни и представляват най-голям интерес за читателите. не приема маркетингово обезпечение за публикуване и си запазва правото да редактира цялото съдържание. Изпращайте всички запитвания на [email protected]