Manière élégante de vérifier les paquets manquants et de les installer?

Oui. Si vous avez votre liste de paquets, de la comparer à la sortie de installed.packages()[,"Package"] et installer les paquets manquants. Quelque chose comme ceci:

list.of.packages <- c("ggplot2", "Rcpp")
new.packages <- list.of.packages[!(list.of.packages %in% installed.packages()[,"Package"])]
if(length(new.packages)) install.packages(new.packages)

Autrement:

Si vous mettez votre code dans un paquet et de les rendre dépendances, alors il sera automatiquement installé lorsque vous installez le package.

Vous pouvez simplement utiliser la valeur de retour de require:

if(!require(somepackage)){
    install.packages("somepackage")
    library(somepackage)
}

- Je utiliser library après l'installation, car il va lever une exception si l'installation n'a pas réussi ou que le paquet ne peut pas être chargé pour une autre raison. Vous rendre plus robustes et réutilisables:

dynamic_require <- function(package){
  if(eval(parse(text=paste("require(",package,")")))) return True

  install.packages(package)
  return eval(parse(text=paste("require(",package,")")))
}

L'inconvénient de cette méthode est que vous devez passer le nom du package dans le devis, ce qui vous ne le faites pas pour la vraie require.

Bien que la réponse de Shane est vraiment bon, pour un de mes projet j'ai besoin de supprimer la sortie des messages, avertissements et installer des paquets automatiquement. J'ai enfin réussi à obtenir ce script:

InstalledPackage <- function(package) 
{
    available <- suppressMessages(suppressWarnings(sapply(package, require, quietly = TRUE, character.only = TRUE, warn.conflicts = FALSE)))
    missing <- package[!available]
    if (length(missing) > 0) return(FALSE)
    return(TRUE)
}

CRANChoosen <- function()
{
    return(getOption("repos")["CRAN"] != "@CRAN@")
}

UsePackage <- function(package, defaultCRANmirror = "http://cran.at.r-project.org") 
{
    if(!InstalledPackage(package))
    {
        if(!CRANChoosen())
        {       
            chooseCRANmirror()
            if(!CRANChoosen())
            {
                options(repos = c(CRAN = defaultCRANmirror))
            }
        }

        suppressMessages(suppressWarnings(install.packages(package)))
        if(!InstalledPackage(package)) return(FALSE)
    }
    return(TRUE)
}

Utilisation:

libraries <- c("ReadImages", "ggplot2")
for(library in libraries) 
{ 
    if(!UsePackage(library))
    {
        stop("Error!", library)
    }
}

Un grand nombre de réponses ci-dessus (et sur les doublons de cette question) s'appuient sur installed.packages qui est mauvais. À partir de la documentation:

Cela peut être lent, lorsque des milliers de paquets sont installés, afin de ne pas l'utiliser pour savoir si un nom de package est installé (utilisation du système.fichier ou le trouver.package), ni pour savoir si un paquet est utilisable (appel exiger et vérifier la valeur de retour), ni pour trouver les détails d'un petit nombre de paquets (utiliser packageDescription). Il a besoin de lire plusieurs fichiers par paquet installé, qui sera lent sur Windows et sur certains systèmes de fichiers montés.

Donc, une meilleure approche est de tenter de charger le package à l'aide de require et et installer si le chargement échoue (require sera de retour FALSE si elle n'est pas trouvé). Je préfère cette mise en œuvre:

using<-function(...) {
    libs<-unlist(list(...))
    req<-unlist(lapply(libs,require,character.only=TRUE))
    need<-libs[req==FALSE]
    if(length(need)>0){ 
        install.packages(need)
        lapply(need,require,character.only=TRUE)
    }
}

qui peut être utilisée comme ceci:

using("RCurl","ggplot2","jsonlite","magrittr")

De cette façon, il charge tous les paquets, puis remonte et installe tous les paquets manquants (qui, si vous voulez, est un endroit pratique pour insérer une invite à se demander si l'utilisateur souhaite installer des paquets). Au lieu d'appeler install.packages séparément pour chaque paquet, il passe l'ensemble de vecteur de désinstallé les paquets juste une fois.

Ici de la même fonction, mais avec une fenêtre de dialogue vous demande si l'utilisateur veut installer les paquets manquants

using<-function(...) {
    libs<-unlist(list(...))
    req<-unlist(lapply(libs,require,character.only=TRUE))
    need<-libs[req==FALSE]
    n<-length(need)
    if(n>0){
        libsmsg<-if(n>2) paste(paste(need[1:(n-1)],collapse=", "),",",sep="") else need[1]
        print(libsmsg)
        if(n>1){
            libsmsg<-paste(libsmsg," and ", need[n],sep="")
        }
        libsmsg<-paste("The following packages could not be found: ",libsmsg,"\n\r\n\rInstall missing packages?",collapse="")
        if(winDialog(type = c("yesno"), libsmsg)=="YES"){       
            install.packages(need)
            lapply(need,require,character.only=TRUE)
        }
    }
}

C'est le but de la rbundler paquet: fournir un moyen de contrôler les paquets qui sont installés pour un projet spécifique. Droit maintenant le logiciel fonctionne avec les devtools fonctionnalités à installer les packages dans le dossier de votre projet. La fonctionnalité est similaire à Ruby bundler.

Si votre projet est un package (recommandé), puis tout ce que vous avez à faire est de charger rbundler et de regrouper les paquets. Le bundle fonction de regarder votre paquet DESCRIPTION fichier pour déterminer quels paquets bundle.

library(rbundler)
bundle('.', repos="http://cran.us.r-project.org")

Maintenant, les paquets seront installés dans le .Rbundle répertoire.

Si votre projet n'est pas un paquet, vous pouvez faire semblant par la création d'un DESCRIPTION fichier dans votre répertoire racine avec un champ Depends que la liste des paquets que vous voulez installer (avec, en option, les informations de version):

Depends: ggplot2 (>= 0.9.2), arm, glmnet

Voici le dépôt github du projet si vous êtes intéressé à contribuer: rbundler.

La fonction suivante fonctionne comme un charme:

  usePackage<-function(p){
      # load a package if installed, else load after installation.
      # Args:
      #   p: package name in quotes

      if (!is.element(p, installed.packages()[,1])){
        print(paste('Package:',p,'Not found, Installing Now...'))
        install.packages(p, dep = TRUE)}
      print(paste('Loading Package :',p))
      require(p, character.only = TRUE)  
    }

(pas de mine, trouvé ceci sur le web il y a quelque temps et a été utilisé depuis lors. pas sûr de la source d'origine)

Vous pouvez simplement utiliser la setdiff fonction pour obtenir les paquets qui ne sont pas installés et de les installer. Dans l'exemple ci-dessous, nous vérifions si le ggplot2 et Rcpp les paquets sont installés avant de les installer.

unavailable <- setdiff(c("ggplot2", "Rcpp"), rownames(installed.packages()))
install.packages(unavailable)

En une seule ligne, le ci-dessus peut être écrite comme:

install.packages(setdiff(c("ggplot2", "Rcpp"), rownames(installed.packages())))

J'ai implémenté la fonction pour installer et charger des packages R silencieusement. L'espoir peut vous aider. Voici le code:

# Function to Install and Load R Packages
Install_And_Load <- function(Required_Packages)
{
    Remaining_Packages <- Required_Packages[!(Required_Packages %in% installed.packages()[,"Package"])];

    if(length(Remaining_Packages)) 
    {
        install.packages(Remaining_Packages);
    }
    for(package_name in Required_Packages)
    {
        library(package_name,character.only=TRUE,quietly=TRUE);
    }
}

# Specify the list of required packages to be installed and load    
Required_Packages=c("ggplot2", "Rcpp");

# Call the Function
Install_And_Load(Required_Packages);

Assez basique.

pkgs = c("pacman","data.table")
if(length(new.pkgs <- setdiff(pkgs, rownames(installed.packages())))) install.packages(new.pkgs)

À l'aide de lapply de la famille et de la fonction anonyme approche, vous pouvez:

1. Essayer de joindre la liste de toutes les packages.
2. Absents (en utilisant || évaluation différée).
3. De tenter de joindre à nouveau ceux qui manquaient à l'étape 1 et installé à l'étape 2.

4. Imprimer chaque paquet final de l'état de charge (TRUE /FALSE).

   req <- substitute(require(x, character.only = TRUE))
   lbs <- c("plyr", "psych", "tm")
   sapply(lbs, function(x) eval(req) || {install.packages(x); eval(req)})
   
   plyr psych    tm 
   TRUE  TRUE  TRUE 

J'utilise la suite qui va vérifier si le paquet est installé et si les dépendances sont mises à jour, puis charge le package.

p<-c('ggplot2','Rcpp')
install_package<-function(pack)
{if(!(pack %in% row.names(installed.packages())))
{
  update.packages(ask=F)
  install.packages(pack,dependencies=T)
}
 require(pack,character.only=TRUE)
}
for(pack in p) {install_package(pack)}

completeFun <- function(data, desiredCols) {
  completeVec <- complete.cases(data[, desiredCols])
  return(data[completeVec, ])
}

 48 lapply_install_and_load <- function (package1, ...)
 49 {
 50     #
 51     # convert arguments to vector
 52     #
 53     packages <- c(package1, ...)
 54     #
 55     # check if loaded and installed
 56     #
 57     loaded        <- packages %in% (.packages())
 58     names(loaded) <- packages
 59     #
 60     installed        <- packages %in% rownames(installed.packages())
 61     names(installed) <- packages
 62     #
 63     # start loop to determine if each package is installed
 64     #
 65     load_it <- function (p, loaded, installed)
 66     {
 67         if (loaded[p])
 68         {
 69             print(paste(p, "loaded"))
 70         }
 71         else
 72         {
 73             print(paste(p, "not loaded"))
 74             if (installed[p])
 75             {
 76                 print(paste(p, "installed"))
 77                 do.call("library", list(p))
 78             }
 79             else
 80             {
 81                 print(paste(p, "not installed"))
 82                 install.packages(p)
 83                 do.call("library", list(p))
 84             }
 85         }
 86     }
 87     #
 88     lapply(packages, load_it, loaded, installed)
 89 }

source("https://bioconductor.org/biocLite.R")
if (!require("ggsci")) biocLite("ggsci")