R Academy · Lektion

Konvertera mellan numeriska typer

Använd as.integer(), as.double() och as.numeric() på ett säkert sätt.

Lektion 2 av 413 steg

Konvertera mellan numeriska typer är en gratis lektion i R Academy på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för R Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i R Academy innehåller totalt 4 lektioner.

Integer jämfört med double i R

R har två numeriska typer: integer (heltal, skapade med suffixet L) och double (flyttal, standardtypen för numeriska literaler). För det mesta använder R double, men det är viktigt att skilja dem åt för typsäkerhet och effektiv minnesanvändning.

x_dbl <- 5        # double by default
x_int <- 5L       # integer (L suffix)

cat('typeof(5):  ', typeof(x_dbl), '
')  # double
cat('typeof(5L): ', typeof(x_int), '
')  # integer
cat('5 == 5L:    ', x_dbl == x_int, '
') # TRUE (values equal)
cat('identical:  ', identical(x_dbl, x_int), '
')  # FALSE (types differ)

as.integer() — konvertera till integer

as.integer(x) konverterar ett värde till integer genom att trunkera (inte avrunda) decimaldelen. Det innebär att 3.9 blir 3, inte 4. Suffixet L är syntaktisk kortform för heltalsliteraler.

cat('as.integer(3.7):  ', as.integer(3.7), '
')   # 3 (truncated, not 4)
cat('as.integer(3.2):  ', as.integer(3.2), '
')   # 3
cat('as.integer(-2.9): ', as.integer(-2.9), '
')  # -2 (toward zero)
cat('as.integer(10.9): ', as.integer(10.9), '
')  # 10

# Compare with round
cat('round(3.7):        ', round(3.7), '
')       # 4

as.double() och as.numeric()

as.double(x) och as.numeric(x) är likvärdiga — båda konverterar till ett double-värde (flyttal). Använd dem för att konvertera heltal till double när Ni behöver precision för bråkdelar.

count <- 7L  # integer
cat('typeof(count):         ', typeof(count), '
')

dbl_count <- as.double(count)
cat('typeof(as.double(7L)): ', typeof(dbl_count), '
')  # double
cat('Value:                 ', dbl_count, '
')           # 7

# Division automatically promotes to double
cat('7L / 2L:              ', 7L / 2L, '
')            # 3.5 (double)
cat('typeof(7L / 2L):      ', typeof(7L / 2L), '
')    # double

Heltalsaritmetik

Heltalsaritmetik i R ger heltal för +, - och *, men returnerar alltid double för /. Det kan bli förvånande om Ni förväntar Er att heltalsdivision ska förbli ett heltal.

a <- 6L
b <- 3L

cat('6L + 3L =', a + b, '| typeof:', typeof(a + b), '
')  # 9 integer
cat('6L - 3L =', a - b, '| typeof:', typeof(a - b), '
')  # 3 integer
cat('6L * 3L =', a * b, '| typeof:', typeof(a * b), '
')  # 18 integer
cat('6L / 3L =', a / b, '| typeof:', typeof(a / b), '
')  # 2 DOUBLE!
cat('6L %/% 3L =', a %/% b, '| typeof:', typeof(a %/% b), '
') # 2 integer

Trunkering jämfört med avrundning

En viktig skillnad är att as.integer() trunkerar (tar bort decimaler), medan round() avrundar till närmaste heltal. Var alltid tydlig med vilket beteende Ni avser.

values <- c(2.1, 2.5, 2.9, -2.1, -2.5, -2.9)

cat('Original:     ', values, '
')
cat('as.integer():  ', as.integer(values), '
')  # truncate toward 0
cat('round():       ', round(values), '
')       # banker rounding
cat('floor():       ', floor(values), '
')       # round down
cat('ceiling():     ', ceiling(values), '
')     # round up

Risk för heltalsöverflöde

Heltal i R är 32-bitars och kan innehålla värden upp till ungefär ±2,1 miljarder. Om detta intervall överskrids blir resultatet NA och en varning visas. Double kan innehålla betydligt större värden (upp till cirka 1,8 × 10^308).

max_int <- .Machine$integer.max
cat('Max integer:', max_int, '
')  # 2147483647

# Overflow produces NA
cat('max_int + 1L:', max_int + 1L, '
')  # NA with warning

# Double handles it fine
cat('as.double(max_int) + 1:', as.double(max_int) + 1, '
')  # 2147483648

Suffixet L i vektorer

Ni kan skapa heltalsvektorer genom att använda suffixet L på varje element eller genom att skicka en sekvens till as.integer(). Kolonoperatorn : skapar automatiskt heltal.

# Colon produces integers
seq_int <- 1:5
cat('1:5 typeof:', typeof(seq_int), '
')  # integer

# Explicit integer vector
vec_int <- c(10L, 20L, 30L, 40L)
cat('c(10L,...) typeof:', typeof(vec_int), '
')  # integer

# as.integer on a vector
vec_dbl <- c(1.1, 2.9, 3.5, 4.7)
cat('as.integer(c(1.1,...)):', as.integer(vec_dbl), '
')  # 1 2 3 4

Minne och prestanda

Heltal använder 4 byte per element, medan double använder 8 byte. För mycket stora vektorer med heltal kan användning av heltal halvera minnesåtgången. Aritmetik mellan blandade typer omvandlas dock automatiskt till double.

n <- 1000000L

vec_int <- 1:n          # integer: 4 bytes each
vec_dbl <- as.double(1:n)  # double: 8 bytes each

cat('Integer vector size:', object.size(vec_int), 'bytes
')
cat('Double vector size: ', object.size(vec_dbl), 'bytes
')
cat('Ratio:', as.numeric(object.size(vec_dbl)) / as.numeric(object.size(vec_int)), '
')

Kontrollera heltalslagring med is.integer()

Använd alltid is.integer() (inte is.numeric()) när Ni specifikt behöver verifiera heltalslagring. Ett tal utan suffixet L är double även om det ser ut som ett heltal.

a <- 5    # looks like integer, but it is double
b <- 5L   # true integer

cat('is.integer(5):  ', is.integer(a), '
')   # FALSE!
cat('is.integer(5L): ', is.integer(b), '
')   # TRUE
cat('is.numeric(5):  ', is.numeric(a), '
')   # TRUE
cat('is.numeric(5L): ', is.numeric(b), '
')   # TRUE
cat('class(5):       ', class(a), '
')        # numeric
cat('class(5L):      ', class(b), '
')        # integer

Exempel på konverteringsflöde

Ett praktiskt arbetsflöde är att läsa in data som double (standardtypen), utföra beräkningar och sedan uttryckligen konvertera resultaten till heltal där heltal krävs (till exempel antal, index och ID:n).

# Simulated: reading counts as doubles (common from CSV)
counts_raw <- c(12.0, 8.0, 15.0, 3.0, 22.0)
cat('typeof raw:', typeof(counts_raw), '
')  # double

# Convert to integer for proper storage
counts_int <- as.integer(counts_raw)
cat('typeof converted:', typeof(counts_int), '
')  # integer
cat('Counts:', counts_int, '
')
cat('Total:', sum(counts_int), '
')

Sammanfattning av numerisk konvertering

Viktiga konverteringsfunktioner för numeriska typer:

as.integer(x) — trunkera till integer (tar bort decimaler, mot noll)
as.double(x) / as.numeric(x) — konvertera till double
round(x) — avrunda till närmaste heltal (använd för heltalsliknande värden)
floor(x) / ceiling(x) — avrunda nedåt / uppåt
5L-syntax — heltalsliteral (ingen konvertering behövs)
1:n — skapar alltid heltal

x <- 7.8
cat('as.integer(7.8):', as.integer(x), '
')  # 7 (truncate)
cat('round(7.8):     ', round(x), '
')       # 8
cat('floor(7.8):     ', floor(x), '
')       # 7
cat('ceiling(7.8):   ', ceiling(x), '
')     # 8

Snabb kontroll

Vad returnerar as.integer(3.9) i R?

Besvara frågan i den interaktiva lektionen

Sammanfattning: konvertering av numeriska typer

Utmärkt! Här är lektionens viktigaste punkter:

R har två numeriska typer: integer (suffixet L, 4 byte) och double (standardtypen, 8 byte)
as.integer(x) trunkerar mot noll — den avrundar inte
as.double() och as.numeric() är identiska — de konverterar till double
/ returnerar alltid double, även när operanderna är heltal
1:n skapar heltalssekvenser; numeriska literaler utan L är double
Heltalsöverflöde vid cirka 2,1 miljarder → använd double för mycket stora heltal

# Demonstrate truncation vs rounding
test_vals <- c(0.1, 0.5, 0.9, 1.5, 2.5, 3.7)
cat('Values:      ', test_vals, '
')
cat('as.integer(): ', as.integer(test_vals), '
')  # truncation
cat('round():      ', round(test_vals), '
')       # nearest (banker)

Gratis att börja

Lär dig R med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 43
Lektioner: 159

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Konvertera mellan numeriska typer” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen R Academy, inklusive ”Konvertera mellan numeriska typer”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i R Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Konvertera mellan numeriska typer”?

Använd as.integer(), as.double() och as.numeric() på ett säkert sätt. Ni övar på R Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig R Academy?

Du behöver inga förkunskaper. Utbildningen i R Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Konvertera mellan numeriska typer”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här R Academy-lektionen?

Ja. Varje R Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Översikt över R:s typsystem
Konvertera mellan numeriska typer
Konvertering mellan logical och character
Fallgropar och bästa praxis vid typomvandling

← Tillbaka till R Academy