Comment puis-je charger un tas de packages à la fois sans retaper la commande require encore et encore? J'ai essayé trois approches qui se brisent et brûlent.

Fondamentalement, je souhaite fournir un vecteur de noms de packages à une fonction qui les chargera.

x<-c("plyr", "psych", "tm")

require(x)
lapply(x, require)
do.call("require", x)

Plusieurs permutations de vos fonctions proposées fonctionnent - mais uniquement si vous spécifiez l' character.onlyargument à être TRUE. Exemple rapide:

lapply(x, require, character.only = TRUE)

Le paquet CRAN Pacman que je maintiens (créé avec Dason Kurkiewicz) peut accomplir ceci:

Ainsi, l'utilisateur peut faire:

## install.packages("pacman")
pacman::p_load(dplyr, psych, tm) 

et si le paquet est manquant, p_loadil le téléchargera depuis CRAN ou Bioconductor.

Cela devrait faire l'affaire:

lapply(x, FUN = function(X) {
    do.call("require", list(X)) 
})

(Le bit clé est que l' argsargument dans do.call(what, args) doit être une liste --- même s'il n'a qu'un seul élément!)

Pour quelqu'un qui veut installer et charger des packages simultanément, je suis tombé sur cette fonction à partir de ce lien

# ipak function: install and load multiple R packages.
# check to see if packages are installed. Install them if they are not, then load them into the R session.

ipak <- function(pkg){
new.pkg <- pkg[!(pkg %in% installed.packages()[, "Package"])]
if (length(new.pkg)) 
    install.packages(new.pkg, dependencies = TRUE)
sapply(pkg, require, character.only = TRUE)
}

# usage
packages <- c("ggplot2", "plyr", "reshape2", "RColorBrewer", "scales", "grid")
ipak(packages)

Une option alternative vient du package easypackages. Une fois installés, vous pouvez charger des packages de la manière la plus intuitive:

libraries("plyr", "psych", "tm")

Le package comprend également une fonction pour installer plusieurs packages:

packages("plyr", "psych", "tm")

Référence ici .

Vous pouvez simplement utiliser le package lubripack et il installe proprement les nouveaux packages, puis les charge tous sur une seule ligne.

lubripack("plyr", "psych", "tm")

Voici la sortie après avoir exécuté le code ci-dessus dans RStudio.

Comment installer le package:

Exécutez le code ci-dessous pour télécharger le package et l'installer à partir de GitHub. Pas besoin d'avoir un compte GitHub.

library(devtools)
install_github("espanta/lubripack")

En vous basant sur la solution de Daroczig, si vous ne souhaitez pas spécifier une liste comme entrée, vous pouvez utiliser

# Foo
mLoad <- function(...) {
  sapply(sapply(match.call(), as.character)[-1], require, character.only = TRUE)
}

# Example 
mLoad(plyr, dplyr, data.table)

... qui est plus court que

lapply(list('plyr', 'dplyr', 'data.table'), require, character.only = TRUE)

J'utilise la fonction suivante:

mrip <- function(..., install = TRUE){
    reqFun <- function(pack) {
        if(!suppressWarnings(suppressMessages(require(pack, character.only = TRUE)))) {
            message(paste0("unable to load package ", pack,
                           ": attempting to download & then load"))
            install.packages(pack)
            require(pack, character.only = TRUE)
        }
    }
    lapply(..., reqFun)
}

Cela tente de se charger, et si cela échoue, installe, puis essayez de charger à nouveau.

Je pense que le code fourni par @daroczig peut être amélioré en remplaçant le requirepar libraryet en enveloppant l' lapplyappel dans la invisible()fonction. Ainsi, le code amélioré ressemblera à ce qui suit:

invisible(lapply(x, library, character.only = TRUE))

Ce code est amélioré car:

1. library()est généralement préféré au require()chargement des paquets car le premier donne une erreur si le paquet n'est pas installé tandis que le second donne juste un avertissement. De plus, les require()appels library(), alors pourquoi ne pas simplement l'utiliser library()directement!

   library("time")
   # Error in library("time") : there is no package called ‘time’
   
   require("time")
   # Loading required package: time
   # Warning message:
   # In library(package, lib.loc = lib.loc, character.only = TRUE, logical.return = TRUE,  :
   # there is no package called ‘time’

2. L'objet de liste retourné et imprimé par l' lapply()appel n'a pas de sens dans ce cas, il est donc logique de rendre la sortie invisible. Supposons que vous utilisiez R Notebook pour votre travail d'analyse, l'utilisation de la invisible()fonction supprimera le contenu de l'objet de liste et empêchera l'encombrement dans le fichier de notebook rendu.

Léger mod de la réponse de Tyler Rinker pour ajouter un chèque pour installer et charger pacman:

#Install/load pacman
if(!require(pacman)){install.packages("pacman");require(pacman)}
#Install/load tons of packages
p_load(plyr,psych,tm)

J'aime la solution p_load car elle évite de citer!