วิธีสร้าง GET Request ใน Node.js: คู่มือสำหรับผู้เริ่มต้น

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

คำขอ GET คืออะไร

คำขอ GET เป็นหนึ่งในประเภทคำขอ HTTP requests ที่พบบ่อยที่สุด HTTP ย่อมาจาก Hypertext Transfer Protocol ซึ่งเป็นโปรโตคอลมาตรฐานสำหรับการสื่อสารระหว่างเว็บเบราว์เซอร์และเว็บเซิร์ฟเวอร์ คำขอ HTTP คือข้อความที่เว็บเบราว์เซอร์ส่งไปยังเว็บเซิร์ฟเวอร์เพื่อขอหรือส่งข้อมูล การตอบสนอง HTTP คือข้อความที่เว็บเซิร์ฟเวอร์ส่งกลับไปยังเว็บเบราว์เซอร์เพื่อส่งมอบข้อมูลที่ร้องขอหรือยืนยันการส่ง

คำขอ GET เป็นประเภทของคำขอ HTTP ที่ขอให้เว็บเซิร์ฟเวอร์ส่งทรัพยากรเฉพาะกลับมา ตัวอย่างเช่น เมื่อคุณพิมพ์ URL ในเว็บเบราว์เซอร์ คุณกำลังสร้างคำขอ GET ไปยังเว็บเซิร์ฟเวอร์เพื่อส่งหน้าเว็บที่เกี่ยวข้องกับ URL นั้นให้คุณ คำขอ GET ยังสามารถรวมพารามิเตอร์แบบสอบถาม ซึ่งเป็นคู่คีย์-ค่าที่ให้ข้อมูลเพิ่มเติมหรือกรองทรัพยากรที่ร้องขอ ตัวอย่างเช่น เมื่อคุณค้นหาสิ่งต่างๆ บน Google คุณกำลังสร้างคำขอ GET ไปยังเว็บเซิร์ฟเวอร์ Google พร้อมพารามิเตอร์แบบสอบถามบางรายการที่ระบุคำค้นหา ภาษา และตัวเลือกอื่นๆ ของคุณ

ทำไมคำขอ GET จึงสำคัญ

คำขอ GET มีความสำคัญเนื่องจากเป็นวิธีหลักในการดึงข้อมูลจากเว็บเซิร์ฟเวอร์ คุณสามารถใช้คำขอ GET เพื่อเข้าถึงข้อมูลประเภทต่างๆ เช่น HTML, JSON, XML, รูปภาพ, วิดีโอ และอื่นๆ คุณยังสามารถใช้คำขอ GET เพื่อโต้ตอบกับ API เว็บ ซึ่งเป็นอินเทอร์เฟซที่ช่วยให้คุณเข้าถึงข้อมูลและบริการจากแอปพลิเคชันเว็บอื่นๆ ตัวอย่างเช่น คุณสามารถใช้คำขอ GET เพื่อรับข้อมูลสภาพอากาศจาก OpenWeatherMap API, รับข้อมูลภาพยนตร์จาก IMDb API หรือรับภาพสุนัขจาก Dog API

คำขอ GET ยังมีความสำคัญเนื่องจากใช้งานและทดสอบได้ง่าย คุณสามารถสร้างคำขอ GET โดยใช้เว็บเบราว์เซอร์ใดก็ได้ โดยไม่ต้องใช้เครื่องมือหรือไลบรารีพิเศษ คุณยังสามารถใช้เครื่องมือเช่น Postman หรือ Apidog เพื่อสร้างและทดสอบคำขอ GET ด้วยพารามิเตอร์และส่วนหัวต่างๆ คุณยังสามารถตรวจสอบข้อมูลการตอบสนองและส่วนหัวโดยใช้เครื่องมือสำหรับนักพัฒนาของเบราว์เซอร์หรืออินเทอร์เฟซของเครื่องมือ

NodeJs คืออะไร

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

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

วิธีการสร้างคำขอ GET ใน Node.js โดยใช้โมดูล http

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

ในการสร้างคำขอ GET ใน Node.js โดยใช้โมดูล http คุณต้องทำตามขั้นตอนเหล่านี้:

1. นำเข้าโมดูล http โดยใช้ฟังก์ชัน require
2. สร้างอ็อบเจกต์ options ที่มีข้อมูลเกี่ยวกับคำขอ GET เช่น ชื่อโฮสต์ พอร์ต เส้นทาง และส่วนหัว
3. ใช้เมธอด http.get เพื่อสร้างคำขอ GET โดยส่งผ่านอ็อบเจกต์ options เป็นอาร์กิวเมนต์แรกและฟังก์ชัน callback เป็นอาร์กิวเมนต์ที่สอง ฟังก์ชัน callback จะถูกดำเนินการเมื่อได้รับการตอบสนอง และจะมีอ็อบเจกต์ response เป็นพารามิเตอร์
4. ใช้อ็อบเจกต์ response เพื่อจัดการข้อมูลและการตอบสนองส่วนหัว อ็อบเจกต์ response เป็นอินสแตนซ์ของคลาส http.IncomingMessage ซึ่งใช้ส่วนต่อประสาน ReadableStream ซึ่งหมายความว่าคุณสามารถใช้อ็อบเจกต์ response เป็นสตรีมของข้อมูล และฟังเหตุการณ์ต่างๆ เช่น data, end และ error คุณยังสามารถใช้คุณสมบัติ response.statusCode เพื่อรับรหัสสถานะของการตอบสนอง และคุณสมบัติ response.headers เพื่อรับส่วนหัวของการตอบสนอง
5. ใช้เมธอด response.on เพื่อลงทะเบียนตัวฟังเหตุการณ์สำหรับอ็อบเจกต์ response ตัวอย่างเช่น คุณสามารถใช้เมธอด response.on('data', callback) เพื่อฟังเหตุการณ์ data ซึ่งจะถูกปล่อยออกมาเมื่อได้รับข้อมูลส่วนหนึ่ง ฟังก์ชัน callback จะมีอ็อบเจกต์ chunk เป็นพารามิเตอร์ ซึ่งเป็นบัฟเฟอร์ของข้อมูล คุณสามารถใช้เมธอด chunk.toString() เพื่อแปลงบัฟเฟอร์เป็นสตริง และผนวกเข้ากับตัวแปรเพื่อจัดเก็บข้อมูลการตอบสนองทั้งหมด คุณยังสามารถใช้เมธอด response.on('end', callback) เพื่อฟังเหตุการณ์ end ซึ่งจะถูกปล่อยออกมาเมื่อการตอบสนองเสร็จสมบูรณ์ ฟังก์ชัน callback จะไม่มีพารามิเตอร์ใดๆ และคุณสามารถใช้เพื่อดำเนินการขั้นสุดท้าย เช่น การบันทึกหรือการแยกวิเคราะห์ข้อมูลการตอบสนอง คุณยังสามารถใช้เมธอด response.on('error', callback) เพื่อฟังเหตุการณ์ error ซึ่งจะถูกปล่อยออกมาเมื่อเกิดข้อผิดพลาดระหว่างการตอบสนอง ฟังก์ชัน callback จะมีอ็อบเจกต์ error เป็นพารามิเตอร์ และคุณสามารถใช้เพื่อจัดการข้อผิดพลาด เช่น การบันทึกหรือการโยน

ตัวอย่างวิธีสร้างคำขอ GET ใน Node.js โดยใช้โมดูล http:

// นำเข้าโมดูล http
const http = require('http');

// สร้างอ็อบเจกต์ options
const options = {
  hostname: 'api.openweathermap.org',
  port: 80,
  path: '/data/2.5/weather?q=Los%20Angeles&appid=YOUR_API_KEY',
  headers: {
    'User-Agent': 'Node.js'
  }
};

// สร้างคำขอ GET
http.get(options, (response) => {
  // เริ่มต้นตัวแปรเพื่อจัดเก็บข้อมูลการตอบสนอง
  let data = '';

  // ฟังเหตุการณ์ data
  response.on('data', (chunk) => {
    // ผนวก chunk เข้ากับตัวแปร data
    data += chunk.toString();
  });

  // ฟังเหตุการณ์ end
  response.on('end', () => {
    // บันทึกรหัสสถานะและส่วนหัว
    console.log(`Status code: ${response.statusCode}`);
    console.log(`Headers: ${JSON.stringify(response.headers)}`);

    // แยกวิเคราะห์ข้อมูลเป็น JSON
    const weather = JSON.parse(data);

    // บันทึกข้อมูลสภาพอากาศ
    console.log(`City: ${weather.name}`);
    console.log(`Temperature: ${weather.main.temp}`);
    console.log(`Description: ${weather.weather[0].description}`);
  });

  // ฟังเหตุการณ์ error
  response.on('error', (error) => {
    // โยนข้อผิดพลาด
    throw error;
  });
});

วิธีการสร้างคำขอ GET ใน Node.js โดยใช้ไลบรารี axios

โมดูล http เป็นโมดูลระดับต่ำที่ให้ฟังก์ชันการทำงานพื้นฐานสำหรับการสร้างคำขอและการตอบสนอง HTTP อย่างไรก็ตาม หากคุณต้องการใช้โมดูลระดับสูงและใช้งานง่ายกว่า คุณสามารถใช้ไลบรารี axios ได้ Axios เป็นไลบรารียอดนิยมและทรงพลังที่ช่วยให้คุณสร้างคำขอ HTTP และจัดการการตอบสนองโดยใช้ promises และไวยากรณ์ async/await Axios ยังรองรับคุณสมบัติต่างๆ เช่น interceptors, transformers, timeouts, cancel tokens และอื่นๆ

ในการสร้างคำขอ GET ใน Node.js โดยใช้ไลบรารี axios คุณต้องทำตามขั้นตอนเหล่านี้:

1. ติดตั้งไลบรารี axios โดยใช้คำสั่ง npm: npm install axios
2. นำเข้าไลบรารี axios โดยใช้ฟังก์ชัน require
3. ใช้เมธอด axios.get เพื่อสร้างคำขอ GET โดยส่งผ่าน URL ของทรัพยากรเป็นอาร์กิวเมนต์แรกและอ็อบเจกต์ config ที่เป็นตัวเลือกเป็นอาร์กิวเมนต์ที่สอง อ็อบเจกต์ config สามารถมีข้อมูลเกี่ยวกับคำขอ GET เช่น ส่วนหัว พารามิเตอร์ หมดเวลา และอื่นๆ เมธอด axios.get จะส่งคืน promise ซึ่งจะแก้ไขเป็นอ็อบเจกต์ response หรือปฏิเสธเป็นอ็อบเจกต์ error
4. ใช้เมธอด then เพื่อจัดการ promise ที่ได้รับการแก้ไข โดยส่งผ่านฟังก์ชัน callback เป็นอาร์กิวเมนต์แรก ฟังก์ชัน callback จะมีอ็อบเจกต์ response เป็นพารามิเตอร์ ซึ่งมีข้อมูลการตอบสนอง สถานะ ส่วนหัว และอื่นๆ คุณสามารถใช้คุณสมบัติ response.data เพื่อเข้าถึงข้อมูลการตอบสนอง และคุณสมบัติ response.status เพื่อเข้าถึงรหัสสถานะของการตอบสนอง คุณยังสามารถใช้เมธอด catch เพื่อจัดการ promise ที่ถูกปฏิเสธ โดยส่งผ่านฟังก์ชัน callback เป็นอาร์กิวเมนต์แรก ฟังก์ชัน callback จะมีอ็อบเจกต์ error เป็นพารามิเตอร์ ซึ่งมีข้อความแสดงข้อผิดพลาด รหัส คำขอ และการตอบสนอง คุณสามารถใช้คุณสมบัติ error.response เพื่อเข้าถึงอ็อบเจกต์การตอบสนอง และคุณสมบัติ error.request เพื่อเข้าถึงอ็อบเจกต์คำขอ
5. อีกวิธีหนึ่ง คุณสามารถใช้ไวยากรณ์ async/await เพื่อสร้างคำขอ GET และจัดการการตอบสนอง ในการทำเช่นนี้ คุณต้องใช้คีย์เวิร์ด async ก่อนฟังก์ชันที่มีคำขอ GET และคีย์เวิร์ด await ก่อนเมธอด axios.get ซึ่งจะช่วยให้คุณเขียนโค้ดแบบอะซิงโครนัสในลักษณะซิงโครนัส และกำหนดอ็อบเจกต์ response ให้กับตัวแปร จากนั้นคุณสามารถใช้บล็อก try/catch เพื่อจัดการข้อผิดพลาดที่อาจเกิดขึ้นระหว่างคำขอ GET

ตัวอย่างวิธีสร้างคำขอ GET ใน Node.js โดยใช้ไลบรารี axios:

// นำเข้าไลบรารี axios
const axios = require('axios');

// สร้างคำขอ GET โดยใช้เมธอด then
axios.get('http://api.openweathermap.org/data/2.5/weather?q=Los%20Angeles&appid=YOUR_API_KEY', {
  headers: {
    'User-Agent': 'Node.js'
  }
}).then((response) => {
// บันทึกรหัสสถานะและส่วนหัว
  console.log(`Status code: ${response.status}`);
  console.log(`Headers: ${JSON.stringify(response.headers)}`);

  // บันทึกข้อมูลสภาพอากาศ
  console.log(`City: ${response.data.name}`);
  console.log(`Temperature: ${response.data.main.temp}`);
  console.log(`Description: ${response.data.weather[0].description}`);
}).catch((error) => {
  // บันทึกข้อความแสดงข้อผิดพลาดและรหัส
  console.log(`Error message: ${error.message}`);
  console.log(`Error code: ${error.code}`);

  // บันทึกสถานะการตอบสนองและข้อมูลหากมี
  if (error.response) {
    console.log(`Response status: ${error.response.status}`);
    console.log(`Response data: ${JSON.stringify(error.response.data)}`);
  }

  // บันทึกเมธอดคำขอและเส้นทางหากมี
  if (error.request) {
    console.log(`Request method: ${error.request.method}`);
    console.log(`Request path: ${error.request.path}`);
  }
});

// สร้างคำขอ GET โดยใช้ไวยากรณ์ async/await
async function getWeather() {
  try {
    // รอคำขอ GET และกำหนดอ็อบเจกต์การตอบสนองให้กับตัวแปร
    const response = await axios.get('http://api.openweathermap.org/data/2.5/weather?q=Los%20Angeles&appid=YOUR_API_KEY', {
      headers: {
        'User-Agent': 'Node.js'
      }
    });

    // บันทึกรหัสสถานะและส่วนหัว
    console.log(`Status code: ${response.status}`);
    console.log(`Headers: ${JSON.stringify(response.headers)}`);

    // บันทึกข้อมูลสภาพอากาศ
    console.log(`City: ${response.data.name}`);
    console.log(`Temperature: ${response.data.main.temp}`);
    console.log(`Description: ${response.data.weather[0].description}`);
  } catch (error) {
    // บันทึกข้อความแสดงข้อผิดพลาดและรหัส
    console.log(`Error message: ${error.message}`);
    console.log(`Error code: ${error.code}`);

    // บันทึกสถานะการตอบสนองและข้อมูลหากมี
    if (error.response) {
      console.log(`Response status: ${error.response.status}`);
      console.log(`Response data: ${JSON.stringify(error.response.data)}`);
    }

    // บันทึกเมธอดคำขอและเส้นทางหากมี
    if (error.request) {
      console.log(`Request method: ${error.request.method}`);
      console.log(`Request path: ${error.request.path}`);
    }
  }
}

// เรียกใช้ฟังก์ชัน getWeather
getWeather();

วิธีการจัดการข้อมูลการตอบสนองใน Node.js

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

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

• หากข้อมูลการตอบสนองเป็นสตริง คุณสามารถใช้เมธอด console.log เพื่อแสดงข้อมูลบนคอนโซล หรือเมธอด fs.writeFile เพื่อบันทึกข้อมูลลงในไฟล์ โมดูล fs เป็นโมดูลในตัวที่ช่วยให้คุณทำงานกับระบบไฟล์ใน Node.js ได้ คุณสามารถนำเข้าโมดูล fs โดยใช้ฟังก์ชัน require และใช้เมธอด fs.writeFile เพื่อเขียนข้อมูลลงในไฟล์ โดยส่งผ่านชื่อไฟล์ ข้อมูล และฟังก์ชัน callback เป็นอาร์กิวเมนต์ ฟังก์ชัน callback จะมีอ็อบเจกต์ error เป็นพารามิเตอร์ และคุณสามารถใช้เพื่อจัดการข้อผิดพลาดที่อาจเกิดขึ้นระหว่างกระบวนการเขียนไฟล์
• หากข้อมูลการตอบสนองเป็นบัฟเฟอร์ คุณสามารถใช้เมธอด buffer.toString เพื่อแปลงบัฟเฟอร์เป็นสตริง จากนั้นใช้วิธีการเดียวกันกับด้านบนเพื่อแสดงหรือบันทึกข้อมูล บัฟเฟอร์เป็นชนิดข้อมูลไบนารีที่แสดงถึงลำดับของไบต์ บัฟเฟอร์มักใช้เพื่อจัดการข้อมูลไบนารี เช่น รูปภาพ วิดีโอ หรือไฟล์ที่ถูกบีบอัด คุณสามารถใช้เมธอด buffer.toString เพื่อแปลงบัฟเฟอร์เป็นสตริง โดยส่งผ่านอาร์กิวเมนต์การเข้ารหัสที่เป็นตัวเลือกเพื่อระบุการเข้ารหัสอักขระของสตริง การเข้ารหัสเริ่มต้นคือ utf8 ซึ่งเป็นการเข้ารหัสที่พบบ่อยที่สุดสำหรับข้อมูลข้อความ
• หากข้อมูลการตอบสนองเป็น JSON คุณสามารถใช้เมธอด JSON.parse เพื่อแยกวิเคราะห์ข้อมูลเป็นอ็อบเจกต์ JavaScript จากนั้นใช้คุณสมบัติและเมธอดของอ็อบเจกต์เพื่อเข้าถึงและจัดการข้อมูล JSON ย่อมาจาก JavaScript Object Notation ซึ่งเป็นรูปแบบมาตรฐานสำหรับการแลกเปลี่ยนและจัดเก็บข้อมูล ข้อมูล JSON เป็นสตริงที่เป็นไปตามไวยากรณ์เฉพาะ ซึ่งประกอบด้วยคู่คีย์-ค่าที่อยู่ในวงเล็บปีกกา และอาร์เรย์ที่อยู่ในวงเล็บเหลี่ยม คุณสามารถใช้เมธอด JSON.parse เพื่อแยกวิเคราะห์สตริง JSON เป็นอ็อบเจกต์ JavaScript โดยส่งผ่านสตริง JSON เป็นอาร์กิวเมนต์ เมธอดจะส่งคืนอ็อบเจกต์ JavaScript ที่คุณสามารถใช้ได้เหมือนกับอ็อบเจกต์อื่นๆ
• หากข้อมูลการตอบสนองเป็น XML คุณสามารถใช้ไลบรารี xml2js เพื่อแยกวิเคราะห์ข้อมูลเป็นอ็อบเจกต์ JavaScript จากนั้นใช้คุณสมบัติและเมธอดของอ็อบเจกต์เพื่อเข้าถึงและจัดการข้อมูล XML ย่อมาจาก Extensible Markup Language ซึ่งเป็นรูปแบบมาตรฐานอีกรูปแบบหนึ่งสำหรับการแลกเปลี่ยนและจัดเก็บข้อมูล ข้อมูล XML เป็นสตริงที่เป็นไปตามไวยากรณ์เฉพาะ ซึ่งประกอบด้วยองค์ประกอบที่อยู่ในแท็ก แอตทริบิวต์ที่อยู่ในเครื่องหมายคำพูด และเนื้อหาข้อความ ไลบรารี xml2js เป็นไลบรารีของบุคคลที่สามที่ช่วยให้คุณสามารถแปลงข้อมูล XML เป็นอ็อบเจกต์ JavaScript และในทางกลับกัน คุณสามารถติดตั้งไลบรารี xml2js โดยใช้คำสั่ง npm: npm install xml2js คุณสามารถนำเข้าไลบรารี xml2js โดยใช้ฟังก์ชัน require และใช้เมธอด xml2js.parseString เพื่อแยกวิเคราะห์สตริง XML เป็นอ็อบเจกต์ JavaScript โดยส่งผ่านสตริง XML และฟังก์ชัน callback เป็นอาร์กิวเมนต์ ฟังก์ชัน callback จะมีอ็อบเจกต์ error และอ็อบเจกต์ result เป็นพารามิเตอร์ และคุณสามารถใช้เพื่อจัดการข้อผิดพลาดหรือเข้าถึงอ็อบเจกต์ที่แยกวิเคราะห์ได้

วิธีการทดสอบคำขอ GET HTTP NodeJs โดยใช้ Apidog

ในการทดสอบคำขอ GET HTTP โดยใช้ Apidog คุณต้องทำตามขั้นตอนง่ายๆ เหล่านี้:

1. เปิด Apidog และคลิกที่ปุ่ม "New Request" เพื่อสร้างคำขอใหม่

2. เลือก "GET" เป็นเมธอดของคำขอ

3. ป้อน URL ของจุดสิ้นสุด API

จากนั้นคลิกที่ปุ่ม "Send" เพื่อส่งคำขอไปยัง API

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

บทสรุป

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

ขอบคุณสำหรับการอ่านและขอให้สนุกกับการเขียนโค้ด!