¿Cuál es la diferencia entre require()y library()?

Además del buen consejo ya dado, agregaría esto:

Probablemente sea mejor evitar el uso a require() menos que realmente esté usando el valor que devuelve, por ejemplo, en algún bucle de comprobación de errores como el que da thierry.

En la mayoría de los otros casos, es mejor usarlo library(), ya que esto dará un mensaje de error en el momento de cargar el paquete si el paquete no está disponible. require()simplemente fallará sin un error si el paquete no está allí. Este es el mejor momento para averiguar si el paquete necesita ser instalado (o tal vez ni siquiera existe porque se deletrea mal). Obtener comentarios de error temprano y en el momento relevante evitará posibles dolores de cabeza al rastrear por qué el código posterior falla cuando intenta usar rutinas de biblioteca

No hay mucho de uno en el trabajo diario.

Sin embargo, de acuerdo con la documentación de ambas funciones (a la que se accede colocando un ?antes del nombre de la función y presionando enter), requirese usa dentro de las funciones, ya que genera una advertencia y continúa si no se encuentra el paquete, mientras libraryque arrojará un error.

Otro beneficio de require()es que devuelve un valor lógico por defecto. TRUEsi los paquetes están cargados, FALSEsi no lo está.

> test <- library("abc")
Error in library("abc") : there is no package called 'abc'
> test
Error: object 'test' not found
> test <- require("abc")
Loading required package: abc
Warning message:
In library(package, lib.loc = lib.loc, character.only = TRUE, logical.return = TRUE,  :
  there is no package called 'abc'
> test
[1] FALSE

Por lo tanto, puede usar require()en construcciones como la siguiente. Lo que es principalmente útil si desea distribuir su código a nuestra instalación de R donde los paquetes podrían no estar instalados.

if(require("lme4")){
    print("lme4 is loaded correctly")
} else {
    print("trying to install lme4")
    install.packages("lme4")
    if(require(lme4)){
        print("lme4 installed and loaded")
    } else {
        stop("could not install lme4")
    }
}

Puede usarlo require()si desea instalar paquetes si y solo si es necesario, como:

if (!require(package, character.only=T, quietly=T)) {
    install.packages(package)
    library(package, character.only=T)
}

Para múltiples paquetes puedes usar

for (package in c('<package1>', '<package2>')) {
    if (!require(package, character.only=T, quietly=T)) {
        install.packages(package)
        library(package, character.only=T)
    }
}

Consejos profesionales:

• Cuando se usa dentro del script, puede evitar una pantalla de diálogo especificando el reposparámetro de install.packages(), como

  install.packages(package, repos="http://cran.us.r-project.org")

• Usted puede envolver require()y library()en el suppressPackageStartupMessages()que, además, mensajes de paquetes suprimir el inicio, y también utilizar los parámetros require(..., quietly=T, warn.conflicts=F)si es necesario para mantener la calma instalaciones.

Siempre uso library. Nunca ¹ uso require.

_{( ¹ Casi nunca. Quizás .)}

En pocas palabras, esto se debe a que, cuando se usa require, su código puede producir resultados diferentes y erróneos, sin indicar un error . ¡Esto es raro pero no hipotético! Considere este código, que produce resultados diferentes dependiendo de si se puede cargar {dplyr}:

require(dplyr)

x = data.frame(y = seq(100))
y = 1
filter(x, y == 1)

Esto puede conducir a resultados sutilmente incorrectos. Usar en librarylugar de requirearroja un error aquí, indicando claramente que algo está mal. Esto es bueno .

También dificulta la depuración de todas las demás fallas: si requireutiliza un paquete al comienzo de su secuencia de comandos y utiliza sus exportaciones en la línea 500, recibirá un mensaje de error "objeto 'foo' no encontrado" en la línea 500, en lugar de un error "no hay paquete llamado 'bla'".

El único caso de uso aceptable requirees cuando su valor de retorno se verifica de inmediato, como muestran algunas de las otras respuestas. Este es un patrón bastante común, pero incluso en estos casos es mejor (y recomendado, ver más abajo) separar la verificación de existencia y la carga del paquete.

Más técnicamente, en requirerealidad llama libraryinternamente (si el paquete ya no estaba adjunto, por lo requiretanto, realiza una verificación redundante, porque library también verifica si el paquete ya estaba cargado). Aquí hay una implementación simplificada de requirepara ilustrar lo que hace:

require = function (package) {
    already_attached = paste('package:', package) %in% search()
    if (already_attached) return(TRUE)
    maybe_error = try(library(package, character.only = TRUE)) 
    success = ! inherits(maybe_error, 'try-error')
    if (! success) cat("Failed")
    success
}

Los desarrolladores experimentados de R están de acuerdo:

Yihui Xie , autor de {knitr}, {bookdown} y muchos otros paquetes dice :

Damas y caballeros, he dicho esto antes: require () es la forma incorrecta de cargar un paquete R; use library () en su lugar

Hadley Wickham , autor de paquetes R más populares que nadie, dice

Uso library(x)en scripts de análisis de datos. […] Nunca necesitas usar require()( requireNamespace()casi siempre es mejor)

?library

y tu verás:

library(package)y require(package)ambos cargan el paquete con el nombre packagey lo ponen en la lista de búsqueda. requireestá diseñado para usarse dentro de otras funciones; vuelve FALSEy da una advertencia (en lugar de un error como lo library()hace por defecto) si el paquete no existe. Ambas funciones verifican y actualizan la lista de paquetes cargados actualmente y no vuelven a cargar un paquete que ya está cargado. (Si desea volver a cargar dicho paquete, llame detach(unload = TRUE)o unloadNamespaceprimero.) Si desea cargar un paquete sin incluirlo en la lista de búsqueda, use requireNamespace.

Mi teoría inicial sobre la diferencia era que librarycarga los paquetes si ya está cargado o no, es decir, podría volver a cargar un paquete ya cargado, mientras que requiresolo verifica que esté cargado o lo carga si no lo está (por lo tanto, el uso en funciones que dependen de un determinado paquete). Sin embargo, la documentación refuta esto y declara explícitamente que ninguna de las funciones volverá a cargar un paquete ya cargado.

Aquí parece ser la diferencia en un paquete ya cargado. Si bien es cierto que tanto require como library no cargan el paquete. La biblioteca hace muchas otras cosas antes de verificar y salir.

Recomendaría eliminar "require" desde el principio de una función que se ejecuta 2mil veces de todos modos, pero si, por alguna razón, necesito mantenerla. requerir es técnicamente una verificación más rápida.

microbenchmark(req = require(microbenchmark), lib = library(microbenchmark),times = 100000)
Unit: microseconds
 expr    min     lq      mean median     uq        max neval
  req  3.676  5.181  6.596968  5.655  6.177   9456.006 1e+05
  lib 17.192 19.887 27.302907 20.852 22.490 255665.881 1e+05