Qual é a diferença entre require()e library()?

Além dos bons conselhos já dados, eu acrescentaria o seguinte:

Provavelmente, é melhor evitar o uso, a require() menos que você realmente utilize o valor que ele retorna, por exemplo, em algum loop de verificação de erros, como o fornecido por thierry.

Na maioria dos outros casos, é melhor usar library(), pois isso dará uma mensagem de erro no tempo de carregamento do pacote, se o pacote não estiver disponível. require()falhará sem erro se o pacote não estiver lá. Este é o melhor momento para descobrir se o pacote precisa ser instalado (ou talvez nem exista porque está incorreto). Obter feedback de erro antecipadamente e no momento relevante evitará possíveis dores de cabeça ao rastrear por que o código posterior falha ao tentar usar as rotinas da biblioteca

Não há muito no trabalho cotidiano.

No entanto, de acordo com a documentação para ambas as funções (acessada colocando a ?antes do nome da função e pressionando enter), requireé usada dentro das funções, pois emite um aviso e continua se o pacote não for encontrado, ao passo que gera um libraryerro.

Outro benefício require()é que ele retorna um valor lógico por padrão. TRUEse os pacotes estiverem carregados, FALSEse não estiverem.

> 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

Então você pode usar require()em construções como a abaixo. O que é útil principalmente se você deseja distribuir seu código para a instalação do R, onde os pacotes podem não 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")
    }
}

Você pode usar require()se quiser instalar pacotes, se e somente se necessário, como:

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

Para vários pacotes, você pode usar

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

Dicas profissionais:

• Quando usado dentro do script, você pode evitar uma tela de diálogo especificando o reposparâmetro de install.packages(), como

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

• Você pode embrulhar require()e library()em suppressPackageStartupMessages()para, assim, as mensagens de pacotes de supressão de inicialização, e também usar os parâmetros require(..., quietly=T, warn.conflicts=F)se necessário para manter o silêncio instala.

Sempre use library. Nunca ¹ uso require.

_{( ¹ Quase nunca. Talvez .)}

Em poucas palavras, isso ocorre porque, ao usar require, seu código pode gerar resultados diferentes e errados, sem sinalizar um erro . Isso é raro, mas não hipotético! Considere este código, que gera resultados diferentes, dependendo de se {dplyr} pode ser carregado:

require(dplyr)

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

Isso pode levar a resultados sutilmente errados. Usar em libraryvez de requiregerar um erro aqui, sinalizando claramente que algo está errado. Isso é bom .

Isso também dificulta a depuração de todas as outras falhas: se você requireempacotar um pacote no início do script e usar suas exportações na linha 500, receberá uma mensagem de erro "objeto 'foo' não encontrado" na linha 500, em vez de um erro "não há pacote chamado 'bla'".

O único caso de uso aceitável de requireé quando seu valor de retorno é verificado imediatamente, como mostram algumas das outras respostas. Esse é um padrão bastante comum, mas mesmo nesses casos é melhor (e recomendado, veja abaixo) separar a verificação de existência e o carregamento do pacote.

Mais tecnicamente, requirena verdade chama libraryinternamente (se o pacote já não estiver anexado - requireportanto, executa uma verificação redundante, porque library também verifica se o pacote já foi carregado). Aqui está uma implementação simplificada de requirepara ilustrar o que ele faz:

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
}

Desenvolvedores experientes em R concordam:

Yihui Xie , autor de {knitr}, {bookdown} e muitos outros pacotes diz :

Senhoras e Senhores Deputados, eu já disse isso antes: require () é a maneira errada de carregar um pacote R; use library ()

Hadley Wickham , autor de pacotes R mais populares do que qualquer outro, diz

Use library(x)em scripts de análise de dados. [...] Você nunca precisa usar require()( requireNamespace()quase sempre é melhor)

?library

e você verá:

library(package)e require(package)ambos carregam o pacote com o nome packagee o colocam na lista de pesquisa. requirefoi projetado para uso dentro de outras funções; ele retorna FALSEe emite um aviso (em vez de um erro como library()ocorre por padrão) se o pacote não existir. Ambas as funções verificam e atualizam a lista de pacotes atualmente carregados e não recarregam um pacote que já esteja carregado. (Se você deseja recarregar esse pacote, ligue detach(unload = TRUE)ou unloadNamespaceprimeiro.) Se você deseja carregar um pacote sem colocá-lo na lista de pesquisa, use requireNamespace.

Minha teoria inicial sobre a diferença era que librarycarrega os pacotes, se ele já está carregado ou não, ou seja, ele pode recarregar um pacote já carregado, enquanto requireapenas verifica se ele está carregado ou carrega, se não estiver (portanto, o uso em funções que dependem de um determinado pacote). A documentação refuta isso, no entanto, e afirma explicitamente que nenhuma função recarregará um pacote já carregado.

Aqui parece haver a diferença em um pacote já carregado. Embora seja verdade que o exigir e a biblioteca não carregam o pacote. A biblioteca faz muitas outras coisas antes de verificar e sair.

Eu recomendaria remover "require" desde o início de uma função que executa 2mil vezes de qualquer maneira, mas se, por algum motivo, eu precisar mantê-la. exigir é tecnicamente uma verificação mais 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