Web Scraping Expedia mit JavaScript

Expedia ist eine beliebte Website, auf der Menschen Flüge, Hotels und mehr buchen. Unter den Giganten im Geschäft mit Online-Reisebuchungen sticht Expedia als führende Plattform hervor und bietet Millionen von Menschen eine Fülle von Reisemöglichkeiten. Aber haben Sie sich jemals gefragt, wie Sie diese Daten für Ihre eigenen Zwecke nutzen könnten, sei es für Recherchen, Analysen oder einfach, um die besten Angebote zu erhalten? Willkommen in der Welt des Web Scraping!

In diesem Blog tauchen wir in die faszinierende Reise des Scrapings von Expedia mit JavaScript ein und eröffnen eine Fülle von Möglichkeiten und Chancen. Wir verwenden die Crawlbase Crawling API um uns dabei zu helfen, Expedia reibungslos zu durchforsten.

Warum Expedia nach Reisedaten durchsuchen?

Dank Online-Plattformen wie Expedia ist die Reiseplanung heutzutage einfacher und individueller geworden. Bei so vielen Optionen und Variablen kann es jedoch überwältigend sein, fundierte Entscheidungen zu treffen. Hier ist das Scraping von Expedia nach Reisedaten von unschätzbarem Wert.

Durch Scraping können wir große Datenmengen von der Expedia-Website sammeln, beispielsweise Flugpreise, Hotelbewertungen und Verfügbarkeit. Durch die Analyse dieser Daten können Reisende fundiertere Entscheidungen treffen, die besten Angebote finden und sogar versteckte Schätze entdecken, die möglicherweise nicht sofort offensichtlich sind.

Für Unternehmen in der Reisebranche stellt die Nutzung von Expedia einen Wettbewerbsvorteil dar. Sie bietet Einblicke in Markttrends, Preisstrategien der Konkurrenz und Kundenpräferenzen, sodass Unternehmen ihre Angebote und Strategien effektiv anpassen können.

Im Wesentlichen ermöglicht das Scraping von Reisedaten bei Expedia sowohl Einzelreisenden als auch Unternehmen, die Komplexität der Reiseplanung effizienter zu bewältigen und so bessere Erlebnisse und Ergebnisse sicherzustellen.

Informationen zur Expedia-Website

Expedia ist ein wichtiger Akteur im komplexen Netz der Online-Reiseplattformen und bietet seinen Nutzern eine große Auswahl an Reisemöglichkeiten. Um das volle Potenzial der Expedia-Angebote auszuschöpfen und wertvolle Erkenntnisse zu gewinnen, ist es wichtig, die zugrunde liegende Struktur und die Technologien zu verstehen, die der Website zugrunde liegen.

Eintauchen in die Suchpfade von Expedia

Expedia bietet verschiedene Suchoptionen, um den unterschiedlichen Reisebedürfnissen gerecht zu werden. Jeder Suchpfad ist darauf ausgelegt, Benutzern dabei zu helfen, bestimmte Arten von Unterkünften oder Aktivitäten zu finden. Hier ist eine Übersicht über einige der wichtigsten verfügbaren Suchpfade:

Verfügbare Suchanfragen auf Expedia

1. Kreuzfahrt Suche: Dieser Pfad ist für Benutzer gedacht, die Kreuzfahrten buchen möchten. Beispielformat: https://www.expedia.com/Cruise-Search?querparams...
2. Autosuche: Für diejenigen, die einen Mietwagen benötigen, vereinfacht dieser Pfad den Suchvorgang. Beispielformat: https://www.expedia.com/carsearch?querparams...
3. Flugsuche: Dieser Pfad konzentriert sich auf die Suche nach den besten Flugoptionen für Reisende. Beispiel: https://www.expedia.com/Flight-Search?querparams...
4. Hotelsuche: Dieser Pfad ist speziell auf Hotelbuchungen zugeschnitten und steht in diesem Beispiel im Mittelpunkt. Beispielformat: https://www.expedia.com/Hotel-Search?querparams...
5. Dinge die zu tun sind: Für Reisende, die nach Aktivitäten und Erlebnissen suchen, bietet dieser Pfad eine kuratierte Liste von Optionen. Beispielformat: https://www.expedia.com/things-to-do/search?querparams...

Beispiel: Hotelsuche auf Expedia

In diesem Blog werden wir uns eingehend mit der Hotelsuchfunktion von Expedia befassen. Sehen wir uns eine Beispiel-URL für die Hotelsuche genauer an:

https://www.expedia.com/Hotel-Search?adults=2&rooms=1&destination=Dubai%2C%20Dubai%2C%20United%20Arab%20Emirates&startDate=2023-12-26&endDate=2023-12-30

In dieser URL können Sie verschiedene Parameter sehen, die dabei helfen, die Suche anzupassen:

• adults=2: Gibt die Anzahl der Erwachsenen an.
• rooms=1: Gibt die Anzahl der benötigten Zimmer an.
• destination=Dubai%2C%20Dubai%2C%20United%20Arab%20Emirates: Definiert das Ziel, in diesem Fall Dubai, Vereinigte Arabische Emirate.
• startDate=2023-12-26: Legt das Startdatum für den Aufenthalt fest.
• endDate=2023-12-30: Legt das Enddatum für den Aufenthalt fest.

Das Verständnis dieser Suchpfade und Parameter ist für ein effektives Scraping von entscheidender Bedeutung, da es uns ermöglicht, bestimmte Daten gezielt anzusprechen und unseren Scraping-Ansatz entsprechend anzupassen.

Einrichten Ihrer Entwicklungsumgebungen

Bevor Sie mit JavaScript und der Crawlbase in das Web-Crawling eintauchen können Crawling APIist es wichtig, Ihre Entwicklungsumgebung vorzubereiten. Dieser Abschnitt bietet eine kurze und dennoch detaillierte Anleitung, die Ihnen beim Einrichten der erforderlichen Tools und Bibliotheken für ein reibungsloses Crawling von E-Commerce-Websites hilft.

Installieren von NodeJS und NPM

NodeJS und NPM (Node Package Manager) sind das Rückgrat der modernen JavaScript-Entwicklung. Sie ermöglichen es Ihnen, JavaScript-Code außerhalb der Grenzen eines Webbrowsers auszuführen und Abhängigkeiten mühelos zu verwalten. Hier ist eine einfache Installationsanleitung:

1. KnotenJS: Besuchen Sie den Beamten NodeJS-Website und laden Sie die neueste, auf Ihr Betriebssystem zugeschnittene LTS-Version (Long-Term Support) herunter. Führen Sie die Installation gemäß den bereitgestellten plattformspezifischen Anweisungen aus.
2. NPM: NPM ist im Lieferumfang von NodeJS enthalten. Nach der Installation von NodeJS steht Ihnen NPM automatisch zur Verfügung.

Um eine erfolgreiche Installation zu bestätigen, öffnen Sie Ihr Terminal oder Ihre Eingabeaufforderung und führen Sie die folgenden Befehle aus:

Knoten - Version
npm --version

Diese Befehle zeigen die installierten Versionen von NodeJS und NPM an und gewährleisten so eine reibungslose Einrichtung.

Festlegen des Projektverzeichnisses

Erstellen Sie zunächst ein Verzeichnis mit dem mkdir Befehl. Es heißt ecommerce crawling für dieses Tutorial, aber Sie können den Namen durch einen Namen Ihrer Wahl ersetzen:

mkdir Expedia_Scraping

Wechseln Sie anschließend in das neu erstellte Verzeichnis mit dem cd Befehl:

cd Expedia\ Scraping/

Initialisieren Sie das Projektverzeichnis als npm-Paket mit dem npm Befehl:

npm init --y

Der Befehl erzeugt eine package.json Datei, die wichtige Metadaten für Ihr Projekt enthält. Die --y weist npm an, alle Standardwerte zu akzeptieren.

Nach dem Ausführen des Befehls wird die folgende Ausgabe auf Ihrem Bildschirm angezeigt:

Schrieb zu /home/hassan/Desktop/E-Commerce-Crawling/Paket.JSON:

{
  "Name": "Expedia Scraping",
  "Ausführung": "1.0.0",
  „Beschreibung“: "",
  "Main": "index.js",
  „Skripte“: {
    "Prüfung": "echo \"Fehler: kein Test angegeben\" && exit 1"
  },
  "Keywords"[],
  "Autor": "",
  "Lizenz": "ISC"
}

Erstellen Sie in Ihrem Projektverzeichnis eine neue Datei mit dem Namen expedia-scraping.js. Hier platzieren Sie den Scraping-Code.

aufnehmen expedia-scraping.js

Erforderliche Bibliotheken installieren

Statten Sie Ihr Projekt mithilfe von NPM mit den folgenden JavaScript-Bibliotheken aus, um ein effizientes Web-Crawling und API-Interaktionen zu ermöglichen:

# Installieren Sie die erforderlichen Bibliotheken
npm install cheerio crawlbase sqlite3 csv-writer

Hier ist ein kurzer Überblick über diese wichtigen Bibliotheken:

• Tschüs: Als agile und leistungsstarke Bibliothek ist Cheerio für die effiziente Analyse von HTML- und XML-Dokumenten konzipiert. Es spielt eine entscheidende Rolle beim einfachen Extrahieren wertvoller Daten aus Webseiten.
• Crawlbase: Crawlbase vereinfacht die Interaktion mit der Crawlbase Crawling API, wodurch der Prozess des Website-Crawlings und der Datenextraktion optimiert wird.
• SQLite3: SQLite3 ist eine eigenständige, serverlose SQL-Datenbank-Engine ohne Konfiguration. Sie dient als Repository zum Speichern der beim Crawling gesammelten Datenmengen.
• CSV-Writer: Es vereinfacht das Schreiben von Daten in CSV-Dateien und erleichtert das Erstellen strukturierter Datendateien zur Speicherung oder weiteren Analyse in Ihren Anwendungen. Es bietet eine intuitive API zum Definieren von Headern und Schreiben von Datensätzen in CSV-Dateien mit minimalem Code.

Auswahl der richtigen Entwicklungs-IDE

Die Auswahl der richtigen integrierten Entwicklungsumgebung (IDE) kann die Produktivität erheblich steigern. Sie können JavaScript-Code zwar in einem einfachen Texteditor schreiben, aber die Verwendung einer dedizierten IDE kann Funktionen wie Codevervollständigung, Debugging-Tools und Versionskontrollintegration bieten. Einige beliebte IDEs für die JavaScript-Entwicklung sind Visual Studio Code (VS Code), WebStorm und Sublime Text.

Einen Token für Crawlbase erhalten Crawling API

Um auf die Crawlbase-Crawling-API zuzugreifen, benötigen Sie ein Zugriffstoken. Um das Token zu erhalten, müssen Sie zunächst ein Konto bei Crawlbase erstellen. Jetzt richten wir Ihnen ein Crawlbase-Konto ein. Folgen Sie diesen Schritten:

1. Besuchen Sie die Crawlbase-Website: Öffnen Sie Ihren Webbrowser und navigieren Sie zu Crawlbase-Anmeldeseite um den Registrierungsprozess zu starten.
2. Geben Sie Ihre Daten an: Sie werden aufgefordert, Ihre E-Mail-Adresse anzugeben und ein Passwort für Ihr Crawlbase-Konto zu erstellen. Geben Sie die erforderlichen Informationen ein.
3. Verification: Nach dem Absenden Ihrer Daten müssen Sie möglicherweise Ihre E-Mail-Adresse bestätigen. Suchen Sie in Ihrem Posteingang nach einer Bestätigungs-E-Mail von Crawlbase und folgen Sie den bereitgestellten Anweisungen.
4. Login: Sobald Ihr Konto verifiziert ist, kehren Sie zur Crawlbase-Website zurück und melden Sie sich mit Ihren neu erstellten Anmeldeinformationen an.
5. Greifen Sie auf Ihr API-Token zu: Sie benötigen ein API-Token zur Nutzung der Crawling API. Sie finden Ihre Token hier Link.

Crawlbase bietet zwei Arten von Token: den Normal Token (TCP) für statische Webseiten und den JavaScript Token (JS) für dynamische oder mit JavaScript gerenderte Webseiten. Für Websites wie Expedia benötigen Sie den JS Token. Sie können mehr lesen HIER.

Mit NodeJS, NPM, wichtigen Bibliotheken und Ihrem API-Token sind Sie nun bereit, mit JavaScript und Crawlbase in das Expedia-Scraping einzutauchen. Crawling APIIn den folgenden Abschnitten führen wir Sie Schritt für Schritt durch den Vorgang.

So extrahieren Sie Expedia-Suchergebnisse

Die riesige Auswahl an Reiseinformationen und -optionen auf Expedia ist eine wahre Fundgrube für Reisende und Analysten. Durch das Scraping der Suchergebnisse von Expedia können Sie wertvolle Daten gewinnen, die Sie für verschiedene Zwecke nutzen können. In diesem Abschnitt führen wir Sie Schritt für Schritt durch den sorgfältigen Prozess des Scrapings der Suchergebnisse von Expedia.

Erstellen der URL für die Expedia-Suche

Jede Online-Plattform arbeitet auf Grundlage eines strukturierten Rahmens und Expedia bildet hier keine Ausnahme. Um eine Suche zu starten oder Daten abzurufen, muss man die entsprechende URL erstellen, die die gewünschten Suchparameter enthält.

Wenn Sie beispielsweise nach Hoteloptionen in Paris für einen Wochenendausflug suchen, könnte Ihre URL etwa so aussehen:

https://www.expedia.com/Hotel-Search?adults=2&rooms=1&destination=Paris&startDate=2023-12-26&endDate=2023-12-30

Aufschlüsselung der Komponenten:

• Basis-URL: https://www.expedia.com/Hotel-Search
• Parameter:
  • adults=2: Gibt die Anzahl der Erwachsenen an.
  • rooms=1: Gibt die Anzahl der benötigten Zimmer an.
  • destination=Paris: Gibt das Ziel im URL-codierten Format an.
  • startDate=2023-12-26: Legt das Startdatum für den Aufenthalt fest.
  • endDate=2023-12-30: Legt das Enddatum für den Aufenthalt fest.

Das Erstellen solcher URLs mit den richtigen Parametern ist die Grundlage für das Scraping genauer und relevanter Daten von Expedia.

Zugriff auf HTML-Inhalte mit Crawlbase Crawling API

Nachdem Sie die erforderliche URL sorgfältig erstellt haben, besteht der nächste Schritt darin, den HTML-Inhalt der Webseite zu extrahieren. Die Crawlbase Crawling API erweist sich bei diesem Unterfangen als hilfreich. Im Folgenden wird ein strukturierter Ansatz zur Erleichterung dieses Vorgangs beschrieben:

1. API-Konfiguration: Initialisieren Sie die Crawlbase Crawling API, Integration Ihres spezifischen API-Tokens.
2. Anforderungsausführung: Verwenden Sie die API, um den HTML-Inhalt von der angegebenen URL abzurufen. Um Ihren Scraping-Prozess weiter zu optimieren, ist es wichtig, die Parameter Sie können mit der Crawlbase arbeiten Crawling API:

• ajax_wait: Ein boolescher Parameter, der angibt, ob die API auf das Laden von AJAX-Inhalten warten soll. Wenn Sie den Wert auf „true“ setzen, wird sichergestellt, dass asynchrone Inhalte vollständig gerendert werden, bevor das HTML erfasst wird.
• Seite_warten: Gibt die Dauer in Millisekunden an, die die API nach dem Laden der Seite warten soll, bevor sie das HTML erfasst. Das Anpassen dieses Werts kann in Fällen hilfreich sein, in denen es länger dauert, bis Inhalte vollständig interaktiv sind, oder bei Websites mit komplizierten Ladesequenzen.

Hier ist ein verfeinertes Beispiel, das die Integration dieser Parameter veranschaulicht:

const { CrawlingAPI } = erfordern(„Crawlbase“);

// Fügen Sie Ihr Crawlbase JS-Token anstelle von „YOUR_CRAWLBASE_JS_TOKEN“ ein.
const API = neu CrawlingAPI({ Zeichen: 'IHR_CRAWLBASE_JS_TOKEN' });

const Optionen = {
  ajax_wait: was immer dies auch sein sollte.,
  Seite_warten: 5000,
};

const expediaURL =
  'https://www.expedia.com/Hotel-Search?adults=2&rooms=1&destination=Paris&startDate=2023-12-26&endDate=2023-12-30';

async Funktion abrufenExpediaHTML(URL) {
  const Antwort = – warten auf Sie! api.bekommen(URL, Optionen);
  Rückkehr Antwort.Körper;
}

abrufenExpediaHTML(Expedia-URL).dann((Antwort) => {
  trösten.Log(Antwort);
});

Ausführungsanweisungen:

• Kopieren Sie den obigen Code und fügen Sie ihn in die Datei expedia-scraping.js ein.
• Um das Skript auszuführen, navigieren Sie im Terminal zu Ihrem Projektverzeichnis und führen Sie Folgendes aus:

Knoten Expedia-Scraping.js

Dadurch wird das abgerufene HTML in Ihrem Terminal angezeigt.

Untersuchen von HTML zum Abrufen von CSS-Selektoren

Nachdem der HTML-Inhalt von der Eigenschaftenseite abgerufen wurde, besteht der nächste Schritt darin, seine Struktur zu analysieren und den Speicherort der Preisdaten zu ermitteln. Bei dieser Aufgabe kommen uns Webentwicklungstools und Browser-Entwicklertools zu Hilfe. Lassen Sie uns skizzieren, wie Sie die HTML-Struktur überprüfen und diese wertvollen CSS-Selektoren freilegen können:

1. Gehen Sie zur Expedia-Website: Öffnen Sie die Expedia-SERP-URL im Browser Ihrer Wahl.
2. Mit Rechtsklick prüfen: Klicken Sie mit der rechten Maustaste auf das Element der Seite, von dem Sie Informationen erhalten möchten. Wählen Sie im angezeigten Menü „Untersuchen“ oder „Element untersuchen“. Dadurch werden die Entwicklertools in Ihrem Browser geöffnet.
3. Suchen Sie den HTML-Code: Suchen Sie in den Entwicklertools nach dem HTML-Quellcode. Bewegen Sie Ihre Maus über verschiedene Teile des Codes, und der entsprechende Bereich auf der Webseite leuchtet auf.
4. Holen Sie sich den CSS-Selektor: Um CSS-Selektoren für ein bestimmtes Element abzurufen, klicken Sie in den Entwicklertools mit der rechten Maustaste darauf und wählen Sie „Kopieren“ > „Selektor kopieren“. Dadurch wird der CSS-Selektor in Ihre Zwischenablage kopiert, die Sie für das Web Scraping verwenden können.

Sobald Sie über diese Selektoren verfügen, können Sie mit der Strukturierung Ihres Daten-Scrapers fortfahren, um die erforderlichen Informationen effektiv zu extrahieren.

Datenextraktion aus Expedia-Suchergebnissen

Nach dem erfolgreichen Abrufen des HTML-Inhalts besteht der nächste Schritt in der sorgfältigen Extraktion der wesentlichen Datenelemente. Für diese Aufgabe nutzen wir die Fähigkeiten von Parsing-Tools, wobei die Cheerio-Bibliothek in JavaScript unsere erste Wahl ist.

Hier ist ein verfeinerter Ansatz für den Prozess:

1. HTML-Analyse: Integrieren Sie den erfassten HTML-Inhalt in ein Parsing-Framework wie Cheerio, um eine nahtlose Navigation durch das Document Object Model (DOM) zu ermöglichen.
2. Präzise Datenextraktion: Setzen Sie CSS-Selektoren strategisch ein, um wichtige Datenfragmente aus der HTML-Struktur zu isolieren und zu extrahieren. Dazu gehören wichtige Kennzahlen wie Hotelnamen, Übernachtungspreise, Gesamtpreise, Bewertungen und die Anzahl der Benutzerbewertungen.
3. Datenstrukturierung: Organisieren Sie die gesammelten Daten im Verlauf der Extraktion methodisch in strukturierte Formate, sei es JSON oder CSV. Dies gewährleistet Übersichtlichkeit und Zugänglichkeit und erleichtert die nachfolgende Datenanalyse oder Archivierung.

Um unsere früheren Skripting-Bemühungen in Einklang zu bringen, bleibt der überarbeitete Codeabschnitt bestehen:

const { CrawlingAPI } = erfordern(„Crawlbase“);
const tschüss = erfordern("Tschüs");

// Crawlbase API initialisieren
const API-Token = 'IHR_CRAWLBASE_JS_TOKEN'; // Fügen Sie hier Ihr Crawlbase JS-Token ein
const API = neu CrawlingAPI({ Zeichen: API-Token });

// API-Optionen
const Optionen = {
  ajax_wait: was immer dies auch sein sollte.,
  Seite_warten: 5000,
};

// Ziel-URL von Expedia
const expediaURL =
  'https://www.expedia.com/Hotel-Search?adults=2&rooms=1&destination=Paris&startDate=2023-12-26&endDate=2023-12-30';

// HTML-Inhalt von Expedia abrufen
async Funktion abrufenExpediaHTML(URL) {
  const Antwort = – warten auf Sie! api.bekommen(URL, Optionen);
  Rückkehr Antwort.Körper;
}

// Hoteldetails aus HTML-Inhalt extrahieren
Funktion extractHotelDetails(htmlInhalt) {
  const $ = Prost.Belastung(html-Inhalt);
  const Hotels = [];

  $('div[data-stid="Immobilien-Listing-Ergebnisse"] .uitk-card').jeder((Index, Element) => {
    const hotel = {
      Name: $(Element).gefunden(„.uitk-Karteninhalt-Abschnitt h3.uitk-Überschrift“).Text()
      PreisProNacht: $(Element)
        .gefunden(
          „.uitk-card-content-section div [data-test-id = ‚Preiszusammenfassung‘] > div > div: erstes Kind > div span div.uitk-text“,
        )
        .Text()
      Gesamtpreis: $(Element)
        .gefunden('.uitk-card-content-section div[data-test-id="price-summary"] > div > div:nth-child(2) div.uitk-text')
        .Text()
      Wertung: $(Element)
        .gefunden(„.uitk-Karteninhaltsabschnitt .uitk-Layout-Flex span.uitk-Badge span.uitk-Badge-Basistext“)
        .Text()
      Rezensionen: $(Element)
        .gefunden(
          „.uitk-card-content-section div.uitk-layout-grid div:erstes-Kind > div.uitk-layout-flex > div:ntes-Kind(2) > div:ntes-Kind(2) > div:letztes-Kind > span > div.uitk-text“,
        )
        .Text()
    };
    Hotels.drücken(Hotel);
  });

  Rückkehr Hotels;
}

// Hauptfunktion zum Ausführen des Scrapings
async Funktion Haupt-() {
  const htmlInhalt = – warten auf Sie! abrufenExpediaHTML(expediaURL);
  const hotelData = extractHotelDetails(html-Inhalt);

  trösten.Log(hotelData); // Extrahierte Hoteldetails anzeigen
}

// Führe die Hauptfunktion aus
Haupt-().Fang((Fehler) => {
  trösten.Fehler(„Ein Fehler ist aufgetreten:“, Fehler);
});

Verwendung der CrawlingAPI Aus der Bibliothek „crawlbase“ holt das Skript den HTML-Inhalt einer vordefinierten Expedia-URL. Dieser Inhalt wird dann mithilfe der cheerio Bibliothek, eine serverseitige Implementierung ähnlich wie jQuery, um wichtige Hoteldetails wie Namen, Preise, Bewertungen und Rezensionen zu extrahieren. Nach der Verarbeitung gibt das Skript die extrahierten Daten an die Konsole aus. Insbesondere ist eine Fehlerbehandlung integriert, um mögliche Probleme während des Scraping-Vorgangs zu bewältigen.

Wenn Sie den obigen Code ausführen, erhalten Sie eine Ausgabe wie diese:

[
  {
    Name: „OKKO Hotels Paris Rueil-Malmaison“,
    PreisProNacht: '$118',
    Gesamtpreis: '$542 gesamt',
    Wertung: '9.0',
    Rezensionen: „Wunderbar286 Bewertungen“
  },
  {
    Name: 'Grand Hotel Leveque',
    PreisProNacht: '$174',
    Gesamtpreis: '$782 gesamt',
    Wertung: '8.4',
    Rezensionen: '1,004 Bewertungen'
  },
  {
    Name: 'Hyatt Regency Paris Etoile',
    PreisProNacht: '$250',
    Gesamtpreis: '$1,129 gesamt',
    Wertung: '8.6',
    Rezensionen: '1,002 Bewertungen'
  },
  {
    Name: 'Hotel Riviera Elysées',
    PreisProNacht: '$98',
    Gesamtpreis: '$449 gesamt',
    Wertung: '7.0',
    Rezensionen: '469 Bewertungen'
  },
  {
    Name: „citizenM Pariser Oper“,
    PreisProNacht: '$192',
    Gesamtpreis: '$871 gesamt',
    Wertung: '9.6',
    Rezensionen: '76 Bewertungen'
  },
  {
    Name: 'Grand Hotel De Turin',
    PreisProNacht: '$98',
    Gesamtpreis: '$448 gesamt',
    Wertung: '7.6',
    Rezensionen: '1,002 Bewertungen'
  },
  ... 93 weitere Artikel
]

Effiziente Handhabung der Paginierung in Expedia

Um die Paginierung effektiv zu handhaben, verwendet die Crawlbase Crawling API stellt ein css_click_selector Parameter. Mit diesem Parameter können wir programmgesteuert auf ein Element auf der Seite klicken und so das Laden von zusätzlichem Inhalt auslösen.

Bei Verwendung des JavaScript-Tokens css_click_selector Parameter erwartet einen gültigen CSS-Selektor, sei es eine ID (z. B. #some-button), eine Klasse (z. B. .some-other-button) oder ein Attribut (z. B. [data-tab-item="tab1"]). Es ist wichtig, sicherzustellen, dass der CSS-Selektor richtig codiert ist, um Unstimmigkeiten zu vermeiden.

Lassen Sie uns dies in unser bestehendes Skript integrieren:

const { CrawlingAPI } = erfordern(„Crawlbase“);
const tschüss = erfordern("Tschüs");

// Crawlbase API initialisieren
const API-Token = 'IHR_CRAWLBASE_JS_TOKEN'; // Fügen Sie hier Ihr Crawlbase JS-Token ein
const API = neu CrawlingAPI({ Zeichen: API-Token });

// API-Optionen
const Optionen = {
  ajax_wait: was immer dies auch sein sollte.,
  Seite_warten: 10000,
  CSS-Klickselektor: URI-Komponente kodieren('button[data-stid="mehr-ergebnisse-anzeigen"]'),
};

// Ziel-URL von Expedia
const expediaURL =
  'https://www.expedia.com/Hotel-Search?adults=2&rooms=1&destination=Paris&startDate=2023-12-26&endDate=2023-12-30';

// HTML-Inhalt von Expedia abrufen
async Funktion abrufenExpediaHTML(URL) {
  const Antwort = – warten auf Sie! api.bekommen(URL, Optionen);
  if (Antwort.Überschriften && Antwort.Überschriften.pc_status === 200) {
    Rückkehr Antwort.Körper;
  }
  Rückkehr null;
}

// Hoteldetails aus HTML-Inhalt extrahieren
Funktion extractHotelDetails(htmlInhalt) {
  const $ = Prost.Belastung(html-Inhalt);
  const Hotels = [];

  $('div[data-stid="Immobilien-Listing-Ergebnisse"] .uitk-card').jeder((Index, Element) => {
    const hotel = {
      Name: $(Element).gefunden(„.uitk-Karteninhalt-Abschnitt h3.uitk-Überschrift“).Text()
      PreisProNacht: $(Element)
        .gefunden(
          „.uitk-card-content-section div [data-test-id = ‚Preiszusammenfassung‘] > div > div: erstes Kind > div span div.uitk-text“,
        )
        .Text()
      Gesamtpreis: $(Element)
        .gefunden('.uitk-card-content-section div[data-test-id="price-summary"] > div > div:nth-child(2) div.uitk-text')
        .Text()
      Wertung: $(Element)
        .gefunden(„.uitk-Karteninhaltsabschnitt .uitk-Layout-Flex span.uitk-Badge span.uitk-Badge-Basistext“)
        .Text()
      Rezensionen: $(Element)
        .gefunden(
          „.uitk-card-content-section div.uitk-layout-grid div:erstes-Kind > div.uitk-layout-flex > div:ntes-Kind(2) > div:ntes-Kind(2) > div:letztes-Kind > span > div.uitk-text“,
        )
        .Text()
    };
    Hotels.drücken(Hotel);
  });

  Rückkehr Hotels;
}

// Hauptfunktion zum Ausführen des Scrapings
async Funktion Haupt-() {
  const htmlInhalt = – warten auf Sie! abrufenExpediaHTML(expediaURL);
  if (htmlInhalt) {
    const hotelData = extractHotelDetails(html-Inhalt);
    trösten.Log(hotelData);
  } sonst {
    trösten.Log(„Beim Abrufen des HTML ist ein Fehler aufgetreten.“);
  }
}

// Führe die Hauptfunktion aus
Haupt-().Fang((Fehler) => {
  trösten.Fehler(„Ein Fehler ist aufgetreten:“, Fehler);
});

In der Ausgabe werden Sie feststellen, dass mehr Ergebnisse vorhanden sind als beim vorherigen Durchlauf.

Speichern von Scraped-Daten

Nach dem erfolgreichen Extrahieren von Daten aus Plattformen wie Expedia ist ein robustes System zur Datenspeicherung unerlässlich. Dadurch wird sichergestellt, dass die Daten zugänglich und organisiert bleiben und in Zukunft effizient für verschiedene Zwecke verwendet werden können. Lassen Sie uns zwei systematische Ansätze zum Speichern Ihrer Scraped-Daten untersuchen: die Verwendung von CSV-Dateien und die Nutzung von SQLite-Datenbanken.

Extrahierte Daten im CSV-Format speichern

CSV (Comma Separated Values) gilt aufgrund seiner Einfachheit und Kompatibilität mit verschiedener Software als Standard für den Datenaustausch. Indem Sie Scraped-Daten im CSV-Format speichern, stellen Sie deren breite Verwendbarkeit sicher.

Um dieses Update einzubinden, können Sie das bestehende Skript wie folgt anpassen.

const { CrawlingAPI } = erfordern(„Crawlbase“);
const tschüss = erfordern("Tschüs");
const Erstellen Sie einen CsvWriter. erfordern(„CSV-Writer“).ObjektCsvWriter erstellen;

// Crawlbase API initialisieren
const API-Token = 'IHR_CRAWLBASE_JS_TOKEN'; // Fügen Sie hier Ihr Crawlbase JS-Token ein
const API = neu CrawlingAPI({ Zeichen: API-Token });

// API-Optionen
const Optionen = {
  ajax_wait: was immer dies auch sein sollte.,
  Seite_warten: 8000,
  CSS-Klickselektor: URI-Komponente kodieren('button[data-stid="mehr-ergebnisse-anzeigen"]'),
};

// Ziel-URL von Expedia
const expediaURL =
  'https://www.expedia.com/Hotel-Search?adults=2&rooms=1&destination=Paris&startDate=2023-12-26&endDate=2023-12-30';

// HTML-Inhalt von Expedia abrufen
async Funktion abrufenExpediaHTML(URL) {
  const Antwort = – warten auf Sie! api.bekommen(URL, Optionen);
  if (Antwort.Überschriften && Antwort.Überschriften.pc_status === '200') {
    Rückkehr Antwort.Körper;
  }
  Rückkehr null;
}

// Hoteldetails aus HTML-Inhalt extrahieren
Funktion extractHotelDetails(htmlInhalt) {
  const $ = Prost.Belastung(html-Inhalt);
  const Hotels = [];

  $('div[data-stid="Immobilien-Listing-Ergebnisse"] .uitk-card').jeder((Index, Element) => {
    const hotel = {
      Name: $(Element).gefunden(„.uitk-Karteninhalt-Abschnitt h3.uitk-Überschrift“).Text()
      PreisProNacht: $(Element)
        .gefunden(
          „.uitk-card-content-section div [data-test-id = ‚Preiszusammenfassung‘] > div > div: erstes Kind > div span div.uitk-text“,
        )
        .Text()
      Gesamtpreis: $(Element)
        .gefunden('.uitk-card-content-section div[data-test-id="price-summary"] > div > div:nth-child(2) div.uitk-text')
        .Text()
      Wertung: $(Element)
        .gefunden(„.uitk-Karteninhaltsabschnitt .uitk-Layout-Flex span.uitk-Badge span.uitk-Badge-Basistext“)
        .Text()
      Rezensionen: $(Element)
        .gefunden(
          „.uitk-card-content-section div.uitk-layout-grid div:erstes-Kind > div.uitk-layout-flex > div:ntes-Kind(2) > div:ntes-Kind(2) > div:letztes-Kind > span > div.uitk-text“,
        )
        .Text()
    };
    Hotels.drücken(Hotel);
  });

  Rückkehr Hotels;
}

// Daten in CSV-Datei speichern
Funktion Speichern in CSV(die Datenerfassung) {
  const csvWriter = CsvWriter erstellen({
    Weg: 'hotels.csv',
    Kopfzeile: [
      { id: 'Süßkartoffel', Titel: 'Name' },
      { id: 'PreisProNacht', Titel: 'Preis pro Nacht' },
      { id: 'Gesamtpreis', Titel: 'Gesamtpreis' },
      { id: 'Bewertung', Titel: 'Bewertung' },
      { id: 'Bewertungen', Titel: 'Rezensionen' },
    ],
  });

  csvWriter.Datensätze schreiben(Daten).dann(() => trösten.Log(„Daten erfolgreich in CSV gespeichert“));
}

// Hauptfunktion zum Ausführen des Scrapings
async Funktion Haupt-() {
  const htmlInhalt = – warten auf Sie! abrufenExpediaHTML(expediaURL);
  if (htmlInhalt) {
    const hotelData = extractHotelDetails(html-Inhalt);
    Speichern in CSV(hotelData);
  } sonst {
    trösten.Log(„Beim Abrufen des HTML ist ein Fehler aufgetreten.“);
  }
}

// Führe die Hauptfunktion aus
Haupt-().Fang((Fehler) => {
  trösten.Fehler(„Ein Fehler ist aufgetreten:“, Fehler);
});

Die saveToCSV Die Funktion verwendet das Modul createCsvWriter, um eine CSV-Writer-Konfiguration zu definieren. Diese Konfiguration gibt an, dass die Daten in eine Datei namens hotels.csv, und stellt die Struktur der CSV-Datei mit Überschriften wie „Name“, „Preis pro Nacht“, „Gesamtpreis“, „Bewertung“ und „Rezensionen“ bereit. Die extrahierten Hoteldaten, die zuvor in einem Array von Objekten organisiert wurden, werden dann in diese CSV-Datei geschrieben.

hotels.csv Vorschau:

Extrahierte Daten in einer SQLite-Datenbank speichern

SQLite bietet eine zuverlässige, serverlose Lösung zur Datenspeicherung. Durch die Verwendung einer SQLite-Datenbank profitieren Sie von strukturierten Abfragefunktionen, die Datenintegrität und effizienten Abruf gewährleisten.

Um dieses Update einzubinden, können Sie das Script wie folgt anpassen.

const { CrawlingAPI } = erfordern(„Crawlbase“);
const tschüss = erfordern("Tschüs");
const sqlite3 = erfordern('sqlite3').ausführlich();

// Crawlbase API initialisieren
const API-Token = 'IHR_CRAWLBASE_JS_TOKEN'; // Fügen Sie hier Ihr Crawlbase JS-Token ein
const API = neu CrawlingAPI({ Zeichen: API-Token });

// API-Optionen
const Optionen = {
  ajax_wait: was immer dies auch sein sollte.,
  Seite_warten: 8000,
  CSS-Klickselektor: URI-Komponente kodieren('button[data-stid="mehr-ergebnisse-anzeigen"]'),
};

// Ziel-URL von Expedia
const expediaURL =
  'https://www.expedia.com/Hotel-Search?adults=2&rooms=1&destination=Paris&startDate=2023-12-26&endDate=2023-12-30';

// HTML-Inhalt von Expedia abrufen
async Funktion abrufenExpediaHTML(URL) {
  const Antwort = – warten auf Sie! api.bekommen(URL, Optionen);
  if (Antwort.Überschriften && Antwort.Überschriften.pc_status === '200') {
    Rückkehr Antwort.Körper;
  }
  Rückkehr null;
}

// Hoteldetails aus HTML-Inhalt extrahieren
Funktion extractHotelDetails(htmlInhalt) {
  const $ = Prost.Belastung(html-Inhalt);
  const Hotels = [];

  $('div[data-stid="Immobilien-Listing-Ergebnisse"] .uitk-card').jeder((Index, Element) => {
    const hotel = {
      Name: $(Element).gefunden(„.uitk-Karteninhalt-Abschnitt h3.uitk-Überschrift“).Text()
      PreisProNacht: $(Element)
        .gefunden(
          „.uitk-card-content-section div [data-test-id = ‚Preiszusammenfassung‘] > div > div: erstes Kind > div span div.uitk-text“,
        )
        .Text()
      Gesamtpreis: $(Element)
        .gefunden('.uitk-card-content-section div[data-test-id="price-summary"] > div > div:nth-child(2) div.uitk-text')
        .Text()
      Wertung: $(Element)
        .gefunden(„.uitk-Karteninhaltsabschnitt .uitk-Layout-Flex span.uitk-Badge span.uitk-Badge-Basistext“)
        .Text()
      Rezensionen: $(Element)
        .gefunden(
          „.uitk-card-content-section div.uitk-layout-grid div:erstes-Kind > div.uitk-layout-flex > div:ntes-Kind(2) > div:ntes-Kind(2) > div:letztes-Kind > span > div.uitk-text“,
        )
        .Text()
    };
    Hotels.drücken(Hotel);
  });

  Rückkehr Hotels;
}

// Daten in SQLite speichern
Funktion Speichern in SQLite(die Datenerfassung) {
  const db = neu sqlite3.Database(„hotels.db“);

  // Sicherstellen, dass die Tabelle existiert
  db.Lauf(`CREATE TABLE IF NOT EXISTS Hotels (
        id INTEGER PRIMÄRSCHLÜSSEL,
        Name TEXT,
        Preis pro Nacht REAL,
        Gesamtpreis REAL,
        Bewertung REAL,
        Bewertungen INTEGER
    )`);

  // Daten einfügen
  Daten.für jeden((Hotels) => {
    db.Lauf(`INSERT INTO hotels (Name, Preis pro Nacht, Gesamtpreis, Bewertung, Rezensionen) VALUES (?, ?, ?, ?, ?)`, [
      Hotel.Name,
      Hotel.PreisProNacht,
      Hotel.Gesamtpreis,
      Hotel.Wertung,
      Hotel.Rezensionen,
    ]);
  });

  db.schließen((sich irren) => {
    if (äh) {
      Rückkehr trösten.Fehler(äh.Nachricht);
    }
    trösten.Log(„Daten erfolgreich in SQLite-Datenbank gespeichert“);
  });
}

// Hauptfunktion zum Ausführen des Scrapings
async Funktion Haupt-() {
  const htmlInhalt = – warten auf Sie! abrufenExpediaHTML(expediaURL);
  if (htmlInhalt) {
    const hotelData = extractHotelDetails(html-Inhalt);
    Speichern in SQLite(hotelData);
  } sonst {
    trösten.Log(„Beim Abrufen des HTML ist ein Fehler aufgetreten.“);
  }
}

// Führe die Hauptfunktion aus
Haupt-().Fang((Fehler) => {
  trösten.Fehler(„Ein Fehler ist aufgetreten:“, Fehler);
});

Die saveToSQLite Funktion dient zum Speichern von Hoteldaten in einer SQLite-Datenbank namens hotels.db. Beim Aufruf stellt sie eine Verbindung zur SQLite-Datenbank her, indem sie den sqlite3 Modul. Bevor Daten eingefügt werden, stellt die Funktion sicher, dass eine Tabelle mit dem Namen hotels in der Datenbank vorhanden ist; wenn nicht, erstellt sie diese Tabelle mit Spalten für eine ID (als Primärschlüssel), Hotelname, Preis pro Nacht, Gesamtpreis, Bewertung und Anzahl der Bewertungen. Anschließend iteriert die Funktion über jedes an sie übergebene Hotelobjekt und führt eine Einfügeabfrage aus, um die Hoteldetails in die hotels Tabelle. Sobald alle Daten eingefügt wurden, schließt die Funktion die Datenbankverbindung und stellt sicher, dass die Daten sicher in der SQLite-Datenbank gespeichert werden.

hotels Tabellenvorschau:

Zusammenfassung

Glückwunsch! Sie haben Rohdaten direkt von einer Webseite genommen und sie in strukturierte Daten in einer JSON-Datei umgewandelt. Jetzt kennen Sie jeden Schritt, um einen Expedia-Scraper in JS zu erstellen!

Dieser Leitfaden vermittelt Ihnen das grundlegende Know-how und die Tools, um Expedia-Suchergebnisse mithilfe von JS und Crawlbase einfach zu scrapen. Crawling API. Lesen Sie weiter unsere Blogs, um weitere Tutorials wie diese zu finden. Einige der Links finden Sie unten:

Wie man Booking.com scrapt

Wenn Sie andere JavaScript-Projekte durchsuchen möchten, empfehlen wir Ihnen, die folgenden Links zu prüfen:

E-Commerce-Web-Crawling mit JavaScript meistern
So scrapen Sie G2 mit JavaScript
So scrapen Sie eBay mit JavaScript

Sollten Sie bis dahin auf Probleme stoßen, können Sie sich gerne an das Crawlbase-Supportteam wenden. Ihr Erfolg beim Web Scraping hat für uns Priorität und wir freuen uns darauf, Sie auf Ihrem Scraping-Weg zu unterstützen.

Häufig gestellte Fragen

Ist es legal, Daten von Expedia zu scrapen?

Web Scraping, insbesondere von großen kommerziellen Plattformen wie Expedia, ist eine rechtliche Grauzone. Während einige Gerichtsbarkeiten und Servicebedingungen Scraping ausdrücklich verbieten, gibt es in anderen möglicherweise keine klaren Richtlinien. Es ist wichtig, die Servicebedingungen von Expedia gründlich zu lesen oder Rechtsexperten zu konsultieren, die mit den Internetgesetzen in Ihrer Region vertraut sind. Denken Sie daran: Auch wenn Scraping nicht ausdrücklich verboten ist, ist es wichtig, ethisches Scraping zu praktizieren und sicherzustellen, dass Sie keine Bedingungen verletzen oder die Server von Expedia übermäßig belasten. Darüber hinaus respektieren Sie immer robots.txt Dateien, die von Websites häufig verwendet werden, um anzugeben, welche Teile der Site gescrapt werden können und welche nicht.

Warum JavaScript-Bibliotheken wie Cheerio zum Scraping verwenden?

JavaScript-Bibliotheken wie Cheerio sind unschätzbare Tools für Web Scraping-Aufgaben. Anders als herkömmliche Browser, die JavaScript ausführen, um Seiten darzustellen, arbeitet Cheerio serverseitig und bietet eine simulierte DOM-Umgebung. Dieser serverseitige Ansatz macht das Rendern der gesamten Webseite überflüssig, was zu schnelleren Datenextraktionsprozessen führt. Entwickler können vertraute jQuery-ähnliche Syntax verwenden, um bestimmte HTML-Elemente zu navigieren und zu extrahieren, was komplexe Scraping-Aufgaben vereinfacht und die Leistung optimiert.

Wie kann ich beim Scraping von Expedia mit Ratenbegrenzungen oder IP-Sperren umgehen?

Websites wie Expedia nutzen verschiedene Mechanismen wie Ratenbegrenzungen oder IP-Sperren, um aggressive oder nicht autorisierte Scraping-Aktivitäten zu verhindern und zu steuern. Wenn Sie Verzögerungen bemerken oder blockiert werden, ist dies ein Zeichen dafür, dass Ihre Scraping-Aktivitäten möglicherweise zu aggressiv sind. So meistern Sie diese Herausforderungen:

• Verzögerungen implementieren: Fügen Sie zufällige oder systematische Verzögerungen zwischen Ihren Scraping-Anfragen ein, um menschliches Verhalten nachzuahmen und die Belastung des Servers zu verringern.
• Verwenden Sie Proxys: Wechseln Sie durch einen Pool von Proxys, um Ihre IP-Adresse zu maskieren und Anfragen zu verteilen. Dadurch wird es für Websites schwieriger, Ihre Scraping-Aktivitäten zu verfolgen und zu blockieren.
• Tools zur Ratenbegrenzung: Erwägen Sie die Integration von Middleware oder Tools zur Verwaltung und Einhaltung von Ratenbegrenzungen, indem Sie Ihre Scraping-Geschwindigkeit dynamisch anhand der Serverantworten anpassen.

Darüber hinaus bieten Plattformen wie Crawlbase für ein optimiertes und problemloses Erlebnis dedizierte Crawling APIs. Durch die Nutzung solcher Dienste können Sie Ihre Scraping-Bemühungen weiter automatisieren und optimieren und so eine zusätzliche Ebene an Komplexität bei der Verwaltung potenzieller Einschränkungen erreichen.

Was soll ich mit den von Expedia extrahierten Daten tun?

Der ethische und legale Umgang mit Scraped-Daten ist von größter Bedeutung. Bevor Sie die Scraped-Daten verwenden:

• Anwendungszweck: Definieren Sie Ihre Absichten klar. Wenn Sie Daten für persönliche Erkenntnisse oder akademische Forschung analysieren, stellen Sie sicher, dass Ihre Aktivitäten den Nutzungsbedingungen der Website entsprechen.
• Kommerzielle Nutzung: Wenn Sie die Daten kommerziell nutzen möchten, holen Sie sich immer die ausdrückliche Genehmigung von Expedia oder der jeweiligen Website ein. Der Verkauf oder die Weiterverwendung von Scraped-Daten ohne Zustimmung kann rechtliche Konsequenzen nach sich ziehen und Ihren Ruf in der Branche schädigen.
• Datenschutz: Datenschutz hat immer oberste Priorität. Stellen Sie sicher, dass alle persönlichen oder vertraulichen Informationen, die von Expedia oder anderen Quellen extrahiert werden, sicher behandelt werden und die individuellen Datenschutzrechte und -bestimmungen eingehalten werden.