Grundlæggende html_element() og html_text()
Udtræk tekst, attributter og tabeldata fra scrapede sider.
Grundlæggende html_element() og html_text() er en gratis R Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i R Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. R Academy-kurset indeholder 4 lektioner i alt.
read_html(): Indlæsning af en side
read_html() er indgangspunktet til rvest. Giv den en URL eller en rå HTML-streng. Den returnerer et xml_document-objekt, der repræsenterer det fortolkede DOM-træ og er klar til forespørgsler.
library(rvest)
# From a URL (requires internet connection)
# page <- read_html('https://books.toscrape.com')
# From a raw HTML string (great for testing)
page <- read_html('
<html><body>
<h1>Book Store</h1>
<p class="desc">Over 1000 books!</p>
</body></html>
')
class(page) # 'xml_document' 'xml_node'html_element() versus html_elements()
html_element() returnerer den første matchende node (eller NA, hvis der ikke findes nogen). html_elements() returnerer alle matchende noder som en liste. Brug entalsformen, når du forventer præcis ét resultat, og flertalsformen, når du skraber lister.
library(rvest)
page <- read_html('
<ul>
<li class="item">Apple</li>
<li class="item">Banana</li>
<li class="item">Cherry</li>
</ul>
')
# Singular: gets first match
first_item <- html_element(page, '.item')
html_text2(first_item) # 'Apple'
# Plural: gets all matches
all_items <- html_elements(page, '.item')
html_text2(all_items) # c('Apple', 'Banana', 'Cherry')
length(all_items) # 3html_text2() til ren tekst
html_text2() udtrækker tekstindhold fra noder, fjerner HTML-tags og samler mellemrum på en ren måde. Den håndterer <br> som linjeskift. Den ældre html_text() er mindre intelligent, når det gælder mellemrum.
library(rvest)
page <- read_html('
<div class="product">
<h2> Laptop </h2>
<p>Price: <strong>$999</strong></p>
<p> Free shipping </p>
</div>
')
# html_text2 trims whitespace intelligently
title <- html_element(page, 'h2')
html_text2(title) # 'Laptop' (no extra spaces)
# From the whole div - collapses nested text
div <- html_element(page, '.product')
html_text2(div) # 'Laptop\nPrice: $999\nFree shipping'html_attr(): Udtrækning af attributter
html_attr(node, 'attr_name') udtrækker værdien af en HTML-attribut. Det er nødvendigt for at hente href fra links, src fra billeder, data-*-attributter og meget mere.
library(rvest)
page <- read_html('
<div>
<a href="https://example.com" title="Example site">Visit</a>
<img src="/images/photo.jpg" alt="A photo">
<div data-price="29.99">Product</div>
</div>
')
# Extract href from link
link <- html_element(page, 'a')
html_attr(link, 'href') # 'https://example.com'
html_attr(link, 'title') # 'Example site'
# Extract src from image
img <- html_element(page, 'img')
html_attr(img, 'src') # '/images/photo.jpg'
# Extract data attributes
div <- html_element(page, 'div[data-price]')
html_attr(div, 'data-price') # '29.99'html_attrs(): Alle attributter
html_attrs(node) returnerer en navngivet tegnvektor med ALLE attributter på en node. Det er nyttigt, når du ikke kender attributnavnene på forhånd, eller når du vil undersøge, hvilke attributter der findes på et element.
library(rvest)
page <- read_html('
<a href="/page" class="nav-link" id="home" data-section="main">Home</a>
')
link <- html_element(page, 'a')
# Get all attributes at once
attrs <- html_attrs(link)
attrs
# href class id data-section
# '/page' 'nav-link' 'home' 'main'
# Access by name
attrs['href'] # '/page'
attrs['class'] # 'nav-link'
names(attrs) # all attribute nameshtml_children(): Underordnede noder
html_children(node) returnerer de umiddelbare underordnede noder for et element. Kombineret med html_name() for at hente tagnavne er det nyttigt til programmatisk at forstå sidens struktur.
library(rvest)
page <- read_html('
<nav>
<a href="/">Home</a>
<a href="/about">About</a>
<span>|</span>
<a href="/contact">Contact</a>
</nav>
')
nav <- html_element(page, 'nav')
# Get all direct children
kids <- html_children(nav)
length(kids) # 4
# Get tag names of children
html_name(kids) # c('a', 'a', 'span', 'a')
# Filter to only anchor children
links <- kids[html_name(kids) == 'a']
html_text2(links) # c('Home', 'About', 'Contact')html_name(): Tagnavne
html_name(node) returnerer nodens tagnavn som en streng med små bogstaver (f.eks. 'div', 'p', 'a'). Det er nyttigt til at filtrere nodelister efter elementtype efter hentningen.
library(rvest)
page <- read_html('
<article>
<h2>Title</h2>
<p>First paragraph.</p>
<img src="img.jpg">
<p>Second paragraph.</p>
</article>
')
article <- html_element(page, 'article')
all_children <- html_children(article)
# Check tag name of each child
html_name(all_children)
# c('h2', 'p', 'img', 'p')
# Get only paragraph children
paras <- all_children[html_name(all_children) == 'p']
html_text2(paras)
# c('First paragraph.', 'Second paragraph.')Kædning af udvælgelser
Du kan give en node (ikke kun dokumentet) som første argument til html_element(). Det begrænser søgningen til denne node — afgørende ved skrabning af gentagne strukturer som produktkort eller tabelrækker.
library(rvest)
page <- read_html('
<div class="card">
<h3>Laptop</h3>
<span class="price">$999</span>
</div>
<div class="card">
<h3>Phone</h3>
<span class="price">$499</span>
</div>
')
# Get all cards, then extract fields from each
cards <- html_elements(page, '.card')
names_list <- html_text2(html_elements(page, '.card h3'))
prices_list <- html_text2(html_elements(page, '.card .price'))
data.frame(name = names_list, price = prices_list)html_attr på et nodesæt
Når html_attr() kaldes på et nodeset (resultatet af html_elements()), returnerer den en vektor med attributværdier — én pr. node. Manglende attributter returneres som NA.
library(rvest)
page <- read_html('
<ul>
<li><a href="/page1">Page 1</a></li>
<li><a href="/page2">Page 2</a></li>
<li><span>No link</span></li>
<li><a href="/page3">Page 3</a></li>
</ul>
')
# Get all a elements
links <- html_elements(page, 'a')
# html_attr on a nodeset returns a vector
hrefs <- html_attr(links, 'href')
hrefs # c('/page1', '/page2', '/page3')
# Link text alongside hrefs
texts <- html_text2(links)
data.frame(text = texts, href = hrefs)Håndtering af manglende elementer
html_element() returnerer en NA-node (ikke NULL), når intet matcher. html_text2() på en NA-node returnerer NA_character_. Kontrollér altid, om dine resultater indeholder NA, når elementer kan være valgfrie.
library(rvest)
page <- read_html('
<div class="product">
<h3>Widget</h3>
<!-- No price tag here -->
</div>
')
# Element exists
title <- html_element(page, 'h3')
html_text2(title) # 'Widget'
# Element does NOT exist -> NA node
price <- html_element(page, '.price')
html_text2(price) # NA
is.na(html_text2(price)) # TRUE
# Safe extraction with default
price_text <- html_text2(price)
if (is.na(price_text)) price_text <- 'N/A'
price_text # 'N/A'Samling af det hele
Kombiner html_elements(), html_text2() og html_attr() for at skrabe strukturerede data ind i en data frame — det typiske slutmål med webskrabning i rvest.
library(rvest)
page <- read_html('
<div class="book">
<a href="/book/1" class="title">R Programming</a>
<span class="author">Hadley Wickham</span>
<span class="rating" data-stars="5">*****</span>
</div>
<div class="book">
<a href="/book/2" class="title">Advanced R</a>
<span class="author">Hadley Wickham</span>
<span class="rating" data-stars="5">*****</span>
</div>
')
titles <- html_text2(html_elements(page, '.title'))
authors <- html_text2(html_elements(page, '.author'))
links <- html_attr(html_elements(page, 'a.title'), 'href')
ratings <- html_attr(html_elements(page, '.rating'), 'data-stars')
data.frame(title=titles, author=authors, link=links, stars=ratings)Hurtigt tjek
Test din viden om rvests centrale funktioner til navigation i HTML-dokumenter.
Opsummering: rvests kernefunktioner
Vigtigste pointer: read_html() indlæser sider, html_element() henter det første match, og html_elements() henter alle match. Udpak tekst med html_text2(), attributter med html_attr(), underordnede noder med html_children() og tagnavne med html_name(). Manglende elementer returneres som NA-noder — håndtér altid NA i skrabere, der bruges i produktion.
library(rvest)
# Core rvest workflow:
# 1. Load page
# page <- read_html(url)
# 2. Find elements
# node <- html_element(page, 'css-selector')
# nodes <- html_elements(page, 'css-selector')
# 3. Extract content
# html_text2(node) -> text content
# html_attr(node, 'href') -> attribute value
# html_attrs(node) -> all attributes
# html_name(node) -> tag name
# html_children(node) -> child nodes
# 4. Build data frame
# data.frame(title = html_text2(...), link = html_attr(...))
cat('rvest follows the tidy data philosophy')
Lær R med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 43
- Lektioner
- 159
Ofte stillede spørgsmål
Er lektionen “Grundlæggende html_element() og html_text()” gratis?
Ja — alle 3 lektioner i læringssporet R Academy, inklusive “Grundlæggende html_element() og html_text()”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. R Academy-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Grundlæggende html_element() og html_text()”?
Udtræk tekst, attributter og tabeldata fra scrapede sider. Du øver dig i R Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på R Academy?
Der kræves ingen tidligere erfaring. R Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.
Hvor lang tid tager lektionen “Grundlæggende html_element() og html_text()”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne R Academy-lektion?
Ja. Alle R Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- HTML-struktur og CSS-selectors
- Grundlæggende html_element() og html_text()
- Scraping af tabeller og links
- Håndtering af paginering og flere sider