Fetching Data in Different Languages (การ Fetch ข้อมูลในภาษาต่างๆ)

Basic Data Fetching (การดึงข้อมูลพื้นฐาน)

JavaScript

// ใช้ Fetch API พร้อม async/await
async function fetchData(url) {
  try {
    const response = await fetch(url);

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data = await response.json();
    console.log("ข้อมูลที่ได้รับ:", data);
    return data;
  } catch (error) {
    console.error("เกิดข้อผิดพลาดในการดึงข้อมูล:", error);
    throw error; // ส่งต่อ error ให้ caller จัดการต่อ
  }
}

// ใช้งาน
// fetchData('https://api.example.com/data');

Rust

use reqwest;
use serde_json::Value;
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let url = "https://api.example.com/data";
    match fetch_data(url).await {
        Ok(data) => println!("ข้อมูลที่ได้รับ: {:#?}", data),
        Err(e) => eprintln!("เกิดข้อผิดพลาด: {}", e),
    }
    Ok(())
}

async fn fetch_data(url: &str) -> Result<Value, Box<dyn Error>> {
    let response = reqwest::get(url).await?;
    
    if !response.status().is_success() {
        return Err(format!("HTTP error! status: {}", response.status()).into());
    }
    
    let data = response.json::<Value>().await?;
    Ok(data)
}

Python

import requests
from typing import Dict, Any

def fetch_data(url: str) -> Dict[str, Any]:
    """
    ดึงข้อมูลจาก API ที่ระบุ
    
    Args:
        url: URL ของ API ที่ต้องการดึงข้อมูล
        
    Returns:
        dict: ข้อมูลที่ได้จาก API
        
    Raises:
        Exception: เมื่อเกิดข้อผิดพลาดในการดึงข้อมูล
    """
    try:
        response = requests.get(url)
        response.raise_for_status()  # ตรวจสอบ HTTP error
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'เกิดข้อผิดพลาดในการเชื่อมต่อ: {e}')
        raise
    except ValueError as e:
        print(f'ไม่สามารถแปลงข้อมูลเป็น JSON ได้: {e}')
        raise

# ใช้งาน
# data = fetch_data('https://api.example.com/data')
# print(data)

Go

package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
)

// fetchData ดึงข้อมูลจาก URL ที่ระบุ
func fetchData(url string) (map[string]interface{}, error) {
	// สร้าง HTTP request
	resp, err := http.Get(url)
	if err != nil {
		return nil, fmt.Errorf("ไม่สามารถเชื่อมต่อกับเซิร์ฟเวอร์: %v", err)
	}
	defer resp.Body.Close()

	// ตรวจสอบ HTTP status code
	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("HTTP error! status: %s", resp.Status)
	}

	// อ่านข้อมูลจาก response body
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("ไม่สามารถอ่านข้อมูล: %v", err)
	}

	// แปลง JSON เป็น map
	var data map[string]interface{}
	if err := json.Unmarshal(body, &data); err != nil {
		return nil, fmt.Errorf("ไม่สามารถแปลงข้อมูล JSON: %v", err)
	}

	return data, nil
}

func main() {
	// ตัวอย่างการใช้งาน
	// data, err := fetchData("https://api.example.com/data")
	// if err != nil {
	// 	fmt.Printf("เกิดข้อผิดพลาด: %v\n", err)
	// 	return
	// }
	// fmt.Printf("ข้อมูลที่ได้รับ: %+v\n", data)
}

Advanced Fetching (การดึงข้อมูลแบบขั้นสูง)

1. Sending Headers and Query Parameters (การส่ง Headers และ Query Parameters)

JavaScript

async function fetchWithHeaders(url, params = {}) {
  try {
    // สร้าง URL พร้อม query parameters
    const urlObj = new URL(url);
    Object.entries(params).forEach(([key, value]) => {
      urlObj.searchParams.append(key, value);
    });

    const response = await fetch(urlObj, {
      headers: {
        "Authorization": "Bearer your_token_here",
        "Content-Type": "application/json",
      },
    });

    if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
    return await response.json();
  } catch (error) {
    console.error("เกิดข้อผิดพลาด:", error);
    throw error;
  }
}

Rust

use reqwest::header::{HeaderMap, HeaderValue, AUTHORIZATION, CONTENT_TYPE};
use std::error::Error;

async fn fetch_with_headers(url: &str, params: &[(&str, &str)]) -> Result<serde_json::Value, Box<dyn Error>> {
    let client = reqwest::Client::new();
    
    let mut headers = HeaderMap::new();
    headers.insert(AUTHORIZATION, "Bearer your_token_here".parse()?);
    headers.insert(CONTENT_TYPE, "application/json".parse()?);
    
    let response = client.get(url)
        .headers(headers)
        .query(params)
        .send()
        .await?;
    
    if !response.status().is_success() {
        return Err(format!("HTTP error! status: {}", response.status()).into());
    }
    
    let data = response.json::<serde_json::Value>().await?;
    Ok(data)
}

Python

def fetch_with_headers(url: str, params: dict = None, headers: dict = None) -> dict:
    """
    ดึงข้อมูลจาก API พร้อม headers และ query parameters
    
    Args:
        url: URL ของ API
        params: Query parameters (dict)
        headers: HTTP headers (dict)
        
    Returns:
        dict: ข้อมูลที่ได้จาก API
    """
    default_headers = {
        'Authorization': 'Bearer your_token_here',
        'Content-Type': 'application/json',
    }
    
    if headers:
        default_headers.update(headers)
    
    try:
        response = requests.get(
            url,
            params=params or {},
            headers=default_headers
        )
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'เกิดข้อผิดพลาด: {e}')
        raise

Go

func fetchWithHeaders(url string, params map[string]string, headers map[string]string) (map[string]interface{}, error) {
	// สร้าง HTTP client
	client := &http.Client{}

	// สร้าง request
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return nil, fmt.Errorf("ไม่สามารถสร้าง request: %v", err)
	}

	// เพิ่ม query parameters
	q := req.URL.Query()
	for key, value := range params {
		q.Add(key, value)
	}
	req.URL.RawQuery = q.Encode()

	// เพิ่ม headers
	req.Header.Add("Authorization", "Bearer your_token_here")
	req.Header.Add("Content-Type", "application/json")
	for key, value := range headers {
		req.Header.Add(key, value)
	}

	// ส่ง request
	resp, err := client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("ไม่สามารถส่ง request: %v", err)
	}
	defer resp.Body.Close()

	// ตรวจสอบ status code
	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("HTTP error! status: %s", resp.Status)
	}

	// อ่านและแปลงข้อมูล
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("ไม่สามารถอ่านข้อมูล: %v", err)
	}

	var data map[string]interface{}
	if err := json.Unmarshal(body, &data); err != nil {
		return nil, fmt.Errorf("ไม่สามารถแปลงข้อมูล JSON: %v", err)
	}

	return data, nil
}

Important Considerations (ข้อควรระวัง)

1. Error Handling (การจัดการข้อผิดพลาด)

   • ตรวจสอบ HTTP status code ทุกครั้ง
   • จัดการกับข้อผิดพลาดที่อาจเกิดขึ้นระหว่างการเชื่อมต่อ
   • ใช้ try-catch หรือ error handling ที่เหมาะสมกับภาษานั้นๆ

2. Security (ความปลอดภัย) อย่าเก็บ credentials (เช่น API keys) ในโค้ดโดยตรง

   • ใช้ environment variables แทน
   • ใช้ HTTPS เสมอเมื่อส่งข้อมูลที่ละเอียดอ่อน

3. Performance (ประสิทธิภาพ)

   • ใช้ connection pooling เมื่อทำได้
   • จำกัดจำนวน concurrent requests
   • ใช้ caching เมื่อเหมาะสม

4. Resource Management (การจัดการทรัพยากร)

   • ปิด connections เมื่อใช้งานเสร็จแล้ว (โดยเฉพาะในภาษา Go)
   • ใช้ defer หรือ finally เพื่อให้มั่นใจว่าทรัพยากรจะถูกปลดปล่อย

5. Rate Limiting (การจำกัดอัตราการเรียกใช้)

   • ตรวจสอบ Rate limits ของ API
   • ใช้ exponential backoff เมื่อเจอ rate limit
   • พิจารณาใช้ retry mechanism

6. Data Validation (การตรวจสอบข้อมูล)

   • ตรวจสอบโครงสร้างของข้อมูลที่ได้รับ
   • ใช้ type hints และ validation libraries เมื่อเป็นไปได้
   • เตรียมรับมือกับข้อมูลที่อาจจะไม่ครบถ้วนหรือไม่ถูกต้อง