എക്സ്ചേഞ്ച് നിരക്കുകൾ ലഭ്യമാക്കുമ്പോൾ JavaScript ഫംഗ്ഷൻ പിശകുകൾ പരിഹരിക്കുന്നു

JavaScript റേറ്റിംഗ് ഫംഗ്ഷനുകളിലെ പിശകുകൾ എങ്ങനെ പരിഹരിക്കാം

വെബ് ഡെവലപ്‌മെൻ്റിനുള്ള ഫലപ്രദമായ ഉപകരണമാണ് JavaScript, പ്രത്യേകിച്ച് ബാഹ്യ API-കളിൽ പ്രവർത്തിക്കുമ്പോൾ. എന്നിരുന്നാലും, API-കളിൽ നിന്ന് ഡാറ്റ വീണ്ടെടുക്കുന്നതിനുള്ള ഫംഗ്‌ഷനുകൾ എഴുതുമ്പോൾ പരിചയസമ്പന്നരായ ഡെവലപ്പർമാർ പോലും സാധാരണ തെറ്റുകൾ വരുത്തുന്നു. ഒരു ഫംഗ്ഷനിലേക്ക് ആർഗ്യുമെൻ്റുകൾ അയയ്‌ക്കാനും പ്രതികരണമായി നിർവചിക്കാത്ത മൂല്യങ്ങൾ നേടാനും ശ്രമിക്കുമ്പോൾ അത്തരത്തിലുള്ള ഒരു പ്രശ്‌നം സംഭവിക്കുന്നു.

രണ്ട് കറൻസികൾക്കിടയിലുള്ള ബിറ്റ്കോയിൻ നിരക്കുകൾ വീണ്ടെടുക്കുന്ന ഒരു JavaScript ഫംഗ്ഷൻ എഴുതുന്നതിലെ ബുദ്ധിമുട്ട് ഈ ലേഖനം ചർച്ചചെയ്യുന്നു. "റഫറൻസ് പിശക്: btc നിർവചിക്കപ്പെട്ടിട്ടില്ല" എന്ന പ്രശ്നം, തെറ്റായി വ്യക്തമാക്കിയ പാരാമീറ്ററുകളും വേരിയബിളുകളും കാരണമാണ്. കോഡ് ശരിയായി രൂപപ്പെടുത്തിയാൽ ഈ ആശങ്കകൾ ഒഴിവാക്കാനാകും.

എന്ന പേരിൽ ഒരു ഫംഗ്ഷൻ എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് ഞങ്ങൾ കാണിച്ചുതരാം താമ്രജാലം (നിന്ന്, വരെ), ഇത് രണ്ട് പാരാമീറ്ററുകൾ സ്വീകരിക്കുകയും രണ്ട് കറൻസികൾ തമ്മിലുള്ള വിനിമയ നിരക്ക് നൽകുകയും ചെയ്യുന്നു. ഈ പുസ്‌തകത്തിൻ്റെ അവസാനത്തോടെ, ഡാറ്റ നേടൽ പ്രക്രിയകളിൽ എങ്ങനെ ശരിയായി ആർഗ്യുമെൻ്റുകൾ കൈമാറാമെന്നും പിശകുകൾ നിയന്ത്രിക്കാമെന്നും നിങ്ങൾക്കറിയാം.

നിങ്ങൾക്ക് സമാനമായ പ്രശ്‌നങ്ങൾ അനുഭവപ്പെടുകയാണെങ്കിലോ "നിർവചിക്കാത്തതിൻ്റെ പ്രോപ്പർട്ടികൾ വായിക്കാൻ കഴിയില്ല ('റേറ്റിംഗ്'')" എന്ന പിശക് ലഭിക്കുകയാണെങ്കിൽ, ഈ ലേഖനം നിങ്ങളെ ട്രബിൾഷൂട്ട് ചെയ്യാനും അവ ഫലപ്രദമായി പരിഹരിക്കാനും സഹായിക്കും. ഈ പ്രശ്നങ്ങൾ എങ്ങനെ പരിഹരിക്കാമെന്ന് നമുക്ക് ഘട്ടം ഘട്ടമായി നോക്കാം.

ക്രിപ്‌റ്റോകറൻസി നിരക്കുകൾക്കായുള്ള API അഭ്യർത്ഥനകൾ JavaScript പ്രവർത്തനങ്ങൾ എങ്ങനെ കൈകാര്യം ചെയ്യുന്നുവെന്ന് മനസ്സിലാക്കുന്നു

ഇവിടെ നൽകിയിരിക്കുന്ന സ്ക്രിപ്റ്റുകൾ ജാവാസ്ക്രിപ്റ്റ് ഉപയോഗിച്ച് രണ്ട് കറൻസികൾക്കിടയിൽ ക്രിപ്റ്റോകറൻസി വിനിമയ നിരക്കുകൾ നേടുന്നതിനുള്ള ഇതര സാങ്കേതിക വിദ്യകൾ കാണിക്കുന്നു. ആദ്യ സ്ക്രിപ്റ്റ് XMLHttpRequest ഒബ്ജക്റ്റ് ഉപയോഗിക്കുന്നു, ഇത് ജാവാസ്ക്രിപ്റ്റിലെ അസിൻക്രണസ് HTTP അഭ്യർത്ഥനകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള പഴയ സാങ്കേതികതകളിലൊന്നാണ്. ചടങ്ങ് താമ്രജാലം (നിന്ന്, വരെ) രണ്ട് പാരാമീറ്ററുകൾ സ്വീകരിക്കുന്നു: പരിവർത്തനം ചെയ്യേണ്ട കറൻസികൾ. വിതരണം ചെയ്‌ത പാരാമീറ്ററുകളെ അടിസ്ഥാനമാക്കി ചലനാത്മകമായി ഒരു URL ജനറേറ്റുചെയ്യുന്നു, കൂടാതെ ഒരു അഭ്യർത്ഥന ബിറ്റ്‌പേയുടെ API എൻഡ്‌പോയിൻ്റിലേക്ക് അയയ്‌ക്കും. ഉത്തരം ലഭിച്ച ശേഷം, JSON.parse() ഉപയോഗിച്ച് ഡാറ്റ പാഴ്‌സ് ചെയ്യുന്നു ഡോക്യുമെൻ്റ് ബോഡിയിൽ വിനിമയ നിരക്ക് കാണിക്കുന്നു. ഈ പരിഹാരം പഴയ ബ്രൗസറുകളുമായി അനുയോജ്യത നിലനിർത്തുന്നു, എന്നാൽ രണ്ടാമത്തെ ഉദാഹരണത്തിൽ ചർച്ച ചെയ്യുന്ന വാഗ്ദാനങ്ങൾ പോലുള്ള ചില പുതിയ കഴിവുകൾ ഇതിന് ഇല്ല.

രണ്ടാമത്തെ ഉദാഹരണത്തിൽ, ഇതേ പ്രവൃത്തി ചെയ്യാൻ XMLHttpRequest-ന് പകരം Fetch API ഉപയോഗിക്കുന്നു. Fetch API കൂടുതൽ നിലവിലുള്ളതും നെറ്റ്‌വർക്ക് അഭ്യർത്ഥനകൾ നടത്തുന്നതിനുള്ള എളുപ്പവഴി വാഗ്ദാനം ചെയ്യുന്നതുമാണ്. അസിൻക്രണസ് ഫ്ലോ കൂടുതൽ വായിക്കാവുന്നതും കൈകാര്യം ചെയ്യാവുന്നതുമാക്കാനുള്ള വാഗ്ദാനങ്ങളെ ഇത് സ്വാധീനിക്കുന്നു. ഫംഗ്‌ഷൻ അഭ്യർത്ഥിക്കുമ്പോൾ, അത് അതേ URL-ലേക്ക് ഒരു HTTP അഭ്യർത്ഥന നടത്തുകയും പ്രതികരണത്തിനായി കാത്തിരിക്കുകയും ചെയ്യുന്നു. പ്രതികരണം ലഭിച്ച ശേഷം, അത് ഡാറ്റയെ JSON ഒബ്‌ജക്റ്റിലേക്ക് മാറ്റുകയും നിരക്ക് നേടുകയും ചെയ്യുന്നു. അഭ്യർത്ഥനയ്‌ക്കോ ഡാറ്റാ പ്രോസസ്സിംഗിനിടെയോ ഉണ്ടാകുന്ന എന്തെങ്കിലും പ്രശ്‌നങ്ങൾ ശേഖരിക്കുന്നതിനും നിയന്ത്രിക്കുന്നതിനും ശ്രമിക്കുക/ക്യാച്ച് ബ്ലോക്കുകൾ ഉപയോഗിച്ച് Fetch API പിശക് മാനേജ്‌മെൻ്റ് മെച്ചപ്പെടുത്തുന്നു.

മൂന്നാമത്തെ സ്ക്രിപ്റ്റ് ലക്ഷ്യമിടുന്നത് എ ബാക്കെൻഡ് പരിസ്ഥിതി കൂടാതെ Node.js-ൻ്റെ HTTP മൊഡ്യൂൾ ഉപയോഗിച്ച് API അന്വേഷണങ്ങൾ നടത്തുന്നു. വിനിമയ നിരക്കുകൾ വീണ്ടെടുക്കേണ്ട സെർവർ സൈഡ് ആപ്പുകൾ വികസിപ്പിക്കുന്നതിന് ഇത് പ്രത്യേകിച്ചും പ്രയോജനകരമാണ്. HTTP മൊഡ്യൂൾ Node.js-ൽ നിർമ്മിച്ചിരിക്കുന്നു കൂടാതെ HTTP പ്രവർത്തനങ്ങൾ നടത്താൻ ഡവലപ്പർമാരെ അനുവദിക്കുന്നു. ഈ ഫംഗ്‌ഷൻ മുമ്പത്തെ സ്‌ക്രിപ്‌റ്റുകളുടെ അതേ രീതിയിൽ URL സൃഷ്‌ടിക്കുന്നു, API-ലേക്ക് ഒരു GET കോൾ അയയ്‌ക്കുന്നു, തുടർന്ന് ലഭിച്ച ഡാറ്റ പാഴ്‌സ് ചെയ്യുന്നു. ഫലം ബ്രൗസറിൽ പ്രദർശിപ്പിക്കുന്നതിനുപകരം കൺസോളിൽ ലോഗിൻ ചെയ്‌തിരിക്കുന്നു, ഇത് വെബ് ബ്രൗസറുകൾ ആവശ്യമില്ലാത്ത ബാക്കെൻഡ് സാഹചര്യങ്ങൾക്ക് അനുയോജ്യമാക്കുന്നു.

അവസാനമായി, Fetch API സൊല്യൂഷൻ ശരിയായി പ്രവർത്തിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കാൻ ഒരു ജെസ്റ്റ് ടെസ്റ്റ് സ്യൂട്ട് ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. ജെസ്റ്റ് ഒരു ജനപ്രിയ ടെസ്റ്റിംഗ് ചട്ടക്കൂടാണ് jest-fetch-mock, ഞങ്ങളുടെ ടെസ്റ്റുകളിൽ API പ്രതികരണങ്ങൾ അനുകരിക്കാനാകും. നെറ്റ്‌വർക്ക് അന്വേഷണങ്ങൾ സൃഷ്ടിക്കാതെ തന്നെ ഡെവലപ്പർമാരെ അവരുടെ കോഡ് പരിശോധിക്കാൻ ഇത് പ്രാപ്‌തമാക്കുന്നു, ഇത് ടെസ്റ്റിംഗ് പ്രക്രിയയെ വേഗത്തിലാക്കുകയും സാധ്യതയുള്ള ബഗുകൾ വേർതിരിച്ചെടുക്കുകയും ചെയ്യുന്നു. വിവിധ സന്ദർഭങ്ങളിൽ ഉദ്ദേശിച്ചതുപോലെ ഫംഗ്‌ഷൻ നിർവ്വഹിക്കുന്നുവെന്ന് സ്ഥിരീകരിക്കുന്ന, നിരക്ക് ഡാറ്റ വിജയകരമായി നേടുകയും ഡോക്യുമെൻ്റ് ബോഡിയിൽ പ്രദർശിപ്പിക്കുകയും ചെയ്‌തെന്ന് പരിശോധനകൾ സ്ഥിരീകരിക്കുന്നു. ടെസ്റ്റിംഗ് എന്നത് വികസനത്തിൻ്റെ ഒരു പ്രധാന ഘടകമാണ്, പ്രത്യേകിച്ച് ബാഹ്യ API-കളിൽ പ്രവർത്തിക്കുമ്പോൾ, കാരണം ഇത് നേരത്തെ തന്നെ തെറ്റുകൾ കണ്ടെത്താനും ഉൽപ്പന്നത്തിൻ്റെ മൊത്തത്തിലുള്ള സ്ഥിരത മെച്ചപ്പെടുത്താനും സഹായിക്കുന്നു.

// Solution 1: Using XMLHTTPRequest to fetch cryptocurrency rates
function grate(from, to) {
  var burl = 'https://bitpay.com/rates/';
  var url = burl + from + '/' + to;
  var ourRequest = new XMLHttpRequest();
  ourRequest.open('GET', url, true);
  ourRequest.onload = function() {
    if (ourRequest.status >= 200 && ourRequest.status < 400) {
      var response = JSON.parse(ourRequest.responseText);
      document.body.innerHTML = 'Rate: ' + response.data.rate;
    } else {
      console.error('Error fetching the data');
    }
  };
  ourRequest.onerror = function() {
    console.error('Connection error');
  };
  ourRequest.send();
}
// Test the function with actual currency codes
grate('btc', 'usd');

// Solution 2: Using Fetch API for cleaner asynchronous requests
async function grate(from, to) {
  var burl = 'https://bitpay.com/rates/';
  var url = burl + from + '/' + to;
  try {
    let response = await fetch(url);
    if (!response.ok) throw new Error('Network response was not ok');
    let data = await response.json();
    document.body.innerHTML = 'Rate: ' + data.data.rate;
  } catch (error) {
    console.error('Fetch error: ', error);
  }
}
// Test the function with Fetch API
grate('btc', 'usd');

// Solution 3: Using Node.js HTTP module to fetch data from API
const http = require('http');
function grate(from, to) {
  const url = 'http://bitpay.com/rates/' + from + '/' + to;
  http.get(url, (resp) => {
    let data = '';
    resp.on('data', (chunk) => { data += chunk; });
    resp.on('end', () => {
      let rateData = JSON.parse(data);
      console.log('Rate: ' + rateData.data.rate);
    });
  }).on('error', (err) => {
    console.log('Error: ' + err.message);
  });
}
// Test the Node.js function
grate('btc', 'usd');

// Solution 4: Unit testing Fetch API using Jest
const fetchMock = require('jest-fetch-mock');
fetchMock.enableMocks();
test('grate() fetches correct rate data', async () => {
  fetch.mockResponseOnce(JSON.stringify({ data: { rate: 50000 }}));
  const rate = await grate('btc', 'usd');
  expect(document.body.innerHTML).toBe('Rate: 50000');
});

API അഭ്യർത്ഥനകൾക്കായി അസിൻക്രണസ് JavaScript ഫംഗ്‌ഷനുകൾ പര്യവേക്ഷണം ചെയ്യുന്നു

JavaScript-ൽ API-കൾക്കൊപ്പം പ്രവർത്തിക്കുമ്പോൾ അസിൻക്രണസ് അഭ്യർത്ഥനകൾ കൈകാര്യം ചെയ്യുന്നത് നിർണായകമാണ്. Fetch API, XMLHttpRequest എന്നിവ ഈ അഭ്യർത്ഥനകൾ നടത്തുന്നതിനുള്ള രണ്ട് അടിസ്ഥാന മാർഗങ്ങളാണ്. പ്രതികരണത്തിനായി കാത്തിരിക്കുമ്പോൾ ബ്രൗസറോ സെർവറോ ഫ്രീസുചെയ്യുന്നത് തടയുക എന്നതാണ് അസിൻക്രണസ് ഫംഗ്‌ഷനുകളുടെ ഉദ്ദേശ്യം, അതിനാൽ ഉപയോക്തൃ അനുഭവവും പ്രകടനവും മെച്ചപ്പെടുത്തുന്നു. അസിൻക്രണസ് സ്വഭാവം മനസ്സിലാക്കുന്നത്, പ്രധാന ത്രെഡിനെ ബാധിക്കാതെ തത്സമയം API-കളിൽ നിന്ന് ഡാറ്റ വീണ്ടെടുക്കാൻ കഴിയുന്ന കൂടുതൽ പ്രതികരിക്കുന്ന ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കാൻ ഡെവലപ്പർമാരെ പ്രാപ്തരാക്കുന്നു.

അസിൻക്രണസ് അഭ്യർത്ഥനകൾ കൈകാര്യം ചെയ്യുന്നതിന് പ്രതികരണങ്ങളും പ്രോസസ്സിനിടെ ഉണ്ടായേക്കാവുന്ന വിവിധ തെറ്റുകളും കൈകാര്യം ചെയ്യേണ്ടതുണ്ട്. ഉദാഹരണത്തിന്, ബാഹ്യ API-കളിൽ നിന്ന് ഡാറ്റ വീണ്ടെടുക്കുമ്പോൾ ഒരു സാധാരണ ബുദ്ധിമുട്ട്, പ്രാരംഭ കേസിലെ പിശക് കാണിക്കുന്നത് പോലെ, നിർവചിക്കാത്ത മൂല്യം നൽകുന്നു. ഒഴിവാക്കലുകൾ ഫലപ്രദമായി കൈകാര്യം ചെയ്യുന്നതിൽ ഡെവലപ്പർമാർ പരാജയപ്പെടുമ്പോൾ, അവരുടെ ആപ്ലിക്കേഷൻ തകരാറിലായേക്കാം അല്ലെങ്കിൽ കൃത്യമല്ലാത്ത ഫലങ്ങൾ ഉണ്ടാക്കിയേക്കാം. ശ്രമിക്കുക/പിടിക്കുക ബ്ലോക്കുകൾ അല്ലെങ്കിൽ പ്രതികരണ നില പരിശോധനകൾ പോലെയുള്ള ഫലപ്രദമായ പിശക് കൈകാര്യം ചെയ്യുന്നത് നിർണായകമാണ്.

പിശക് കൈകാര്യം ചെയ്യുന്നതിനു പുറമേ, ബാഹ്യ API-കളുമായി സംവദിക്കുമ്പോൾ സുരക്ഷ ഒരു പ്രധാന പരിഗണനയാണ്. സെൻസിറ്റീവ് ഡാറ്റ വെളിപ്പെടുത്തുകയോ മൂല്യനിർണ്ണയം കൂടാതെ API-കളിലേക്ക് നേരിട്ട് ആക്സസ് അനുവദിക്കുകയോ ചെയ്യുന്നത് കേടുപാടുകൾക്ക് കാരണമാകാം. സെർവർ-സൈഡ് അഭ്യർത്ഥനകൾ നടപ്പിലാക്കുക എന്നതാണ് ഒരു പരിഹാരം, അതിൽ API കോളുകൾ ഒരു ബാക്കെൻഡ് സെർവറിൽ നിന്നാണ് ചെയ്യുന്നത്, ഇത് അധിക സുരക്ഷ നൽകുന്നു. ഫ്രണ്ട് എൻഡ് അഭ്യർത്ഥനകളിൽ ഇടപെടുന്നതിൽ നിന്നും അല്ലെങ്കിൽ ബ്രൗസർ വഴി നേരിട്ട് സെൻസിറ്റീവ് ഡാറ്റ നേടുന്നതിൽ നിന്നും ക്ഷുദ്രകരമായ അഭിനേതാക്കളെ ഇത് വിലക്കുന്നു. ഈ API കണക്ഷനുകൾ സുരക്ഷിതമാക്കുന്നത് നിർണായകമാണ്, പ്രത്യേകിച്ചും ബിറ്റ്കോയിൻ നിരക്കുകൾ പോലുള്ള സാമ്പത്തിക വിവരങ്ങൾ കൈകാര്യം ചെയ്യുമ്പോൾ.