10 konsep JavaScript yang mesti dikuasai oleh pembangun Node.js

Rahul Mhatre adalah ketua pasukan pemaju di Software AG.

Dengan javascript dan mesin V8 sebagai teras, seni bina berdasarkan acara, dan skalabilitas di luar kotak, Node.js dengan cepat menjadi standard de facto untuk membuat aplikasi web dan produk SaaS. Kerangka kerja Node.js seperti Express, Sails, dan Socket.IO membolehkan pengguna untuk bootstrap aplikasi dengan cepat dan hanya fokus pada logik perniagaan.

Node.js banyak berhutang dengan JavaScript kerana popularitinya. JavaScript adalah bahasa multiparadigma yang menyokong pelbagai gaya pengaturcaraan, termasuk pengaturcaraan fungsional, pengaturcaraan prosedural, dan pengaturcaraan berorientasi objek. Ini membolehkan pemaju bersikap fleksibel dan memanfaatkan pelbagai gaya pengaturcaraan.

Tetapi JavaScript boleh menjadi pedang bermata dua. Sifat multiparadigma JavaScript bermaksud bahawa hampir semuanya boleh berubah. Oleh itu, anda tidak dapat mengabaikan kemungkinan mutasi objek dan skop semasa menulis kod Node.js. Kerana JavaScript tidak mempunyai pengoptimuman panggilan ekor (yang membolehkan fungsi rekursif menggunakan kembali bingkai tumpukan untuk panggilan berulang), berbahaya untuk menggunakan rekursi untuk lelaran besar. Sebagai tambahan kepada perangkap seperti ini, Node.js adalah utas tunggal, jadi sangat penting bagi pembangun untuk menulis kod tak segerak.

JavaScript boleh menjadi kebaikan jika digunakan dengan berhati-hati - atau tidak berguna jika anda ceroboh. Mengikuti peraturan tersusun, corak reka bentuk, konsep utama, dan peraturan asas akan membantu anda memilih pendekatan yang optimum untuk masalah. Konsep utama mana yang harus difahami oleh pengaturcara Node.js? Di bawah ini saya akan kongsikan 10 konsep JavaScript yang saya percaya sangat penting untuk menulis kod Node.js yang cekap dan boleh diskalakan.

Video berkaitan: Petua dan muslihat Node.js

Dalam video penjelasan ini, pelajari beberapa teknik yang dapat meningkatkan pengalaman pengembangan Node anda.

JavaScript IIFE: Segera fungsi dipanggil

Ekspresi fungsi yang segera dipanggil (IIFE) adalah fungsi yang dilaksanakan sebaik sahaja dibuat. Ia tidak mempunyai kaitan dengan peristiwa atau pelaksanaan asinkron. Anda boleh menentukan IIFE seperti yang ditunjukkan di bawah:

(fungsi () {

// semua kod anda di sini

// ...

}) ();

Pasangan kurungan pertama function(){...}menukar kod di dalam tanda kurung menjadi ekspresi. Pasangan kurungan kedua memanggil fungsi yang dihasilkan dari ungkapan. IIFE juga boleh digambarkan sebagai fungsi tanpa nama yang menggunakan sendiri. Penggunaannya yang paling umum adalah untuk membatasi ruang lingkup pemboleh ubah yang dibuat melalui varatau untuk merangkum konteks untuk mengelakkan pelanggaran nama.

Penutupan JavaScript

Penutupan dalam JavaScript adalah fungsi dalaman yang memiliki akses ke ruang lingkup fungsi luarnya, bahkan setelah fungsi luarnya kembali dikendalikan. Penutupan menjadikan pemboleh ubah fungsi dalaman menjadi peribadi. Contoh ringkas penutupan ditunjukkan di bawah:

var count = (fungsi () {

    var _counter = 0;

    fungsi kembali () {return _counter + = 1;}

}) ();

hitung ();

hitung ();

hitung ();

> // kaunter sekarang 3

Pemboleh ubah countdiberikan fungsi luar. Fungsi luar hanya berjalan sekali, yang menetapkan pembilang ke sifar dan mengembalikan fungsi dalaman. Yang _counterberubah-ubah boleh diakses hanya oleh fungsi dalaman, yang menjadikan ia berkelakuan seperti pembolehubah swasta.

Prototaip JavaScript

Setiap fungsi JavaScript mempunyai sifat prototaip yang digunakan untuk melampirkan sifat dan kaedah. Harta ini tidak dapat dikira. Ini membolehkan pemaju melampirkan kaedah atau fungsi anggota ke objeknya. JavaScript menyokong pewarisan hanya melalui sifat prototaip. Sekiranya terdapat objek yang diwarisi, sifat prototaip menunjuk ke induk objek. Pendekatan umum untuk melampirkan kaedah ke fungsi adalah menggunakan prototaip seperti yang ditunjukkan di bawah:

segi empat tepat (x, y) {

    ini._panjang = x;

    ini._ lebar = y;

}

Rectangle.prototype.getDimensions = fungsi () {

    pulangkan {length: this._length, lebar: ini._breadth};

};

Rectangle.prototype.setDimensions = fungsi (len, bred) {

    ini._length = len;

    ini._breadth = dibiakkan;

};

Properti peribadi JavaScript, menggunakan penutupan

JavaScript membolehkan anda menentukan sifat peribadi dengan menggunakan awalan garis bawah seperti yang ditunjukkan dalam contoh di atas. Walau bagaimanapun, ini tidak menghalang pengguna mengakses atau mengubah langsung harta yang sepatutnya menjadi milik peribadi.

Mendefinisikan harta persendirian menggunakan penutupan akan membantu anda menyelesaikan masalah ini. Fungsi anggota yang memerlukan akses ke sifat peribadi harus ditentukan pada objek itu sendiri. Anda boleh membuat hartanah peribadi menggunakan penutupan seperti di bawah

Rectangle fungsi (_length, _breadth) {

     this.getDimensions = fungsi () {

     kembali {panjang: _length, lebar: _breadth};

     };

     this.setDimension = fungsi (len, bred) {

     _length = len;

    _breadth = dibiakkan

    };

}

Corak Modul JavaScript

Corak Modul adalah corak reka bentuk yang paling kerap digunakan dalam JavaScript untuk mencapai kod yang tersusun dan tersusun dengan baik. Ini membolehkan anda membuat tahap akses awam dan swasta. Salah satu cara untuk mencapai corak Modul ditunjukkan di bawah:

var Direction = (fungsi () {

  var _direction = 'ke hadapan'

  var changeDirection = fungsi (d) {

          _direction = d;

  }

  kembali {setDirection: function (d) {

          ubahDirection (d);

          console.log (_direction);

          }

  };

}) ();

Direction.setDirection ('kebelakang'); // Keluaran: 'mundur'

console.log (Direction._direction);

Corak Revealing Modul mirip dengan pola Modul di mana pemboleh ubah dan kaedah yang perlu didedahkan dikembalikan dalam literal objek. Contoh di atas boleh ditulis menggunakan corak Revealing Module seperti berikut:

var Direction = (fungsi () {

  var _direction = 'ke hadapan';

  var _privateChangeDirection = fungsi (d) {

_direction = d;

  }

  kembali {

          setDirection: _privateChangeDirection

  };

}) ();

Pengangkatan JavaScript

JavaScript memindahkan pemboleh ubah dan deklarasi fungsi ke atas skopnya sebelum pelaksanaan kod. Ini dipanggil mengangkat. Tidak kira di mana anda meletakkan pengisytiharan fungsi dan pemboleh ubah dalam kod anda, mereka dipindahkan ke bahagian atas skopnya oleh jurubahasa. Ini mungkin atau tidak di tempat yang anda mahukan. Sekiranya tidak, program anda akan mengalami kesilapan.

Deklarasi berubah-ubah diproses sebelum mana-mana kod dijalankan. Ironinya, pemboleh ubah yang tidak diisytiharkan tidak wujud sehingga mereka diberi nilai. Ini menyebabkan semua pemboleh ubah yang tidak diisytiharkan menjadi pemboleh ubah global. Walaupun deklarasi fungsi diangkat, ekspresi fungsi tidak dikibarkan. JavaScript mempunyai urutan keutamaan sambil mengangkat pemboleh ubah dan fungsi.

Keutamaan diberikan di bawah dari lebih tinggi ke bawah:

  • Tugasan berubah
  • Pengisytiharan fungsi
  • Deklarasi berubah-ubah

Untuk mengelakkan pepijat, anda harus menyatakan pemboleh ubah dan fungsi anda di awal setiap skop. 

Penjelajahan JavaScript

Currying adalah kaedah menjadikan fungsi lebih fleksibel. Dengan fungsi curried, anda dapat menyampaikan semua argumen yang diharapkan oleh fungsi dan mendapatkan hasilnya, atau anda hanya dapat meneruskan subkumpulan argumen dan menerima kembali fungsi yang menunggu sisa argumen. Contoh ringkas kari diberikan di bawah:

var myFirstCurry = fungsi (perkataan) {

  fungsi kembali (pengguna) {

            kembali [word, ",", user] .join ("");

  };

};

var HelloUser = myFirstCurry ("Hello");

HelloUser ("Rahul"); // Output: "Helo, Rahul"

Fungsi kari asli boleh dipanggil secara langsung dengan melewati setiap parameter dalam satu set kurungan yang terpisah satu demi satu seperti yang ditunjukkan di bawah:

myFirstCurry ("Hei, wassup!") ("Rahul"); // Output: "Hei, wassup !, Rahul"

JavaScript menggunakan kaedah panggilan, panggilan dan pengikat

Ia adalah penting bagi mana-mana pemaju JavaScript untuk memahami perbezaan di antara call, applydan bindkaedah. Ketiga fungsi itu serupa kerana argumen pertama mereka selalu adalah nilai "ini", atau konteks, yang ingin anda berikan pada fungsi yang anda gunakan.

Dari ketiga-tiganya, calladalah yang paling mudah. Ia sama dengan memanggil fungsi sambil menentukan konteksnya. Inilah contohnya:

pengguna var = {

     nama: "Rahul Mhatre",

     whatIsYourName: fungsi () {

     console.log (nama ini.);

     }

};

pengguna.whatIsYourName (); // Keluaran: "Rahul Mhatre",

var pengguna2 = {

     nama: "Neha Sampat"

};

user.whatIsYourName.call (pengguna2); // Keluaran: "Neha Sampat"

Perhatikan bahawa applyhampir sama dengan call. Satu-satunya perbezaan ialah anda menyampaikan argumen sebagai larik dan tidak secara berasingan. Susunan lebih mudah dimanipulasi dalam JavaScript, membuka lebih banyak kemungkinan untuk bekerja dengan fungsi. Berikut adalah contoh menggunakan applydan call:

pengguna var = {

     salam: "Hello!",

     salamUser: fungsi (nama pengguna) {

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

     }

};

var greet1 = {

     greet: "Hola"

};

user.greetUser.call (salam1, "Rahul") // Keluaran: "Hola Rahul"

user.greetUser.apply (salam1, ["Rahul"]) // Output: "Hola Rahul"

The bindkaedah membolehkan anda untuk lulus hujah ke fungsi tanpa memohon ia. Fungsi baru dikembalikan dengan argumen yang dibatasi sebelum argumen selanjutnya. Berikut adalah contoh:

pengguna var = {

     salam: "Hello!",

     salamUser: fungsi (nama pengguna) {

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

}

};

var SalamHola = user.greetUser.bind ({salam: "Hola"});

var SalamBonjour = user.greetUser.bind ({salam: "Bonjour"});

salamHola ("Rahul") // Keluaran: "Hola Rahul"

salamBonjour ("Rahul") // Output: "Bonjour Rahul"

Menghafal JavaScript

Memoisasi adalah teknik pengoptimuman yang mempercepat pelaksanaan fungsi dengan menyimpan hasil operasi yang mahal dan mengembalikan hasil cache apabila set input yang sama terjadi lagi. Objek JavaScript berkelakuan seperti susunan bersekutu, memudahkan pelaksanaan penghafalan dalam JavaScript. Sebagai contoh, kita boleh menukar fungsi faktorial rekursif menjadi fungsi faktorial yang diingat seperti yang ditunjukkan di bawah:

fungsi memoizeFunction (func) {

  var cache = {};

  fungsi kembali () {

          var key = hujah [0];

          jika (cache [kunci]) {

          kembalikan cache [kunci];

          }

          lain {

          var val = func.apply (ini, hujah);

          cache [kunci] = val;

          pulangan val;

          }

  };

}

var fibonacci = memoizeFungsi (fungsi (n)

  pulangan (n === 0);

Terlalu banyak kaedah JavaScript

Overloading kaedah membolehkan pelbagai kaedah mempunyai nama yang sama tetapi berbeza argumen. Penyusun atau jurubahasa menentukan fungsi mana yang akan dipanggil berdasarkan jumlah argumen yang dilalui. Kaedah overloading tidak disokong secara langsung dalam JavaScript. Tetapi anda boleh mencapai sesuatu seperti yang ditunjukkan di bawah:

fungsi overloadMode (objek, nama, fn) {

     jika (! object._overload) {

    objek._overload = {};

     }

     jika (! object._overload [name]) {

    object._overload [nama] = {};

    }

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

object._overload [nama] [fn.length] = fn;

    }

     objek [nama] = fungsi () {

         jika (this._overload [name] [argument.length])

         kembalikan ini._lebihan muat [nama] [argumen.length] .mohon (ini, argumen);

     };

Pelajar berfungsi () {

  kaedah overload (ini, "cari", fungsi () {

          // Cari pelajar dengan nama

  });

overloadMethod (ini, "cari", fungsi (pertama, terakhir) {

          // Cari pelajar dengan nama depan dan belakang

  });

}

pelajar var = Pelajar baru ();

pelajar.cari (); // Cari semua

pelajar.cari ("Rahul"); // Mencari pelajar mengikut nama

students.find ("Rahul", "Mhatre"); // Mencari pengguna dengan nama depan dan belakang

Semasa anda menjadi mahir dengan Node.js, anda akan melihat terdapat banyak cara untuk menyelesaikan hampir semua masalah. Tetapi mengambil pendekatan yang betul adalah penting. Pendekatan yang salah akan menghasilkan pelbagai kesan sampingan seperti aplikasi atau regresi tambal sulam atau kereta yang memaksa anda menulis semula keseluruhan logik. Di sisi lain, pendekatan yang tepat akan meletakkan asas untuk aplikasi yang kuat, cekap, dan terukur.

10 konsep JavaScript yang dijelaskan dalam artikel ini adalah asas yang harus diketahui oleh pemaju Node.js. Tetapi mereka adalah puncak gunung es. JavaScript kuat dan kompleks. Semakin banyak anda menggunakannya, semakin banyak anda akan memahami betapa besarnya JavaScript. Pemahaman yang lebih baik mengenai bahasa yang sebegitu pasti akan membantu anda mengelakkan kesilapan. Sementara itu, dapatkan asasnya dengan betul dan anda akan melihat hasil yang baik.

Rahul Mhatre adalah ketua pasukan pemaju di Software AG. Sebelumnya dia adalah arkitek teknikal di Built.io, yang diambil alih oleh Software AG. 

-

Forum Teknologi Baru menyediakan tempat untuk meneroka dan membincangkan teknologi perusahaan yang baru muncul dalam kedalaman dan luas yang belum pernah terjadi sebelumnya. Pemilihannya bersifat subjektif, berdasarkan pilihan teknologi yang kami percayai penting dan menarik minat pembaca. tidak menerima jaminan pemasaran untuk penerbitan dan berhak untuk mengedit semua kandungan yang disumbangkan. Hantarkan semua pertanyaan ke [email protected]