0Pricing
R Academy · 课时

在数值类型之间转换

安全地使用 as.integer()、as.double() 和 as.numeric()

在数值类型之间转换 是 CoddyKit 上的免费 R Academy 课时。 这是第 2 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 R Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 R Academy 课程共包含 4 节课。

R 中的 Integer 与 Double

R 有两种数值类型：integer（整数，通过 L 后缀创建）和 double（浮点数，数值字面量的默认类型）。R 大多数时候使用 double，但区分两者对于类型安全和内存效率很重要。

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() — 转换为 Integer

as.integer(x) 会通过截断（而不是四舍五入）小数部分，将值转换为 integer。这意味着 3.9 会变成 3，而不是 4。L 后缀是整数型字面量的语法简写。

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() 与 as.numeric()

as.double(x) 和 as.numeric(x) 是等价的——两者都会将值转换为 double（浮点数）。当需要保留小数精度时，可以使用它们将整数转换为 double。

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

整数运算

R 中的整数运算对 +、- 和 * 会产生整数，但对 / 始终返回 double。如果您以为整数除法会保持整数类型，这可能会令人意外。

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

截断与四舍五入

有一个关键区别：as.integer() 会截断（去掉小数），而 round() 会四舍五入到最接近的整数。请始终明确您需要哪种行为。

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

整数溢出风险

R 中的整数为 32 位，最多可存储约 ±21 亿。超出此范围会产生一个带警告的 NA。Double 可以存储大得多的值（最大约为 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

向量中的 L 后缀

您可以在每个元素后使用 L 后缀来创建整数向量，也可以将一个序列传递给 as.integer()。冒号运算符 : 会自动生成整数。

# 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

内存与性能

整数每个元素占用 4 个字节；double 每个元素占用 8 个字节。对于非常大的整数向量，使用整数可以将内存占用减半。不过，混合类型之间的运算会自动提升为 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)), '
')

使用 is.integer() 检查整数存储

当您确实需要验证整数存储时，请使用 is.integer()（而不是 is.numeric()）。即使一个数字看起来像整数，只要没有 L 后缀，它就是 double。

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

转换流程示例

一种实用流程是：以 double（默认类型）读取数据，进行计算，然后在需要整数的地方（例如计数、索引和 ID）将结果显式转换为整数。

# 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), '
')

数值转换总结

数值类型的主要转换函数：

  • as.integer(x) — 截断为整数（去掉小数，向零方向截断）
  • as.double(x) / as.numeric(x) — 转换为 double
  • round(x) — 四舍五入到最接近的整数（适用于类似整数的值）
  • floor(x) / ceiling(x) — 向下取整 / 向上取整
  • 5L 语法 — 整数型字面量（无需转换）
  • 1:n — 始终生成整数
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

快速检查

在 R 中，as.integer(3.9) 会返回什么？

回顾：数值类型转换

非常好！本课的要点如下：

  • R 有两种数值类型：integer（L 后缀，占 4 个字节）和 double（默认类型，占 8 个字节）
  • as.integer(x) 会向零方向截断，而不是四舍五入
  • as.double() 和 as.numeric() 完全相同，都会转换为 double
  • 即使操作数是整数，/ 也始终返回 double
  • 1:n 会创建整数序列；不带 L 的数值字面量是 double
  • 整数在约 21 亿处会溢出；对于非常大的整数，请使用 double
# 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)

常见问题解答

「在数值类型之间转换」课时是免费的吗？

是的 — 「在数值类型之间转换」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 R Academy 课程的其余内容，请升级到 CoddyKit PRO。 R Academy 课程共包含 4 节课。

「在数值类型之间转换」这节课中我会学到什么？

安全地使用 as.integer()、as.double() 和 as.numeric() 你通过在浏览器中直接运行的动手代码来练习 R Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 R Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 R Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 2 节课，共 4 节。

「在数值类型之间转换」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 R Academy 课中编写并运行代码吗？

能。每节 R Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. R 类型系统概览
  2. 在数值类型之间转换
  3. 逻辑类型与字符类型转换
  4. 强制类型转换的陷阱与最佳实践
← 返回 R Academy