Qual è la differenza tra require()e library()?

Oltre ai buoni consigli già forniti, aggiungerei questo:

Probabilmente è meglio evitare di usare a require() meno che tu non stia effettivamente usando il valore che restituisce, ad es. In qualche ciclo di controllo degli errori come quello dato da Thierry.

Nella maggior parte degli altri casi è meglio usarlo library(), perché questo darà un messaggio di errore al momento del caricamento del pacchetto se il pacchetto non è disponibile. require()fallirà senza errori se il pacchetto non è presente. Questo è il momento migliore per scoprire se il pacchetto deve essere installato (o forse non esiste nemmeno perché è stato scritto in modo errato). Ottenere feedback sugli errori in anticipo e al momento opportuno eviterà possibili mal di testa con il rilevamento verso il basso perché il codice successivo non riesce quando tenta di utilizzare le routine di libreria

Non ce n'è molto nel lavoro quotidiano.

Tuttavia, secondo la documentazione per entrambe le funzioni (cui si accede inserendo ?prima il nome della funzione e premendo invio), requireviene utilizzato all'interno delle funzioni, poiché emette un avviso e continua se il pacchetto non viene trovato, mentre libraryverrà generato un errore.

Un altro vantaggio require()è che restituisce un valore logico per impostazione predefinita. TRUEse i pacchetti sono caricati, in FALSEcaso contrario.

> 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

Quindi puoi usare require()in costruzioni come quella qui sotto. Che è utile soprattutto se si desidera distribuire il codice alla nostra installazione R in cui i pacchetti potrebbero non essere installati.

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")
    }
}

È possibile utilizzare require()se si desidera installare pacchetti se e solo se necessario, come:

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

Per più pacchetti è possibile utilizzare

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

Suggerimenti professionali:

• Se utilizzato all'interno dello script, è possibile evitare una schermata di dialogo specificando il reposparametro di install.packages(), ad esempio

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

• Si può avvolgere require()e library()in suppressPackageStartupMessages()a, bene, i messaggi del pacchetto sopprimere l'avvio, e anche utilizzare i parametri require(..., quietly=T, warn.conflicts=F), se necessario, per mantenere la quiete installazioni.

Usa sempre library. Mai ¹ utilizzo require.

_{( ¹ Quasi mai. Forse .)}

In breve, ciò è dovuto al fatto che, durante l'utilizzo require, il codice potrebbe produrre risultati diversi, errati, senza segnalare un errore . Questo è raro ma non ipotetico! Considera questo codice, che produce risultati diversi a seconda che {dplyr} possa essere caricato:

require(dplyr)

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

Questo può portare a risultati leggermente sbagliati. Utilizzando libraryinvece di requiregenerare un errore qui, segnalando chiaramente che qualcosa non va. Questo è un bene .

Inoltre, rende più difficile il debug di tutti gli altri errori: se si crea requireun pacchetto all'inizio dello script e si utilizzano le sue esportazioni nella riga 500, nella riga 500 verrà visualizzato un messaggio di errore "oggetto" non trovato "nella riga 500 errore "non esiste un pacchetto chiamato 'bla'".

L'unico caso d'uso accettabile di requireè quando il suo valore di ritorno viene immediatamente verificato, come mostrano alcune delle altre risposte. Questo è un modello abbastanza comune ma anche in questi casi è meglio (e consigliato, vedi sotto) invece separare il controllo di esistenza e il caricamento del pacchetto.

Più tecnicamente, in requirerealtà chiama libraryinternamente (se il pacchetto non era già collegato, requirequindi esegue un controllo ridondante, perché controlla library anche se il pacchetto è già stato caricato). Ecco un'implementazione semplificata di requireper illustrare cosa fa:

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
}

Gli sviluppatori R esperti concordano:

Yihui Xie , autore di {knitr}, {bookdown} e molti altri pacchetti afferma :

Onorevoli colleghi, l'ho già detto prima: requisito () è il modo sbagliato di caricare un pacchetto R; utilizzare invece library ()

Hadley Wickham , autore di pacchetti R più popolari di chiunque altro, afferma

Utilizzare library(x)negli script di analisi dei dati. […] Non hai mai bisogno di usare require()( requireNamespace()è quasi sempre meglio)

?library

e vedrai:

library(package)ed require(package)entrambi caricano il pacchetto con il nome packagee lo inseriscono nell'elenco di ricerca. requireè progettato per l'uso all'interno di altre funzioni; restituisce FALSEe fornisce un avviso (anziché un errore come library()per impostazione predefinita) se il pacchetto non esiste. Entrambe le funzioni controllano e aggiornano l'elenco dei pacchetti attualmente caricati e non ricaricano un pacchetto che è già caricato. (Se si desidera ricaricare un pacchetto del genere, chiamare detach(unload = TRUE)o unloadNamespaceprima.) Se si desidera caricare un pacchetto senza inserirlo nell'elenco di ricerca, utilizzare requireNamespace.

La mia teoria iniziale sulla differenza era che librarycarica i pacchetti indipendentemente dal fatto che sia già caricato o meno, cioè potrebbe ricaricare un pacchetto già caricato, mentre requirecontrolla solo che sia caricato o lo carica se non lo è (quindi l'uso nelle funzioni che si basano su un determinato pacchetto). La documentazione rifiuta ciò, tuttavia, e afferma esplicitamente che nessuna delle due funzioni ricaricherà un pacchetto già caricato.

Qui sembra esserci la differenza su un pacchetto già caricato. Mentre è vero che sia richiedono che la libreria non caricano il pacchetto. La libreria fa molte altre cose prima di controllare ed uscire.

Consiglierei di rimuovere "request" dall'inizio di una funzione in esecuzione 2mil volte comunque, ma se, per qualche motivo, avessi bisogno di mantenerlo. richiede è tecnicamente un controllo più veloce.

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