R语言其他相关函数(各函数解析含实例，可供查询)

一.函数相关

1.函数定义：function

my_sum <- function(x, y) {
  result <- x + y
  return(result)
}

2.调用文件:source

source("file_path.R")
#file_path.R是文件执行的路径

3. Call

my_function <- "mean"
my_arguments <- c(1, 2, 3, 4, 5)
my_call <- call(my_function, my_arguments)
result <- eval(my_call)
#输出 [1] 3

4.Recall

在递归函数中进行递归调用。

factorial <- function(n) {

if (n <= 1) {
    return(1)
  } else {
    return(n * Recall(n - 1))
  }
}
result <- factorial(5)
print(result)  # 输出结果：120

5.browser

插入调试点，逐行执行代码

my_function <- function(x, y) {
  z <- x + y
  browser()  # 在这里插入调试点
  result <- z * 2
  return(result)
}
result <- my_function(3, 4)
print(result)

6.debug和undebug

debug：启用调试模式
undebug:禁用调试模式
my_function <- function(x, y) {
  z <- x + y
  result <- z * 2
  return(result)
}
debug(my_function)  # 启用调试模式
result <- my_function(3, 4)
print(result)
undebug(my_function)  # 禁用调试模式

7.trace

添加跟踪代码，以便追踪函数的执行过程。添加跟踪代码后，每次调用函数时都会输出相关信息。

my_function <- function(x, y) {
  z <- x + y
  result <- z * 2
  return(result)
}
trace(my_function, quote(print(x)), at = 2)  # 添加跟踪代码
result <- my_function(3, 4)
print(result)
untrace(my_function)  # 移除跟踪代码

8.traceback

当程序发生错误时，可以使用 traceback() 来查看导致错误的函数调用链，帮助定位错误来源。

my_function <- function(x, y) {
  z <- x + y
  result <- z * 2
  stop("An error occurred")
  return(result)
}
result <- my_function(3, 4)
print(result)
traceback()  # 显示函数调用堆栈

9.options

常用参数

digits：设置浮点数的显示精度。默认值为 7，表示小数点后显示 7 位有效数字。例如，options(digits = 3) 将显示小数点后的 3 位有效数字。
scipen：控制科学计数法的显示方式。默认值为 0，表示使用标准的十进制显示。通过调整 scipen 的值，可以选择是否使用科学计数法以及在何时启用科学计数法。
warn：控制警告信息的处理方式。默认值为 0，表示将警告信息显示为简短的警告消息。将 warn 设置为正整数可以控制警告信息的显示程度。
max.print：控制打印输出的最大行数。默认值为 9999，表示最大打印行数。如果需要限制打印输出的行数，可以通过设置 max.print 参数来实现。
error：控制错误信息的处理方式。默认值为 dump.frames，表示在发生错误时保存调用堆栈并进入调试模式。通过修改 error 参数，可以选择如何处理错误信息，如简单地中断程序执行或保存调用堆栈等。
stringsAsFactors：控制是否将字符型变量默认转换为因子型。默认值为 TRUE，表示字符型变量在需要时被自动转换为因子型。如果想要禁止自动转换，请设置 stringsAsFactors = FALSE。
options(digits = 3)  # 设置数字的显示精度为 3
x <- sqrt(2)
print(x)  # 输出结果：1.41

10.missing

用于判断函数中的虚参（没有默认值的参数）是否有对应的实参传递

my_function <- function(x, y) {
  if (missing(y)) {
    print("y is missing")
  } else {
    print("y is provided")
  }
}
my_function(10)  # 输出结果：y is missing
my_function(10, 20)  # 输出结果：y is provided

11.nargs

nargs 是一个变量，用于获取函数调用时传递的参数个数。

my_function <- function(...) {
  num_args <- nargs()
  print(paste("Number of arguments:", num_args))
}
my_function(1, 2, 3)  # 输出结果：Number of arguments: 3
my_function("a", "b")  # 输出结果：Number of arguments: 2

12.stop

在函数执行过程中终止函数的执行，并抛出一个错误信息。

my_function <- function(x) {
  if (x <= 0) {
    stop("Input must be a positive number")
  }
  # 执行其他操作
}
my_function(-5)  # 抛出错误：Input must be a positive number

13.指定退出时执行的表达式

cleanup <- function() {
  cat("Performing cleanup operations...\n")
  # 执行清理操作的代码
}
on.exit(cleanup())

14.expression和eval

expression() 函数用于构建一个表达式对象，该对象可以在后续代码中使用 eval() 来进行求值。

expr <- expression(2 + 3 * 4)
result <- eval(expr)
print(result)  # 输出结果：14

15.system.time

用于测量执行给定表达式所需的时间。

result <- system.time({
  # 执行需要计时的代码
  for (i in 1:1000000) {
    sqrt(i)
  }
})
print(result)  # 输出计时信息

16. invisible

在函数内部生成结果，但不立即显示结果

my_function <- function() {
  result <- 10
  invisible(result)  # 隐藏输出结果
}
output <- my_function()
print(output)  # 不会显示输出结果

17.menu

在控制台上显示一个字符列表菜单，并允许用户选择其中的选项

options <- c("Option 1", "Option 2", "Option 3", "Exit")
selection <- menu(options, title = "Select an option:")
if (selection == length(options)) {
#如果选项是4(length),最后一个选项 "Exit" 的索引,则退出
  cat("Exiting the program...\n")
} else {
  cat("You selected:", options[selection], "\n")
}

18.deparse

将 R 对象转换为字符向量

x <- 10
y <- c(1, 2, 3)
dep_x <- deparse(x)
dep_y <- deparse(y)
print(dep_x)  # 输出结果：[1] "10"
print(dep_y)  # 输出结果：[1] "1" "2" "3"

19.do.call

它接受一个函数对象和参数列表，并在给定上下文中执行该函数。

add_numbers <- function(a, b) {
  return(a + b)
}
args <- list(a = 5, b = 3)
result <- do.call(add_numbers, args)
print(result)  # 输出结果：8

20.dput

将 R 对象的表示形式以 R 代码的方式输出到控制台或文件中。

x <- c("apple", "banana", "cherry")
dput(x)
# 输出结果：
# c("apple", "banana", "cherry")

21.environment

使用 environment() 获取当前环境

current_env <- environment()
print(current_env)

22.new.env

创建一个新的空环境

custom_env <- new.env()
assign("x", 10, envir = custom_env)#使用 assign() 将值 10 分配给变量 x
print(custom_env$x)

23.parent.env

获取当前环境的父环境

parent <- parent.env(environment())

print(parent)

24.formals

获取或设置函数的形式参数和其默认值

(1) 获取或设置函数的形式参数和其默认值

# 定义一个简单的函数
my_function <- function(a, b = 10, c = "hello") {
  # 函数体
}
# 使用 formals() 获取函数的形式参数和默认值
parameters <- formals(my_function)
print(parameters)

(2)设置函数的形式参数和默认值：

# 使用 formals() 设置函数的形式参数和默认值
formals(my_function) <- list(a = 20, b = 30, c = "world")
# 打印修改后的形式参数和默认值
print(formals(my_function))

25.interactive

interactive 是一个逻辑值（TRUE 或 FALSE），用于判断当前 R 环境是否为交互式环境

当 R 运行在交互式模式下时，interactive 的值为 TRUE；

当 R 运行在非交互式（批处理）模式下时，interactive 的值为 FALSE。

if (interactive()) {
  print("Running in interactive mode")
} else {
  print("Running in non-interactive mode")
}

26.is.finite

用于检查一个值是否为有限数值（finite numeric）

x <- 10
y <- Inf
print(is.finite(x))  # 输出结果：TRUE
print(is.finite(y))  # 输出结果：FALSE
# y 是无穷大值（Infinity）

27.is.function

用于判断一个对象是否为函数（function）。它返回一个逻辑值（TRUE 或 FALSE）

my_function <- function(x) {
  return(x * 2)
}
print(is.function(my_function))  # 输出结果：TRUE
print(is.function(x))            # 输出结果：FALSE

28.is.language

用于判断一个对象是否为语言对象（language object）。语言对象是 R 中表示表达式和控制结构的一种特殊数据类型。它返回一个逻辑值（TRUE 或 FALSE）。

expr <- quote(print("Hello, world!"))
print(is.language(expr))  # 输出结果：TRUE
print(is.language(x))     # 输出结果：FALSE
# x 是一个变量，不是语言对象

29.is.recursive

用于检查一个对象是否包含递归元素。如果对象是递归的，则返回 TRUE；否则返回 FALSE。

x <- list(1, 2, list(3, 4))
print(is.recursive(x))  # 输出结果：TRUE
print(is.recursive(5))  # 输出结果：FALSE

30.match.arg

将输入参数与指定的可选值进行匹配。它返回与输入参数最匹配的选项值，或者如果没有匹配的选项，则返回一个默认值。

my_function <- function(option) {
  arg <- match.arg(option, choices = c("option1", "option2", "option3"), several.ok = FALSE)
  print(arg)
}
my_function("option2")  # 输出结果：option2
my_function("option4")  # 输出结果：Error in match.arg(option, choices = c("option1", "option2", "option3"), several.ok = FALSE) :
                        # 'arg' must be one of "option1", "option2", "option3"

31.match.call

用于获取当前函数的调用。它返回一个表示函数调用的语法树（call）对象。

my_function <- function(x, y) {
  call <- match.call()
  print(call)
}
my_function(10, 20)
#输出 my_function(x = 10, y = 20)

32.match.fun

用于匹配字符串或符号与函数对象。它返回与输入匹配的函数对象。

add_numbers <- function(a, b) {

 return(a + b)

}

func <- match.fun("add_numbers")

result <- func(10, 20)

print(result)

#输出 [1] 30

33.name

获取对象的名称,并返回一个表示对象名称的字符字符串。

x <- 10

obj_name <- name(x)

print(obj_name)  # 输出结果："x"

34.parse

将字符字符串解析为 R 表达式（expression）对象

它返回一个表示解析后的表达式的对象。

expr_str <- "2 * (x + y)"

expr <- parse(text = expr_str)

print(expr)  # 输出结果：expression(2 * (x + y))

35.quote

用于创建一种特殊的对象，称为表达式（expression），来表示一段代码或一个表达式本身。它返回一个表示给定代码或表达式的对象。

(1)引用表达式

x <- 10

y <- 5

expr <- quote(x + y)

print(expr)  # 输出结果：x + y

（2）使用eval()进行求值

x <- 10

y <- 5

expr <- quote(x + y)

result <- eval(expr)

print(result)  # 输出结果：15

36.deparse

用于将表达式（expression）对象转换为字符字符串。它返回一个表示表达式的字符向量。

expr <- quote(2 * (x + y))

expr_str <- deparse(expr)

print(expr_str)  # 输出结果："2 * (x + y)"

37.substitute

用于将符号（symbol）替换为表达式中的相应值或参数。它返回一个表示替换后的表达式的对象。

x <- 10

y <- 5

expr <- substitute(x + y, list(x = 20))

print(expr)  # 输出结果：20 + y

38.warning

用于生成警告信息

x <- 10

if (x > 5) {

 warning("x 大于 5，可能导致意外结果")

}

二.输入输出相关

1.cat,print

在控制台显示对象或输出结果。

（1）cat

#连接（concatenate）并打印一个或多个对象到控制台，以文本形式显示

x <- 10

y <- 20

cat("x 的值为", x, "，y 的值为", y)

#控制台会显示

x 的值为 10 ，y 的值为 20

（2）print

#使用 print() 函数打印变量 x 和 y 的值。结果会在控制台显示

x <- 10

y <- 20

print(x)

print(y)

#控制台显示

[1] 10

[1] 20

2.sink

sink() 函数用于改变输出的目的地。它可以将输出重定向到文件或其他设备，从而控制输出的保存或显示方式。

(1)将输出重定向到文件

使用 sink() 将输出重定向到名为 "output.txt" 的文件。然后，通过使用 cat() 打印文本 "Hello, world!"，它实际上会被写入到文件中。最后，通过调用 sink()，将输出恢复到标准输出（控制台）。

sink("output.txt")

cat("Hello, world!")

sink()

(2)将输出重定向到字符串变量

#capture.output() 函数用于捕获代码块中的输出，并将其保存为字符向量

output <- capture.output({

 cat("Hello, world!")

})

print(output)

3.dump，save，dput，write

用于将对象输出到文件或控制台的函数

(1)dump

x <- 10

y <- "Hello, world!"

#文件 "data.R" 将包含相应的 R 代码来定义这些对象

dump(c("x", "y"), file = "data.R")

(2)save

x <- 10

y <- "Hello, world!"

#将一个或多个对象保存到二进制文件中

save(x, y, file = "data.RData")

(3)dput

x <- list(a = 1, b = 2)

#用于生成一个对象的可重现表达式，并将其输出到控制台或文件。

dput(x)

(4)write

x <- c(1, 2, 3, 4, 5)

#用于将对象以文本形式写入文件

write(x, file = "data.txt")

4.scan，read.table，readlines, load，dget

用于读取数据或加载对象的函数

（1）scan

#用于逐行扫描输入文件或控制台，并将数据读入为向量或矩阵。

data <- scan("data.txt")

（2）read.table

#用于从文件中读取表格形式的数据，并创建一个数据框（data frame）

df <- read.table("data.txt", header = TRUE)

（3）redlines

#用于从文件中读取表格形式的数据，并创建一个数据框（data frame）

lines <- readlines("data.txt")

（4）load

#用于加载以二进制格式保存的 R 工作空间（Workspace）或对象。

load("data.RData")

（5）dget

#用于将以字符串形式表示的 R 表达式读取为相应的对象

expr <- dget("expression.txt")

三.工作环境相关

1.ls,objects

来显示当前环境中定义的对象列表

x <- 10

y <- "Hello, world!"

# 使用 ls() 函数显示对象列表

print(ls())

# 或者使用 objects() 函数显示对象列表

print(objects())

2.rm(remove)

可以删除一个或多个对象

x <- 10

y <- 20

rm(x)  # 或 remove("x")

#x 对象将从内存中移除，不再可访问

#rm(x, y)（或 remove("x", "y")）将一次性删除 x 和 y 两个对象

#如果要删除当前环境中的所有对象

可以使用 rm(list = ls())（或 remove(list = ls())）来清空环境。

3.q(quit)

两个函数都用于终止 R 会话并退出。

# 使用 q() 函数退出系统

q()

# 或者使用 quit() 函数退出系统

quit()

4.First,Last

(1)First

# .Rprofile 文件

#.First 函数是一个可选的全局环境中的函数，在 R 启动时被自动调用

.First <- function() {

 cat("Welcome to R!")

}

(2)Last

# .Rprofile 文件

#也是一个可选的全局环境中的函数，在 R 即将退出时被自动调用

.Last <- function() {

 cat("Goodbye! Thanks for using R.")

}

5.options

(1)获取当前的系统选项

current_options <- options()

print(current_options)

(2)设置系统选项

# 设置浮点数的显示精度

options(digits = 3)

# 设置警告消息的处理方式

options(warn = 2)

6.?，help，help.start，apropos

(1)?

? 或 help() 函数用于获取特定函数或主题的帮助文档

# 获取特定函数的帮助文档

?mean

help(mean)

# 获取特定主题的帮助文档

?graphics

help("plotting")

(2)help.start

用于启动一个基于 HTML 的本地帮助文档

help.start()

(3)apropos

用于搜索对象名和函数名称，返回与给定字符串相关的所有对象和函数

apropos("plot")

7.data

使用 data() 函数来列出附带R安装的数据集

#使用 data() 函数来列出附带R安装的数据集

# 列出所有附带的数据集

data()

# 查看特定数据集的帮助文档

?iris

8.head

使用 head() 函数来查看数据的前几行

# 查看 iris 数据集的前 6 行

head(iris)

# 查看 mtcars 数据集的前 10 行

head(mtcars, 10)

9.tail

使用 tail() 函数来查看数据的最后几行

# 查看 iris 数据集的最后 6 行

tail(iris)

# 查看 mtcars 数据集的最后 10 行

tail(mtcars, 10)