数据类型是指数据的存储格式，定义了存储在变量中的数据的性质和类别，通常无法分解成更简单的类型。

元素类型（element type）

R 有 5种基础和 4 种特殊的 element types：

基础 特殊
numeric ：integer（整型）double（双精度） raw（原始型）
logical（逻辑） NA（缺失值）
character（字符串） NULL（空）
complex （复数型） expression（表达式）

2.1 numeric

2.1.1 integer

Show the code
mode(2024L)
#> [1] "numeric"
typeof(2024L)
#> [1] "integer"

2.1.2 double

十进制decimal ()，科学计数法scientific () ，十六进制hexadecimal ()

Show the code
mode(1.1)
#> [1] "numeric"
typeof(1.1)
#> [1] "double"
0.1234
#> [1] 0.1234
1.23e4
#> [1] 12300
0x111   # 16^2×1+ 16^1×1 + 16^0×1
#> [1] 273

浮点标准定义的特殊值

Inf(正无穷)，-Inf（负无穷），NaN（非数）

  • Infinity 无穷大

    Show the code
    mode(-Inf)
#> [1] "numeric"
Inf
#> [1] Inf

  • NaN，Not a Number，非数字

    Show the code
    NaN
#> [1] NaN
0 / 0
#> [1] NaN
is.nan(0 / 0)
#> [1] TRUE
mode(0 / 0)
#> [1] "numeric"

2.2 logical

比较运算符 ?Comparison

逻辑运算符?Logic

Show the code
typeof(TRUE)
#> [1] "logical"
x <- c(T,F,T)
y <- c(T,T,F)

# 非
!x
#> [1] FALSE  TRUE FALSE

# 与
x&y
#> [1]  TRUE FALSE FALSE
T&&F
#> [1] FALSE
# 或
x|y
#> [1] TRUE TRUE TRUE
T||F
#> [1] TRUE

# 异或  不同为TRUE 或 1
xor(x,y)
#> [1] FALSE  TRUE  TRUE

2.3 character

Show the code
typeof("R language")
#> [1] "character"
sprintf("%.30f", 5.2)
#> [1] "5.200000000000000177635683940025"

2.4 强制类型转换

逻辑 -> 整数 -> 浮点数 -> 字符

2.5 complex

Show the code
z <- 2+3i
typeof(z) 
#> [1] "complex"
is.complex(z)
#> [1] TRUE
# 获取实部
Re(z)
#> [1] 2

# 获取虚部
Im(z)
#> [1] 3

# 模
Mod(z)
#> [1] 3.605551

# 共轭
Conj(z)
#> [1] 2-3i

2.6 raw

Show the code
charToRaw("abcde12345") #每个字符的原始二进制表示（ASCII码）转换成16进制输出
#>  [1] 61 62 63 64 65 31 32 33 34 35
typeof(charToRaw("abcde12345")) 
#> [1] "raw"
# ?raw

2.7 NA

NA，Not Available，该值是其他内容的占位符，因此长度为 1

实际上，每种原子类型有一个缺失值：NA_logical_、NA_integer_、NA_double_、NA_character_。

Show the code
length(NA)
#> [1] 1

2.8 NULL

长度始终为零，并且没有属性。

Show the code
typeof(NULL)
#> [1] "NULL"
length(NULL)
#> [1] 0
is.null(NULL)
#> [1] TRUE
c()
#> NULL

2.9 表达式

expression是一种特殊的 element type，单独的一个expression存储的是一个没有执行的 R 代码

Show the code
expr <- expression(1 + 3)
typeof(expr)
#> [1] "expression"
eval(expr)
#> [1] 4