Zum Hauptinhalt springen

JavaScript-Scraper: Funktionsübersicht

JavaScript-Parser bieten die Möglichkeit, eigene vollwertige Scraper mit beliebig komplexer Logik unter Verwendung der Sprache JavaScript zu erstellen. Dabei kann in JS-Parsern auch der gesamte Funktionsumfang der Standard-Scraper genutzt werden.

Übersicht

Besonderheiten​

Unter Nutzung der vollen Leistung von A-Parser ist es nun möglich, eigene Scraper/Regger/Poster mit beliebig komplexer Logik zu schreiben. Für die Code-Erstellung wird JavaScript mit ES6-Funktionen (v8-Engine) verwendet.

Der Code der Scraper ist maximal prägnant und erlaubt es, sich auf die Logik zu konzentrieren; die Arbeit mit Multithreading, Netzwerk, Proxys, Ergebnissen, Logs usw. übernimmt A-Parser. Der Code kann direkt in der Benutzeroberfläche des Parsers geschrieben werden, indem ein neuer Parser im Task-Editor hinzugefügt wird. Zudem können externe Editoren wie VSCode zur Entwicklung benutzerdefinierter Scraper verwendet werden.

Beim Speichern des Parser-Codes über den integrierten Editor wird eine automatische Versionierung verwendet.

Hinweis

Die Arbeit mit JavaScript-Parsern ist für die Lizenzen Pro und Enterprise verfügbar.

Zugriff auf den JS-Parser-Editor​

Wenn A-Parser remote verwendet wird, ist der JS-Parser-Editor aus Sicherheitsgründen standardmäßig nicht verfügbar. Um den Zugriff freizuschalten, müssen Sie:

Bedienungsanleitung​

Erstellen Sie im Task-Editor einen neuen Parser und geben Sie ihm einen Namen. Standardmäßig wird ein einfaches Beispiel geladen, auf dessen Basis Sie schnell mit der Erstellung Ihres eigenen Parsers beginnen können.

Hinweis

Wenn ein externer Editor zum Schreiben des Codes verwendet wird, muss die Datei des zu bearbeitenden Parsers im Ordner /parsers/ geöffnet werden. Dateistruktur des installierten Programms.

Sobald der Code fertig ist, speichern Sie ihn und verwenden ihn wie einen gewöhnlichen Parser: Wählen Sie im Task-Editor den erstellten Parser aus, legen Sie bei Bedarf die erforderlichen Parameter, die Thread-Konfiguration, den Dateinamen usw. fest.

Der erstellte Parser kann jederzeit bearbeitet werden. Alle Änderungen an der Benutzeroberfläche erscheinen nach erneuter Auswahl des Parsers in der Liste oder nach einem Neustart von A-Parser; Änderungen in der Logik des Parsers werden beim erneuten Starten eines Auftrags mit diesem Parser wirksam.

Für jeden erstellten Parser wird standardmäßig ein Standard-Icon angezeigt. Sie können ein eigenes Icon im Format png oder ico hinzufügen, indem Sie es im Ordner des Parsers unter /parsers/ ablegen:

Allgemeine Funktionsprinzipien​

Standardmäßig wird ein Beispiel eines einfachen Parsers erstellt, das zur weiteren Bearbeitung bereit ist.

files/parsers/v2-example/v2-example.ts

import { BaseParser } from 'a-parser-types';

export class JS_v2_example extends BaseParser {
    static defaultConf: typeof BaseParser.defaultConf = {
        version: '0.0.1',
        results: {
            flat: [
                ['title', 'HTML title'],
            ]
        },
        max_size: 2 * 1024 * 1024,
        parsecodes: {
            200: 1,
        },
        results_format: '$query: $title\\n',
    };

    static editableConf: typeof BaseParser.editableConf = [];

    async parse(set, results) {
        this.logger.put("Start scraping query: " + set.query);

        let response = await this.request('GET', set.query, {}, {
            check_content: ['<\/html>'],
            decode: 'auto-html',
        });

        if (response.success) {
            let matches = response.data.match(/<title>(.*?)<\/title>/i);
            if (matches)
                results.title = matches[1];
        }

        results.success = response.success;

        return results;
    }
}

Der Konstruktor wird einmalig für jede Aufgabe aufgerufen. Es ist zwingend erforderlich, this.defaultConf.results und this.defaultConf.results_format festzulegen; die übrigen Felder sind optional und nehmen Standardwerte an.

Das Array this.editableConf definiert, welche Einstellungen vom Benutzer über die A-Parser-Oberfläche geändert werden können. Folgende Feldtypen können verwendet werden:

  • combobox - Ein Dropdown-Auswahlmenü. Es kann auch ein Auswahlmenü für ein Preset eines Standard-Parsers erstellt werden, zum Beispiel:
['Util_AntiGate_preset', ['combobox', 'AntiGate preset']]
  • combobox mit Mehrfachauswahl. Hierfür muss zusätzlich der Parameter {'multiSelect': 1} gesetzt werden:
['proxyCheckers', ['combobox', 'Proxy Checkers', {'multiSelect': 1}, ['*', 'All']]]
  • checkbox - Eine Checkbox für Parameter, die nur 2 Werte (true/false) haben können
  • textfield - Ein Textfeld
  • textarea - Ein Textfeld mit mehrzeiliger Eingabe

Die Methode parse ist eine asynchrone Funktion und muss für jede blockierende Operation ein await zurückgeben (dies ist der Haupt- und einzige Unterschied zu einer normalen Funktion). Die Methode wird für jede zur Verarbeitung eingehende Abfrage aufgerufen. Es werden obligatorisch set (ein Hash mit der Abfrage und ihren Parametern) und results (eine leere Vorlage für die Ergebnisse) übergeben. Zudem muss zwingend das ausgefüllte results-Objekt zurückgegeben werden, nachdem zuvor das Flag success gesetzt wurde.

Automatische Versionierung​

Die Version hat das Format Major.Minor.Revision

this.defaultConf: typeof BaseParser.defaultConf = {
    version: '0.1.1',
    ...
}

Der Wert Revision (die letzte Ziffer) wird bei jedem Speichern automatisch erhöht. Die anderen Werte (Major, Minor) können manuell geändert werden, wobei auch die Revision auf 0 zurückgesetzt werden kann.

Tipp

Falls aus irgendeinem Grund die Revision nur manuell geändert werden soll, muss die Version in doppelte Anführungszeichen "" gesetzt werden.

Stapelverarbeitung von Abfragen​

In einigen Fällen kann es erforderlich sein, mehrere Abfragen gleichzeitig aus der Warteschlange zu nehmen und in einem Durchgang zu verarbeiten. Dieser Modus wird bei integrierten Scrapern verwendet, wenn Daten für mehrere Schlüssel gleichzeitig (als Paket) angefordert werden sollen.

Um diese Funktionalität in einem JS-Parser zu implementieren, müssen Sie in this.defaultConf den Wert bulkQueries: N festlegen, wobei N die gewünschte Anzahl der Abfragen im Paket ist. In diesem Fall nimmt der Parser Abfragen in Paketen von N Stück auf, und alle Abfragen der aktuellen Iteration sind im Array set.bulkQueries enthalten (einschließlich aller Standardvariablen: query.first, query.orig, query.prev usw.). Unten ein Beispiel für ein solches Array:

[
    {
        "first": "test",
        "prev": "",
        "lvl": 0,
        "num": 0,
        "query": "test",
        "queryUid": "6eb301",
        "orig": "test"
    },
    {
        "first": "Prüfung",
        "prev": "",
        "lvl": 0,
        "num": 1,
        "query": "Prüfung",
        "queryUid": "774563",
        "orig": "Prüfung"
    },
    {
        "first": "third query",
        "prev": "",
        "lvl": 0,
        "num": 2,
        "query": "third query",
        "queryUid": "2bc8ed",
        "orig": "third query"
    }
]

Die Ergebnisse bei der Stapelverarbeitung müssen im Array results.bulkResults ausgefüllt werden, wobei jedes Element ein results-Objekt ist. Die Elemente in results.bulkResults sind in derselben Reihenfolge angeordnet wie in set.bulkQueries.