Non c’è molto di uno nel lavoro di tutti i giorni.

Tuttavia, in base alla documentazione di entrambe le funzioni (a cui si accede inserendo un carattere prima del nome della funzione e premendo enter), viene require all’interno delle funzioni, in quanto emette un avviso e continua se il pacchetto non viene trovato, mentre la library genera un errore .

Un altro vantaggio di require() è che restituisce un valore logico per impostazione predefinita. TRUE se i pacchetti sono caricati, FALSE se non lo è.

 > 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 pricipalmente se vuoi distribuire il tuo codice alla nostra installazione R, 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") } } 

È ansible utilizzare require() se si desidera installare i pacchetti se e solo se necessario, come ad esempio:

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

Per più pacchetti che puoi usare

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

Suggerimenti Pro:

• Se utilizzato all’interno dello script, è ansible evitare una finestra di dialogo specificando il parametro repos di install.packages() , ad esempio

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

• Puoi racchiudere require() e library() in suppressPackageStartupMessages() per, beh, sopprimere i messaggi di avvio del pacchetto, e anche usare i parametri require(..., quietly=T, warn.conflicts=F) se necessario per mantenere le installazioni silenzioso.

Oltre ai buoni consigli già forniti, vorrei aggiungere questo:

Probabilmente è meglio evitare l’uso di require() meno che non si utilizzi effettivamente il valore che restituisce, ad esempio in un ciclo di controllo degli errori come quello fornito da thierry.

Nella maggior parte degli altri casi è meglio usare la 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 è necessario installare il pacchetto (o forse non esiste nemmeno perché è stato scritto erroneamente). Ottenere il feedback degli errori in anticipo e al momento opportuno eviterà possibili mal di testa con il rilevamento del motivo per cui un codice successivo non riesce quando tenta di utilizzare le routine di libreria

 ?library 

e vedrai:

library(package) e require(package) entrambi caricare il pacchetto con il pacchetto nome e inserirlo nell’elenco di ricerca. require è progettato per l’uso all’interno di altre funzioni; restituisce FALSE e fornisce un avvertimento (piuttosto che 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à stato caricato. (Se si desidera ricaricare un pacchetto di questo tipo, richiamare prima lo detach(unload = TRUE) o unloadNamespace .) Se si desidera caricare un pacchetto senza inserirlo nell’elenco di ricerca, utilizzare requireNamespace .

La mia teoria iniziale sulla differenza era che la library carica i pacchetti sia che sia già caricata o meno, cioè che potrebbe ricaricare un pacchetto già caricato, mentre require semplicemente di controllare che sia caricato, o lo carica se non lo è (quindi l’uso in funzioni che si basano su un determinato pacchetto). Tuttavia, la documentazione lo confuta e afferma esplicitamente che nessuna funzione ricaricherà un pacchetto già caricato.

Qui sembra essere la differenza su un pacchetto già caricato. Mentre è vero che entrambi richiedono e la libreria non carica il pacchetto. La libreria fa un sacco di altre cose prima che controlli ed esca.

Vorrei raccomandare di rimuovere “require” dall’inizio di una funzione che esegue comunque 2mil time, ma se, per qualche motivo, dovevo tenerlo. richiedere è 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 

Usa sempre la library . Mai ¹ uso require .

_{( ¹ Quasi mai, forse .)}

In poche parole, questo è dovuto al fatto che, quando si utilizza require , il proprio codice potrebbe produrre risultati errati diversi, senza segnalare un errore . Questo è raro ma non ipotetico! Considera questo codice, che produce risultati diversi a seconda che possa essere caricato {dplyr}:

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

Questo può portare a risultati leggermente sbagliati. Usare la library invece di require genera qui un errore, segnalando chiaramente che qualcosa non va. Questo è buono

Inoltre, rende più difficile il debug di tutti gli altri errori: se hai require un pacchetto all’inizio dello script e utilizzi le sue esportazioni nella riga 500, riceverai un messaggio di errore “object ‘pippo’ non trovato” nella riga 500, anziché un errore “non c’è nessun pacchetto chiamato ‘bla'”.

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

Più tecnicamente, require effettivamente chiamate alla library internamente (se il pacchetto non era già collegato – require quindi di eseguire un controllo ridondante, poiché la library controlla anche se il pacchetto è già stato caricato). Ecco una implementazione semplificata di require per 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 dice :

Signore e signori, l’ho già detto prima: require () è il modo sbagliato per caricare un pacchetto R; usa invece la libreria ()

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

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

require() carica tutti i pacchetti aggiuntivi