M

MLOG

தமிழ்

வலுவான, பராமரிக்கக்கூடிய மற்றும் பிழையற்ற வலைப் பயன்பாடுகளுக்கு டைப்ஸ்கிரிப்டில் டைப்-சேஃப் ஏபிஐ அழைப்புகளில் தேர்ச்சி பெறுங்கள். சிறந்த நடைமுறைகள் மற்றும் மேம்பட்ட நுட்பங்களைக் கற்றுக்கொள்ளுங்கள்.

டைப்ஸ்கிரிப்ட் உடன் டைப்-சேஃப் ஏபிஐ அழைப்புகள்: ஒரு விரிவான வழிகாட்டி

நவீன வலை உருவாக்கத்தில், ஏபிஐகளுடன் தொடர்புகொள்வது ஒரு அடிப்படைப் பணியாகும். டைப்ஸ்கிரிப்ட், அதன் சக்திவாய்ந்த டைப் சிஸ்டம் மூலம், டைப்-சேஃப் ஏபிஐ அழைப்புகளை இயக்குவதன் மூலம் உங்கள் பயன்பாடுகளின் நம்பகத்தன்மை மற்றும் பராமரிப்பை உறுதி செய்வதில் ஒரு குறிப்பிடத்தக்க நன்மையை வழங்குகிறது. இந்த வழிகாட்டி, டைப்ஸ்கிரிப்ட்டின் அம்சங்களைப் பயன்படுத்தி வலுவான மற்றும் பிழையற்ற ஏபிஐ தொடர்புகளை உருவாக்குவது எப்படி என்பதை ஆராயும், சிறந்த நடைமுறைகள், மேம்பட்ட நுட்பங்கள் மற்றும் நிஜ-உலக உதாரணங்களை உள்ளடக்கியது.

ஏபிஐ அழைப்புகளுக்கு டைப் சேஃப்டி ஏன் முக்கியம்

ஏபிஐகளுடன் பணிபுரியும் போது, நீங்கள் அடிப்படையில் ஒரு வெளிப்புற மூலத்திலிருந்து வரும் தரவைக் கையாளுகிறீர்கள். இந்தத் தரவு நீங்கள் எதிர்பார்க்கும் வடிவத்தில் எப்போதும் இல்லாமல் இருக்கலாம், இது இயக்க நேரப் பிழைகள் (runtime errors) மற்றும் எதிர்பாராத நடத்தைக்கு வழிவகுக்கும். டைப் சேஃப்டி நீங்கள் பெறும் தரவு ஒரு முன்வரையறுக்கப்பட்ட கட்டமைப்பிற்கு இணங்குவதை சரிபார்ப்பதன் மூலம் ஒரு முக்கியமான பாதுகாப்பு அடுக்கை வழங்குகிறது, இது மேம்பாட்டு செயல்முறையின் ஆரம்பத்திலேயே சாத்தியமான சிக்கல்களைக் கண்டறிய உதவுகிறது.

உங்கள் டைப்ஸ்கிரிப்ட் திட்டத்தை அமைத்தல்

ஏபிஐ அழைப்புகளுக்குள் நுழைவதற்கு முன், உங்களிடம் ஒரு டைப்ஸ்கிரிப்ட் திட்டம் அமைக்கப்பட்டுள்ளதா என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள். நீங்கள் புதிதாகத் தொடங்குகிறீர்கள் என்றால், இதைப் பயன்படுத்தி ஒரு புதிய திட்டத்தை தொடங்கலாம்:

npm init -y
npm install typescript --save-dev
tsc --init

இது இயல்புநிலை டைப்ஸ்கிரிப்ட் கம்பைலர் விருப்பங்களுடன் ஒரு `tsconfig.json` கோப்பை உருவாக்கும். உங்கள் திட்டத்தின் தேவைகளுக்கு ஏற்ப இந்த விருப்பங்களைத் தனிப்பயனாக்கலாம். எடுத்துக்காட்டாக, கடுமையான டைப் சரிபார்ப்புக்கு நீங்கள் ஸ்ட்ரிக்ட் மோடை இயக்க விரும்பலாம்:

// tsconfig.json
{
  "compilerOptions": {
    "target": "es5",
    "module": "commonjs",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  }
}

ஏபிஐ பதில்களுக்கான டைப்களை வரையறுத்தல்

டைப்-சேஃப் ஏபிஐ அழைப்புகளை அடைவதற்கான முதல் படி, ஏபிஐயிலிருந்து நீங்கள் பெற எதிர்பார்க்கும் தரவின் கட்டமைப்பைக் குறிக்கும் டைப்ஸ்கிரிப்ட் டைப்களை வரையறுப்பதாகும். இது பொதுவாக `interface` அல்லது `type` அறிவிப்புகளைப் பயன்படுத்தி செய்யப்படுகிறது.

இன்டர்ஃபேஸ்களைப் பயன்படுத்துதல்

இன்டர்ஃபேஸ்கள் ஒரு பொருளின் வடிவத்தை வரையறுக்க ஒரு சக்திவாய்ந்த வழியாகும். எடுத்துக்காட்டாக, நீங்கள் ஒரு ஏபிஐயிலிருந்து பயனர்களின் பட்டியலைப் பெறுகிறீர்கள் என்றால், நீங்கள் இதுபோன்ற ஒரு இன்டர்ஃபேஸை வரையறுக்கலாம்:

interface User {
  id: number;
  name: string;
  email: string;
  address?: string; // Optional property
  phone?: string; // Optional property
  website?: string; // Optional property
  company?: {
    name: string;
    catchPhrase: string;
    bs: string;
  };
}

ஒரு ப்ராபர்ட்டி பெயருக்குப் பிறகு உள்ள `?` குறியீடு அந்த ப்ராபர்ட்டி விருப்பத்தேர்வு (optional) என்பதைக் குறிக்கிறது. சில புலங்கள் விடுபட்டிருக்கக்கூடிய ஏபிஐ பதில்களைக் கையாள இது பயனுள்ளதாக இருக்கும்.

டைப்களைப் பயன்படுத்துதல்

டைப்கள் இன்டர்ஃபேஸ்களைப் போலவே இருக்கின்றன, ஆனால் யூனியன் டைப்கள் மற்றும் இன்டர்செக்ஷன் டைப்களை வரையறுக்கும் திறன் உட்பட அதிக நெகிழ்வுத்தன்மையை வழங்குகின்றன. மேலே உள்ள இன்டர்ஃபேஸைப் போன்ற அதே முடிவை ஒரு டைப்பைப் பயன்படுத்தி நீங்கள் அடையலாம்:

type User = {
  id: number;
  name: string;
  email: string;
  address?: string; // Optional property
  phone?: string; // Optional property
  website?: string; // Optional property
  company?: {
    name: string;
    catchPhrase: string;
    bs: string;
  };
};

எளிய பொருள் கட்டமைப்புகளுக்கு, இன்டர்ஃபேஸ்களும் டைப்களும் பெரும்பாலும் ஒன்றுக்கொன்று மாற்றாகப் பயன்படுத்தப்படுகின்றன. இருப்பினும், மிகவும் சிக்கலான சூழ்நிலைகளைக் கையாளும் போது டைப்கள் மிகவும் சக்திவாய்ந்ததாகின்றன.

ஆக்சியோஸ் மூலம் ஏபிஐ அழைப்புகளைச் செய்தல்

ஆக்சியோஸ் என்பது ஜாவாஸ்கிரிப்ட் மற்றும் டைப்ஸ்கிரிப்டில் ஏபிஐ கோரிக்கைகளைச் செய்வதற்கான ஒரு பிரபலமான HTTP கிளையன்ட் ஆகும். இது ஒரு தெளிவான மற்றும் உள்ளுணர்வு ஏபிஐயை வழங்குகிறது, இது வெவ்வேறு HTTP முறைகள், கோரிக்கை ஹெடர்கள் மற்றும் ரெஸ்பான்ஸ் தரவைக் கையாள்வதை எளிதாக்குகிறது.

ஆக்சியோஸை நிறுவுதல்

npm install axios

ஒரு டைப்டு ஏபிஐ அழைப்பைச் செய்தல்

ஆக்சியோஸ் மூலம் டைப்-சேஃப் ஏபிஐ அழைப்பைச் செய்ய, நீங்கள் `axios.get` முறையைப் பயன்படுத்தலாம் மற்றும் ஜெனரிக்குகளைப் பயன்படுத்தி எதிர்பார்க்கப்படும் ரெஸ்பான்ஸ் டைப்பை குறிப்பிடலாம்:

import axios from 'axios';

async function fetchUsers(): Promise {
  try {
    const response = await axios.get('https://jsonplaceholder.typicode.com/users');
    return response.data;
  } catch (error) {
    console.error('Error fetching users:', error);
    throw error;
  }
}

fetchUsers().then(users => {
  users.forEach(user => {
    console.log(user.name);
  });
});

இந்த எடுத்துக்காட்டில், `axios.get('...')` என்பது ரெஸ்பான்ஸ் தரவு `User` பொருட்களின் வரிசையாக (array) இருக்கும் என்று டைப்ஸ்கிரிப்ட்டிடம் கூறுகிறது. இது ரெஸ்பான்ஸ் தரவுடன் பணிபுரியும் போது டைப் சரிபார்ப்பு மற்றும் ஆட்டோகம்ப்ளீஷனை வழங்க டைப்ஸ்கிரிப்டை அனுமதிக்கிறது.

வெவ்வேறு HTTP முறைகளைக் கையாளுதல்

ஆக்சியோஸ் `GET`, `POST`, `PUT`, `DELETE`, மற்றும் `PATCH` உள்ளிட்ட பல்வேறு HTTP முறைகளை ஆதரிக்கிறது. வெவ்வேறு வகையான ஏபிஐ கோரிக்கைகளைச் செய்ய நீங்கள் தொடர்புடைய முறைகளைப் பயன்படுத்தலாம். எடுத்துக்காட்டாக, ஒரு புதிய பயனரை உருவாக்க, நீங்கள் `axios.post` முறையைப் பயன்படுத்தலாம்:

async function createUser(user: Omit): Promise {
  try {
    const response = await axios.post('https://jsonplaceholder.typicode.com/users', user);
    return response.data;
  } catch (error) {
    console.error('Error creating user:', error);
    throw error;
  }
}

const newUser = {
  name: 'John Doe',
  email: 'john.doe@example.com',
  address: '123 Main St',
  phone: '555-1234',
  website: 'example.com',
  company: {
    name: 'Example Corp',
    catchPhrase: 'Leading the way',
    bs: 'Innovative solutions'
  }
};

createUser(newUser).then(user => {
  console.log('Created user:', user);
});

இந்த எடுத்துக்காட்டில், `Omit` என்பது `User`-ஐப் போன்ற ஒரு டைப்பை உருவாக்குகிறது, ஆனால் `id` ப்ராபர்ட்டி இல்லாமல். இது பயனுள்ளதாக இருக்கும், ஏனெனில் `id` பொதுவாக ஒரு புதிய பயனரை உருவாக்கும் போது சர்வரால் உருவாக்கப்படுகிறது.

ஃபெட்ச் ஏபிஐயைப் பயன்படுத்துதல்

ஃபெட்ச் ஏபிஐ என்பது HTTP கோரிக்கைகளைச் செய்வதற்கான ஒரு உள்ளமைக்கப்பட்ட ஜாவாஸ்கிரிப்ட் ஏபிஐ ஆகும். இது ஆக்சியோஸை விட அடிப்படையானது என்றாலும், டைப்-சேஃப் ஏபிஐ அழைப்புகளை அடைய டைப்ஸ்கிரிப்டுடன் இதையும் பயன்படுத்தலாம். உங்கள் தேவைகளுக்குப் பொருத்தமாக இருந்தால், ஒரு சார்புநிலையை (dependency) சேர்ப்பதைத் தவிர்க்க நீங்கள் இதை விரும்பலாம்.

ஃபெட்ச் மூலம் ஒரு டைப்டு ஏபிஐ அழைப்பைச் செய்தல்

ஃபெட்ச் மூலம் டைப்-சேஃப் ஏபிஐ அழைப்பைச் செய்ய, நீங்கள் `fetch` செயல்பாட்டைப் பயன்படுத்தலாம், பின்னர் ரெஸ்பான்ஸை JSON ஆகப் பிரித்து, எதிர்பார்க்கப்படும் ரெஸ்பான்ஸ் டைப்பைக் குறிப்பிடலாம்:

async function fetchUsers(): Promise {
  try {
    const response = await fetch('https://jsonplaceholder.typicode.com/users');
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const data: User[] = await response.json();
    return data;
  } catch (error) {
    console.error('Error fetching users:', error);
    throw error;
  }
}

fetchUsers().then(users => {
  users.forEach(user => {
    console.log(user.name);
  });
});

இந்த எடுத்துக்காட்டில், `const data: User[] = await response.json();` என்பது ரெஸ்பான்ஸ் தரவு `User` பொருட்களின் வரிசையாகக் கருதப்பட வேண்டும் என்று டைப்ஸ்கிரிப்டிடம் கூறுகிறது. இது டைப் சரிபார்ப்பு மற்றும் ஆட்டோகம்ப்ளீஷனைச் செய்ய டைப்ஸ்கிரிப்டை அனுமதிக்கிறது.

ஃபெட்ச் மூலம் வெவ்வேறு HTTP முறைகளைக் கையாளுதல்

ஃபெட்ச் மூலம் வெவ்வேறு வகையான ஏபிஐ கோரிக்கைகளைச் செய்ய, நீங்கள் `method` மற்றும் `body` விருப்பங்கள் போன்ற வெவ்வேறு விருப்பங்களுடன் `fetch` செயல்பாட்டைப் பயன்படுத்தலாம். எடுத்துக்காட்டாக, ஒரு புதிய பயனரை உருவாக்க, நீங்கள் பின்வரும் கோடைப் பயன்படுத்தலாம்:

async function createUser(user: Omit): Promise {
  try {
    const response = await fetch('https://jsonplaceholder.typicode.com/users', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(user)
    });
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const data: User = await response.json();
    return data;
  } catch (error) {
    console.error('Error creating user:', error);
    throw error;
  }
}

const newUser = {
  name: 'John Doe',
  email: 'john.doe@example.com',
  address: '123 Main St',
  phone: '555-1234',
  website: 'example.com',
  company: {
    name: 'Example Corp',
    catchPhrase: 'Leading the way',
    bs: 'Innovative solutions'
  }
};

createUser(newUser).then(user => {
  console.log('Created user:', user);
});

ஏபிஐ பிழைகளைக் கையாளுதல்

பிழை கையாளுதல் என்பது ஏபிஐ அழைப்புகளின் ஒரு முக்கியமான அம்சமாகும். நெட்வொர்க் இணைப்பு சிக்கல்கள், சர்வர் பிழைகள் மற்றும் செல்லுபடியாகாத கோரிக்கைகள் உட்பட பல காரணங்களுக்காக ஏபிஐகள் தோல்வியடையக்கூடும். உங்கள் பயன்பாடு செயலிழப்பதைத் தடுக்க அல்லது எதிர்பாராத நடத்தையைக் காண்பிப்பதைத் தடுக்க இந்தப் பிழைகளை அழகாகக் கையாள்வது அவசியம்.

Try-Catch பிளாக்குகளைப் பயன்படுத்துதல்

ஒத்திசைவற்ற (asynchronous) கோடில் பிழைகளைக் கையாள்வதற்கான மிகவும் பொதுவான வழி try-catch பிளாக்குகளைப் பயன்படுத்துவதாகும். ஏபிஐ அழைப்பின் போது எறியப்படும் எந்த விதிவிலக்குகளையும் பிடித்து அவற்றை முறையாகக் கையாள இது உங்களை அனுமதிக்கிறது.

async function fetchUsers(): Promise {
  try {
    const response = await axios.get('https://jsonplaceholder.typicode.com/users');
    return response.data;
  } catch (error) {
    console.error('Error fetching users:', error);
    // Handle the error, e.g., display an error message to the user
    throw error; // Re-throw the error to allow calling code to handle it as well
  }
}

குறிப்பிட்ட பிழைக் குறியீடுகளைக் கையாளுதல்

ஏபிஐகள் பெரும்பாலும் ஏற்பட்ட பிழையின் வகையைக் குறிக்க குறிப்பிட்ட பிழைக் குறியீடுகளைத் தருகின்றன. மேலும் குறிப்பிட்ட பிழை கையாளுதலை வழங்க இந்த பிழைக் குறியீடுகளை நீங்கள் பயன்படுத்தலாம். எடுத்துக்காட்டாக, நீங்கள் 500 உள் சர்வர் பிழைக்கு (Internal Server Error) பதிலாக 404 கிடைக்கவில்லை (Not Found) பிழைக்கு வேறு பிழைச் செய்தியைக் காட்ட விரும்பலாம்.

async function fetchUser(id: number): Promise {
  try {
    const response = await axios.get(`https://jsonplaceholder.typicode.com/users/${id}`);
    return response.data;
  } catch (error: any) {
    if (error.response?.status === 404) {
      console.log(`User with ID ${id} not found.`);
      return null; // Or throw a custom error
    } else {
      console.error('Error fetching user:', error);
      throw error;
    }
  }
}

fetchUser(123).then(user => {
  if (user) {
    console.log('User:', user);
  } else {
    console.log('User not found.');
  }
});

தனிப்பயன் பிழை டைப்களை உருவாக்குதல்

மிகவும் சிக்கலான பிழை கையாளுதல் சூழ்நிலைகளுக்கு, வெவ்வேறு வகையான ஏபிஐ பிழைகளைக் குறிக்க நீங்கள் தனிப்பயன் பிழை டைப்களை உருவாக்கலாம். இது மேலும் கட்டமைக்கப்பட்ட பிழைத் தகவலை வழங்கவும், பிழைகளை மிகவும் திறம்பட கையாளவும் உங்களை அனுமதிக்கிறது.

class ApiError extends Error {
  constructor(public statusCode: number, message: string) {
    super(message);
    this.name = 'ApiError';
  }
}

async function fetchUser(id: number): Promise {
  try {
    const response = await axios.get(`https://jsonplaceholder.typicode.com/users/${id}`);
    return response.data;
  } catch (error: any) {
    if (error.response?.status === 404) {
      throw new ApiError(404, `User with ID ${id} not found.`);
    } else {
      console.error('Error fetching user:', error);
      throw new ApiError(500, 'Internal Server Error'); //Or any other suitable status code
    }
  }
}

fetchUser(123).catch(error => {
  if (error instanceof ApiError) {
    console.error(`API Error: ${error.statusCode} - ${error.message}`);
  } else {
    console.error('An unexpected error occurred:', error);
  }
});

தரவு சரிபார்ப்பு

டைப்ஸ்கிரிப்டின் டைப் சிஸ்டம் இருந்தாலும், ஏபிஐகளிலிருந்து நீங்கள் பெறும் தரவை இயக்க நேரத்தில் (runtime) சரிபார்ப்பது முக்கியம். ஏபிஐகள் அறிவிப்பு இல்லாமல் தங்கள் ரெஸ்பான்ஸ் கட்டமைப்பை மாற்றக்கூடும், மேலும் உங்கள் டைப்ஸ்கிரிப்ட் டைப்கள் எப்போதும் ஏபிஐயின் உண்மையான ரெஸ்பான்ஸுடன் சரியாக ஒத்திசைக்கப்படாமல் இருக்கலாம்.

இயக்க நேர சரிபார்ப்புக்கு ஸாட் (Zod) பயன்படுத்துதல்

ஸாட் (Zod) என்பது இயக்க நேர தரவு சரிபார்ப்பிற்கான ஒரு பிரபலமான டைப்ஸ்கிரிப்ட் லைப்ரரி ஆகும். இது உங்கள் தரவின் எதிர்பார்க்கப்படும் கட்டமைப்பை விவரிக்கும் ஸ்கீமாக்களை வரையறுக்கவும், பின்னர் இயக்க நேரத்தில் அந்த ஸ்கீமாக்களுக்கு எதிராக தரவைச் சரிபார்க்கவும் உங்களை அனுமதிக்கிறது.

ஸாட் (Zod) நிறுவுதல்

npm install zod

ஸாட் (Zod) உடன் ஏபிஐ பதில்களை சரிபார்த்தல்

ஸாட் (Zod) உடன் ஏபிஐ பதில்களைச் சரிபார்க்க, உங்கள் டைப்ஸ்கிரிப்ட் டைப்பிற்குப் பொருத்தமான ஒரு ஸாட் ஸ்கீமாவை வரையறுத்து, பின்னர் தரவைச் சரிபார்க்க `parse` முறையைப் பயன்படுத்தலாம்.

import { z } from 'zod';

const userSchema = z.object({
  id: z.number(),
  name: z.string(),
  email: z.string().email(),
  address: z.string().optional(),
  phone: z.string().optional(),
  website: z.string().optional(),
  company: z.object({
    name: z.string(),
    catchPhrase: z.string(),
    bs: z.string(),
  }).optional(),
});

type User = z.infer;

async function fetchUsers(): Promise {
  try {
    const response = await axios.get('https://jsonplaceholder.typicode.com/users');
    const data = z.array(userSchema).parse(response.data);
    return data;
  } catch (error) {
    console.error('Error fetching users:', error);
    throw error;
  }
}

இந்த எடுத்துக்காட்டில், `z.array(userSchema).parse(response.data)` ரெஸ்பான்ஸ் தரவு `userSchema`-க்கு இணங்கக்கூடிய பொருட்களின் வரிசையா என்பதைச் சரிபார்க்கிறது. தரவு ஸ்கீமாவுக்கு இணங்கவில்லை என்றால், ஸாட் ஒரு பிழையை எறியும், அதை நீங்கள் முறையாகக் கையாளலாம்.

மேம்பட்ட நுட்பங்கள்

மறுபயன்பாட்டு ஏபிஐ செயல்பாடுகளுக்கு ஜெனரிக்குகளைப் பயன்படுத்துதல்

ஜெனரிக்குகள் வெவ்வேறு வகையான தரவைக் கையாளக்கூடிய மறுபயன்பாட்டு ஏபிஐ செயல்பாடுகளை எழுத உங்களை அனுமதிக்கின்றன. எடுத்துக்காட்டாக, எந்தவொரு ஏபிஐ எண்ட்பாயிண்டிலிருந்தும் தரவைப் பெற்று சரியான டைப்புடன் அதைத் திருப்பக்கூடிய ஒரு பொதுவான `fetchData` செயல்பாட்டை நீங்கள் உருவாக்கலாம்.

async function fetchData(url: string): Promise {
  try {
    const response = await axios.get(url);
    return response.data;
  } catch (error) {
    console.error(`Error fetching data from ${url}:`, error);
    throw error;
  }
}

// Usage
fetchData('https://jsonplaceholder.typicode.com/users').then(users => {
  console.log('Users:', users);
});

fetchData<{ title: string; body: string }>('https://jsonplaceholder.typicode.com/todos/1').then(todo => {
    console.log('Todo', todo)
});

உலகளாவிய பிழை கையாளுதலுக்கு இன்டர்செப்டர்களைப் பயன்படுத்துதல்

ஆக்சியோஸ் உங்கள் கோடால் கையாளப்படுவதற்கு முன்பு கோரிக்கைகளையும் பதில்களையும் இடைமறிக்க உங்களை அனுமதிக்கும் இன்டர்செப்டர்களை வழங்குகிறது. பிழைகளைப் பதிவு செய்தல் அல்லது பயனருக்கு பிழைச் செய்திகளைக் காண்பித்தல் போன்ற உலகளாவிய பிழை கையாளுதலைச் செயல்படுத்த நீங்கள் இன்டர்செப்டர்களைப் பயன்படுத்தலாம்.

axios.interceptors.response.use(
  (response) => response,
  (error) => {
    console.error('Global error handler:', error);
    // Display an error message to the user
    return Promise.reject(error);
  }
);

ஏபிஐ URLகளுக்கு சுற்றுச்சூழல் மாறிகளைப் பயன்படுத்துதல்

உங்கள் கோடில் ஏபிஐ URLகளை ஹார்ட்கோட் செய்வதைத் தவிர்க்க, URLகளை சேமிக்க நீங்கள் சுற்றுச்சூழல் மாறிகளைப் பயன்படுத்தலாம். இது டெவலப்மென்ட், ஸ்டேஜிங் மற்றும் புரொடக்ஷன் போன்ற வெவ்வேறு சூழல்களுக்கு உங்கள் பயன்பாட்டை உள்ளமைப்பதை எளிதாக்குகிறது.

`.env` கோப்பு மற்றும் `dotenv` தொகுப்பைப் பயன்படுத்தும் உதாரணம்.

// .env
API_URL=https://api.example.com

// Install dotenv
npm install dotenv

// Import and configure dotenv
import * as dotenv from 'dotenv'
dotenv.config()

const apiUrl = process.env.API_URL || 'http://localhost:3000'; // provide a default value

async function fetchData(endpoint: string): Promise {
  try {
    const response = await axios.get(`${apiUrl}/${endpoint}`);
    return response.data;
  } catch (error) {
    console.error(`Error fetching data from ${apiUrl}/${endpoint}:`, error);
    throw error;
  }
}

முடிவுரை

வலுவான, பராமரிக்கக்கூடிய மற்றும் பிழையற்ற வலைப் பயன்பாடுகளை உருவாக்க டைப்-சேஃப் ஏபிஐ அழைப்புகள் அவசியம். ஏபிஐ பதில்களுக்கான டைப்களை வரையறுக்கவும், இயக்க நேரத்தில் தரவைச் சரிபார்க்கவும், பிழைகளை அழகாகக் கையாளவும் டைப்ஸ்கிரிப்ட் சக்திவாய்ந்த அம்சங்களை வழங்குகிறது. இந்த வழிகாட்டியில் கோடிட்டுக் காட்டப்பட்டுள்ள சிறந்த நடைமுறைகள் மற்றும் நுட்பங்களைப் பின்பற்றுவதன் மூலம், உங்கள் ஏபிஐ தொடர்புகளின் தரம் மற்றும் நம்பகத்தன்மையை நீங்கள் கணிசமாக மேம்படுத்தலாம்.

டைப்ஸ்கிரிப்ட் மற்றும் ஆக்சியோஸ், ஸாட் போன்ற லைப்ரரிகளைப் பயன்படுத்துவதன் மூலம், உங்கள் ஏபிஐ அழைப்புகள் டைப்-சேஃப் ஆக இருப்பதையும், உங்கள் தரவு சரிபார்க்கப்படுவதையும், உங்கள் பிழைகள் அழகாகக் கையாளப்படுவதையும் உறுதிசெய்யலாம். இது மேலும் வலுவான மற்றும் பராமரிக்கக்கூடிய பயன்பாடுகளுக்கு வழிவகுக்கும்.

டைப்ஸ்கிரிப்டின் டைப் சிஸ்டம் இருந்தாலும், உங்கள் தரவை எப்போதும் இயக்க நேரத்தில் சரிபார்க்க நினைவில் கொள்ளுங்கள். ஏபிஐகள் மாறலாம், மேலும் உங்கள் டைப்கள் ஏபிஐயின் உண்மையான ரெஸ்பான்ஸுடன் எப்போதும் சரியாக ஒத்திசைக்கப்படாமல் இருக்கலாம். இயக்க நேரத்தில் உங்கள் தரவைச் சரிபார்ப்பதன் மூலம், உங்கள் பயன்பாட்டில் சிக்கல்களை ஏற்படுத்துவதற்கு முன்பு சாத்தியமான சிக்கல்களை நீங்கள் கண்டறியலாம்.

மகிழ்ச்சியான கோடிங்!