Guida completa al web scraping con PHP

PHP non serve solo a creare siti dinamici. Può anche diventare un alleato per raccogliere dati online.

Grazie alle librerie specializzate, è possibile impostare un raschietto efficace. Vediamo come.

PHP facilita il web scraping, consentendo di recuperare e analizzare rapidamente i dati direttamente dai siti web. ©Christina per Alucare.fr

Prerequisiti per lo scraping con PHP

Prima di iniziare, accertarsi che :

✅ Avere programmazione di base con PHP.
✅ Avere conoscenza di HTML e CSS per indirizzare i dati da estrarre.
✅ Saper usare Quadrante. Si tratta di uno strumento per gestire le dipendenze PHP per installare librerie di scraping come Guzzle, Symfony DomCrawler o Goutte.
✅ Avere un server web locale per eseguire il codice (XAMPP, WAMP o MAMP).
✅ Avere un editor di codice per scrivere gli script PHP.

Quali strumenti sono essenziali per il web scraping con PHP?

PHP da solo non basta. Qui ci sono le biblioteche che rendono lo scraping veloce ed efficiente.

1. Guzzle: il client HTTP

Guzzle è la libreria più utilizzata per inviare richieste HTTP. Per installarlo con Quadranteaprire il terminale, andare nella cartella del progetto e digitare il comando :

composer richiede guzzlehttp/guzzle

Composer scarica la libreria e la rende utilizzabile direttamente nel codice.

Ecco un esempio di codice semplice per recuperare il contenuto di un URL :

request('GET', $url);

    // Recuperare il codice HTTP
    $statusCode = $response->getStatusCode();

    // Recuperare il contenuto della pagina
    $content = $response->getBody()->getContents();

    echo "Codice HTTP: " . $statusCode . PHP_EOL;
    echo "Contenuto della pagina:" . PHP_EOL;
    echo $content;

} catch (\Exception $e) {
    echo "Errore: " . $e->getMessage();
}

2. Symfony DomCrawler e Goutte: l'estrazione dei dati

Due librerie sono ampiamente utilizzate per la navigazione e l'analisi dell'HTML:

Symfony DomCrawler che consente di navigare nell'HTML usando i selettori CSS e di puntare a elementi specifici.
Goccia che è un wrapper per Guzzle e DomCrawler e semplifica notevolmente il processo di scraping.

Esempio con Symfony DomCrawler :

request('GET', 'https://exemple.com');

$html = $response->getBody()->getContents();
$crawler = nuovo Crawler($html);

// Selezione per classe
$crawler->filtro('.my-class')->each(function ($node) {
    echo $node->text() . PHP_EOL;
});

// Selezione per ID
$crawler->filtro('#mon-id')->each(function ($node) {
    echo $node->text() . PHP_EOL;
});

// Selezione per tag
$crawler->filtro('h1')->each(function ($node) {
    echo $node->text() . PHP_EOL;
});

Esempio con Goutte

request('GET', 'https://exemple.com');

// Selezione per classe
$crawler->filtro('.ma-class')->each(function ($node) {
    echo $node->text() . PHP_EOL;
});

// Selezione per ID
$crawler->filtro('#mon-id')->each(function ($node) {
    echo $node->text() . PHP_EOL;
});

// Selezione per tag
$crawler->filtro('p')->each(function ($node) {
    echo $node->text() . PHP_EOL;
});

3. Altre librerie e strumenti

Per approfondire, ecco altre opzioni:

🔥 PHP-Scraper : è una libreria PHP che facilita l'estrazione di informazioni dalle pagine web gestendo le complessità dell'HTML e dei selettori. È molto utilizzata dagli sviluppatori nei loro progetti tramite Composer.

Installazione di # con Composer
comporre richiedere fabpot/goutte


request('GET', 'https://example.com');
$title = $crawler->filtro('titolo')->testo();

echo "Titolo della pagina: " . $title;

🔥 Dati luminosi : è una piattaforma professionale per la raccolta di dati su larga scala con proxy integrati.

Bright Data: lo strumento di scraping web più completo. — Bright Data: lo strumento di web scraping più completo. ©Christina per Alucare.fr

🔥 ScraperAPI : è un servizio di web scraping basato su cloud, accessibile tramite API. Invece di utilizzare librerie locali per eseguire tutto il lavoro, è sufficiente inviare una semplice richiesta all'API di ScraperAPI specificando l'URL della pagina da sottoporre a scraping.

Come si crea un semplice web scraper in PHP?

Ecco un tutorial per creare uno scraper funzionale in PHP:

Passo 1: Installazione delle dipendenze

Utilizzo Quadrante per installare Goccia grazie al :

comporre richiedere fabpot/goutte

Fase 2: Recuperare il contenuto di una pagina

Fare un Richiesta HTTP GET e rscremare il contenuto HTML della pagina utilizzando Goutte con il comando :

request('GET', $url);

// Recuperare l'HTML grezzo, se richiesto
$html = $crawler->html();
echo substr($html, 0, 500) . '...'; // anteprima

Fase 3: Estrazione dei dati

Una volta recuperato il contenuto HTML della pagina, l'obiettivo è quello di estrarre dati specifici.

👉 Ecco un esempio di codice PHP per scraper i titoli di una pagina blog con Goutte, utilizzando un selettore CSS per indirizzare l'elemento <h2> negli elementi <article>.

request('GET', $url); // Seleziona gli elementi <h2> in <article> con il selettore CSS $titres = [];

$crawler-&gt;filter('article h2')-&gt;each(function ($node) use (&amp;$titres) { // Recupera il testo del titolo $titres[] = trim($node-&gt;text()); });

// Visualizza i titoli estratti print_r($titres); ?&gt;

In questo esempio:

Utilizziamo il selettore CSS voce h2 per indirizzare i titoli degli articoli nella sezione <h2> all'interno dei tag <article>.
Il testo di ogni titolo viene estratto utilizzando il metodo testo(), e lo aggiungiamo alla tabella $itoli.
I titoli vengono quindi visualizzati con print_r($itoli);.

Il Selettori CSS (o XPath) può essere utilizzato anche per estratto attributi elementi HTML. Ad esempio, se ogni titolo del blog è un link in un tag <a>, possiamo estrarre l'attributo href per ottenere gli URL degli articoli.

👉 Ecco un esempio con Goutte per estrarre il collegamenti articoli :

request('GET', $url);

// Selezionare i link nei titoli
$itoli = [];

$crawler->filtro('articolo h2 a')->each(function ($node) use (&$itoli) {
    $itle = trim($node->text());
    $link = $node->attr('href'); // Estrarre l'attributo href

    // Aggiungere il titolo e l'URL alla tabella
    $itoli[] = [
        title' => $itle,
        url' => $lien,
    ];
});

// Visualizzare i risultati
print_r($itoli);
?>

In questo esempio:

Selezioniamo i link contenuti nel <a> all'interno dei tag <h2> negli elementi <article>.
Recuperiamo l'attributo href di ogni collegamento con il attr('href').
I titoli e i relativi URL vengono aggiunti alla tabella $itoliquindi visualizzato con print_r($itoli);.

👉 Il dipinto $itoli conterrà elementi con entrambi gli elementi titolo e il collegamento per ogni elemento. Ecco un esempio del formato dei dati restituiti:

Array
(
    [0] => Array
        (
            [title] => Titolo dell'articolo 1
            [url] => /articolo1
        )

    [1] => Array
        (
            [title] => Titolo dell'articolo 2
            [url] => /articolo2
        )
)

In questo esempio:

Ogni elemento dell'array è un array associativo con due chiavi : titolo per il titolo dell'articolo e url per l'URL corrispondente.
I dati estratti sono presentati sotto forma di tabella a due livelli, con ogni voce contenente un titolo e un link associato.

Fase 4: strutturazione e archiviazione dei dati

Una volta estratti i dati, è importante organizzarli correttamente. A tale scopo, li struttureremo in un file Tabella PHPquindi esportarli in un formato strutturato come JSON Dove CSV.

request('GET', $url);

// Estrarre titoli e URL in una tabella strutturata
$data = [];
$crawler->filtro('articolo h2 a')->each(function ($node) use (&$data) {
    $data[] = [
        title' => trim($node->text()), // Estrai il titolo
        url' => $node->attr('href'), // Estrarre l'attributo href (URL)
    ];
});

// Visualizzare i dati estratti
print_r($data);
?>

Una volta organizzati i dati, è possibile esportarli nel formato JSONutile per le API o per l'uso nelle applicazioni web:

<?php
// Exporter les données en JSON
file_put_contents('export.json', json_encode($data, JSON_PRETTY_PRINT|JSON_UNESCAPED_UNICODE));

echo "Les données ont été exportées en JSON dans 'export.json'.";
?>

Il file esportazione.json sarà creato in un formato leggibile, che potrebbe assomigliare a questo:

[
    {
        "title": "Titolo dell'articolo 1",
        "url: "/articolo1".
    },
    {
        "title": "Titolo dell'articolo 2",
        "url": "/articolo2".
    }
]

Se si desidera esportare i dati come tabella CSV, si può utilizzare il metodo fputcsv per scrivere i dati in un file CSV :

<?php
// Exporter les données en CSV
$fp = fopen('export.csv', 'w');

// Ajouter l'en-tête (titres des colonnes)
fputcsv($fp, ['title', 'url']);

// Ajouter chaque ligne de données
foreach ($data as $row) {
    fputcsv($fp, [$row['title'], $row['url']]);
}

// Fermer le fichier
fclose($fp);

echo "Les données ont été exportées en CSV dans 'export.csv'.";
?>

Il file esportazione.csv avrà il seguente aspetto:

titolo,url
Titolo articolo 1,/articolo1
Titolo articolo 2,/articolo2

Come si possono risolvere i problemi più comuni di web scraping in PHP?

Durante un'operazione di scraping del web in PHPTuttavia, è possibile incontrare dei problemi. Ecco le soluzioni per quelli più comuni.

1. Gestione degli errori

Errori di connessione

A volte la richiesta non arriva nemmeno al server. Potresti imbatterti in “Nessuna rete”, "URL non valido", “Server non raggiungibile”ecc. In questo caso, un try/catch per evitare che lo script si interrompa bruscamente.

👉 Ecco un esempio con Guzzle :

request('GET', 'https://example.com/api/data');
        
        // Verificare se la richiesta è andata a buon fine
        if ($response->getStatusCode() === 200) {
            // Elaborare la risposta in caso di successo
            $body = $response->getBody();
            echo "Dati ricevuti: " . $body;
        }
        
    } catch (RequestException $e) {
        // Cattura gli errori di connessione e di richiesta
        if ($e->hasResponse()) {
            // Mostra il codice di errore, se disponibile
            echo "Errore di richiesta: " . $e->getResponse()->getStatusCode();
        } else {
            // Se la connessione fallisce (ad esempio, server irraggiungibile)
            echo "Errore di connessione: " . $e->getMessage();
        }
    }
}

// Chiamare la funzione
make_request_with_guzzle();
?>

Codici di stato HTTP

Anche se la connessione funziona, il server potrebbe rispondere con un errore (404 = pagina non trovata, 500 = errore internetecc.). È possibile verificare il codice di stato con getStatusCode().

request('GET', 'https://example.com/api/data');
        
        // Controllare il codice di stato della risposta
        $status_code = $response->getStatusCode();
        
        // Controllare se la richiesta è andata a buon fine
        if ($status_code === 200) {
            // Elaborare la risposta in caso di esito positivo
            $body = $response->getBody();
            echo "Risposta riuscita con codice: " . $status_code . "
";
            echo "Dati ricevuti: " . $body;
        } elseif ($status_code === 404) {
            echo "Errore 404: pagina non trovata".
";
        } elseif ($status_code === 500) {
            echo "Errore 500 : errore interno del server
";
        } else {
            echo "Codice di stato: " . $status_code . "
";
        }
        
    } catch (RequestException $e) {
        // Cattura gli errori di connessione e di richiesta
        if ($e->hasResponse()) {
            // Mostra il codice di errore HTTP, se disponibile
            echo "Errore HTTP: " . $e->getResponse()->getStatusCode() . "
";
        } else {
            // In caso di fallimento della connessione (ad esempio, server irraggiungibile)
            echo "Errore di connessione: " . $e->getMessage();
        }
    }
}

// Chiamare la funzione
make_request_with_guzzle();
?>

Errori di parsing

Il parsing è l'analisi dell'HTML da parte del vostro scraper. Se la pagina è malformata, DomCrawler o Goutte potrebbero bloccarsi o non restituire alcun risultato.

Per gestire questo tipo di errore, è necessario verificare sempre che il contenuto esista prima di provare a estrarlo. Utilizzare le condizioni (conteggio(), filtro()...) per assicurarsi che l'elemento desiderato sia effettivamente presente. Quindi, racchiudere il parsing in un try/catch per evitare che lo script si blocchi.

request('GET', 'https://example.com');

        // Verificare che l'elemento di destinazione esista prima di tentare di estrarlo
        $elements = $crawler->filtro('div.target-element');
        
        if ($elements->count() > 0) {
            // L'elemento è presente, possiamo estrarlo
            $content = $elements->first()->text();
            echo "Contenuto estratto: " . $content;
        } else {
            // L'elemento non è stato trovato
            echo "L'elemento di destinazione non è stato trovato nella pagina;
        }
        
    } catch (Exception $e) {
        // Cattura gli errori di parsing
        echo "Errore durante l'analisi della pagina: " . $e->getMessage();
    }
}

// Chiamare la funzione
funzione scrape_website();
?>

2. Come aggirare le limitazioni

Alcuni siti utilizzano misure di protezione per rendere più difficile lo scraping.

Blocco per IP È possibile utilizzare proxy come quelli presenti sulla piattaforma Bright Data.
❗ JavaScript per impostazione predefinita, PHP non può eseguire JavaScript. A tal fine è necessario utilizzare un browser headless (browser senza interfaccia grafica).
❗ Robots.txt Prima di rottamare, è importante controllare questo fascicolo per poter agire in modo legale e responsabile.

Domande frequenti

Il web scraping è legale?

📌 Il legalità del web scraping è un argomento complesso. In Francia come altrove, tutto dipende dal quadro giuridico, dai dati raccolti e dal modo in cui vengono utilizzati.

Qual è la differenza tra web scraping e web crawling?

il scraping del web è l'estrazione di dati precisi da un sito.
il crawling del web è l'atto di sfogliare le pagine per indicizzarle.

Il web crawling consiste nell'esplorare e scoprire automaticamente diversi siti web, mentre il web scraping si concentra sull'estrazione di dati precisi da un obiettivo specifico utilizzando un software specializzato. — Il web crawling consiste nell'esplorare e scoprire automaticamente diversi siti web, mentre il web scraping si concentra sull'estrazione di dati precisi da un obiettivo specifico utilizzando software specializzati. ©Christina per Alucare.fr

Come si esegue lo scraping di un sito che richiede l'autenticazione (login)?

Per eseguire lo scraping di un sito che richiede l'autenticazione, occorre simulare la connessione. Con PHP, la soluzione più comune è Guzzle.

Si inviano gli identificatori tramite una richiesta POST, quindi si mantiene aperta la sessione per recuperare le pagine protette.

Come si gestisce lo scraping di siti con pagine dinamiche caricate in AJAX?

Come promemoria, PHP non può eseguire codice JavaScript lato client.

Per effettuare lo scraping di questo tipo di pagine con PHP, è possibile utilizzo BrowserShotuna libreria che utilizza un vero browser in background (Headless Chrome/Chromium) per caricare la pagina ed eseguire il codice JavaScript.

Un'altra soluzione è quella di integrare PHP con strumenti basati su Node.jscome Puppeteer per generare HTML renderizzato e poi recuperare i dati da PHP.

Per tutti i tipi di web scraping con pagine dinamiche, è possibile utilizzare anche strumenti specializzati chiamati browser senza testa.

Esistono alternative a PHP per il web scraping?

Sì, sono diffuse diverse lingue:

Pitone con le sue potenti librerie come BeautifulSoup e Scrapy.
Node.js che è molto efficace per lo scraping di siti web dinamici, utilizzando librerie come Puppeteer o Cheerio.

Il web scraping con Python funziona utilizzando librerie come BeautifulSoup o Scrapy per sfogliare le pagine web ed estrarre automaticamente i dati desiderati. Cristina per Alucare.fr

Come programmare uno "scraper" in modo etico e responsabile?

Per fare scraping in modo etico, è necessario :

Controllare il file robots.txt per scoprire le regole.
✔ Limitare la frequenza delle richieste in modo da non sovraccaricare il server del sito.
✔ Rispettare le condizioni utilizzo del sito.
✔ Non raccogliere dati personali senza autorizzazione.

In sintesi scraping del web è una pratica potente, ma deve essere usata con metodo e responsabilità.

👉 E voi, avete mai creato un scraper in PHP o un'altra lingua? Condividete le vostre esperienze nella sezione commenti.