Hoppa till huvudinnehåll

Hook-metoder

Dessa metoder fungerar enligt hook-principen. Implementering av dessa metoder gör det möjligt att kontrollera scraperns arbete i olika stadier, från initialisering till destruktion av objektet.

Implementering av alla metoder utom parse är valfri.

async parse(set, results)​

Metoden parse implementerar huvudlogiken för att bearbeta en förfrågan och erhålla ett resultat av dataskrapning, följande argument skickas:

  • set - ett objekt med information om förfrågan:
    • set.query - söksträngen i textformat
    • set.lvl - förfrågans nivå, standardvärde är 0
  • results - ett objekt med resultat som behöver fyllas i och returneras från metoden parse()
    • scrapern bör kontrollera förekomsten av varje nyckel i results-objektet och endast fylla i den om den finns, på så sätt optimeras hastigheten och endast de data som används för att forma resultatet skrapas
    • results innehåller nycklar för nödvändiga flat-variabler med värdet none, vilket som standard betyder att inget resultat har erhållits, samt nycklar för array-variabler (arrays) med värdet i form av en tom array, redo att fyllas i
    • results.success bör sättas till värdet 1 vid framgångsrik bearbetning av förfrågan, standardvärdet är 0, vilket innebär att förfrågan bearbetades med fel

Låt oss titta på ett exempel:

class JS_HTML_Tags extends BaseParser {
    static defaultConf = {
        results: {
            flat: [
                ['title', 'Title'],
            ],
            arrays: {
                h2: ['H2 Headers List', [
                    ['header', 'Header'],
                ]],
            }
        },
        ...
    };

    async parse(set, results) {
        // Hämtar innehållet på HTML-sidan vars adress skickades i förfrågan
        const {success, data, headers} = await this.request('GET', set.query);
    
        // Kontrollerar framgång och typ av data; vid korrekt bearbetning av HTML-sidor bör vi få typen 'string', annars returnerar A-Parser ett objekt av typen Buffer
        if (success && typeof data == 'string') {
            let matches;
            
            // Kontrollerar behovet av att samla in title och sparar värdet
            if (results.title && matches = data.match(/<title[^>]*>(.*?)<\/title>/))
                results.title = matches[1];

            // Kontrollerar behovet av att samla in h2
            if (results.h2) {
                let count = 0;
                const re = /<h2[^>]*>(.*?)<\/h2>/g;
                while(matches = re.exec(data)) {
                    // Sparar alla hittade h2-taggar i en loop
                    results.h2.push(matches[1]);
                }
            }

            // Meddelar om framgångsrik dataskrapning
            results.success = 1;
        }

        // Returnerar de bearbetade resultaten
        return results;
    }
};

Observera att du kan skapa egna funktioner och metoder för bättre kodorganisering:

function Answer() {
    return 42;
}

class JS_HTML_Tags extends BaseParser {
    ...

    async parse(set, results) {
        results = await this.doWork(set, results);
        return results;
    }

    async doWork(set, results) {
        results.answer = Answer();
        return results;
    }
};

async processConf?(conf)​

Denna metod används för att transformera konfigurationen enligt vissa regler, till exempel när man använder captcha måste vi alltid använda sessioner:

async processConf(conf) {
    if (conf.useCaptcha)
        conf.useSessions = 1
}

async parse(set, results) {
    if (conf.useSessions)
        await this.login();
}

Existensen av denna metod beror på att A-Parser stöder dynamiska konfigurationsfält och inom ramen för en uppgift kan konfigurationen ha olika värden, ett sådant scenario är möjligt i två fall:

  • Användning av mallar i konfigurationsfält, till exempel [% tools.ua.random() %] för fältet User-Agent
  • Användning av overrides vid anrop av en scraper från en annan för this.parser.request

Metoden processConf anropas en gång före init(). För de fall som beskrivs ovan anropas processConf dessutom före bearbetning av varje förfrågan

Huvudregler för användning av processConf:

  • Använd endast om transformationer av konfigurationen har en effekt på prestandan
  • Tänk på att init körs en gång, medan processConf kan köras för varje förfrågan, i detta fall kan logiken brytas om init beror på föränderliga konfigurationsfält (se nedan)

async init?()​

Metoden init anropas en gång vid initialisering av scraperns basobjekt och tjänar till att utföra engångsåtgärder:

  • Start av webbläsare
  • Initialisering av sessionshanteraren med metoden this.sessionManager.init()
  • Anslutning till databas och skapande av tabeller i DB
  • Läsning av statiska data
  • Och så vidare.
varning

Eftersom metoden anropas en gång kan alla konfigurationsfält som init() beror på inte användas tillsammans med mallar för konfigurationsfält eller med overrides vid anrop av this.parsers.request

async destroy?()​

Metoden destroy anropas en gång när uppgiften avslutas, och är nödvändig för korrekt destruktion av öppna resurser:

  • Stängning av webbläsare
  • Stängning av DB-anslutning
  • Och så vidare.

async threadInit?()​

Denna metod körs vid initialisering av varje tråd, varje tråd är en kopia av scraperns basobjekt med sitt eget unika this.threadId, som börjar med 0 och slutar med threads_count - 1

Huvudsakliga användningsområden:

  • skapande av en webbläsarsida (flik) för varje tråd

async threadDestroy?()​

Körs när en tråd avslutas under processen att avsluta uppgiften, och tjänar till att frigöra resurser som tilldelats för den aktuella tråden

async afterResultsProcessor?(results)​

Denna metod körs efter att resultaten har bearbetats: av resultatkonstruktören, filtrering och dubblettkontroll. Det huvudsakliga användningsområdet är att lägga till frågor i kön med metoden this.query.add efter att användarfilter har tillämpats, på så sätt implementeras länkfiltrering för navigering (followlinks) för scrapern HTML::LinkExtractorHTML::LinkExtractor