การสร้างและใช้งาน Module บน Node.js

26 March 2021

ในบทนี้ คุณจะได้เรียนรู้เกี่ยวกับโมดูลบน Node.js เราจะพูดถึงการสร้างและการใช้งานโมดูลซึ่งสามารถช่วยให้เราแยกโปรแกรมออกเป็นหลายไฟล์ได้ และจะแนะนำให้คุณรู้จักกับขอบเขตของตัวแปรในโมดูล ซึ่งเป็นสิ่งทีสำคัญที่ต้องทราบเมื่อทำงานกับโมดูล นี่เป็นเนื้อหาในบทนี้

  • Module คืออะไร
  • การทำงานของ Module บน Node.js
  • การนำเข้าโมดูลด้วยฟังก์ชัน require
  • การทำงานของไฟล์โมดูล
  • การส่งออกค่าจากโมดูล module.exports
  • ขอบเขตตัวแปรใน Module

Module คืออะไร

โมดูล (Module) บน Node.js นั้นเป็นแค่เพียงไฟล์ของโปรแกรม เมื่อคุณสร้างไฟล์ของโปรแกรมใหม่ขึ้นมาบน Node.js นั่นหมายความว่าคุณสร้างโมดูลโดยปริยาย โมดูลช่วยให้เราสามารถแบ่งโค้ดออกเป็นส่วนและห่อหุ่มการทำงานในขอบเขตของตัวเอง (Encapsulated) โค้ดที่มีลักษณะการทำงานเหมือนกันอาจอยู่ในโมดูลเดียวกัน นี่สามารถช่วยลดความซับซ้อนและทำให้โปรแกรมง่ายต่อการดูแลและการพัฒนา และสามารถนำโค้ดมาใช้ซ้ำได้ง่าย

โมดูลบน Node.js ใช้ระบบจัดการโมดูลแบบ CommonJS ในการกำหนดลักษณะการทำงาน โดยใช้ฟังก์ชัน require ในการนำเข้าโมดูลเข้ามาใช้งานในโปรแกรม และส่งออกค่าจากโมดูลไปภายนอกด้วยการกำหนดค่าผ่านออบเจ็ค module.exports

นอกจากนี้ ยังมีระบบของโมดูลในรูปแบบอื่นๆ ที่สามารถใช้ได้บน Node.js เช่น ES modules ซึ่งเป็นระบบโมดูลของ ECMAScript 2015 หรือ ES6 ที่ใช้คำสั่ง import ในการนำเข้าโมดูลและใช้คำสั่ง export ในการส่งออกโมดูลแทน แต่นี่ไม่ได้ครอบคลุมในบทเรียนนี้

การทำงานของ Module บน Node.js

แน่นอนว่าในการเขียนโปรแกรมบน Node.js นั้น การสร้างโมดูลเป็นสิ่งพื้นฐานที่คุณต้องทำอยู่แล้ว เมื่อไหร่ก็ตามที่คุณสร้างไฟล์โปรแกรมของภาษา JavaScript นั่นหมายความว่าคุณได้สร้างโมดูล นี่เป็นตัวอย่างของการสร้างไฟล์ index.js ซึ่งเป็นโมดูลใหม่ของเรา

index.js
function add(a, b) {
    return a + b;
}

function subtract(a, b) {
    return a - b;
}

let a = 3;
let b = 2;

console.log('3 + 2 = %d', add(a, b));
console.log('3 - 2 = %d', subtract(a, b));

นี่เป็นผลลัพธ์การทำงานของโปรแกรม

3 + 2 = 5
3 - 2 = 1

ในไฟล์หรือโมดูล index.js นี้ได้มีการประกาศสองฟังก์ชันสำหรับหาผลรวมและผลต่างของสองตัวเลขที่ส่งเข้าไปยังฟังก์ชัน นี่เป็นเพียงโปรแกรมสำหรับคำนวณทางคณิตศาสตร์อย่างง่ายเท่านั้น เราได้สร้างไฟล์โปรแกรมภาษา JavaScript ขึ้นมาและรันมันด้วยคำสั่ง

node index.js

เมื่อโปรแกรมถูกรันด้วยคำสั่ง node เราเรียกไฟล์ที่ใช้รันโปรแกรมว่าไฟล์เริ่มต้นของการทำงานหรือโมดูลหลัก (Main module) ของโปรแกรม ซึ่งในกรณีนี้คือ index.js และจากนั้นโมดูลนี้่ มันสามารถนำเข้าโมดูลอื่นๆ มาใช้งานในโปรแกรมได้

ต่อไปเรามาแยกฟังก์ชันทั้งสองออกไปอีกไฟล์หรือโมดูลที่มีชื่อว่า math.js เพื่อทำให้โค้ดแบ่งเป็นสัดส่วนมากขึ้น และจากนั้นนำมันเข้ามาใช้งานในโมดูล index.js แทน นี่เป็นโค้ดของโปรแกรมที่ประกอบไปด้วยสองโมดูล

math.js
function add(a, b) {
    return a + b;
}

function subtract(a, b) {
    return a - b;
}

module.exports.add = add;
module.exports.subtract = subtract;

และนี่เป็นไฟล์โมดูลหลักของโปรแกรม

index.js
const { add, subtract } = require('./math');

let a = 3;
let b = 2;

console.log('3 + 2 = %d', add(a, b));
console.log('3 - 2 = %d', subtract(a, b));

ในตอนแรก เราสร้างโมดูล math.js สำหรับเก็บฟังก์ชันบวกเลข add และฟังก์ชันลบเลข subtract จากนั้นส่งฟังก์ชันออกมาจากโมดูลผ่านทางออบเจ็ค module.exports โดยการกำหนดค่าที่ต้องการส่งออกผ่าน Property ของออบเจ็ค ซึ่งนี่เรียกว่าการส่งออกโมดูล (Export)

const { add, subtract } = require('./math');

จากนั้นเราใช้ฟังก์ชัน require นำเข้าฟังก์ชันจากโมดูล math.js เพื่อนำมาใช้งานในโมดูลหลัก index.js ซึ่งการทำงานของโปรแกรมจะได้ผลลัพธ์เหมือนกับตัวอย่างก่อนหน้า แต่ในตอนนี้เราใช้ความสามารถของโมดูลบน Node.js โดยการแบ่งแยกโค้ดออกเป็นโมดูลแทน

จะเห็นว่าในการใช้งานโมดูล เราไม่จำเป็นต้องเขียนทุกอย่างไว้ในไฟล์เดียวกัน หากโปรแกรมเริ่มมีขนาดใหญ่และซับซ้อนมากขึ้น เราสามารถแยกออกไปเป็นโมดูลที่เล็กลงและนำเข้าโมดูลเหล่านั้นมาใช้งานในโปรแกรมแทนได้

การนำเข้าโมดูลด้วยฟังก์ชัน require

เหมือนกับที่คุณเห็นในตัวอย่างก่อนหน้า ในการนำเข้าโมดูลบน Node.js นั้นสามารถทำได้โดยการใช้ฟังก์ชัน require นี่เป็นรูปแบบการใช้งาน

let myModule = require('path/to/myModule');

ฟังก์ชันรับพารามิเตอร์เป็นพาธของโมดูลที่คุณต้องการนำเข้า ค่าที่ส่งกลับโดยฟังก์ชันคือออบเจ็ค module.exports ของโมดูลที่ได้รับการนำเข้า ส่วนพาธของโมดูลนั้นสามารถเป็นได้ทั้งแบบ Relative Absolute หรือพาธในรูปแบบเต็มก็ได้ ยกตัวอย่างเช่น

  • ./myModule - นำเข้าโมดูลที่อยู่ในโฟล์เดอร์เดียวกัน
  • ./sub/myModule'- นำเข้าโมดูลที่อยู่ในโฟล์เดอร์ sub โดยอ้างจากโฟล์เดอร์ปัจจุบัน
  • ../myModule - นำเข้าโมดูลที่อยู่เหนือขึ้นไปหนึ่งขั้น
  • C:/path/to/myModule - นำเข้าโมดูลโดยใช้พาธแบบเต็ม

การทำงานของไฟล์โมดูล

อีกสิ่งที่ควรทราบเกี่ยวกับโมดูลบน Node.js คือการทำงานของโมดูลเมื่อมีการนำเข้าโมดูลมาใช้งาน ในตัวอย่างนี้่ จะเป็นการแสดงวิธีการทำงานของไฟล์โมดูลบน Node.js เมื่อมันถูกนำเข้ามาใช้งานในโปรแกรม เราได้สร้างสองโมดูลที่มีชื่อว่า foo.js และ bar.js สำหรับแสดงตัวอย่าง นี่เป็นโมดูลแรกของเรา

bar.js
console.log('Hello from bar.js');

function hello() {
    console.log('Hello inside function in bar.js');
}

module.exports = hello;

นี่เป็นโมดูลที่สองและเป็นโมดูลหลักที่จะใช้ในการรันโปรแกรม

foo.js
const hello1 = require('./bar');

console.log('Hello from foo.js');

const hello2 = require('./bar');

console.log(hello1, hello2);

จากนั้นเรารันโปรแกรมด้วยคำสั่ง

node foo.js

ในกรณีนี้ foo.js เป็นโมดูลหลักที่ใช้รันโปรแกรม และได้มีการนำเข้าโมดูล bar.js มาใช้งาน บน Node.js ในการนำเข้าโมดูลด้วยฟังก์ชัน require โค้ดภายในโมดูลจะทำงานเพียงครั้งแรกเท่านั้น นั่นหมายความว่าคำสั่ง console.log และฟังก์ชัน hello ในโมดูล bar.js จะแสดงผลและประกาศเพียงครั้งเดียว นี่จะช่วยให้เราสามารถนำเข้าโมดูลเดิมหลายครั้งในโปรแกรมได้

const hello2 = require('./bar');

และเมื่อเราเรียกใช้ฟังก์ชัน require เพื่อนำเข้าโมดูล bar.js อีกครั้ง ค่าในออบเจ็ค module.exports จะถูกส่งกลับมาในทันที โดยที่โค้ดในโมดูลจะไม่ทำงานอีกครั้ง ดังนั้นผลลัพธ์การทำงานของโปรแกรมจะเป็นดังนี้

Hello from bar.js
Hello from foo.js
[Function: hello] [Function: hello]

การแสดงผลในโมดูล bar.js จะถูกทำงานเพียงแค่ครั้งแรกที่มีการนำเข้าโมดูล และส่งออกค่าจากโมดูลผ่านทางออบเจ็ค module.exports ทันทีในการนำเข้าโมดูลในครั้งถัดไป นั่นเป็นเพราะว่า Node.js ได้ทำการแคชค่าที่ส่งออกจากโมดูลเอาไว้

นี่เป็นวิธีการทำงานของ Node.js มันสามารถช่วยให้เรานำเข้าโมดูลเดิมมาใช้ในโปรแกรมหลายๆ ครั้งได้โดยที่โมดูลไม่ต้องทำงานใหม่เสมอ

การส่งออกค่าจากโมดูล module.exports

หลังจากที่คุณได้เรียนรู้การนำเข้าโมดูลด้วยการใช้ฟังก์ชัน require แล้ว ต่อไปมาดูตัวอย่างการส่งออกค่าจากโมดูลในรูปแบบต่างๆ บน Node.js ในการส่งออกจากจากโมดูล เรากำหนดค่าที่ต้องการส่งออกผ่านออบเจ็ค module.exports ดังนีี้

module.exports = expression;

โดยที่ expression สามารถเป็นค่าใดๆ ในภาษา JavaScript เช่น ค่าคงที่ ตัวแปร ออบเจ็ค หรือฟังก์ชัน เป็นต้น และมันเป็นค่าที่จะถูกส่งกลับมาเมื่อเรานำเข้าโมดูลด้วยฟังก์ชัน require ต่อไปมาดูการส่งออกค่าจากโมดูลในรูปแบบต่างๆ บน Node.js

ส่งออกตัวแปรและค่าคงที่จาก Module

คุณสามารถสร้างโมดูลสำหรับเก็บและส่งออกข้อมูลได้ทุกประเภท มาเริ่มต้นกับโมดูลที่เก็บตัวแปรและค่าคงที่แบบง่ายๆ และจากนั้นส่งมันออกเพื่อให้โมดูลอื่นสามารถนำไปใช้งานได้ นี่เป็นตัวอย่าง

constants.js
const siteName = 'MarcusCode';
const year = 2021;
let color = 'blue';

module.exports.siteName = siteName;
module.exports.year = year;
module.exports.color = color;

นี่เป็นโมดูลที่มีชื่อว่า constants.js เราได้ประกาศค่าคงที่และตัวแปรไว้ภายโมดูล จากนั้นส่งออกค่าโดยการกำหนดผ่าน Property ของออบเจ็ค module.exports เพื่อให้โมดูลอื่นสามารถนำค่าเหล่านี้ไปใช้งานได้

เราได้ส่งสามค่าออกจากโมดูลผ่านทาง Property siteName year และ color จากนั้นในโมดูลหลักได้นำเข้าค่าในโมดูลนี้ไปใช้งาน นี่เป็นตัวอย่าง

index.js
const myModule = require('./constants');

console.log(`Welcome to ${myModule.siteName}`);
console.log(`${myModule.year} is a good year to learn things`);
console.log(`The site color is ${myModule.color}`);

นี่เป็นผลลัพธ์การทำงานของโปรแกรม

Welcome to MarcusCode
2021 is a good year to learn things
The site color is blue

ในตัวอย่าง เราได้สร้างโมดูล index.js ซึ่งเป็นโมดูลหลักของโปรแกรม และทำการนำเข้าค่าจากโมดูล constants.js มาใช้งาน จะเห็นว่าค่าที่ส่งกลับมาจากการนำเข้าก็คือออบเจ็ค module.exports ในโมดูลนั่นเอง

และแทนที่จะส่งค่าออกจากโมดูลที่ละค่าผ่านทาง Property คุณสามารถส่งออกค่าทั้งหมดพร้อมกันได้โดยการกำหนดค่าสุดท้ายที่ต้องการส่งออกให้กับออบเจ็ค module.exports ยกตัวอย่างเช่น

const object = {
    siteName: siteName,
    year: year,
    color: color
};

module.exports = object;

หรือกำหนดออบเจ็คที่ต้องการส่งออกโดยตรง ซึ่งนี่ีให้ผลลัพธ์การทำงานที่ไม่แตกต่างกัน คุณสามารถทำแบบไหนก็ได้

module.exports = {
    siteName: siteName,
    year: year,
    color: color
};

การส่งออกฟังก์ชันจาก Module

เช่นเดียวกับค่าคงที่และตัวแปร คุณสามารถส่งออกฟังก์ชันออกจากโมดูลได้ เพียงคิดว่าฟังก์ชันเป็นเพียงค่าๆ หนึ่งในภาษา JavaScript ที่เราสามารถส่งเป็นพารามิเตอร์ของฟังก์ชันหรือกำหนดในตัวแปร นี่เป็นตัวอย่างของการส่งออกฟังก์ชันจากโมดูลบน Node.js

string.js
function countLength(str) {
    return str.length;
}

function countVowels(str) {
    let count = 0;
    for (let ch of str) {
        if (['a', 'e', 'i', 'o', 'u'].includes(ch)) {
            count++;
        }
    }
    return count;
}

module.exports.countLength = countLength;
module.exports.countVowels = countVowels;

และนี่เป็นโมดูลหลักของโปรแกรมที่จะถูกรัน

main.js
const { countLength, countVowels } = require('./string');

let name = 'Matteo Crisco';

console.log(name);
console.log('Length:', countLength(name));
console.log('Vowels:', countVowels(name));

นี่เป็นผลลัพธ์การทำงานของโปรแกรม

Matteo Crisco
Length: 13
Vowels: 5

เราได้ส่งออกสองฟังก์ชันทีี่ประกาศในโมดูล string.js ผ่านทาง Property countLength และ countVowels โดยที่ฟังก์ชัน countLength ใช้สำหรับนับความยาวของตัวอักษรใน String ส่วนฟังก์ชัน countVowels ใช้สำหรับนับสระที่ปรากฏใน String คุณสามารถใช้มันเพื่อดูว่ามีสระเป็นจำนวนเท่าไหร่ในชื่อของคุณ

การสร้างโมดูลเพื่อเก็บฟังก์ชันทำให้เราสามารถแยกการทำงานหลักและการประกาศฟังก์ชันออกจากกันได้ คุณอาจจะสร้างโมดูลสำหรับเก็บฟังก์ชันที่ทำงานกับ String หรือตัวเลข แยกออกจากกันก็ได้ และโมดูลอื่นสามารถนำมันไปใช้ได้ทุกเมื่อที่ต้องการ

ออบเจ็คทุกประเภทสามารถส่งออกจาก Module

ไม่ใช่เพียงค่าคงที่ ตัวแปร หรือฟังก์ชันเท่านั้นที่สามารถส่งออกจากโมดูลได้ แต่คุณสามารถส่งออกออบเจ็คทุกประเภทออกจากโมดูล ไม่ว่าจะเป็น JavaScript ออบเจ็ค ฟังก์ชัน คลาส หรือค่า Literal โดยตรง นี่เป็นตัวอย่าง

miscellaneous.js
const user = {
    id: 1,
    name: 'Metin'
};

function hello(user) {
    console.log(`Hello ${user.name}!`);
}

module.exports.user = user;
module.exports.hello = hello;
module.exports.siteName = 'MarcusCode';

การส่งออกโดยกำหนดค่าให้กับ module.exports

นอกจากจะกำหนดแต่ละค่าที่ต้องการส่งออกผ่านทาง Property แล้ว คุณสามารถส่งออกค่าทั้งหมดผ่านทาง module.exports ได้ นี่มักจะใช้ในกรณีที่เราต้องการส่งออกค่าเพียงค่าเดียวในโมดูล นี่เป็นตัวอย่างของการส่งออกออบเจ็คทั้งหมดออกจากโมดูล

hello.js
function hello(name) {
    console.log(`Hello ${name}!`);
}

module.exports = hello;

เมื่อไรก็ตามที่เราส่งออกออบเจ็คโดยการกำหนดค่าผ่านทางออบเจ็ค module.exports ค่าดังกล่าวจะเป็นค่าที่ส่งกลับมาจากการนำเข้าโมดูลด้วยฟังก์ชัน require ดังนั้นเราสามารถนำเข้ามาใช้งานได้ด้วยคำสั่งต่อไปนี้

const hello = require('./hello');

เนื่องจากโมดูล hello.js ได้ส่งออกฟังก์ชันโดยการกำหนดค่าให้กับออบเจ็ค module.exports โดยตรง ดังนั้นนี่จะเป็นค่าที่ส่งกลับมาโดยการเรียกใช้ฟังก์ชัน require ในการนำเข้าโมดูลมาใช้งาน

ในทางปฏิบัติแล้ว การส่งออกในรูปแบบนี้มักใช้ในกรณีที่โมดูลนั้นใช้สำหรับเก็บค่าหรือออบเจ็คเพียงอย่างเดียว นี่เป็นตัวอย่างของโมดูลที่ใช้สำหรับเก็บคลาส User และส่งออกไปเพื่อให้โมดูลอื่นสามารถนำไปใช้งานได้

user.js
class User {

    constructor(firstName, lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    getFullname() {
        return this.firstName + ' ' + this.lastName;
    }
}

module.exports = User;

ในโมดูล user.js เราได้ประกาศคลาส User สำหรับสร้างออบเจ็คของผู้ใช้ที่ประกอบไปด้วย ตัวแปร firstName และ lastName สำหรับเก็บชื่อและนามสกุล ตามลำดับ นอกจากนี้ คลาสยังมีเมธอด getFullname สำหรับรับเอาชื่อแบบเต็มโดยการนำชื่อและนามสกุลมาเชื่อมต่อกัน

เมื่อเราประกาสคลาสพร้อมแล้ว เราส่งมันออกไปนอกโมดูลด้วยการกำหนดคลาสให้กับออบเจ็ค module.exports และมันเป็นเพียงค่าเดียวที่ถูกส่งออก จากนั้นในโมดูลหลักของโปรแกรม เราสามารถนำเข้าโมดูล user.js เพื่อนำคลาสมาใช้สร้างออบเจ็คได้ดังนี้

index.js
const User = require('./user');

let user = new User('Matteo', 'Crisco');
console.log(user.getFullname());

และนี่เป็นผลลัพธ์การทำงานของโปรแกรม

Matteo Crisco

คลาส User ที่เราส่งออกมาจากโมดูล user.js นั้นเป็นค่าที่ส่งกลับมาโดยตรงจากการเรียกใช้งานฟังก์ชัน require เพื่อนำเข้าโมดูลมาใช้งาน เราเก็บค่าของคลาสไว้ในตัวแปรค่าคงที่ User และจากนั้นนำไปสร้างออบเจ็คของผู้ใช้

const MyUser = require('./user');
let user = new MyUser('Matteo', 'Crisco');

เนื่องจากคลาสที่ส่งออกมาเป็นเพียงค่าๆ หนึ่งในภาษา JavaScript คุณสามารถกำหนดมันไว้ในตัวแปรที่ชื่อว่าอะไรก็ได้ ในกรณีนี้เราเก็บมันไว้ในตัวแปร MyUser จากนั้นเราอ้างถึงคลาสนี้ผ่านตัวแปรดังกล่าวแทน นี่ได้ผลเช่นเดียวกันกับฟังก์ชัน ออบเจ็ค หรือค่าอื่นๆ ที่ส่งออกมา

ขอบเขตตัวแปรใน Module

โมดูลบน Node.js มีขอบเขตตัวแปรเป็นของมันเอง มีเพียงออบเจ็คที่ถูกส่งออกจากโมดูลเท่านั้นที่จะสามารถเข้าถึงได้จากภายนอกโมดูล ในขณะที่ออบเจ็คภายโมดูลจะยังคงสามารถเข้าถึงได้จากในโมดูลเดียวกัน ซึ่งแนวคิดการทำงานจะเหมือนกับขอบเขตของตัวแปรในฟังก์ชันหรือบล็อคในภาษา JavaScript

นี่เป็นตัวอย่างสำหรับแสดงการทำงานขอบเขตของตัวแปรในโมดูล เราได้สร้างโมดูล counter.js สำหรับนับเลขโดยเริ่มจากศูนย์

counter.js
let count = 0;

function increaseCounter() {
    count++;
}

function getCounter() {
    return count;
}

module.exports = {
    increaseCounter: increaseCounter,
    getCounter: getCounter
};

จากนั้นในโมดูลหลักเรานำเข้าโมดูล counter.js มาใช้งาน

index.js
const { increaseCounter, getCounter } = require('./counter');

console.log(`Counter: ${getCounter()}`);

increaseCounter();
increaseCounter();
console.log(`Counter: ${getCounter()}`);

โมดูล counter.js ประกอบไปด้วยสองฟังก์ชันได้แก่ ฟังก์ชัน increaseCounter สำหรับเพิ่มค่าตัวนับ และฟังก์ชัน getCounter สำหรับรับเอาค่าของตัวนับปัจจุบัน ภายในโมดูลนั้นมีตัวแปร count สำหรับเป็นตัวนับจำนวนโดยเริ่มจาก 0 และทุกครั้งที่ฟังก์ชัน increaseCounter ถูกเรียกใช้งาน ค่าในตัวแปรจะเพิ่มขึ้น 1

เนื่องจากตัวแปร count ถูกประกาศในโมดูล counter.js และไม่ได้ถูกส่งออกมาผ่านออบเจ็ค module.exports ดังนั้นเราไม่สามารถเข้าถึงตัวแปรนี้โดยตรงได้

increaseCounter();
console.log(`Counter: ${getCounter()}`);

สิ่งที่เราสามารถทำได้ในโมดูลหลักคือการเรียกใช้ฟังก์ชัน increaseCounter เพื่อเพิ่มค่าและฟังก์ชัน getCounter รับค่าตัวนับจากภายในโมดูล และทั้งสองฟังก์ชันนี้สามารถเข้าถึงตัวแปร count เนื่องจากมันประกาศในโมดูลเดียวกัน

อีกตัวอย่างสำหรับการทำงานของขอบเขตตัวแปรในโมดูล ในการที่แต่ละโมดูลมีขอบเขตตัวแปรเป็นของมันเอง นี่ทำให้เราสามารถประกาศตัวแปรภายในโมดูลได้โดยที่ไม่ต้องกังวลว่าตัวแปรจะถูกใช้ในโมดูลอื่นๆ แล้ว ยกตัวอย่างเช่น

another.js
let a = 3;
let b = 4;
let c = a + b;

module.exports = {
    a: a,
    b: b,
    c: c
};

และนี่เป็นโมดูลหลักของโปรแกรม

index.js
const another = require('./another');

let a = 1;
let b = 2;
let c = a + b;

console.log('Main module');
console.log(`a = ${a}, b = ${b}, c = ${c}`);

let x = another.a;
let y = another.b;
let z = another.c;

console.log('Another module');
console.log(`a = ${x}, b = ${y}, c = ${z}`);

นี่เป็นผลลัพธ์การทำงานของโปรแกรม

Main module
a = 1, b = 2, c = 3
Another module
a = 3, b = 4, c = 7

ในตัวอย่าง ทั้งโมดูล another.js และ index.js ต่างก็มีตัวแปร a, b และ c เป็นของมันเอง ซึ่งนี่เป็นไปได้เนื่องจากแต่ละโมดูลมีขอบตัวแปรเป็นของมันเอง เช่น เดียวกับขอบเขตของตัวแปรในฟังก์ชัน สองฟังก์ชันที่อยู่ระดับเดียวกันสามารถม่ีตัวแปรที่เหมือนกันได้โดยไม่มีความขัดแย้ง

let x = another.a;
let y = another.b;
let z = another.c;

แต่เมื่อไรก็ตามที่เรานำเข้าโมดูล another.js มาใช้งานในโมดูล index.js เราจะต้องกำหนดค่าไว้ในตัวแปรใหม่นั่นคือ x, y และ z ซึ่งนี่ก็ชัดเจนเนื่องจากว่าตัวแปร a, b และ c ถูกใช้ในโมดูลหลักแล้วนั่นเอง

ในบทนี้ คุณได้เรียนรู้เกี่ยวกับการสร้างและใช้งานโมดูลบน Node.js เราได้พูดถึงความหมายและแสดงการทำงานของระบบโมดูลบน Node.js ซึ่งมีการกำหนดการทำงานด้วยระบบโมดูล CommonJS โดยการใช้ require และ module.exports ในการนำเข้าและส่งออกโมดูล นอกจากนี้เราได้พูดถึงขอบเขตของตัวแปรในโมดูล

กลุ่มหัดเขียนโปรแกรมภาษา Python

กลุ่มหัดเขียนโปรแกรมเบื้องต้น เข้าร่วมกลุ่มเพื่อสอบถามปัญหาเกี่ยวกับการเขียนโปรแกรมในภาษาต่างๆ

เข้าร่วมกลุ่ม
บทความนี้เป็นประโยชน์หรือไม่? Yes · No