Description des méthodes (v1)

avertissement

Cette API JavaScript est considérée comme obsolète, nous recommandons d'utiliser l'API version 2

Veuillez noter que certaines méthodes nécessitent l'utilisation du mot-clé yield

`yield this.request()`

yield this.request(method, url, queryParams, opts)

Obtention d'une réponse HTTP sur demande, les arguments suivants sont spécifiés :

method - méthode de requête (GET, POST...)
url - lien pour la requête
queryParams - hash avec les paramètres get ou hash avec le corps de la requête post
opts - hash avec les options de la requête

Si la méthode POST est utilisée, le corps de la requête peut être transmis de deux manières :

en énumérant simplement les noms des variables et leurs valeurs dans queryParams. Par exemple :

{
    key: set.query,
    id: 1234,
    type: 'text'
}

via la variable body dans opts. Par exemple :

body: 'key=' + set.query + '&id=1234&type=text'

`opts.check_content`

check_content: [ condition1, condition2, ...] - tableau de conditions pour vérifier le contenu reçu, si la vérification échoue, la requête sera répétée avec un autre proxy.

Possibilités :

utilisation de chaînes de caractères comme conditions (recherche par occurrence de chaîne)
utilisation d'expressions régulières comme conditions
utilisation de vos propres fonctions de vérification, auxquelles sont transmis les données et les en-têtes de la réponse
possibilité de définir plusieurs types de conditions différents à la fois
pour une négation logique, placez la condition dans un tableau, c'est-à-dire check_content: ['xxxx', [/yyyy/]] signifie que la requête sera considérée comme réussie si les données reçues contiennent la sous-chaîne xxxx et que l'expression régulière /yyyy/ ne trouve pas de correspondances sur la page

Pour une requête réussie, toutes les vérifications spécifiées dans le tableau doivent passer

Exemple (les commentaires indiquent ce qui est nécessaire pour que la requête soit considérée comme réussie) :

let response = yield this.request('GET', set.query, {}, {
    check_content: [
        /<\/html>|<\/body>/, //cette expression régulière doit correspondre sur la page reçue
        ['XXXX'], //cette sous-chaîne ne doit pas être présente sur la page reçue
        '</html>', //cette sous-chaîne doit être présente sur la page reçue
        (data, hdr) => {
            return hdr.Status == 200 && data.length > 100;
        } //cette fonction doit retourner true
    ]
});

`opts.decode`

decode: 'auto-html' - détection automatique de l'encodage et conversion en utf8

Valeurs possibles :

auto-html - basé sur les en-têtes, les balises meta et le contenu de la page (option recommandée optimale)
utf8 - indique que le document est en encodage utf8
<encoding> - tout autre encodage

`opts.headers`

headers: { ... } - hash avec les en-têtes, le nom de l'en-tête est spécifié en minuscules, on peut y inclure notamment cookie Exemple :

headers: {
    accept: 'image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8',
    'accept-encoding': 'gzip, deflate, br',
    cookie: 'a=321; b=test',
    'user-agent' 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.150 Safari/537.36'
}

`opts.headers_order`

headers_order: ['cookie', 'user-agent', ...] - permet de redéfinir l'ordre de tri des en-têtes

`opts.recurse`

recurse: N - nombre maximum de redirections à suivre, par défaut 7, utilisez 0 pour désactiver le suivi des redirections

`opts.proxyretries`

proxyretries: N - nombre de tentatives d'exécution de la requête, par défaut pris dans les paramètres du scraper

`opts.parsecodes`

parsecodes: { ... } - liste des codes de réponse HTTP que le scraper considérera comme réussis, par défaut pris dans les paramètres du scraper. Si vous spécifiez '*': 1, toutes les réponses seront considérées comme réussies. Exemple :

parsecodes: {
    200: 1,
    403: 1,
    500: 1
}

`opts.timeout`

timeout: N - délai d'attente de la réponse en secondes, par défaut pris dans les paramètres du scraper

`opts.do_gzip`

do_gzip: 1 - détermine s'il faut utiliser la compression (gzip/deflate/br), activé par défaut (1), pour désactiver, définissez la valeur à 0

`opts.max_size`

max_size: N - taille maximale de la réponse en octets, par défaut pris dans les paramètres du scraper

`opts.cookie_jar`

cookie_jar: { ... } - hash avec les cookies.

`opts.attempt`

attempt: N - indique le numéro de la tentative actuelle, lors de l'utilisation de ce paramètre, le gestionnaire de tentatives intégré pour cette requête est ignoré

`opts.browser`

browser: 1 - émulation automatique des en-têtes du navigateur (1 - activé, 0 - désactivé)

`opts.use_proxy`

use_proxy: 1 - redéfinit l'utilisation du proxy pour une requête individuelle à l'intérieur du scraper JS par-dessus le paramètre global Use proxy (1 - activé, 0 - désactivé)

`opts.noextraquery`

noextraquery: 0 - désactive l'ajout de Extra query string à l'URL de la requête (1 - activé, 0 - désactivé)

`opts.save_to_file`

save_to_file: file - permet de télécharger un fichier directement sur le disque, sans passer par la mémoire vive. Au lieu de file, indiquez le nom et le chemin sous lesquels enregistrer le fichier. Lors de l'utilisation de cette option, tout ce qui concerne data est ignoré (vérification du contenu dans check_content, response.data sera vide, etc.).

`opts.data_as_buffer`

data_as_buffer: 0 - détermine s'il faut retourner data comme une chaîne String (0) ou comme un objet Buffer (1), par défaut une chaîne String est retournée

`opts.bypass_cloudflare`

bypass_cloudflare: 0 - contournement automatique de la protection JavaScript de CloudFlare en utilisant le navigateur Chrome (1 - activé, 0 - désactivé)

`opts.follow_meta_refresh`

follow_meta_refresh: 0 - permet de suivre les redirections déclarées via la balise HTML meta :

<meta http-equiv="refresh" content="time; url=..." />

`opts.tlsOpts`

tlsOpts: { ... } – permet de transmettre les paramètres pour les connexions https

`yield this.parser.request()`

yield this.parser.request(parser, preset, overrideParams, query)

Obtention des résultats d'un autre scraper (intégré ou un autre scraper JS), les arguments suivants sont spécifiés :

parser - nom du scraper (SE::Google, JS::Custom::Example)
preset - préset de configuration du scraper appelé
overrideParams - hash avec les redéfinitions des paramètres du scraper appelé
query - requête

Dans overrideParams, vous pouvez redéfinir les paramètres du scraper appelé, les drapeaux suivants sont également disponibles :

`overrideParams.resultArraysWithObjects`

resultArraysWithObjects: 0 - détermine sous quelle forme retourner les tableaux de résultats du scraper appelé :

si activé (1) - des tableaux d'objets seront retournés

[{link: 'link1', anchor: 'anchor1'}, {link: 'link2', anchor: 'anchor2'}, ...]

si désactivé (0) - des tableaux de valeurs standard seront retournés
```
['link1', 'anchor1', 'link2', 'anchor2', ...]
```

`overrideParams.needData`

needData: 1 - détermine s'il faut transmettre (1) ou non (0) dans la réponse data/pages[], peut être utilisé pour l'optimisation

`tools.*`

Objet global tools, permet d'accéder aux fonctions intégrées d'A-Parser (analogue aux outils du moteur de gabarit $tools.*).

note

tools.query n'est pas disponible, il faut utiliser this.query

`this.doLog()`

Indique si la journalisation de la tâche est activée, peut être utilisé comme drapeau pour l'optimisation, dans les cas où le log n'est pas tenu et que l'argument de this.logger.put est une expression complexe

`this.logger.*`

`.put()`

this.logger.put(message) - ajoute la ligne message au log de la tâche

`.putHTML()`

this.logger.putHTML(code) - sortie de code HTML dans le log de la tâche, qui sera affiché dans le textarea

`yield this.sleep()`

yield this.sleep(sec)

Définit un délai dans le thread pour un nombre de secondes sec, peut être fractionnaire.

`yield this.mutex.*`

Mutex pour la synchronisation entre les threads, permet de verrouiller une section de code pour un seul thread

`.lock()`

Attente du verrou, l'exécution continuera pour le premier thread qui a saisi le verrou, les autres threads attendront la libération du verrou

`.unlock()`

Libération du verrou, le thread suivant continuera l'exécution s'il attendait le verrou (.lock())

`this.cookies.*`

Travail avec les cookies pour la requête actuelle

`.getAll()`

Obtention d'un tableau de cookies

`.setAll()`

Définition des cookies, un tableau de cookies doit être passé en argument

`.set()`

this.cookies.set(host, path, name, value) - définition d'un cookie individuel

`this.query.add()`

this.query.add(query, maxLvl)

Ajout d'une nouvelle requête (query) avec la possibilité optionnelle de spécifier le niveau maximum (maxLvl), similaire à tools.query.add() On peut passer comme requête (query) un hash avec des paramètres, fonctionne de manière analogue au Constructeur de requêtes

Exemple :

this.query.add({
    query: "http://site.com",
    param1: "..",
    ...
});

`this.proxy.*`

Travail avec les proxies

`.next()`

Changer de proxy pour le suivant, l'ancien proxy ne sera plus utilisé pour la requête actuelle

`.ban()`

Changer et bannir le proxy (à utiliser lorsque le service bloque le travail par IP), le proxy sera banni pour la durée spécifiée dans les paramètres du scraper (proxybannedcleanup)

`.get()`

Obtenir le proxy actuel (le dernier proxy avec lequel la requête a été effectuée)

`.set()`

this.proxy.set('http://127.0.0.1:8080', noChange = false) - définir le proxy pour la prochaine requête, le paramètre noChange est optionnel, s'il est défini sur true, le proxy ne changera pas entre les tentatives

`yield this.captcha.*`

Travail avec les captchas

`.recognize()`

yield this.captcha.recognize(preset, image, type, overrides) - chargement d'un captcha pour reconnaissance

image - données binaires de l'image pour la reconnaissance
preset - indique le préréglage pour Util::AntiGate
type spécifie l'un des suivants : 'jpeg', 'gif', 'png'

Le résultat sera un hash avec les champs :

answer - texte de l'image
id - id du captcha, pour pouvoir signaler ultérieurement une erreur via reportBad
error - erreur textuelle, si answer n'est pas défini

`.recognizeFromUrl()`

yield this.captcha.recognizeFromUrl(preset, url, overrides) - similaire à la méthode précédente, mais le chargement du captcha sera effectué automatiquement via le lien (url), sans utiliser de proxy

`.reportBad()`

yield this.captcha.reportBad(preset, id, overrides) - signaler au service que le captcha a été mal résolu

`this.utils.*`

`.updateResultsData()`

this.utils.updateResultsData(results, data) - méthode pour le remplissage automatique de $pages.$i.data et $data, doit être appelée pour ajouter le contenu de la page de résultat

`.urlFromHTML()`

this.utils.urlFromHTML(url, base) - traite un lien obtenu à partir du code HTML - décode les entités (& etc.), on peut optionnellement passer base - l'URL de base (par exemple l'URL de la page source), ainsi un lien complet peut être obtenu

`.url.extractDomain()`

this.utils.url.extractDomain(url, removeDefaultSubdomain) - la méthode prend en premier paramètre un lien et retourne le domaine de ce lien. Le deuxième paramètre optionnel détermine s'il faut supprimer le sous-domaine www du domaine. Par défaut 0 - c'est-à-dire ne pas supprimer.

`.url.extractTopDomain()`

this.utils.url.extractTopDomain(url) - la méthode prend en premier paramètre un lien et retourne le domaine de ce lien, sans les sous-domaines.

`.url.extractTopDomainByZone()`

this.utils.url.extractTopDomainByZone(url) - la méthode prend en premier paramètre un lien et retourne le domaine de ce lien, sans les sous-domaines également. Fonctionne avec toutes les zones régionales

`.url.extractMaxPath()`

this.utils.url.extractMaxPath(url) - la méthode prend une chaîne et en extrait l'URL

`.url.extractWOParams()`

this.utils.url.extractWOParams(url)- la méthode prend un lien et retourne ce même lien tronqué avant la chaîne de paramètres. C'est-à-dire qu'elle retournera l'URL jusqu'au ?

`.removeHtml()`

this.utils.removeHtml(string) - la méthode prend une chaîne et la retourne nettoyée des balises html

`.removeNoDigit()`

this.utils.removeNoDigit(string) - la méthode prend une chaîne, en supprime tout sauf les chiffres et retourne le résultat

`.removeComma()`

this.utils.removeComma(string) - la méthode prend une chaîne, en supprime les caractères tels que .,\r\n et retourne le résultat

`this.sessionManager.*`

Pour utiliser les sessions dans un scraper JS, vous devez d'abord initialiser le Gestionnaire de sessions. Cela se fait à l'aide de la fonction init()

init() {
    this.sessionManager.init({
       //ici vous pouvez définir des paramètres supplémentaires
    });
}

Dans this.sessionManager.init(), vous pouvez utiliser les paramètres suivants :

name - paramètre optionnel, permet de redéfinir le nom du scraper auquel appartiennent les sessions, par défaut égal au nom du scraper dans lequel l'initialisation a lieu
canChangeProxy - paramètre optionnel, possibilité de changer de proxy, par défaut égal à 1
domain - paramètre optionnel, indique de chercher les sessions parmi toutes celles enregistrées pour ce scraper (si la valeur n'est pas définie), ou seulement pour un domaine spécifique (il est nécessaire d'indiquer le domaine avec un point devant, par exemple .site.com)

Il existe plusieurs fonctions pour travailler avec les sessions :

`.get()`

this.sessionManager.get() - obtient une nouvelle session, doit être appelée avant d'effectuer une requête

`.reset()`

this.sessionManager.reset() - effacement des cookies et obtention d'une nouvelle session. Doit être appelée si la requête avec la session actuelle n'a pas réussi.

`.save()`

this.sessionManager.save() - enregistrement d'une session réussie ou enregistrement de données arbitraires dans la session

`results.<array>.addElement()`

La méthode results.<array>.addElement() permet de remplir plus facilement les tableaux dans results. Lors de son utilisation, il n'est pas nécessaire de se souvenir de l'ordre des variables dans le tableau et de les énumérer manuellement.

results.serp.addElement({
    link: 'https://google.com',
    anchor: 'Google',
    snippet: 'Loreps ipsum...',
});

Méthodes `init()` et `destroy()`

La méthode init() est appelée au démarrage de la tâche, destroy() - à la fin.

Exemple d'utilisation :

const puppeteer = require("puppeteer");
let globalBrowser;

class Parser {
    constructor() {
       ...
    }
 
    async init() {
        globalBrowser = await puppeteer.launch();
    };

    async destroy() {
        if(globalBrowser)
            await globalBrowser.close();
    }
}

yield this.request()
yield this.parser.request()
- overrideParams.resultArraysWithObjects
- overrideParams.needData
tools.*
this.doLog()
this.logger.*
- .put()
- .putHTML()
yield this.sleep()
yield this.mutex.*
- .lock()
- .unlock()
this.cookies.*
this.query.add()
this.proxy.*
yield this.captcha.*
this.utils.*
this.sessionManager.*
results.<array>.addElement()
Méthodes init() et destroy()
Liens utiles

yield this.request()​

opts.check_content​

Possibilités :​

opts.decode​

opts.headers​

opts.headers_order​

opts.recurse​

opts.proxyretries​

opts.parsecodes​

opts.timeout​

opts.do_gzip​

opts.max_size​

opts.cookie_jar​

opts.attempt​

opts.browser​

opts.use_proxy​

opts.noextraquery​

opts.save_to_file​

opts.data_as_buffer​

opts.bypass_cloudflare​

opts.follow_meta_refresh​

opts.tlsOpts​

yield this.parser.request()​

overrideParams.resultArraysWithObjects​

overrideParams.needData​

tools.*​

this.doLog()​

this.logger.*​

.put()​

.putHTML()​

yield this.sleep()​

yield this.mutex.*​

.lock()​

.unlock()​

this.cookies.*​

.getAll()​

.setAll()​

.set()​

this.query.add()​

this.proxy.*​

.next()​

.ban()​

.get()​

.set()​

yield this.captcha.*​

.recognize()​

.recognizeFromUrl()​

.reportBad()​

this.utils.*​

.updateResultsData()​

.urlFromHTML()​

.url.extractDomain()​

.url.extractTopDomain()​

.url.extractTopDomainByZone()​

.url.extractMaxPath()​

.url.extractWOParams()​

.removeHtml()​

.removeNoDigit()​

.removeComma()​

this.sessionManager.*​

.get()​

.reset()​

.save()​

results.<array>.addElement()​

Méthodes init() et destroy()​

Liens utiles​

🔗 Exemple d'enregistrement de fichier sur le disque

🔗 Exemple de travail avec les sessions

🔗 Exemple de sauvegarde de données dans une session

🔗 Utilisation de results.addElement()

`yield this.request()`

`opts.check_content`

Possibilités :

`opts.decode`

`opts.headers`

`opts.headers_order`

`opts.recurse`

`opts.proxyretries`

`opts.parsecodes`

`opts.timeout`

`opts.do_gzip`

`opts.max_size`

`opts.cookie_jar`

`opts.attempt`

`opts.browser`

`opts.use_proxy`

`opts.noextraquery`

`opts.save_to_file`

`opts.data_as_buffer`

`opts.bypass_cloudflare`

`opts.follow_meta_refresh`

`opts.tlsOpts`

`yield this.parser.request()`

`overrideParams.resultArraysWithObjects`

`overrideParams.needData`

`tools.*`

`this.doLog()`

`this.logger.*`

`.put()`

`.putHTML()`

`yield this.sleep()`

`yield this.mutex.*`

`.lock()`

`.unlock()`

`this.cookies.*`

`.getAll()`

`.setAll()`

`.set()`

`this.query.add()`

`this.proxy.*`

`.next()`

`.ban()`

`.get()`

`.set()`

`yield this.captcha.*`

`.recognize()`

`.recognizeFromUrl()`

`.reportBad()`

`this.utils.*`

`.updateResultsData()`

`.urlFromHTML()`

`.url.extractDomain()`

`.url.extractTopDomain()`

`.url.extractTopDomainByZone()`

`.url.extractMaxPath()`

`.url.extractWOParams()`

`.removeHtml()`

`.removeNoDigit()`

`.removeComma()`

`this.sessionManager.*`

`.get()`

`.reset()`

`.save()`

`results.<array>.addElement()`

Méthodes `init()` et `destroy()`

Liens utiles