So scrapen Sie G2-Produktbewertungen mit JavaScript

Bei der Auswahl neuer Software sind die Perspektiven früherer Benutzer von unschätzbarem Wert. Online-Bewertungen bieten einen direkten Einblick in echte Benutzererfahrungen. In diesem Umfeld hat sich G2 als zuverlässige Plattform für vertrauenswürdiges Software-Feedback etabliert.

Viele Käufer nutzen G2, um sich über die Qualität ihrer Bewertungen zu informieren, und schätzen deren Authentizität und Tiefe. Angesichts dieses Trends sind Unternehmen zunehmend daran interessiert, die Fülle an Informationen zu nutzen, die diese Bewertungen enthalten.

Dieser Leitfaden führt Sie durch den Prozess des Web Scraping von G2-Produktbewertungen. Wir behandeln Themen vom Verständnis der Bewertungsstruktur über das Umgehen potenzieller Sperren bis hin zur Analyse der Daten. Erlernen Sie die Fähigkeiten, um Erkenntnisse aus G2-Bewertungen effektiv zu nutzen.

Inhaltsverzeichnis

I. Projektumfang

II. Erste Schritte

III. Erforderliche Pakete installieren

IV. Initialisieren von ExpressJS und Crawlbase Crawling API

V. Crawlen der G2-Bewertungsseite mit Crawlbase

VI. HTML mit Cheerio parsen

VII. Konfigurieren der Firebase-Datenbank

VIII. Datenspeicherung in der Firebase-Echtzeitdatenbank

IX. Abschluss

X. Häufig gestellte Fragen

I. Projektumfang

Lassen Sie uns den Kern unseres Projekts erkunden, bei dem es um das Extrahieren von G2-Produktbewertungen geht. Um einen reibungslosen Ablauf zu gewährleisten, haben wir eine erstklassige Auswahl an Tools kombiniert: Crawlbase, JavaScript, Firebase, ExpressJS und Cheerio. Jedes dieser Tools spielt in diesem Projekt eine einzigartige Rolle.

1. Der Crawlbase-Vorteil

Crawlbases Crawling API ist unser wichtigstes Tool, wenn es um Herausforderungen wie Blöcke und CAPTCHAs geht. Diese API stellt sicher, dass wir die benötigten Daten ohne Unterbrechungen sammeln können. Mit Crawlbase sind wir bestens gerüstet, um effektiv und effizient zu scrapen.

2. Die Magie von JavaScript entfesseln

JavaScript ist die Magie hinter der modernen Webentwicklung, und wir setzen sie in unserem Projekt ein. Es ist unsere Methode, um Dinge dynamisch geschehen zu lassen. Von der Bearbeitung von Inhalten bis zur Optimierung von HTML-Elementen gibt uns die Flexibilität von JavaScript die Möglichkeit, eine reaktionsfähige und dynamische Scraping-Lösung zu entwickeln.

3. Die Firebase-Verbindung

Firebase ist eine leistungsstarke Echtzeit-Datenbankplattform, auf der wir alle wertvollen G2-Produktbewertungen sicher speichern. Mit Firebase sind unsere Daten übersichtlich organisiert und bei Bedarf jederzeit zur Analyse bereit.

4. Bauen mit Express

Denken Sie an Express.js als starkes Fundament unseres Projekts. Es ist wie das Gerüst, mit dem wir eingehende Anfragen verarbeiten und die Antworten bereitstellen können. Routen einrichten, unsere Scraping-Aufgaben verwalten und eine Verbindung zu Firebase herstellen – all das und mehr ist dank ExpressJS möglich.

5. Cheerio: Der HTML-Magier

Tschüs ist unser Geheimnis zum Verständnis von HTML. Mit diesem Scraper können wir aus dem Roh-HTML von G2-Bewertungen wichtige Informationen extrahieren.

II. Erste Schritte

Erstellen eines Crawlbase-Kontos

Besuchen Sie die Website und Schließen Sie den Anmeldevorgang ab um ein Konto zu erstellen. Behalten Sie den Überblick über Ihre Kontotoken, insbesondere die Normale Anfrage/TCP-Token, da wir es zum Crawlen des Inhalts der G2-Bewertungsseite verwenden werden.

Beachten Sie, dass G2 eine komplexe Website ist und Crawlbase eine spezielle Lösung implementiert, um den Bot-Erkennungsalgorithmus von G2 zu umgehen. Wenden Sie sich an das Support-Team um diese maßgeschneiderte Lösung für Ihr Konto zu aktivieren.

Node.js installieren

Gehe zum Beamten Node.js Website und laden Sie das entsprechende Installationsprogramm für Ihr Betriebssystem (Windows, macOS oder Linux) herunter. Führen Sie das Installationsprogramm aus und folgen Sie den Anweisungen auf dem Bildschirm.

Postman

Erstellen Sie eine kostenlose Postman Konto. Es ist ein beliebtes API-Test- und Entwicklungstool (Application Programming Interface), das die Arbeit mit APIs vereinfacht. Es bietet eine benutzerfreundliche Oberfläche, mit der Entwickler HTTP-Anfragen an APIs senden, die Antworten anzeigen und mit verschiedenen API-Endpunkten interagieren können.

Firebase-Projekt

Richten Sie ein kostenloses Konto ein bei Google Firebase. Behalten Sie Ihr Konto, da wir diese Echtzeitdatenbank im weiteren Verlauf des Artikels verwenden werden.

III. Erforderliche Pakete installieren

Nachdem Sie nun die ersten Grundlagen gelegt haben, statten wir Ihre Entwicklungsumgebung mit den erforderlichen Tools aus. Dazu installieren wir die erforderlichen Pakete mit npm (Node Package Manager).

Mit npm, einem Befehlszeilentool, das Node.js begleitet, können Sie mühelos externe Bibliotheken und Pakete herunterladen und verwalten. Diese Pakete bieten vorgefertigte Funktionen, die verschiedene Aufgaben vereinfachen, einschließlich Web Scraping.

In diesem Schritt initiieren wir ein neues Node.js-Projekt und installieren drei wichtige Pakete: express, cheerio und Crawlbasedem „Vermischten Geschmack“. Seine ExpressJS Paket ermöglicht Ihnen die einfache Erstellung eines Webservers, Tschüs erleichtert das Parsen von HTML und die Crawlbase Bibliothek unterstützt Ihre Scraping-Bemühungen.

Öffnen Sie Ihr Terminal oder Ihre Eingabeaufforderung, navigieren Sie zu Ihrem Projektverzeichnis und führen Sie die folgenden Befehle aus:

npm init --ja
npm install express cheerio crawlbase

Der erste Befehl initialisiert ein neues Node.js-Projekt mit Standardeinstellungen, während der zweite Befehl diese Pakete und ihre Abhängigkeiten herunterlädt und installiert und sie in einem Ordner namens node_modules in Ihrem Projektverzeichnis.

Diese Pakete dienen als Bausteine ​​dieses Projekts und ermöglichen uns die Interaktion mit Webinhalten, das Extrahieren von Informationen und das Speichern wertvoller Erkenntnisse.

IV. Initialisierung von Express und Crawlbase Crawling API

Initialisieren Sie Ihre ExpressJS-App und definieren Sie die erforderlichen Routen. Wir erstellen eine Route für den Scraping-Prozess.

const ausdrücken = erfordern("ausdrücken");
const { CrawlingAPI } = erfordern("Crawlbase" - Übersetzung);

// Verwenden der Crawlbase-Crawling-API zum Crawlen des HTML
const API = neu CrawlingAPI({ Zeichen: "USER_TOKEN" }); // Ersetzen Sie es durch Ihr normales Crawlbase-Token

// Haupt-App
const app = express();
const PORT = Prozess.env.PORT || 3000;

App.bekommen("/kratzen", (erforderlich, res) => {
  Bienen
    .bekommen(erforderlichquery.URL)
    .dann((Antwort) => {
      res.Status(200).JSON(Antwort.Körper);
    })
    .Fang((Fehler) => {
      Rückkehr res.Status(500).senden({ Nachricht: „Anfrage fehlgeschlagen“});
    });
});

App.hören(PORT, () =>
  trösten.Log(`Server läuft auf Port ${PORT}`);
);

Dieser Code richtet einen ExpressJS-Webserver ein, der Web Scraping über die crawlbase Bibliothek. Nach Erhalt einer GET-Anforderung an der /scrape Endpunkt extrahiert der Server eine URL aus einem Abfrageparameter. Anschließend verwendet er die CrawlingAPI Klasse, authentifiziert mit Ihrem user token (achten Sie darauf, den USER_TOKEN-Wert durch Ihren tatsächlichen zu ersetzen Normal request/ TCP token), um eine GET-Anfrage für die angegebene URL auszuführen.

Erfolgreiche Antworten werden in JSON formatiert und an den Client zurückgesendet. Bei Fehlern während des API-Aufrufs antwortet der Server mit einem 500 Statuscode und eine Fehlermeldung. Der Server ist so konfiguriert, dass er auf einem bestimmten Port lauscht oder standardmäßig 3000, mit einer Protokollnachricht, die den Betriebsstatus angibt.

V. Crawlen der G2-Bewertungsseite mit Crawlbase

Beim Extrahieren von G2-Produktbewertungen nutzen wir die leistungsstarken Funktionen von Crawlbase. In diesem Schritt wird der HTML-Inhalt der G2-Bewertungsseite abgerufen, was eine wichtige Voraussetzung für das Parsen und Extrahieren wertvoller Informationen ist.

Durch die Integration von Crawlbase erhalten Sie einen erheblichen Vorteil bei der Bewältigung potenzieller Herausforderungen wie CAPTCHAs und IP-Blockaden. Crawlbases Crawling API ermöglicht es Ihnen, diese Hindernisse zu umgehen und einen effizienten und unterbrechungsfreien Extraktionsprozess sicherzustellen.

Um die Funktionalität Ihres /scrape Route können Sie den ExpressJS-Server initiieren, indem Sie den Befehl ausführen node index.js, oder wenn Sie ein Startskript in Ihrer Datei package.json konfiguriert haben, können Sie npm start. Diese Aktion initiiert den Server und ermöglicht Ihnen, die Funktionalität der definierten Route zu beurteilen.

Der Server ist standardmäßig aktiv und läuft auf Port 3000. Sie können über Ihren Browser darauf zugreifen, indem Sie zu http://localhost:3000.

Zum testen /scrape Route, öffnen Sie Postman und erstellen Sie eine neue GET request. Geben Sie die URL ein http://localhost:3000/scrape und fügen Sie den Abfrageparameter „Anforderungs-URL“ hinzu. In diesem Beispiel crawlen und scrapen wir Xcode-Bewertungen.

Senden Sie die Anfrage durch Klicken auf das Send button. Postman erfasst die Antwort, die den HTML-Inhalt der G2-Produktbewertungsseite enthält.

Indem Sie Postman verwenden, um den HTML-Inhalt unserer Ziel-URL abzurufen, können Sie den zurückgegebenen Inhalt visuell überprüfen. Dieser Validierungsschritt stellt sicher, dass Ihre Integration mit Crawlbase erfolgreich ist und Sie den wesentlichen Webinhalt abrufen können.

VI. HTML mit Cheerio parsen

Sobald wir den HTML-Inhalt erhalten haben, verwenden wir Cheerio, um ihn zu analysieren und die relevanten Informationen zu extrahieren. Dazu müssen die richtigen Selektoren gefunden werden, also Muster, die verwendet werden, um bestimmte Elemente in der HTML-Struktur anzusprechen. So erhalten Sie Selektoren:

1. Überprüfen Sie die Webseite

Öffnen Sie die G2-Produktbewertungsseite in Ihrem Webbrowser. Klicken Sie mit der rechten Maustaste auf das Element, das Sie scrapen möchten, und wählen Sie Inspect or Inspect Element. Dadurch werden die Entwicklertools des Browsers geöffnet.

2. Suchen Sie das Element

In den Entwicklertools sehen Sie die HTML-Struktur der Seite. Navigieren Sie durch die Elemente, bis Sie das Element mit den gewünschten Daten finden. Bewegen Sie den Mauszeiger über verschiedene HTML-Elemente, um sie auf der Seite hervorzuheben und so das richtige Element zu identifizieren.

3. Identifizieren Sie Klassen und IDs

Suchen Sie nach Attributen wie Klasse und ID, die das zu scrapende Element eindeutig identifizieren. Diese Attribute sind Selektoren, die Sie mit Cheerio verwenden können, um den gewünschten Wert zu erhalten.

4. Verwenden Sie CSS-Selektoren

Sobald Sie die Klassen oder IDs identifiziert haben, können Sie sie als CSS-Selektoren in Ihrem Cheerio-Code verwenden. Wenn Sie beispielsweise Bewertungstitel scrapen möchten, haben Sie möglicherweise einen Selektor wie .review-title auf Elemente mit dem review-title Klasse.

5. Testen Sie Selektoren mit Cheerio

Um sicherzustellen, dass Ihre Selektoren korrekt sind, öffnen Sie ein neues Node.js-Skript und verwenden Sie Cheerio, um den HTML-Inhalt zu laden und Ihre Selektoren zu testen. Verwenden Sie die $(selector) Syntax zum Auswählen von Elementen und Überprüfen, ob Sie die richtigen Daten erfassen.

Funktion analysierteDatenausHTML(html) {
  versuchen {
    // Verwenden Sie Cheerio, um HTML zu laden
    const $ = Prost.Belastung(html),
      // ProductData-Objekt initialisieren
      Produktdaten = {
        Produktname: '',
        Sterne: '',
        Gesamtbewertungen: '',
        alleBewertungen[],
      };

    // Füllen Sie productData-Felder mit Cheerio-Selektoren
    Produktdaten['Produktname'] = $(„.product-head [itemprop=name]“).Text();
    Produktdaten['Sterne'] = $('#Produkte-Dropdown .fw-semibold').zuerst().Text();
    Produktdaten[„Gesamtbewertungen“] = $(„.filters-product h3“).Text();

    // Durch Review-Elemente iterieren
    $(„.nested-ajax-loading > div.paper“).jeder((_, Element) => {
      // Daten mit Cheerio-Selektoren extrahieren
      const Gutachtername = $(Element).gefunden(„[itemprop=Autor]“).Text()
        Sterne = $(Element).gefunden(„[itemprop='Bewertungswert']“).attr('Inhalt'),
        Bewertungstext = $(Element)
          .gefunden('.pjax')
          .Text()
          .ersetzen(/[^a-zA-Z ]/g, ''),
        rezensentAvatar = $(element).gefunden(„.avatar [ue=verzögertes Bild]“).attr(„Daten-verzögertes-Bild-Quelle“) || '',
        Bewertungslink = $(Element).gefunden('.pjax').attr('href'),
        ProfilTitel = $(Element)
          .gefunden(„.mt-4th“)
          .Karte((_, Etikett) => $(Bezeichnung).Text())
          .bekommen()
        Profillabels = $(Element)
          .gefunden('[ue=tooltip]')
          .Karte((_, Etikett) => $(Bezeichnung).Text())
          .bekommen()
        Überprüfungsdatum = $(Element).gefunden(„.x-aktuelles-Überprüfungsdatum“).Text();

      // Objekt „reviewData“ füllen und in Array „allReviews“ übertragen
      Produktdaten[„Alle Bewertungen“].drücken({
        Name des Gutachters,
        Rezensionstext,
        Sterne,
        Profiltitel: Profiltitel.Länge ? Profiltitel.join(''): '',
        RezensentAvatar,
        ProfilLabels,
        Überprüfungsdatum,
        Bewertungslink,
      });
    });
    Rückkehr Produktdaten;
  } Fang (Fehler) {
    Rückkehr Fehler;
  }
}

Dieser Code definiert eine Funktion namens parsedDataFromHTML das einen HTML-Inhalt als Eingabe verwendet, der die Cheerio-Bibliothek verwendet, um bestimmte Daten aus dem HTML zu extrahieren. Es initialisiert ein Objekt namens productData mit Feldern für Produktinformationen und Bewertungen.

Der Code verwendet Cheerio-Selektoren, um Details zu extrahieren wie product name, star rating, total reviews countund einzelne Bewertungsdaten. Es durchläuft Bewertungselemente und extrahiert Details zum Bewerter, Bewertungstext, Sternebewertungen, Avatar des Bewerters, Bewertungslinks, Profiltitel, Profilbezeichnungen und Bewertungsdaten.

Alle diese Daten werden in einem strukturierten Objekt organisiert und zurückgegeben. Falls während des Analysevorgangs Fehler auftreten, gibt die Funktion eine Fehlermeldung zurück.

Hinweis: Um zu überprüfen, ob die Analyse erfolgreich war, können Sie die folgenden Schritte ausführen.

1. Stellen Sie sicher, dass Ihr Express-Server auf Port läuft 3000Alternativ können Sie node index.js or npm start um den Server zu starten.
2. Öffnen Postman und erstellen Sie eine neue GET-Anfrage. Geben Sie ein http://localhost:3000/scrape als Anforderungs-URL und fügen Sie die URL-Abfrageparameter hinzu.
3. Senden Sie die Anfrage durch Klicken auf das Send button. Durch Postman wird der JSON-Inhalt der G2-Produktbewertungsseite erfasst.

VII. Konfigurieren der Firebase-Datenbank

An diesem Punkt werden wir Firebase in Ihr Web Scraping-Projekt integrieren. Sie können die folgenden Schritte ausführen.

1. Erstellen Sie ein neues Projekt

Melden Sie sich bei Ihrer Firebase-Konsole an und erstellen Sie ein neues Projekt, indem Sie auf das Add project Schaltfläche. Geben Sie Ihrem Projekt einen passenden Namen und wählen Sie die gewünschten Optionen aus.

2. Erstellen Sie eine Echtzeitdatenbank

Nachdem Sie das Projekt erfolgreich eingerichtet haben, navigieren Sie zum linken Menü der Firebase-Konsole und wählen Sie Database. Klicken Sie dort auf Create Database und entscheide dich für die Start in test mode Auswahl. Mit diesem Ansatz können Sie eine Echtzeitdatenbank mit eingeschränkten Sicherheitsregeln erstellen, die sich gut für Test- und Entwicklungszwecke eignet.

3. Regeln und Sicherheit überprüfen

Im Testmodus ist es wichtig, sich darüber im Klaren zu sein, dass Ihre Datenbank nur mit eingeschränkten Sicherheitsregeln zugänglich ist. Wenn Sie in die Produktion wechseln, überprüfen und implementieren Sie geeignete Sicherheitsregeln zum Schutz Ihrer Daten. Klicken Sie auf Next und dann Enable.

4. Generieren eines privaten Schlüssels

Gehen Sie zu den Einstellungen Ihres Firebase-Projekts und generieren Sie dann ein neues private key speziell für das Firebase Admin SDK. Stellen Sie nach dem Generieren des Schlüssels sicher, dass Sie die resultierende JSON-Datei im Stammverzeichnis Ihres Projekts speichern. Diese JSON-Datei enthält Ihren Dienstkontoschlüssel und ist für die SDK-Funktionalität von entscheidender Bedeutung.

5. Einbindung des privaten Schlüssels

In Ihrem ExpressJS Projekt, installieren Sie das Firebase Admin SDK-Paket und initialisieren Sie es mit Ihrem private key und Datenbank-URL.

npm ich Firebase-Admin

const Administrator = erfordern(„Firebase-Administrator“);
const Dienstkonto = erfordern('./path/to/serviceAccountKey.json'); // Ersetzen Sie es durch Ihren Pfad

Administrator.initialisierenApp({
  Zeugnis: Administrator.Zeugnis.cert(Dienstkonto),
  Datenbank-URL: „https://your-project-id.firebaseio.com“, // Ersetzen Sie es durch Ihre Firebase-URL
});

Dieser Codeausschnitt installiert zunächst die firebase-admin Paket mit npm. Anschließend importiert es das Paket und initialisiert das SDK mit einer JSON-Datei des Dienstkontos zur Authentifizierung und der URL Ihrer Firebase Realtime Database. Mit diesem Setup kann Ihre Node.js-App mithilfe der Funktionen des Admin SDK mit Firebase-Diensten interagieren.

VIII. Datenspeicherung in der Firebase-Echtzeitdatenbank

In deinem /scrape Die Logik der Route strukturiert nach dem Parsen des HTML mit Cheerio die extrahierten Daten in einem für Ihre Anforderungen geeigneten Format. Dies könnte ein Array von Objekten sein, wobei jedes Objekt eine Bewertung darstellt.

1. Wählen Sie einen sinnvollen Speicherort in der Datenbank, um die Bewertungen zu einem bestimmten Produkt zu speichern. Sie können den Produktnamen als Schlüssel in der Datenbank verwenden, um zwischen mehreren Produktbewertungen zu unterscheiden.

2. Implementieren Sie eine Route, wie zum Beispiel ~/productName/reviews, entsprechend dem Speicherort in der Datenbank, an dem Sie die Bewertungen speichern möchten.

3. Wenn eine Anforderung an diese Route gestellt wird, übertragen Sie die strukturierten Daten an den angegebenen Speicherort in der Firebase-Echtzeitdatenbank.

Hier ist der vollständige Code zum Crawlen und Scrapen von G2-Produktbewertungen und zum Speichern der Scraped-Daten in Ihrer Datenbank.

const ausdrücken = erfordern('äußern');
const tschüss = erfordern("Tschüs");
const { CrawlingAPI } = erfordern(„Crawlbase“);
const Administrator = erfordern(„Firebase-Administrator“);
const Dienstkonto = erfordern("./path/to/serviceAccountKey.json'"); // Ersetzen Sie es durch Ihren Pfad

Administrator.initialisierenApp({
  Zeugnis: Administrator.Zeugnis.cert(Dienstkonto),
  Datenbank-URL: „https://your-project-id.firebaseio.com“, // Ersetzen Sie es durch Ihre Firebase-URL
});
// Verwenden der Crawlbase-Crawling-API zum Crawlen des HTML
const API = neu CrawlingAPI({ Zeichen: 'BENUTZERTOKEN' }); // Ersetzen Sie es durch Ihr normales Crawlbase-Token
// Haupt-App
const app = express();
const PORT = Prozess.env.PORT || 3000;

Funktion analysierteDatenausHTML(html) {
  versuchen {
    // Verwenden Sie Cheerio, um HTML zu laden
    const $ = Prost.Belastung(html),
      // ProductData-Objekt initialisieren
      Produktdaten = {
        Produktname: '',
        Sterne: '',
        Gesamtbewertungen: '',
        alleBewertungen[],
      };

    // Füllen Sie productData-Felder mit Cheerio-Selektoren
    Produktdaten['Produktname'] = $(„.product-head [itemprop=name]“).Text();
    Produktdaten['Sterne'] = $('#Produkte-Dropdown .fw-semibold').zuerst().Text();
    Produktdaten[„Gesamtbewertungen“] = $(„.filters-product h3“).Text();

    // Durch Review-Elemente iterieren
    $(„.nested-ajax-loading > div.paper“).jeder((_, Element) => {
      // Daten mit Cheerio-Selektoren extrahieren
      const Gutachtername = $(Element).gefunden(„[itemprop=Autor]“).Text()
        Sterne = $(Element).gefunden(„[itemprop='Bewertungswert']“).attr('Inhalt'),
        Bewertungstext = $(Element)
          .gefunden('.pjax')
          .Text()
          .ersetzen(/[^a-zA-Z ]/g, ''),
        rezensentAvatar = $(element).gefunden(„.avatar [ue=verzögertes Bild]“).attr(„Daten-verzögertes-Bild-Quelle“) || '',
        Bewertungslink = $(Element).gefunden('.pjax').attr('href'),
        ProfilTitel = $(Element)
          .gefunden(„.mt-4th“)
          .Karte((_, Etikett) => $(Bezeichnung).Text())
          .bekommen()
        Profillabels = $(Element)
          .gefunden('[ue=tooltip]')
          .Karte((_, Etikett) => $(Bezeichnung).Text())
          .bekommen()
        Überprüfungsdatum = $(Element).gefunden(„.x-aktuelles-Überprüfungsdatum“).Text();

      // Objekt „reviewData“ füllen und in Array „allReviews“ übertragen
      Produktdaten[„Alle Bewertungen“].drücken({
        Name des Gutachters,
        Rezensionstext,
        Sterne,
        Profiltitel: Profiltitel.Länge ? Profiltitel.join(''): '',
        RezensentAvatar,
        ProfilLabels,
        Überprüfungsdatum,
        Bewertungslink,
      });
    });
    Rückkehr Produktdaten;
  } Fang (Fehler) {
    Rückkehr Fehler;
  }
}

App.bekommen('/kratzen', (erforderlich, res) => {
  Bienen
    .bekommen(erforderlichquery.URL)
    .dann((Antwort) => {
      const analysierteDaten = analysierteDatenausHTML(Antwort.Körper);
      const Datenbankreferenz = admin.Datenbank().ref(`${parsedData['Produktname']}/`); // Ersetzen Sie durch den Pfad, in dem Sie die Daten speichern möchten

      Datenbankreferenz
        .drücken(analysierte Daten)
        .dann(() => {
          Rückkehr res.Status(200).JSON(analysierte Daten);
        })
        .Fang((Fehler) => {
          res.Status(500).senden('Fehler beim Speichern der Daten: ' + Fehler.Nachricht);
        });
    })
    .Fang((Fehler) => {
      trösten.Log(Fehler, 'FEHLER');
      Rückkehr res.Status(500).senden({ Status: 'Fehlgeschlagen', msg: „Daten nicht gespeichert“ });
    });
});

App.hören(PORT, () => trösten.Log(`Server läuft auf Port ${PORT}`));

Zusammenfassend lässt sich sagen, dass dieser Code eine Node.js-App mit mehreren Funktionen erstellt. Zunächst werden wichtige Bibliotheken importiert, darunter express.js zur Webserver-Erstellung, cheerio für die HTML-Analyse, crawlbase für das Web-Crawling und firebase-admin zur Interaktion mit Firebase-Diensten. Das Firebase Admin SDK wird mit der JSON-Datei eines Dienstkontos und der entsprechenden Datenbank-URL initialisiert. Eine Instanz des CrawlingAPI Die Klasse wird mit einem Benutzertoken instanziiert, um das Web-Crawling zu erleichtern.

Der Code erstellt dann eine ExpressJS-App und stellt sie so ein, dass sie auf einem bestimmten Port lauscht, entweder einem benutzerdefinierten oder dem Standardport 3000. Eine Funktion namens parsedDataFromHTML ist definiert und verwendet Cheerio-Selektoren, um HTML-Inhalte zu analysieren und in organisierte Daten zu strukturieren.

Eine Route /scrape wird innerhalb der ExpressJS-App eingerichtet und ist für die Verarbeitung von GET-Anfragen konfiguriert. Nach Erhalt einer Anfrage durchsucht die API die angegebene URL mithilfe der CrawlingAPIDie Antwort wird analysiert mit dem parsedDataFromHTML Funktion, was zu strukturierten Daten führt. Diese analysierten Daten werden dann über das Firebase Admin SDK in der Firebase Realtime-Datenbank gespeichert und unter einem bestimmten Pfad abgelegt. Bei erfolgreicher Datenspeicherung wird eine JSON-Antwort mit den analysierten Daten ausgegeben.

Wir haben nun erfolgreich eine nahtlose Verbindung zwischen der ExpressJS-App und der Firebase Realtime-Datenbank hergestellt, sodass Sie die extrahierten G2-Produktbewertungen strukturiert und organisiert speichern können. Dadurch wird sichergestellt, dass diese wertvollen Erkenntnisse sicher gespeichert und bei Bedarf leicht zugänglich sind.

IX. Abschluss

Hier ist ein einfaches Flussdiagramm, das unseren Projektumfang zusammenfasst:

Zusammenfassend hat Sie dieser umfassende Leitfaden mit den notwendigen Techniken ausgestattet, um G2-Produktbewertungen mithilfe von JavaScript und Crawlbase kompetent zu extrahieren. Indem Sie sich an die detaillierten Schritte halten, haben Sie ein tiefgreifendes Verständnis für die Navigation in der Produktoberfläche von G2, die Verfeinerung und Strukturierung der abgerufenen Daten und deren effiziente Archivierung in einer Datenbank für die anschließende Analyse erlangt.

Die Bedeutung von Web Scraping für die Gewinnung umsetzbarer Geschäftserkenntnisse ist unbestreitbar. Es bildet eine solide Grundlage für fundierte Entscheidungen, Produktverbesserungen und maßgeschneiderte Strategien. Es ist jedoch wichtig, die Notwendigkeit ethischer Scraping-Praktiken zu betonen – die Einhaltung der Website-Bedingungen ist unerlässlich.

Denken Sie bei Ihrer weiteren Reise mit Crawlbase daran, dass es beim Web Scraping nicht nur um technische Fähigkeiten, sondern auch um Verantwortung geht. Lernen Sie kontinuierlich dazu und nutzen Sie diese Fülle an Daten, um neue Möglichkeiten zu erkennen und zukunftsweisende Innovationen voranzutreiben.

Die Welt des Web Scraping ist dynamisch und expansiv und bietet eine Fülle an Wissen und Erkenntnissen, die Ihrem Unternehmen erheblich zugute kommen können. Nehmen Sie die Herausforderungen an, nutzen Sie die Chancen optimal und lassen Sie sich bei Ihren zukünftigen Unternehmungen mit Crawlbase von Ihrer Entdeckerlust leiten.

X. Häufig gestellte Fragen

F. Wie hilft Crawlbase beim Crawlen und Scrapen? g2.com und andere Websites?

Die Crawlbase-API verwendet fortschrittliche Algorithmen und ein umfangreiches Proxy-Netzwerk, um durch Blöcke und CAPTCHAs zu navigieren und gleichzeitig Ihre IP bei jeder Anfrage effektiv zu maskieren. Dieser strategische Prozess garantiert Anonymität und verhindert, dass die Zielwebsites Ihre Crawling-Aktivitäten verfolgen.

Für den Umgang mit komplexen Websites wie G2.com haben wir eine maßgeschneiderte Lösung implementiert, die geschulte KI-Bots nutzt. Diese Erweiterung verbessert unsere Fähigkeit, Proxy-Herausforderungen zu umgehen und Unterbrechungen durch Blockierungen zu vermeiden. Durch die Nutzung erstklassiger privater Netzwerke in den USA ahmen wir effektiv das authentische Surfverhalten von Menschen nach. Dieser Ansatz gewährleistet ein nahtloses und unterbrechungsfreies Crawling-Erlebnis.

F: Kann ich eine andere Datenbank verwenden?

In diesem Blog wurde die Nutzung der Firebase Realtime Database zum Speichern von Scraped-Daten vorgestellt. Ihre Auswahl ist jedoch nicht nur auf diese Möglichkeit beschränkt. Abhängig von den spezifischen Anwendungsfällen oder Anforderungen Ihres Projekts können Sie sich mit alternativen Datenbanklösungen wie MongoDB, PostgreSQL, MySQL oder sogar Cloud-basierten Plattformen wie Amazon DynamoDB befassen.

F: Wie kann ich die Seitennummerierung beim Scraping von G2-Bewertungen handhaben?

Die Handhabung der Seitennummerierung beim Scraping von G2-Bewertungen umfasst das Abrufen von Daten aus mehreren Seiten des Bewertungsbereichs. Hier ist ein allgemeiner Ansatz zur Handhabung der Seitennummerierung beim Web Scraping:

1. Paginierungsmethode identifizieren: Untersuchen Sie die Struktur der G2-Bewertungsseite, um festzustellen, wie die Paginierung implementiert ist. In diesem Fall umfasst die Implementierung von G2 das Klicken auf die Schaltfläche „Weiter“ unten auf der Bewertungsseite.

2. URLs oder Parameter anpassen: Wenn bei der Paginierung URL-Parameter (wie Seitenzahlen) in der URL geändert werden müssen, ändern Sie die URL für jede Seite entsprechend, wie im folgenden Beispiel gezeigt.
   1 Seite: https://www.g2.com/products/xcode/reviews
   2 Seite: https://www.g2.com/products/xcode/reviews.html?page=2
   3 Seite: https://www.g2.com/products/xcode/reviews.html?page=3

3. Seiten durchlaufen: Sobald Sie die Paginierungsmethode verstanden haben, verwenden Sie eine Schleife, um durch die Seiten zu iterieren. Senden Sie eine Anfrage an jede Seite, um Daten mithilfe Ihrer Scraping-Bibliothek (z. B. Axios, Fetch) zu crawlen und zu scrapen, um den HTML-Inhalt abzurufen. Analysieren Sie dann das HTML, um die gewünschten Informationen mithilfe von Cheerio oder einer anderen HTML-Parsing-Bibliothek zu extrahieren.

F: Wie kann ich die Rechtmäßigkeit und Ethik von Web Scraping sicherstellen?

Um die Legitimität und Ethik des Web Scraping sicherzustellen, müssen die von Websites festgelegten Regeln und Richtlinien eingehalten werden. Bevor Sie mit dem Scraping beginnen, sollten Sie sich einen Moment Zeit nehmen, um die Nutzungsbedingungen der Website gründlich durchzulesen und die robots.txt-Datei zu überprüfen. Achten Sie außerdem auf die Daten, die Sie extrahieren, und vergewissern Sie sich, dass Sie die rechtmäßige Befugnis besitzen, diese für Ihre beabsichtigten Ziele zu verwenden. Dieser Ansatz trägt dazu bei, eine verantwortungsvolle und ethische Scraping-Praxis aufrechtzuerhalten.