Pembuatan Module Pada Node Js - CRUDPRO
Home  ›  javascript  ›  nodejs

Pembuatan Module Pada Node Js

Written By Agus Handi Prayitna Wednesday, May 25, 2022

Kata pengantar

Di Node.js, module adalah kumpulan function dan objek JavaScript yang dapat digunakan oleh aplikasi eksternal. Menjelaskan bagian dari kode sebagai module tidak berarti apa kode itu, tetapi apa kode itu. File Node.js atau kumpulan file dapat dianggap sebagai module jika fungsionalitas dan datanya tersedia untuk program eksternal.

module menyediakan unit fungsionalitas yang dapat digunakan kembali di banyak program besar, menciptakan aplikasi yang digabungkan secara longgar yang dapat diskalakan dengan kompleksitas dan membuka pintu untuk berbagi kode dengan pengembang lain. Mampu membuat module yang mengekspor function dan data yang berguna akan membantu Anda berkontribusi pada komunitas Node.js yang lebih luas. Faktanya, semua paket yang digunakan oleh npm dibundel dan dibagikan sebagai module. Ini menjadikan pembuatan module sebagai keterampilan penting bagi pengembang Node.js.

Dalam tutorial ini, Anda akan membuat module Node.js yang menyarankan warna untuk digunakan pengembang web dalam desain mereka. Kembangkan module dengan menyimpan warna sebagai array dan menyediakan function untuk mendapatkannya secara acak. Kemudian lakukan berbagai cara untuk mengimpor module ke dalam aplikasi Node.js Anda.

Prasyarat

Langkah 1 Buat module

Langkah ini akan memandu Anda melalui langkah-langkah untuk membuat module Node.js pertama Anda. module berisi kumpulan warna dalam array dan menyediakan function untuk mendapatkan warna secara acak. Gunakan properti exports bawaan Node.js untuk membuat function dan array tersedia untuk program eksternal.

Mulailah dengan memutuskan data warna apa yang akan disimpan dalam module. Semua warna adalah objek yang berisi properti nama yang mudah dikenali oleh manusia dan properti kode yang berupa string yang berisi kode warna HTML. Kode warna HTML adalah 6 digit angka heksadesimal yang memungkinkan Anda untuk mengubah warna elemen pada halaman web. Anda dapat mempelajari lebih lanjut tentang kode warna HTML dengan membaca artikel ini tentang kode warna dan nama HTML.

Kemudian putuskan warna mana yang akan didukung module. module berisi array yang disebut allColors yang berisi 6 warna. module ini juga berisi function yang disebut getRandomColor() yang secara acak memilih dan mengembalikan warna dari array.

Di terminal, buat folder baru bernama colors dan navigasikan ke folder itu.

mkdir colors
cd colors

Inisialisasi npm agar program lain dapat mengimpor module ini nanti dalam tutorial.

npm init -y

Saya menggunakan flag -y untuk melewati prompt biasa untuk menyesuaikan package.json. Jika ini adalah module yang ingin Anda ekspos ke npm, tanggapi semua perintah ini dengan data yang relevan seperti yang dijelaskan dalam Menggunakan module Node.js di npm dan package.json.

Dalam hal ini, outputnya terlihat seperti ini:

Output
{
  "name": "colors",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

Kemudian buka editor teks baris perintah seperti nano dan buat file baru yang akan berfungsi sebagai titik masuk untuk module Anda.

nano index.js

module melakukan beberapa hal. Pertama, tentukan kelas Color. Kelas Warna dipakai dengan nama dan kode HTML-nya. Tambahkan baris berikut untuk membuat kelas.

class Color {
  constructor(name, code) {
    this.name = name;
    this.code = code;
  }
}

Sekarang kita memiliki struktur data Warna, mari tambahkan beberapa instance ke module.

// ~/colors/index.js
class Color {
  constructor(name, code) {
    this.name = name;
    this.code = code;
  }
}

const allColors = [
  new Color('brightred', '#E74C3C'),
  new Color('soothingpurple', '#9B59B6'),
  new Color('skyblue', '#5DADE2'),
  new Color('leafygreen', '#48C9B0'),
  new Color('sunkissedyellow', '#F4D03F'),
  new Color('groovygray', '#D7DBDD'),
];

Terakhir, masukkan function yang secara acak memilih item dari array allColors yang Anda buat.

// ~/colors/index.js
  class Color {
  constructor(name, code) {
    this.name = name;
    this.code = code;
  }
}

const allColors = [
  new Color('brightred', '#E74C3C'),
  new Color('soothingpurple', '#9B59B6'),
  new Color('skyblue', '#5DADE2'),
  new Color('leafygreen', '#48C9B0'),
  new Color('sunkissedyellow', '#F4D03F'),
  new Color('groovygray', '#D7DBDD'),
];

exports.getRandomColor = () => {
  return allColors[Math.floor(Math.random() * allColors.length)];
}

exports.allColors = allColors;

Kata kunci export mengacu pada objek global yang tersedia di semua module Node.js. Semua function dan objek yang disimpan dalam objek ekspor module akan diekspos saat module Node.js lainnya diimpor. Misalnya, function getRandomColor() dibuat langsung pada objek ekspor. Selanjutnya, saya menambahkan properti allColors ke objek ekspor yang mereferensikan array allColors konstanta lokal yang dibuat sebelumnya dalam skrip.

Saat module lain mengimpor module ini, allColors dan getRandomColor() akan diekspos dan tersedia.

Simpan file dan keluar.

Sejauh ini, Anda telah membuat module yang berisi array warna dan function yang mengembalikannya secara acak. Saya juga mengekspor array dan function sehingga program eksternal dapat menggunakannya. Langkah selanjutnya adalah menggunakan module di aplikasi lain untuk menunjukkan manfaat ekspor. Langkah 2-Menguji module dengan REPL

Pastikan module berfungsi sebelum membuat aplikasi lengkap. Langkah ini menggunakan REPL untuk memuat module warna. Saat berada di REPL, panggil function getRandomColor() untuk melihat apakah berfungsi seperti yang diharapkan.

Mulai Node.js REPL di folder yang sama dengan file index.js.

node

Ketika REPL dimulai, Anda akan diminta>. Artinya Anda bisa memasukkan kode JavaScript yang akan segera dievaluasi. Jika Anda ingin tahu lebih banyak tentang ini, ikuti panduan penggunaan REPL.

Pertama, ketik:

colors = require('./index');

Dalam perintah ini, require() memuat module warna pada titik masuk. Ketika Anda menekan Enter, Anda akan melihat sesuatu seperti ini:

Output
{
  getRandomColor: [Function],
  allColors: [
    Color { name: 'brightred', code: '#E74C3C' },
    Color { name: 'soothingpurple', code: '#9B59B6' },
    Color { name: 'skyblue', code: '#5DADE2' },
    Color { name: 'leafygreen', code: '#48C9B0' },
    Color { name: 'sunkissedyellow', code: '#F4D03F' },
    Color { name: 'groovygray', code: '#D7DBDD' }
  ]
}

REPL menunjukkan nilai semua function dan objek, warna, yang diimpor dari file index.js. Dengan kata kunci yang dibutuhkan, Node.js mengembalikan semua konten dalam objek ekspor module.

Ingatlah bahwa kami menambahkan getRandomColor() dan allColors ke ekspor module warna. Oleh karena itu, keduanya ditampilkan dalam REPL selama impor.

Saat diminta, uji function getRandomColor(). 
colors.getRandomColor();

Prompt ditampilkan dalam warna acak.

Output
Color { name: 'groovygray', code: '#D7DBDD' }

Indeksnya acak, jadi outputnya mungkin berbeda. Sekarang setelah Anda memverifikasi bahwa module warna berfungsi, keluar dari Node.js REPL.

.exit

Ini akan mengembalikan Anda ke baris perintah terminal.

Saya menggunakan REPL untuk memverifikasi bahwa module berfungsi seperti yang diharapkan. Kemudian terapkan konsep yang sama ini dan muat module ke dalam aplikasi Anda, seperti yang Anda lakukan dalam proyek nyata.

Langkah 3 — Simpan module lokal sebagai dependensi

Saat menguji module di REPL, saya mengimpor module menggunakan jalur relatif. Ini berarti Anda menggunakan lokasi file index.js yang terkait dengan direktori kerja Anda untuk mendapatkan isinya. Ini berfungsi, tetapi biasanya merupakan pengalaman pemrograman yang lebih baik untuk mengimpor module berdasarkan nama sehingga impor tidak terganggu saat konteksnya berubah. Langkah ini menginstal module warna menggunakan fitur instalasi module lokal npm.

Siapkan module Node.js baru di luar folder Warna. Pertama, buka direktori sebelumnya dan buat folder baru.

cd ..
mkdir really-large-application

Kemudian pindah ke proyek baru.

cd really-large-application

Inisialisasi folder dengan npm, seperti module warna.

npm init -y

Package.json berikut akan dibuat:

Output
{
  "name": "really-large-application",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

Kemudian instal module warna dan gunakan flag -save untuk merekamnya di file package.json.

npm install --save ../colors

Saya telah menginstal module warna di proyek baru. Buka file package.json untuk melihat dependensi lokal baru.

nano package.json

Anda dapat melihat bahwa baris yang disorot berikut telah ditambahkan.

// ~/really-large-application/package.json
  {
  "name": "really-large-application",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "colors": "file:../colors"
  }
}

Keluar dari file.

module warna telah disalin ke direktori node_modulees. Pastikan itu ada dengan perintah berikut:

ls node_modulees

Ini akan memberi Anda output berikut:

Output
colors

Program baru ini akan menggunakan module lokal yang diinstal. Buka editor teks lagi dan buat file JavaScript lain.

nano index.js

Program pertama-tama mengimpor module warna. Kemudian gunakan function getRandomColor() yang disediakan oleh module untuk memilih warna secara acak. Terakhir, ia mencetak pesan ke konsol yang memberi tahu pengguna warna mana yang akan digunakan.

Masukkan kode berikut di index.js.

// ~/really-large-application/index.js
  const colors = require('colors');

const chosenColor = colors.getRandomColor();
console.log(`You should use ${chosenColor.name} on your website. It's HTML code is ${chosenColor.code}`);

Simpan file ini dan keluar.

Aplikasi sekarang memberi tahu pengguna tentang opsi warna acak untuk komponen situs web.< Jalankan skrip ini dengan perintah berikut:

node index.js

Outputnya terlihat seperti ini:

Output
You should use leafygreen on your website. It's HTML code is #48C9B0

module warna sekarang berhasil diinstal dan dapat dikelola seperti paket npm lain yang digunakan dalam proyek Anda. Namun, jika Anda menambahkan lebih banyak warna dan function ke module warna lokal, aplikasi Anda harus menjalankan npm update agar dapat menggunakan opsi baru. Langkah selanjutnya adalah menggunakan warna module lokal secara berbeda untuk mendapatkan pembaruan otomatis ketika kode module berubah.

Langkah 4 — Tautkan module lokal

Seiring perkembangan module lokal, pembaruan paket secara terus-menerus dapat menjadi hal yang membosankan. Cara lain adalah dengan menghubungkan module. Saat Anda menautkan module, pembaruan ke module segera tercermin dalam aplikasi yang menggunakannya.

Pada langkah ini, Anda akan menautkan module warna ke aplikasi Anda. Juga, pastikan bahwa perubahan terbaru berfunction di aplikasi Anda tanpa mengubah module warna dan menginstal ulang atau memutakhirkan.

Pertama, hapus instalan module lokal.

npm un colors

npm menautkan module menggunakan tautan simbolik (atau tautan simbolik) yang merupakan referensi yang mengarah ke file atau direktori di komputer Anda. Menautkan module dilakukan dalam dua langkah:

  • Buat tautan global ke module. npm membuat tautan simbolis antara direktori global node_modulees dan direktori module. Direktori node_modulees global adalah tempat semua paket npm seluruh sistem (paket yang Anda instal dengan flag -g) diinstal.
  • Buat tautan lokal. npm membuat tautan simbolis antara proyek lokal menggunakan module dan tautan global module.

Pertama, kembali ke folder warna dan gunakan perintah tautan untuk membuat tautan global.

cd ../colors
sudo npm link

Setelah selesai, shell akan menampilkan:

Output
/usr/local/lib/node_modulees/colors -> /home/sammy/colors
Anda baru saja membuat symlink di folder node_modulees Anda ke direktori warna Anda. Kembali ke folder aplikasi yang sangat besar dan tautkan paketnya: 
cd ../really-large-application
sudo npm link colors

Anda akan menerima output yang mirip dengan berikut:

Output
/home/sammy/really-large-application/node_modulees/colors -> /usr/local/lib/node_modulees/colors -> /home/sammy/colors

Catatan: Jika Anda menginginkan input yang lebih sedikit, Anda dapat menggunakan ln sebagai ganti tautan. Misalnya, npmlncolors bekerja persis sama.

Seperti yang ditunjukkan oleh output, saya membuat tautan simbolik dari direktori node_modulees lokal dari aplikasi yang sangat besar ke tautan simbolik warna dari node_modulees global. Ini menunjuk ke direktori sebenarnya di mana module warna berada.

Proses penyambungan selesai. Jalankan file untuk memastikannya terus berfungsi.

node index.js

Outputnya terlihat seperti ini:

Output
You should use sunkissedyellow on your website. It's HTML code is #F4D03F

Fungsionalitas program tidak terganggu. Kemudian uji apakah pembaruan diterapkan segera. Di editor teks, buka kembali file index.js di module warna.

cd ../colors
nano index.js

Kemudian tambahkan function untuk memilih warna biru terbaik yang ada. Tidak memerlukan argumen dan selalu mengembalikan item ketiga dalam array allColors. Tambahkan baris berikut ke akhir file.

// ~/colors/index.js 
class Color {
  constructor(name, code) {
    this.name = name;
    this.code = code;
  }
}

const allColors = [
  new Color('brightred', '#E74C3C'),
  new Color('soothingpurple', '#9B59B6'),
  new Color('skyblue', '#5DADE2'),
  new Color('leafygreen', '#48C9B0'),
  new Color('sunkissedyellow', '#F4D03F'),
  new Color('groovygray', '#D7DBDD'),
];

exports.getRandomColor = () => {
        return allColors[Math.floor(Math.random() * allColors.length)];
        }

exports.allColors = allColors;

exports.getBlue = () => {
  return allColors[2];
}

Simpan file, keluar, dan buka kembali file index.js yang terletak di folder aplikasi yang sangat besar.

cd ../really-large-application
nano index.js

Panggil function getBlue() yang baru dibuat dan cetak pernyataan menggunakan properti warna. Tambahkan pernyataan berikut di akhir file.

// ~/really-large-application/index.js 
const colors = require('colors');

const chosenColor = colors.getRandomColor();
console.log(`You should use ${chosenColor.name} on your website. It's HTML code is ${chosenColor.code}`);

const favoriteColor = colors.getBlue();
console.log(`My favorite color is ${favoriteColor.name}/${favoriteColor.code}, btw`);

Simpan file dan keluar.

Kode sekarang menggunakan function getBlue() yang baru dibuat. Jalankan file seperti sebelumnya.

node index.js

Anda akan mendapatkan output yang mirip dengan berikut:

Output

You should use brightred on your website. It's HTML code is #E74C3C
My favorite color is skyblue/#5DADE2, btw

Skrip dapat menggunakan function terbaru dalam module warna tanpa menjalankan pembaruan npm. Hal ini memudahkan untuk melakukan perubahan pada aplikasi yang sedang dikembangkan ini.

Saat Anda membuat aplikasi yang lebih besar dan lebih kompleks, pertimbangkan cara mengelompokkan kode terkait ke dalam module dan cara mengonfigurasi module ini. Jika module hanya digunakan oleh satu program, module tetap berada di proyek yang sama dan direferensikan oleh jalur relatif. Instalasi atau penautan mungkin lebih layak jika module kemudian dibagikan satu per satu atau jika mereka berada di lokasi yang sama sekali berbeda dari proyek yang sedang Anda kerjakan. module yang dikembangkan secara aktif juga mendapat manfaat dari pembaruan tautan otomatis. Jika module tidak dikembangkan secara aktif, menggunakan npm install adalah opsi yang lebih mudah.

Kesimpulan

Dalam tutorial ini, Anda mempelajari bahwa module Node.js adalah file JavaScript yang berisi function dan objek yang dapat digunakan oleh program lain. Selanjutnya, saya membuat module dan melampirkan function dan objek ke objek ekspor global untuk digunakan dalam program eksternal. Akhirnya, saya mengimpor module ke dalam program saya dan menunjukkan bagaimana module bekerja sama untuk membuat aplikasi yang lebih besar.

Sekarang setelah Anda mengetahui cara membuat module, pikirkan tentang jenis program yang Anda tulis, bagi menjadi komponen yang berbeda, dan simpan setiap rangkaian aktivitas dan data unik dalam module Anda sendiri. Semakin banyak Anda berlatih membangun module, semakin baik kemampuan Anda untuk membuat program Node.js berkualitas tinggi selama proses pembelajaran. Untuk menjalankan contoh aplikasi Node.js yang menggunakan module, lihat tutorial tentang cara menyiapkan aplikasi Node.js untuk produksi di Ubuntu 18.04.