Guia completo para a recolha de dados da Web com PHP

PHP não serve apenas para criar sites dinâmicos. Também pode tornar-se um aliado para 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. — O PHP facilita o web scraping, permitindo recuperar e analisar rapidamente dados diretamente dos sites. ©Christina para Alucare.fr

Pré-requisitos para a recolha de dados com PHP

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

✅ Ter programação básica com PHP.
✅ Ter conhecimentos de HTML e CSS para direcionar os dados a extrair.
Saber como utilizar Marcação. É uma ferramenta para gerir as dependências do PHP para instalar bibliotecas de scraping como Guzzle, Symfony DomCrawler ou Goutte.
✅ Ter um servidor Web local para executar o seu código (XAMPP, WAMP ou MAMP).
✅ Ter um 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. Para instalá-lo com 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 recuperar o conteúdo de um 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 e Goutte: Extração de Dados

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

Para ir mais longe, eis outras opções:

PHP-Scraper : é uma biblioteca PHP que facilita a extração de informações de páginas web, gerindo as complexidades do HTML e dos seletores. É muito utilizada pelos programadores nos seus projetos através do 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 : é uma plataforma profissional para a recolha de dados em grande escala com proxies integrados.

Bright Data: a ferramenta de recolha de dados da Web mais completa. — Bright Data: a ferramenta de web scraping mais completa. ©Christina para Alucare.fr

🔥 API do raspador : é um serviço de scraping web baseado na nuvem, acessível através de uma API. Em vez de usar bibliotecas locais para fazer todo o trabalho, você envia uma simples solicitação à API do ScraperAPI, especificando a URL da página a ser raspada.

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

Etapa 2: Recuperar o conteúdo de uma página

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

Depois de recuperar o conteúdo HTML da página, o objetivo é extrair dados específicos.

Aqui está um exemplo de código PHP para extrair os títulos de uma página 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> dentro das balizas <article>.
O texto de cada título é extraído utilizando o texto(), e adicionamo-lo à tabela $í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 de elementos HTML. Por exemplo, se cada título do blog for um link em uma tag <a>, podemos extrair o atributo 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> dentro das balizas <h2> nos elementos <article>.
Recuperamos o atributo 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 para o título do artigo e url para o URL correspondente.
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?

Durante uma operação 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

Às vezes, a solicitação nem chega ao servidor. Você pode se deparar com “Sem rede”, “URL inválido”, “Servidor inacessível”etc. Neste caso, um try/catch para evitar que o seu script pare abruptamente.

👉 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

A análise é a análise do HTML pelo seu scraper. Se a página estiver mal formatada, o DomCrawler ou o Goutte podem travar ou não retornar nada.

Para gerir este tipo de erro, deve sempre verificar se o conteúdo existe antes de tentar extraí-lo. Utilize condições (count(), filtro()...) para garantir que o elemento pretendido está realmente presente. Em seguida, envolva a análise num 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. Para isso, é necessário utilizar um navegador sem interface gráfica (headless browser).
❗ 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 é o ato de extrair dados precisos de um 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. — O web crawling consiste em explorar e descobrir automaticamente vários sites, enquanto o web scraping se concentra na extração de dados específicos de um alvo específico usando software especializado. ©Christina para 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

Como programar um «scraper» de forma ética e responsável?

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 de utilização do 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.