Guia completo para a recolha de dados da Web com PHP

PHP ne sert pas qu’à créer des sites dynamiques. Il peut aussi devenir un allié pour recolher dados em linha.

Graças às bibliotecas especializadas, pode facilmente instalar um raspador eficaz. Vejamos como.

O PHP facilita a raspagem da Web, permitindo que os dados sejam rapidamente recuperados e analisados diretamente a partir de sítios Web. — PHP facilite le web scraping, permettant de récupérer et d’analyser rapidement des données directement depuis les sites web. ©Christina pour Alucare.fr

Pré-requisitos para a recolha de dados com PHP

Antes de começar, certifique-se de que :

✅ D’avoir des programação básica com PHP.
✅ D’avoir des conhecimentos de HTML e CSS para direcionar os dados a extrair.
Saber como utilizar Marcação. C’est un outil pour gérer les dépendances de PHP pour installer les bibliothèques de scraping comme Guzzle, Symfony DomCrawler ou Goutte.
✅ D’avoir un servidor Web local para executar o seu código (XAMPP, WAMP ou MAMP).
✅ D’avoir un editor de código para escrever os seus scripts PHP.

Que ferramentas são essenciais para a recolha de dados da Web com PHP?

O PHP, por si só, não é suficiente. Aqui estão os bibliotecas que tornam o scraping rápido e eficiente.

1. Guzzle : O cliente HTTP

Guzzle é a biblioteca mais utilizada para enviar pedidos HTTP. Pour l’installer avec Marcaçãoabra o seu terminal, vá para a pasta do seu projeto e escreva o comando :

compositor require guzzlehttp/guzzle

O Composer descarrega a biblioteca e torna-a utilizável diretamente no seu código.

Aqui está um exemplo de código simples para récupérer le contenu d’une URL :

request('GET', $url);

    // Obter o código HTTP
    $statusCode = $response->getStatusCode();

    // Obter o conteúdo da página
    $content = $response->getBody()->getContents();

    echo "Código HTTP : " . $statusCode . PHP_EOL;
    echo "Conteúdo da página:" . PHP_EOL;
    echo $content;

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

2. Symfony DomCrawler et Goutte : L’Extraction de Données

Duas bibliotecas são amplamente utilizadas para navegar e analisar HTML:

Symfony DomCrawler que lhe permite navegar no HTML utilizando selectores CSS e visar elementos específicos.
Gota que é um wrapper para o Guzzle e o DomCrawler, simplifica bastante o processo de recolha de dados.

Exemplo com o Symfony DomCrawler :

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

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

// Seleção por classe
$crawler->filter('.my-class')->each(function ($node) {
    echo $node->text() . PHP_EOL;
});

// Seleção por ID
$crawler->filter('#mon-id')->each(function ($node) {
    echo $node->text() . PHP_EOL;
});

// Seleção por etiqueta
$crawler->filter('h1')->each(function ($node) {
    echo $node->text() . PHP_EOL;
});

Exemplo com Goutte

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

// Seleção por classe
$crawler->filter('.ma-class')->each(function ($node) {
    echo $node->text() . PHP_EOL;
});

// Seleção por ID
$crawler->filter('#mon-id')->each(function ($node) {
    echo $node->text() . PHP_EOL;
});

// Seleção por etiqueta
$crawler->filter('p')->each(function ($node) {
    echo $node->text() . PHP_EOL;
});

3. Outras bibliotecas e ferramentas

Pour aller plus loin, voici d’autres options :

PHP-Scraper : c’est une bibliothèque PHP qui facilite l’extraction d’informations depuis des pages web en gérant les complexités du HTML et des sélecteurs. Elle est très utilisée par les développeurs dans leurs projets via Composer.

Instalação do # com o Composer
compose require fabpot/goutte


request('GET', 'https://example.com');
$title = $crawler->filtro('título')->texto();

echo "Título da página: " . $title;

🔥 Dados brilhantes : c’est une plateforme professionnelle pour la collecte de données à grande échelle avec des proxys intégrés.

Bright Data: a ferramenta de recolha de dados da Web mais completa. — Bright Data : l’outil de web scraping le plus complet. ©Christina pour Alucare.fr

🔥 API do raspador : c’est un service de scraping web basé sur le cloud, accessible via une API. Au lieu d’utiliser des bibliothèques locales pour faire tout le travail, vous envoyez une simple requête à l’API de ScraperAPI en spécifiant l’URL de la page à scraper.

Como posso criar um raspador Web simples em PHP?

Aqui está um tutorial para criar um raspador funcional em PHP :

Passo 1: Instalar as dependências

Utilização Marcação para instalar Gota graças ao :

compose require fabpot/goutte

Étape 2 : Récupérer le contenu d’une page

faça um Pedido HTTP GET e rpassar os olhos pelo conteúdo HTML da página utilizando Goutte com o comando :

request('GET', $url);

// Recuperar o HTML em bruto, se necessário
$html = $crawler->html();
echo substr($html, 0, 500) . '...'; // pré-visualização

Passo 3: Extrair os dados

Une fois que vous avez récupéré le contenu HTML de la page, l’objectif est d’extraire des données spécifiques.

Aqui está um exemplo de código PHP para scraper les titres d’une page blogue com Goutte, utilizando um seletor CSS para direcionar o <h2> nos elementos <article>.

<?php
require 'vendor/autoload.php';

use Goutte\Client;

$client = new Client();
$url = 'https://exemple.com/blog'; // Remplacez par l'URL de votre page cible

// Faire une requête GET pour récupérer la page
$crawler = $client->request('GET', $url);

// Sélectionner les éléments <h2> dans <article> avec le sélecteur CSS
$titres = [];

$crawler->filter('article h2')->each(function ($node) use (&$titres) {
    // Récupérer le texte du titre
    $titres[] = trim($node->text());
});

// Afficher les titres extraits
print_r($titres);
?>

Neste exemplo :

Utilizamos o seletor CSS item h2 tags para direcionar títulos de artigos no <h2> à l’intérieur des balises <article>.
O texto de cada título é extraído utilizando o texto(), et nous l’ajoutons au tableau $ítulos.
Os títulos são então apresentados com print_r($itles);.

o Seletores CSS (ou XPath) também pode ser utilizado para extrato atributos d’éléments HTML. Par exemple, si chaque titre de blog est un lien dans une balise <a>, nous pouvons extraire l’attribut href para obter os URLs dos artigos.

👉 Eis um exemplo com Goutte para extrair o ligações artigos :

request('GET', $url);

// Selecionar as ligações nos títulos
$itles = [];

$crawler->filter('article h2 a')->each(function ($node) use (&$itles) {
    $itle = trim($node->text());
    $link = $node->attr('href'); // Extrai o atributo href

    // Adicionar o título e o URL à tabela
    $itles[] = [
        title' => $itle,
        url' => $lien,
    ];
});

// Visualizar os resultados
print_r($itles);
?>

Neste exemplo :

Seleccionamos as ligações contidas no <a> à l’intérieur des balises <h2> nos elementos <article>.
Nous récupérons l’attribut href de cada ligação com o attr('href').
Os títulos e os seus URLs são adicionados à tabela $ítulose depois apresentado com print_r($itles);.

O quadro $ítulos conterá elementos com ambos os título e a link para cada item. Eis um exemplo do formato dos dados devolvidos:

Matriz
(
    [0] => Matriz
        (
            [título] => Título do artigo 1
            [url] => /artigo1
        )

    [1] => Matriz
        (
            [título] => Título do artigo 2
            [url] => /artigo2
        )
)

Neste exemplo :

Cada elemento da matriz é uma matriz associativa com duas chaves: título pour le titre de l’article et url pour l’URL correspondante.
Os dados extraídos são apresentados sob a forma de uma tabela de dois níveis, em que cada entrada contém um título e a respectiva ligação.

Fase 4: Estruturação e armazenamento de dados

Uma vez extraídos os dados, é importante organizá-los corretamente. Para isso, vamos estruturá-los numa Tabela PHPdepois exportá-los num formato estruturado, como JSON Onde CSV.

request('GET', $url);

// Extrair títulos e URLs numa tabela estruturada
$data = [];
$crawler->filter('article h2 a')->each(function ($node) use (&$data) {
    $data[] = [
        title' => trim($node->text()), // Extrair título
        url' => $node->attr('href'), // Extrai o atributo href (URL)
    ];
});

// Visualizar os dados extraídos
print_r($data);
?>

Uma vez organizados os dados, é possível exportá-los no formato JSONque é útil para APIs ou para utilização em aplicações 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'.";
?>

O ficheiro exportar.json será criado num formato legível, que poderá ter o seguinte aspeto:

[
    {
        "title": "Título do artigo 1",
        "url": "/article1"
    },
    {
        "título": "Título do artigo 2",
        "url": "/article2"
    }
]

Se pretender exportar os dados como uma tabela CSV, pode utilizar fputcsv para escrever dados num ficheiro 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'.";
?>

O ficheiro exportar.csv terá o seguinte aspeto:

título,url
Título do artigo 1,/article1
Título do artigo 2,/article2

Como posso lidar com problemas comuns de raspagem da Web em PHP?

Lors d’une opération de recolha de dados da web em PHPNo entanto, é possível encontrar problemas. Eis as soluções para os problemas mais comuns.

1. Gestão de erros

Erros de ligação

Parfois, la requête n’arrive même pas au serveur. Vous pouvez tomber sur “Pas de réseau”, “URL invalide”, “Serveur inaccessible”etc. Neste caso, um try/catch pour éviter que votre script s’arrête brutalement.

👉 Aqui está um exemplo com o Guzzle :

request('GET', 'https://example.com/api/data');
        
        // Verificar se o pedido foi bem sucedido
        if ($response->getStatusCode() === 200) {
            // Processa a resposta se for bem sucedida
            $body = $response->getBody();
            echo "Dados recebidos: " . $body;
        }
        
    } catch (RequestException $e) {
        // Capturar erros de conexão e solicitação
        if ($e->hasResponse()) {
            // Exibe o código de erro, se disponível
            echo "Erro de pedido: " . $e->getResponse()->getStatusCode();
        } else {
            // Se a ligação falhar (por exemplo, servidor inacessível)
            echo "Erro de ligação: " . $e->getMessage();
        }
    }
}

// Chamar a função
make_request_with_guzzle();
?>

Códigos de estado HTTP

Mesmo que a ligação funcione, o servidor pode responder com um erro (404 = página não encontrada, 500 = erro de Internetetc.). Pode testar o código de estado com getStatusCode().

request('GET', 'https://example.com/api/data');
        
        // Verificar o código de estado da resposta
        $status_code = $response->getStatusCode();
        
        // Verificar se o pedido foi bem sucedido
        if ($status_code === 200) {
            // Processa a resposta se for bem sucedida
            $body = $response->getBody();
            echo "Resposta bem sucedida com o código: " . $status_code . "
";
            echo "Dados recebidos: " . $body;
        } elseif ($status_code === 404) {
            echo "Erro 404: Página não encontrada
";
        } elseif ($status_code === 500) {
            echo "Erro 500: Erro interno do servidor
";
        } else {
            echo "Código de estado: " . $status_code . "
";
        }
        
    } catch (RequestException $e) {
        // Capturar erros de conexão e de solicitação
        if ($e->hasResponse()) {
            // Exibe o código de erro HTTP, se disponível
            echo "Erro HTTP: " . $e->getResponse()->getStatusCode() . "
";
        } else {
            // No caso de uma falha de ligação (por exemplo, servidor inacessível)
            echo "Erro de ligação: " . $e->getMessage();
        }
    }
}

// Chamar a função
make_request_with_guzzle();
?>

Erros de análise

Le parsing, c’est l’analyse du HTML par votre scraper. Si la page est mal formée, DomCrawler ou Goutte peuvent planter ou ne rien renvoyer.

Pour gérer ce genre d’erreur, il faut toujours vérifier que le contenu existe avant d’essayer de l’extraire. Utilisez des conditions (count(), filtro()...) pour vous assurer que l’élément ciblé est bien présent. Puis, entourez le parsing dans un try/catch para evitar que o script falhe.

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

        // Verificar se o elemento alvo existe antes de o tentar extrair
        $elements = $crawler->filter('div.target-element');
        
        se ($elements->count() > 0) {
            // O elemento está presente, podemos extraí-lo
            $content = $elements->first()->text();
            echo "Conteúdo extraído: " . $content;
        } else {
            // O elemento não foi encontrado
            echo "O elemento alvo não foi encontrado na página;
        }
        
    } catch (Exception $e) {
        // Apanhar erros de análise
        echo "Erro ao analisar a página: " . $e->getMessage();
    }
}

// Chamar a função
função scrape_website();
?>

2. Contornar as limitações

Alguns sítios utilizam medidas de proteção para dificultar a raspagem.

Bloqueio por IP Pode utilizar proxies como os da plataforma Bright Data.
❗ JavaScript por defeito, o PHP não pode executar JavaScript. Pour ce faire, l’utilisation d’un navigateur sans tête (headless browser) est nécessaire.
❗ Robots.txt Antes de proceder à demolição, é importante verificar este dossier para poder atuar de forma legal e responsável.

Perguntas frequentes

A raspagem da Web é legal?

📌 O legalidade da recolha de dados na Web é um assunto complexo. Em França como noutros países, tudo depende do quadro jurídico, dos dados recolhidos e da forma como são utilizados.

Qual é a diferença entre web scraping e web crawling?

a raspagem da web est le fait d’extraire des données précises sur un site.
a rastreio da web é o ato de navegar nas páginas para as indexar.

A recolha de dados da Web consiste em explorar e descobrir automaticamente vários sítios Web, enquanto a recolha de dados da Web se centra na extração de dados precisos de um alvo específico utilizando software especializado. — Le web crawling consiste à explorer et découvrir automatiquement plusieurs sites web, tandis que le web scraping se concentre sur l’extraction de données précises d’une cible spécifique à l’aide de logiciels spécialisés. ©Christina pour Alucare.fr

Como é que faço scraping de um sítio que requer autenticação (login)?

Para fazer scraping de um sítio que requer autenticação, é necessário simular a ligação. Com PHP, a solução mais comum é Guzzle.

Envia os identificadores através de um pedido POST e, em seguida, mantém a sessão aberta para recuperar as páginas protegidas.

Como é que se gere a recolha de dados de sítios com páginas dinâmicas carregadas em AJAX?

Como um lembrete, o PHP não pode executar código JavaScript do lado do cliente.

Para extrair este tipo de página com PHP, pode utilização BrowserShotuma biblioteca que usa um navegador real em segundo plano (Headless Chrome/Chromium) para carregar a página e executar o JavaScript.

Outra solução é integrar PHP com ferramentas baseadas em Node.jscomo o Puppeteer para gerar o HTML renderizado e, em seguida, recuperar os dados do PHP.

Para todos os tipos de recolha de dados da Web com páginas dinâmicas, pode também utilizar ferramentas especializadas chamadas navegadores sem cabeça.

Existem alternativas ao PHP para a recolha de dados da Web?

Sim, várias línguas são populares:

Python com as suas poderosas bibliotecas, como a BeautifulSoup e a Scrapy.
Node.js que é muito eficaz para a recolha de dados de sítios Web dinâmicos, utilizando bibliotecas como a Puppeteer ou a Cheerio.

O Web scraping com Python funciona utilizando bibliotecas como BeautifulSoup ou Scrapy para navegar em páginas Web e extrair automaticamente os dados desejados. — O Web scraping com Python funciona utilizando bibliotecas como a BeautifulSoup ou a Scrapy para navegar em páginas Web e extrair automaticamente os dados pretendidos. Cristina para Alucare.fr

Comment programmer un “scraper” de manière éthique et responsable ?

Para fazer scraping de forma ética, é necessário :

Verificar o ficheiro robots.txt para conhecer as regras.
✔ Limitar a frequência dos seus pedidos para não sobrecarregar o servidor do sítio.
✔ Respeitar as condições d’utilisation du site.
✔ Não recolher dados pessoais sem autorização.

Em resumo raspagem da web é uma prática poderosa, mas deve ser utilizada de forma metódica e responsável.

👉 E tu, já criaste um raspador em PHP ou outra língua? Partilhe as suas experiências na secção de comentários.