ஜாவாஸ்கிரிப்ட்-அடிப்படையிலான பேஜர் இணையதளங்களை எவ்வாறு வழிநடத்துவது மற்றும் இணைப்புகளை சேகரிப்பது

ஜாவாஸ்கிரிப்ட் அடிப்படையிலான பேஜினேஷன் மற்றும் ஏபிஐ சவால்களைப் புரிந்துகொள்வது

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

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

சில சூழ்நிலைகளில், உலாவியின் டெவலப்பர் கருவிகளில் உள்ள "நெட்வொர்க்" தாவல் பயனுள்ள தகவலை வழங்கும் API இறுதிப்புள்ளிகளைக் காண்பிக்கலாம். இருப்பினும், இந்த இறுதிப்புள்ளிகளுடன் நேரடியாக ஈடுபடுவது எப்போதாவது சிக்கல்களை ஏற்படுத்தலாம், ஏனெனில் அவை தரவுகளை மீட்டெடுக்க பொதுவாகப் பயன்படுத்தப்படும் GET கோரிக்கைகள் போன்ற சில HTTP முறைகளை அனுமதிக்காது.

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

கட்டளை	பயன்பாட்டின் உதாரணம்
document.querySelector()	கொடுக்கப்பட்ட CSS தேர்வாளருடன் பொருந்தக்கூடிய முதல் உறுப்பைத் தேர்ந்தெடுக்க இந்த முறை பயன்படுத்தப்படுகிறது. பேஜினேஷன் கண்டெய்னரை (const pagerContainer = document.querySelector('.pagination')) தேர்வு செய்யவும் மற்றும் பேஜர் பொத்தான்களைக் கட்டுப்படுத்தவும் ஸ்கிரிப்ட் இதைப் பயன்படுத்துகிறது.
Array.from()	வரிசை போன்ற அல்லது மீண்டும் இயக்கக்கூடிய பொருளை சரியான அணிவரிசையாக மாற்றுகிறது. ஸ்கிரிப்ட் எளிதாக கையாளுதல் மற்றும் மேப்பிங்கிற்கான விளம்பர இணைப்புகளின் நோட்லிஸ்ட்டை ஒரு வரிசையாக மாற்றுகிறது (Array.from(document.querySelectorAll('.ad-link-selector')).
puppeteer.launch()	Puppeteer உடன் பயன்படுத்தப்படும் போது, ​​இந்த கட்டளை ஒரு புதிய தலையில்லாத உலாவி நிகழ்வைத் தொடங்குகிறது. இது பக்க வழிசெலுத்தல் மற்றும் பயனர் தொடர்புகளை உருவகப்படுத்துதல் போன்ற தானியங்கு உலாவி செயல்களை ஆதரிக்கிறது (const browser = காத்திருக்கும் puppeteer.launch()).
page.evaluate()	In Puppeteer, this method allows you to run JavaScript code in the context of the web page you are controlling. It is used here to extract ad links from the DOM (await page.evaluate(() =>Puppeteer இல், நீங்கள் கட்டுப்படுத்தும் வலைப்பக்கத்தின் சூழலில் JavaScript குறியீட்டை இயக்க இந்த முறை உங்களை அனுமதிக்கிறது. DOM இலிருந்து விளம்பர இணைப்புகளைப் பிரித்தெடுக்க இது இங்கே பயன்படுத்தப்படுகிறது (காத்திருக்க page.evaluate(() => {...})).
page.waitForSelector()	தொடர்வதற்கு முன் பக்கத்தில் குறிப்பிட்ட தேர்வி தோன்றும் வரை காத்திருக்கிறது, அனைத்து டைனமிக் கூறுகளும் ஏற்றப்பட்டதை உறுதி செய்கிறது. ஒவ்வொரு பக்க மாற்றத்தின் போதும் புதிய விளம்பரங்கள் தோன்றுவதால், பக்கவாட்டு உள்ளடக்கத்தில் உலாவும்போது இது மிகவும் முக்கியமானது (காத்திருங்கள் page.waitForSelector('.ad-link-selector').
axios.post()	வழங்கப்பட்ட URL க்கு HTTP POST கோரிக்கையை அனுப்புகிறது. மாதிரியானது GET ஐ விட POST வழியாக தரவைப் பெறுவதன் மூலம் 405 சிக்கலைத் தவிர்க்க முயற்சிக்கிறது (const response = axios.post() காத்திருக்கிறது).
console.error()	கன்சோலில் பிழை செய்திகளை எழுதப் பயன்படுகிறது. சில உருப்படிகள் அல்லது API கோரிக்கைகள் தோல்வியடையும் போது பிழைத் தகவலைக் காண்பிப்பதன் மூலம் பிழைத்திருத்தத்திற்கு உதவுகிறது (console.error('பக்க பொத்தான் கிடைக்கவில்லை!').
$()	ஆவணம்.querySelector() உடன் ஒப்பிடக்கூடிய, Puppeteer இல் உள்ள கூறுகளைத் தேர்ந்தெடுப்பதற்கான சுருக்கெழுத்து. பேஜினேஷன் கிளிக் நிகழ்வை உருவாக்க இந்த ஸ்கிரிப்ட் "அடுத்த பக்கம்" பொத்தானைப் பயன்படுத்துகிறது (const nextButton = காத்திருக்கும் பக்கம்.$('.pagination-next').
click()	இந்த அணுகுமுறை ஒரு HTML உறுப்பு மீது கிளிக் செய்வதை பிரதிபலிக்கிறது. ஸ்கிரிப்ட்களில், சரியான பக்க பொத்தானைக் கிளிக் செய்வதன் மூலம் பேஜரை நிரல் முறையில் செல்ல இது பயன்படுத்தப்படுகிறது.

ஜாவாஸ்கிரிப்ட் அடிப்படையிலான பேஜினேஷன் மற்றும் ஏபிஐ வழிசெலுத்தலில் தேர்ச்சி பெறுதல்

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

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

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

முடிக்கப்பட்ட ஸ்கிரிப்ட் பின்தளத்தில் வாக்குறுதிகளின் அடிப்படையில் ஒரு Node.js HTTP கிளையண்டான Axios ஐப் பயன்படுத்துகிறது. இங்கே, நாங்கள் API எண்ட்பாயிண்டிலிருந்து நேரடியாக தரவைப் பெற முயற்சிக்கிறோம், இது HTTP 405 பிழையின் படி ஏற்காது கேள்விகள். இதைத் தவிர்க்க, ஸ்கிரிப்ட் அனுப்புகிறது கோரிக்கை, இது சேவையகத்தால் அங்கீகரிக்கப்படலாம். முன் முனையில் செல்லாமல் தரவைப் பிரித்தெடுக்க விரும்பும் பயனர்களுக்கு இந்த முறை மிகவும் பொருத்தமானது, ஆனால் இது சேவையகத்தின் API இன் கட்டமைப்பு மற்றும் நடத்தையைப் புரிந்துகொள்வதை உள்ளடக்கியது. ஏபிஐ கோரிக்கை தோல்விகள் புகாரளிக்கப்படும் என்பதற்கு பிழை கையாளுதல் உத்தரவாதம் அளிக்கிறது, இது சர்வர் பக்க தரவு மீட்டெடுப்பு சிக்கல்களைச் சரிசெய்வதை எளிதாக்குகிறது.

// 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();

வலை ஸ்கிராப்பிங் மற்றும் தரவு சேகரிப்புக்கான ஜாவாஸ்கிரிப்ட் பக்கத்தை மேம்படுத்துதல்

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

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

இறுதியாக, பேஜினேட் தரவை ஸ்க்ராப் செய்யும் போது, ​​கோரிக்கைகளுக்கு இடையில் பொருத்தமான இடைநிறுத்தங்களை அனுமதிப்பது மிகவும் முக்கியமானது. துஷ்பிரயோகத்தைத் தடுக்க பல இணையதளங்கள் கட்டணக் கட்டுப்பாடு அல்காரிதங்களைப் பயன்படுத்துகின்றன, மேலும் பல கோரிக்கைகளை விரைவாக அடுத்தடுத்து அனுப்புவதால் உங்கள் IP முகவரி தற்காலிகமாக தடுப்புப்பட்டியலில் சேர்க்கப்படலாம். கண்டறிதலைத் தவிர்க்கவும், வெற்றிகரமான தரவுப் பிரித்தெடுப்பை உறுதிப்படுத்தவும், வினவல்களுக்கு இடையே சீரற்ற தாமதத்தைச் சேர்க்கவும் அல்லது ஒரே நேரத்தில் வரும் கோரிக்கைகளின் எண்ணிக்கையைக் கட்டுப்படுத்தவும். போன்ற கருவிகளைப் பயன்படுத்துதல் Node.js இல் மற்றும் சரியான விகிதக் கையாளுதல் இதை அடைய ஒரு அற்புதமான அணுகுமுறையாகும்.

1. ஜாவாஸ்கிரிப்ட் அடிப்படையிலான பேஜினேஷன் என்றால் என்ன?
2. ஜாவாஸ்கிரிப்ட்-அடிப்படையிலான பேஜினேஷன் என்பது பேஜினேஷன் பொத்தான்கள் ஜாவாஸ்கிரிப்டைப் பயன்படுத்தி, URLஐ அடிக்கடி மாற்றாமல், புதிய உள்ளடக்கத்தை மாறும் வகையில் ஏற்றுவதற்கு ஒரு வழியாகும்.
3. ஜாவாஸ்கிரிப்ட்-பக்கமிட்ட இணையதளத்தில் இருந்து தரவை எப்படி ஸ்கிராப் செய்வது?
4. போன்ற கருவிகளைப் பயன்படுத்தலாம் அல்லது பேஜினேஷன் பொத்தான் கிளிக்குகளை தானியக்கமாக்க அல்லது பேஜினேஷனின் போது நெட்வொர்க் கோரிக்கைகளைப் பிடிக்க.
5. API ஏன் 405 முறை அனுமதிக்கப்படாத பிழையை வழங்குகிறது?
6. API ஆனது சில HTTP முறைகளை மட்டுமே ஆதரிப்பதால் இது நிகழ்கிறது. உதாரணமாக, அது தடுக்கலாம் அனுமதிக்கும் போது கோரிக்கைகள் கோரிக்கைகள்.
7. பக்கங்களுக்கு செல்ல URL ஐ மாற்ற முடியுமா?
8. ஜாவாஸ்கிரிப்ட் அடிப்படையிலான பக்கங்களில், நீங்கள் அடிக்கடி URL ஐ நேரடியாக மாற்ற முடியாது. வழிசெலுத்த, நீங்கள் JavaScript நிகழ்வுகளைத் தூண்ட வேண்டும் அல்லது API இறுதிப்புள்ளிகளைப் பயன்படுத்த வேண்டும்.
9. பேஜினேட் தரவை ஸ்கிராப்பிங் செய்ய நான் என்ன கருவிகளைப் பயன்படுத்தலாம்?
10. பிரபலமான ஸ்கிராப்பிங் திட்டங்கள் அடங்கும் உலாவி தானியங்கு மற்றும் HTTP கோரிக்கைகளுக்கு. இரண்டும் பக்க உள்ளடக்கத்தை திறமையாக கையாளுகின்றன.

ஜாவாஸ்கிரிப்ட் அடிப்படையிலான பேஜினேஷனுடன் பணிபுரிய முன்-இறுதி மற்றும் பின்-இறுதி தீர்வுகளின் கலவை தேவைப்படுகிறது. உலாவி செயல்பாடுகளை தானியக்கமாக்குவதற்கு Puppeteer ஐப் பயன்படுத்தினாலும் அல்லது API எண்ட்பாயிண்ட்களுடன் நேரடியாக இடைமுகப்படுத்த Axios ஐப் பயன்படுத்தினாலும், திறமையான ஸ்கிராப்பிங்கிற்கு கவனமாக வடிவமைப்பு மற்றும் செயல்படுத்தல் தேவைப்படுகிறது.

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