Définition

Le DOM Parsing consiste à analyser le Document Object Model d'une page web pour en extraire des données structurées. Les parsers HTML comme BeautifulSoup (Python), Cheerio (Node.js) ou lxml transforment le HTML brut en arbre navigable. Cette technique est fondamentale pour le web scraping et l'indexation.

Deep Dive

DOM Parsing : l'extraction de données à grande échelle

Parsers populaires par écosystème

**Python**

`BeautifulSoup` : Simple, flexible, lent

`lxml` : Rapide, support XPath

`selectolax` : Ultra-rapide, API moderne

`parsel` : Utilisé par Scrapy

**Node.js**

`cheerio` : API jQuery-like, rapide

`jsdom` : DOM complet, plus lent

`linkedom` : Alternative légère à jsdom

Sélecteurs : CSS vs XPath

**CSS Selectors** - Plus lisibles

```

div.product > h2.title

article[data-id="123"]

li:nth-child(odd)

```

**XPath** - Plus puissants

```

//div[contains(@class, "product")]//h2

//a[starts-with(@href, "/category")]

//text()[normalize-space()]

```

Performance à grande échelle

Pour parser des millions de pages :

1. Utiliser un parser C-based (lxml, selectolax)

2. Parser en streaming si possible

3. Paralléliser avec multiprocessing

4. Éviter les regex sur du HTML

Code Playground

Parsing HTML performant avec selectolax et lxml, incluant gestion des données manquantes

python

# Extraction de données structurées avec selectolax (ultra-rapide)
from selectolax.parser import HTMLParser
from dataclasses import dataclass
from typing import List, Optional
import httpx

@dataclass
class Product:
    name: str
    price: float
    rating: Optional[float]
    url: str

def parse_products(html: str) -> List[Product]:
    """Parse une page produit et extrait les données structurées"""
    tree = HTMLParser(html)
    products = []
    
    for item in tree.css('article.product-card'):
        # Extraction avec gestion des valeurs manquantes
        name_node = item.css_first('h2.product-title')
        price_node = item.css_first('[data-price]')
        rating_node = item.css_first('.rating-value')
        link_node = item.css_first('a.product-link')
        
        if name_node and price_node and link_node:
            product = Product(
                name=name_node.text(strip=True),
                price=float(price_node.attributes.get('data-price', 0)),
                rating=float(rating_node.text()) if rating_node else None,
                url=link_node.attributes.get('href', '')
            )
            products.append(product)
    
    return products

def extract_with_xpath(html: str) -> List[dict]:
    """Alternative avec lxml et XPath pour des requêtes complexes"""
    from lxml import html as lxml_html
    
    tree = lxml_html.fromstring(html)
    
    # XPath pour trouver des patterns complexes
    items = tree.xpath('''
        //article[contains(@class, "product")]
        [.//span[@class="in-stock"]]
        [number(.//span[@data-price]) < 100]
    ''')
    
    return [
        {
            'name': item.xpath('.//h2/text()')[0],
            'price': item.xpath('.//@data-price')[0]
        }
        for item in items
    ]

# Benchmark : selectolax est ~20x plus rapide que BeautifulSoup
# sur des documents HTML volumineux

DOM Parsing