Com navegar pels llocs web de cercapersones basats en JavaScript i recopilar enllaços

Entendre la paginació basada en JavaScript i els reptes de l'API

Els llocs web amb paginació basada en JavaScript poden dificultar que els visitants naveguin pel material, especialment si els controls de paginació no revelen cap paràmetre d'URL. Això fa que sigui impossible modificar o automatitzar la navegació per pàgines mitjançant enfocaments convencionals, com ara canviar les consultes d'URL. És possible interactuar amb aquests buscapersones mitjançant diferents mètodes.

Un d'aquests problemes es produeix quan s'intenta recuperar enllaços o dades d'aquest tipus de llocs web. Si no podeu navegar manualment per centenars de pàgines, un millor enfocament és simular els esdeveniments de clic al cercapersones JavaScript. Aquesta tecnologia automatitza el procediment de navegació, simplificant molt les tasques de recollida de dades.

En algunes circumstàncies, la pestanya "Xarxa" de les Eines per a desenvolupadors del navegador pot mostrar punts finals de l'API que proporcionen informació útil. Tanmateix, relacionar-se directament amb aquests punts finals pot ocasionar problemes perquè no permeten certs mètodes HTTP, com ara les sol·licituds GET, que s'utilitzen habitualment per recuperar dades.

En aquest article s'explica com simular esdeveniments de clic al cercapersones JavaScript d'un lloc web i com fer front a les limitacions de l'API que restringeixen l'accés directe a les dades que necessiteu. També buscarem maneres de solucionar els límits de mètodes d'API específics per garantir que recopileu tota la informació important de manera eficaç.

Dominar la paginació basada en JavaScript i la navegació per API

El primer script introduït utilitza JavaScript pur per explorar dinàmicament una pàgina amb paginació basada en JavaScript. La idea bàsica darrere d'aquest mètode és imitar un usuari que premeu els botons del cercapersones escollint i activant esdeveniments de clic als elements HTML adequats. En identificar el contenidor de paginació mitjançant el document.querySelector() comanda, podem accedir als diferents botons de la pàgina i automatitzar la navegació. Aquest enfocament és ideal per als casos en què canviar manualment l'URL no és una opció i necessiteu una interfície ràpida i frontal per participar amb el mecanisme de paginació.

Al segon script, vam utilitzar Puppeteer, un paquet Node.js per controlar un navegador sense cap. Aquest script no només simula les pressions dels botons del cercapersones, sinó que també automatitza tot el procés de viatge per nombroses pàgines, reunint tots els enllaços d'anuncis amb cada iteració. Puppeteer us permet raspar contingut carregat dinàmicament interactuant directament amb elements DOM, com ho faria un usuari real. Un dels components principals aquí és page.evaluate(), que permet que el codi JavaScript s'executi dins del context de la pàgina. Això és perfecte per recopilar dades com enllaços d'anuncis a les pàgines paginades.

Tots dos scripts requereixen la gestió d'errors per garantir que el procés automatitzat funcioni bé fins i tot si falten peces específiques o si l'API es comporta de manera inesperada. Per exemple, console.error() registra tots els errors trobats durant l'execució, com ara quan no es troba un botó orientat a la pàgina. A més, el Titellaire page.waitForSelector() L'ordre garanteix que els components dinàmics, com ara els enllaços d'anuncis, estiguin completament carregats abans que l'script intenti interactuar. Això fa que sigui molt útil quan es treballa amb llocs web que depenen significativament de JavaScript per representar contingut, ja que evita problemes causats per càrregues de pàgines faltes o incompletes.

L'script acabat utilitza Axios, un client HTTP Node.js basat en promeses, al backend. Aquí, intentem obtenir dades directament des del punt final de l'API, que, segons l'error HTTP 405, no accepta OBTENIR consultes. Per evitar-ho, l'script envia a PUBLICACIÓ sol·licitud, que pot ser aprovada pel servidor. Aquest mètode és més adequat per als usuaris que volen extreure dades sense haver de navegar per la portada, però implica entendre l'estructura i el comportament de l'API del servidor. La gestió d'errors garanteix que s'informarà de qualsevol error de sol·licitud de l'API, cosa que facilita la resolució de problemes de recuperació de dades del servidor.

// Select the pagination container
const pagerContainer = document.querySelector('.pagination');

// Function to trigger a click event on a pager button
function clickPageButton(pageNumber) {
  const buttons = pagerContainer.querySelectorAll('button');
  const targetButton = [...buttons].find(btn => btn.textContent === String(pageNumber));
  if (targetButton) {
    targetButton.click();
  } else {
    console.error('Page button not found!');
  }
}

// Example usage: clicking the 2nd page button
clickPageButton(2);

const puppeteer = require('puppeteer');

// Function to scrape all ad links from a paginated website
async function scrapeAds() {
  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  await page.goto('https://www.supralift.com/uk/itemsearch/results');

  let ads = [];
  let hasNextPage = true;

  while (hasNextPage) {
    // Scrape the ad links from the current page
    const links = await page.evaluate(() => {
      return Array.from(document.querySelectorAll('.ad-link-selector')).map(a => a.href);
    });
    ads.push(...links);

    // Try to click the next page button
    const nextButton = await page.$('.pagination-next');
    if (nextButton) {
      await nextButton.click();
      await page.waitForSelector('.ad-link-selector');
    } else {
      hasNextPage = false;
    }
  }

  await browser.close();
  return ads;
}

// Call the scraping function and log results
scrapeAds().then(ads => console.log(ads));

const axios = require('axios');

// Function to fetch data from the API using POST instead of GET
async function fetchData() {
  try {
    const response = await axios.post('https://www.supralift.com/api/search/item/summary', {
      headers: {
        'Content-Type': 'application/json'
      },
      data: { /* Add necessary POST body if applicable */ }
    });

    console.log(response.data);
  } catch (error) {
    console.error('Error fetching data:', error.response ? error.response.data : error.message);
  }
}

// Invoke the fetchData function
fetchData();

Optimització de la paginació de JavaScript per al raspat web i la recollida de dades

Quan exploreu llocs web amb un sistema de paginació basat en JavaScript, és fonamental investigar diversos mètodes per extreure dades ràpidament. Una opció de vegades ignorada és interceptar les sol·licituds de xarxa emeses pel mecanisme de paginació. Si revisem detingudament les consultes realitzades a les Eines per a desenvolupadors del navegador, en particular la pestanya "Xarxa", podeu determinar els punts finals utilitzats per obtenir dades de cada pàgina. Poden utilitzar sistemes basats en JavaScript AJAX o buscar sol·licituds per carregar dades dinàmicament sense canviar l'URL, a diferència de la paginació tradicional que requereix canviar els paràmetres de l'URL.

Per extreure enllaços o dades d'aquests llocs web, interceptar les sol·licituds i recuperar les dades que retornin. Puppeteer i altres eines us permeten controlar el trànsit de la xarxa i recopilar dades útils. Quan aquesta estratègia no és practicable a causa de les limitacions del servidor, entendre el comportament de l'API esdevé fonamental. Algunes API, com ara Supralift, pot prohibir mètodes específics com OBTENIR i només permetre PUBLICACIÓ consultes. Adaptar les vostres consultes perquè coincideixin amb el mètode previst de l'API és una solució alternativa eficaç per a aquestes limitacions.

Finalment, mentre es redueixen les dades paginades, és fonamental permetre les pauses adequades entre les sol·licituds. Molts llocs web utilitzen algorismes de limitació de velocitat per evitar l'abús, i l'enviament de massa sol·licituds de forma ràpida pot provocar que la vostra adreça IP sigui temporalment a la llista negra. Per evitar la detecció i assegurar una extracció de dades correcta, incloeu un retard aleatori entre les consultes o limiteu el nombre de sol·licituds concurrents. Utilitzant eines com axios a Node.js i la gestió adequada de les tarifes és un enfocament meravellós per aconseguir-ho.