JavaScripti funktsiooni vigade parandamine vahetuskursside toomisel

Kuidas lahendada JavaScripti kiiruse toomise funktsioonide vigu

JavaScript on tõhus tööriist veebiarenduseks, eriti väliste API-dega töötamisel. Kuid isegi kogenud arendajad teevad API-dest andmete toomiseks funktsioone kirjutades tüüpilisi vigu. Üks selline probleem ilmneb siis, kui proovite saata funktsiooni argumente ja saada vastuseks määratlemata väärtusi.

Selles artiklis käsitletakse raskusi JavaScripti funktsiooni kirjutamisel, mis hangib kahe valuuta vahelisi bitcoini kursse. Probleemi "ReferenceError: btc pole määratletud" põhjustavad sageli valesti määratud parameetrid ja muutujad. Neid probleeme saab vältida, kui kood on õigesti üles ehitatud.

Näitame teile, kuidas luua funktsiooni nimega riivida (alates, kuni), mis aktsepteerib kahte parameetrit ja tagastab kahe valuuta vahelise vahetuskursi. Selle raamatu lõpuks saate teada, kuidas andmetoomise käigus argumente õigesti edastada ja vigu hallata.

Kui teil on sarnaseid probleeme või olete saanud veateate "Määratlemata atribuute ei saa lugeda (lugemismäär"), aitab see artikkel teil tõrkeotsingut teha ja neid tõhusalt lahendada. Vaatame samm-sammult, kuidas neid probleeme lahendada.

Mõistmine, kuidas JavaScripti funktsioonid käsitsevad API-taotlusi krüptovaluutakursside kohta

Siin esitatud skriptid näitavad alternatiivseid tehnikaid kahe valuuta vahelise krüptovaluuta vahetuskursside saamiseks JavaScripti abil. Esimene skript kasutab objekti XMLHttpRequest, mis on üks vanemaid meetodeid JavaScriptis asünkroonsete HTTP-päringute käsitlemiseks. Funktsioon riivida (alates, kuni) aktsepteerib kahte parameetrit: konverteeritavad valuutad. URL luuakse dünaamiliselt esitatud parameetrite põhjal ja päring saadetakse Bitpay API lõpp-punktile. Pärast vastuse saamist sõelutakse andmed JSON.parse() abil. kuvab vahetuskursi dokumendi sisus. See lahendus säilitab ühilduvuse vanemate brauseritega, kuid sellel puuduvad mõned uuemad võimalused, näiteks lubadused, mida käsitletakse teises näites.

Teises näites kasutatakse sama toimingu tegemiseks XMLHttpRequesti asemel Fetch API-t. Fetch API on ajakohasem ja pakub lihtsamat viisi võrgupäringute tegemiseks. See kasutab lubadusi muuta asünkroonne voog loetavamaks ja hallatavamaks. Funktsiooni käivitamisel teeb see HTTP päringu samale URL-ile ja ootab vastust. Pärast vastuse saamist muudab see andmed JSON-objektiks ja hangib kiiruse. Fetch API parandab tõrkehaldust, kasutades päringu või andmetöötluse käigus tekkivate probleemide kogumiseks ja haldamiseks proovimis- ja püüdmisplokke.

Kolmas skript on suunatud a taustakeskkond ja teeb API päringuid Node.js'i HTTP-mooduliga. See on eriti kasulik serveripoolsete rakenduste arendamiseks, mis vajavad vahetuskursside hankimist. HTTP-moodul on Node.js-i sisse ehitatud ja võimaldab arendajatel HTTP-toiminguid läbi viia. See funktsioon loob URL-i samal viisil nagu eelmised skriptid, saadab API-le GET-kutse ja seejärel sõelub saadud andmeid. Tulemus logitakse pigem konsooli, mitte ei kuvata brauseris, mistõttu sobib see paremini taustastsenaariumide jaoks, mis ei vaja veebibrausereid.

Lõpuks on kaasas Jest testkomplekt, mis kontrollib, kas Fetch API lahendus töötab korralikult. Jest on populaarne testimisraamistik ja koos nalja-tooma-mõtlema, saame oma testides jäljendada API vastuseid. See võimaldab arendajatel testida oma koodi ilma võrgupäringuid genereerimata, mis kiirendab testimisprotsessi ja isoleerib võimalikud vead. Testid kontrollivad, kas kiirusandmed on edukalt hangitud ja dokumendi kehas kuvatud, kinnitades, et funktsioon toimib erinevates kontekstides ettenähtud viisil. Testimine on arenduse oluline element, eriti väliste API-dega töötamisel, sest see aitab varakult vigu avastada ja parandab toote üldist stabiilsust.

// 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');
});

Asünkroonsete JavaScripti funktsioonide uurimine API taotluste jaoks

Asünkroonsete päringute käsitlemine on JavaScriptis API-dega töötamisel ülioluline. Fetch API ja XMLHttpRequest on kaks peamist viisi nende päringute tegemiseks. Asünkroonsete funktsioonide eesmärk on vältida brauseri või serveri külmumist vastuse ootamise ajal, parandades seeläbi kasutajakogemust ja jõudlust. Asünkroonse käitumise mõistmine võimaldab arendajatel luua tundlikumaid rakendusi, mis saavad API-delt andmeid reaalajas hankida ilma põhilõime mõjutamata.

Asünkroonsete päringute käsitlemine nõuab vastuste ja erinevate protsessi käigus tekkida võivate vigade haldamist. Näiteks üks levinud probleem andmete toomisel välistest API-dest on määratlemata väärtuse tagastamine, mida näitab algjuhtumi viga. Kui arendajad ei suuda erandeid tõhusalt hallata, võib nende rakendus kokku kukkuda või anda ebatäpseid tulemusi. Tõhus vigade käsitlemine, nt proovimis-/kinnitusplokid või vastuse oleku kontroll, on ülioluline.

Lisaks vigade käsitlemisele on väliste API-dega suhtlemisel oluline ka turvalisus. Tundlike andmete avalikustamine või API-dele otsejuurdepääsu võimaldamine ilma kinnitamiseta võib põhjustada haavatavusi. Üks lahendus on juurutada serveripoolsed päringud, mille puhul API-kutsed tehakse taustaserverist, pakkudes täiendavat turvalisust. See keelab pahatahtlikel osalejatel kasutajaliidese päringuid segada või brauseri kaudu tundlikke andmeid otse hankida. Nende API-ühenduste turvamine on kriitiline, eriti kui käsitlete finantsteavet, näiteks bitcoini määrasid.