¿Una forma elegante de buscar paquetes faltantes e instalarlos?


337

Parece que estoy compartiendo mucho código con los coautores en estos días. Muchos de ellos son usuarios novatos / intermedios de R y no se dan cuenta de que tienen que instalar paquetes que ya no tienen.

¿Hay una manera elegante de llamar installed.packages(), compararla con las que estoy cargando e instalar si falta?


1
@krlmlr ¿Qué pasa con la respuesta aceptada que está desactualizada y requiere revisión? Funciona para mí (para algunas pruebas rápidas) en R version 3.0.2 (2013-09-25) x86_64-w64-mingw32/x64 (64-bit).
Brian Diggs el

1
@BrianDiggs: han aparecido al menos tres paquetes que abordan este problema, solo se hace referencia a uno a continuación. ¿Hay aún más? Esa es la pregunta.
krlmlr

2
@krlmlr Parece haber un pequeño problema irónico de huevo y gallina sobre el uso de un paquete para garantizar que (otros) tengan los paquetes necesarios. Pero ciertamente vale la pena tener a alguien que los conozca y escriba una respuesta.
Brian Diggs el

2
@BrianDiggs: Bootstrapping este paquete de comprobación de instalación es una molestia necesaria, pero pequeña. A menos que, por supuesto, la funcionalidad se encuentre en base... ;-)
krlmlr

Respuestas:


304

Si. Si tiene su lista de paquetes, compárela con el resultado installed.packages()[,"Package"]e instale los paquetes que faltan. Algo como esto:

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)

De otra manera:

Si coloca su código en un paquete y las convierte en dependencias, se instalarán automáticamente cuando instale su paquete.


11
Creo que la sintaxis adecuada es: if(length(new.packages)>0) {install.packages(new.packages)}

55
@psql, Shine tiene razón, ya que "> 0" es "implícito" dentro de la condición if. ejecutar esto para verificarlo:new.packages <- c(1,2) length(new.packages) if(length(new.packages)){print("hello!")}else{print("oh no!")}
Andrea Cirillo

77
El documento de instal.packages establece: "Esto puede ser lento cuando se instalan miles de paquetes, así que no lo use para averiguar si está instalado un paquete con nombre (use system.file o find.package) ..."
Thomas Materna

2
De acuerdo con Thomas, este sería un mejor rendimiento en requirelugar de verificarinstalled.packages
Matthew

1
packratfue hecho para esto. Es un sistema de gestión de paquetes reproducible. De esta manera, está yendo por el camino equivocado y se mete con el entorno de otra persona y no es reproducible. Packrat tiene su propia carpeta y entorno para las bibliotecas compartidas. rstudio.github.io/packrat
mtelesha

231

Dason K. y yo tenemos el paquete pacman que puede hacer esto bien. La función p_loaden el paquete hace esto. La primera línea es solo para garantizar que pacman esté instalado.

if (!require("pacman")) install.packages("pacman")
pacman::p_load(package1, package2, package_n)

1
¿Cuál es el estado del paquete? No puedo ver en C-RAN.
MERose

44

66
Lo he instalado ahora y funciona maravillosamente; debe ser parte de la base!
AndyF

3
La única forma en que esto sería mejor sería si verificara /y, si se encuentra, instale / cargue automáticamente desde github.
ataque aéreo

44
@NealBarsch si quiere decir que if (!require("pacman")) install.packages("pacman")hay una función en pacman llamada p_boot()que hace que esta línea sea automática para usted y la copia al portapapeles.
Tyler Rinker

72

Puede usar el valor de retorno de require:

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

Lo uso librarydespués de la instalación porque arrojará una excepción si la instalación no fue exitosa o el paquete no se puede cargar por alguna otra razón. Lo haces más robusto y reutilizable:

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

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

La desventaja de este método es que debe pasar el nombre del paquete entre comillas, lo que no hace de verdad require.


44
Se puede simplificar su vida mucho más mediante el uso character.only = TRUEde require, pero entonces creo que no hay nada para diferenciar su respuesta a la mía.
Simon O'Hanlon el

Esto se ve bien, pero no parece funcionar, al menos para mí. Cuando probé la versión robusta de esto, recibo dos mensajes de error ya que R no sabe cómo manejar "return True" y "return eval" por alguna razón. Así que realmente me gustaría una función como esta que cargue un paquete si está presente en mi biblioteca y de lo contrario instala (y luego carga) el paquete. Lo ideal sería usar esto como predeterminado para cargar paquetes. Al menos parece que tendría sentido hacerlo y ahorraría algo de tiempo.
Fabian Habersack

23
if (!require('ggplot2')) install.packages('ggplot2'); library('ggplot2')

"ggplot2" es el paquete. Comprueba si el paquete está instalado, si no lo está, lo instala. Luego carga el paquete independientemente de la rama que tomó.


21

Esta solución tomará un vector de caracteres de los nombres de los paquetes e intentará cargarlos o instalarlos si falla la carga. Se basa en el comportamiento de retorno de requirehacer esto porque ...

require devuelve (invisiblemente) una lógica que indica si el paquete requerido está disponible

Por lo tanto, simplemente podemos ver si pudimos cargar el paquete requerido y, de lo contrario, instalarlo con dependencias. Entonces, dado un vector de caracteres de los paquetes que desea cargar ...

foo <- function(x){
  for( i in x ){
    #  require returns TRUE invisibly if it was able to load package
    if( ! require( i , character.only = TRUE ) ){
      #  If package was not able to be loaded then re-install
      install.packages( i , dependencies = TRUE )
      #  Load package after installing
      require( i , character.only = TRUE )
    }
  }
}

#  Then try/install packages...
foo( c("ggplot2" , "reshape2" , "data.table" ) )

¿No le gustaría volver a llamar requiredespués de la instalación?
krlmlr

@krlmlr No, porque para que la ifdeclaración se evalúe primero debe evaluar require, ¡cuyo efecto secundario es cargar el paquete si está disponible!
Simon O'Hanlon

1
SimonO101: Creo que krlmlr significa en la instrucción if, después de la llamada a install.packages, ya que esto realmente no cargaría ese paquete. Pero (a @krlmlr) sospecho que la intención es que este fragmento de código solo se llame una vez; no escribirías esto cada vez que requieras el paquete. En su lugar, lo ejecutaría una vez antes y luego llamaría de la requireforma habitual, según sea necesario.
Aaron dejó Stack Overflow el

@ Aaron, sí, sí, entiendo lo que quieres decir, y sí, tu interpretación es correcta. Lo editaré un poco para ser más explícito sobre la carga después de la instalación.
Simon O'Hanlon

1
¿No sería mejor requirellamar al segundo librarypara que falle ruidosamente si aún no puede adjuntar el paquete por alguna razón?
kabdulla

18

Muchas de las respuestas anteriores (y en duplicados de esta pregunta) dependen de installed.packagescuál es una mala forma. De la documentación:

Esto puede ser lento cuando se instalan miles de paquetes, así que no lo use para averiguar si un paquete con nombre está instalado (use system.file o find.package) ni para averiguar si un paquete es utilizable (llame y solicite valor de retorno) ni para encontrar detalles de una pequeña cantidad de paquetes (use packageDescription). Necesita leer varios archivos por paquete instalado, lo que será lento en Windows y en algunos sistemas de archivos montados en red.

Por lo tanto, un mejor enfoque es intentar cargar el paquete usando requiree instalarlo si falla la carga ( requirevolverá FALSEsi no se encuentra). Prefiero esta implementación:

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

que se puede usar así:

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

De esta manera, carga todos los paquetes, luego regresa e instala todos los paquetes que faltan (que si lo desea, es un lugar útil para insertar un mensaje para preguntar si el usuario desea instalar paquetes). En lugar de llamar install.packagespor separado para cada paquete, pasa el vector completo de los paquetes desinstalados solo una vez.

Aquí está la misma función pero con un cuadro de diálogo de Windows que pregunta si el usuario desea instalar los paquetes faltantes

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

Esta es una forma bastante elegante, mucho mejor que la aceptada. Lo incluiré en mi biblioteca personal. Gracias.
Bing

15

Aunque la respuesta de Shane es realmente buena, para uno de mis proyectos necesitaba eliminar los mensajes de salida, advertencias e instalar paquetes automáticamente . Finalmente logré obtener este 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)
}

Utilizar:

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

9
# List of packages for session
.packages = c("ggplot2", "plyr", "rms")

# Install CRAN packages (if not already installed)
.inst <- .packages %in% installed.packages()
if(length(.packages[!.inst]) > 0) install.packages(.packages[!.inst])

# Load packages into session 
lapply(.packages, require, character.only=TRUE)

6

Este es el propósito del paquete rbundler : proporcionar una forma de controlar los paquetes que están instalados para un proyecto específico. En este momento, el paquete funciona con la funcionalidad devtools para instalar paquetes en el directorio de su proyecto. La funcionalidad es similar al paquete de Ruby .

Si su proyecto es un paquete (recomendado), todo lo que tiene que hacer es cargar rbundler y agrupar los paquetes. La bundlefunción mirará el DESCRIPTIONarchivo de su paquete para determinar qué paquetes agrupar.

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

Ahora los paquetes se instalarán en el directorio .Rbundle.

Si su proyecto no es un paquete, puede simularlo creando un DESCRIPTIONarchivo en el directorio raíz de su proyecto con un campo Depende que enumere los paquetes que desea instalar (con información de versión opcional):

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

Aquí está el repositorio de github para el proyecto si está interesado en contribuir: rbundler .


5

Por supuesto.

Necesita comparar 'paquetes instalados' con 'paquetes deseados'. Eso está muy cerca de lo que hago con CRANberries, ya que necesito comparar 'paquetes conocidos almacenados' con 'paquetes conocidos actualmente' para determinar paquetes nuevos y / o actualizados.

Entonces haz algo como

AP <- available.packages(contrib.url(repos[i,"url"]))   # available t repos[i]

para obtener todos los paquetes conocidos, llame de forma simulada a los paquetes instalados actualmente y compárelos con un conjunto dado de paquetes de destino.


5

Úselo packratpara que las bibliotecas compartidas sean exactamente iguales y no cambien el entorno de los demás.

En términos de elegancia y mejores prácticas, creo que básicamente lo estás haciendo mal. El paquete packratfue diseñado para estos problemas. Está desarrollado por RStudio por Hadley Wickham. En lugar de tener que instalar dependencias y posiblemente estropear el sistema de entorno de alguien, packratusa su propio directorio e instala todas las dependencias para sus programas allí y no toca el entorno de alguien.

Packrat es un sistema de gestión de dependencias para R.

Las dependencias del paquete R pueden ser frustrantes. ¿Alguna vez ha tenido que usar prueba y error para descubrir qué paquetes R necesita instalar para que el código de otra persona funcione? Y luego se quedó con esos paquetes instalados globalmente para siempre, porque ahora no está seguro de si los necesita ? ¿Alguna vez ha actualizado un paquete para que el código de uno de sus proyectos funcione, solo para descubrir que el paquete actualizado hace que el código de otro proyecto deje de funcionar?

Construimos Packrat para resolver estos problemas. Use packrat para hacer que sus proyectos de R sean más:

  • Aislado: la instalación de un paquete nuevo o actualizado para un proyecto no interrumpirá sus otros proyectos, y viceversa. Eso es porque packrat le da a cada proyecto su propia biblioteca de paquetes privados.
  • Portátil: transporte fácilmente sus proyectos de una computadora a otra, incluso a través de diferentes plataformas. Packrat facilita la instalación de los paquetes de los que depende su proyecto.
  • Reproducible: Packrat registra las versiones exactas de los paquetes de los que depende y garantiza que esas versiones exactas sean las que se instalan donde quiera que vaya.

https://rstudio.github.io/packrat/


4

La siguiente función simple funciona como un encanto:

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

(no el mío, encontré esto en la web hace algún tiempo y lo había estado usando desde entonces. No estoy seguro de la fuente original)


4

Uso la siguiente función para instalar el paquete si require("<package>")sale con un error de paquete no encontrado. Consultará los repositorios CRAN y Bioconductor para el paquete faltante.

Adaptado del trabajo original de Joshua Wiley, http://r.789695.n4.nabble.com/Install-package-automatically-if-not-there-td2267532.html

install.packages.auto <- function(x) { 
  x <- as.character(substitute(x)) 
  if(isTRUE(x %in% .packages(all.available=TRUE))) { 
    eval(parse(text = sprintf("require(\"%s\")", x)))
  } else { 
    #update.packages(ask= FALSE) #update installed packages.
    eval(parse(text = sprintf("install.packages(\"%s\", dependencies = TRUE)", x)))
  }
  if(isTRUE(x %in% .packages(all.available=TRUE))) { 
    eval(parse(text = sprintf("require(\"%s\")", x)))
  } else {
    source("http://bioconductor.org/biocLite.R")
    #biocLite(character(), ask=FALSE) #update installed packages.
    eval(parse(text = sprintf("biocLite(\"%s\")", x)))
    eval(parse(text = sprintf("require(\"%s\")", x)))
  }
}

Ejemplo:

install.packages.auto(qvalue) # from bioconductor
install.packages.auto(rNMF) # from CRAN

PD: update.packages(ask = FALSE)& biocLite(character(), ask=FALSE)actualizará todos los paquetes instalados en el sistema. ¡Esto puede llevar mucho tiempo y considerarlo como una actualización completa de R que puede no estar garantizada todo el tiempo!


Podría mejorarse comprobando si los paquetes están realmente disponibles en cran o bc. También debe usar la biblioteca al final para generar un error si la instalación falla o si no existe un paquete. Véase mi versión mejorada llamada loadpack()en raw.githubusercontent.com/holgerbrandl/datautils/master/R/...
Holger Brandl

4

Simplemente puede usar la setdifffunción para obtener los paquetes que no están instalados y luego instalarlos. En el ejemplo a continuación, verificamos si los paquetes ggplot2y Rcppestán instalados antes de instalarlos.

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

En una línea, lo anterior se puede escribir como:

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

Yo uso el mismo enfoque. También podemos usar en installed.packages()[,'Package']lugar de rownames(installed.packages()).
Scudelletti

3

He implementado la función para instalar y cargar los paquetes R necesarios de forma silenciosa. La esperanza podría ayudar. Aquí está el código:

# 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);

3

La próxima versión de RStudio (1.2), ya disponible como vista previa, incluirá una función para detectar paquetes faltantes library()y require()llamadas, y solicitará al usuario que los instale:

Detectar paquetes R faltantes

Muchos scripts R se abren con llamadas library()y require()para cargar los paquetes que necesitan para ejecutarlos. Si abre un script R que hace referencia a paquetes que no ha instalado, RStudio ahora ofrecerá instalar todos los paquetes necesarios con un solo clic. ¡No más escribir install.packages()repetidamente hasta que los errores desaparezcan!
https://blog.rstudio.com/2018/11/19/rstudio-1-2-preview-the-little-things/

Esto parece abordar la preocupación original de OP particularmente bien:

Muchos de ellos son usuarios R principiantes / intermedios y no se dan cuenta de que tienen que instalar paquetes que ya no tienen.


2

Con respecto a su objetivo principal "instalar bibliotecas que aún no tienen" e independientemente del uso de "instllaed.packages ()". La siguiente función enmascara la función original de require. Intenta cargar y verificar el paquete con nombre "x"; si no está instalado, instálelo directamente, incluidas las dependencias; y por último cargarlo normalmente. cambia el nombre de la función de 'require' a 'library' para mantener la integridad. La única limitación es que se deben citar los nombres de los paquetes.

require <- function(x) { 
  if (!base::require(x, character.only = TRUE)) {
  install.packages(x, dep = TRUE) ; 
  base::require(x, character.only = TRUE)
  } 
}

Por lo tanto, puede cargar e instalar el paquete a la antigua usanza de R. require ("ggplot2") require ("Rcpp")


Si ya no le gusta su respuesta, no la destruya, simplemente elimínela.
Michael Petrotta

Bueno, lo intenté, pero no pude. Creo que mi extensión NoScript de FF lo está desactivando o no tengo los derechos y créditos para eliminar mi propia respuesta. LoL Sin embargo, creo que Livius está bastante cerca de mi respuesta, pensada sin enmascarar. Gracias Michael Petrotta. para la notificación
GeoObserver

Debería ver un deleteenlace sobre estos comentarios. Si no lo hace, y aún desea eliminar, use el flagenlace, seleccione "otro" y explique a un moderador que desea que se elimine la respuesta.
Michael Petrotta

2

Bastante básico.

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

2

Pensé que contribuiría con el que uso:

testin <- function(package){if (!package %in% installed.packages())    
install.packages(package)}
testin("packagename")

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

2

Usando el enfoque de familia anónima y función anónima, usted puede:

  1. Intente adjuntar todos los paquetes enumerados.
  2. Instalar solo faltante (usando ||evaluación perezosa).
  3. Intente adjuntar nuevamente los que faltaban en el paso 1 y se instalaron en el paso 2.
  4. Imprima el estado de carga final de cada paquete ( 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 

1

Utilizo lo siguiente que verificará si el paquete está instalado y si las dependencias se actualizan, luego carga el paquete.

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, ])
}

1

Aquí está mi código para ello:

packages <- c("dplyr", "gridBase", "gridExtra")
package_loader <- function(x){
    for (i in 1:length(x)){
        if (!identical((x[i], installed.packages()[x[i],1])){
            install.packages(x[i], dep = TRUE)
        } else {
            require(x[i], character.only = TRUE)
        }
    }
}
package_loader(packages)

1
 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 }

1
library <- function(x){
  x = toString(substitute(x))
if(!require(x,character.only=TRUE)){
  install.packages(x)
  base::library(x,character.only=TRUE)
}}

Esto funciona con nombres de paquetes sin comillas y es bastante elegante (véase la respuesta de GeoObserver)


1

En mi caso, quería un trazador de líneas que pudiera ejecutar desde la línea de comandos (en realidad a través de un Makefile). Aquí hay un ejemplo de instalación de "VGAM" y "pluma" si aún no están instalados:

R -e 'for (p in c("VGAM", "feather")) if (!require(p, character.only=TRUE)) install.packages(p, repos="http://cran.us.r-project.org")'

Desde dentro de R solo sería:

for (p in c("VGAM", "feather")) if (!require(p, character.only=TRUE)) install.packages(p, repos="http://cran.us.r-project.org")

Aquí no hay nada más allá de las soluciones anteriores, excepto que:

  • Lo mantengo en una sola línea
  • Codifico el repos parámetro (para evitar cualquier ventana emergente que pregunte sobre el espejo para usar)
  • No me molesto en definir una función para usar en otro lugar

También tenga en cuenta lo importante character.only=TRUE(sin él, requireintentaría cargar el paquete p).


0
  packages_installed <- function(pkg_list){
        pkgs <- unlist(pkg_list)
        req <- unlist(lapply(pkgs, require, character.only = TRUE))
        not_installed <- pkgs[req == FALSE]
        lapply(not_installed, install.packages, 
               repos = "http://cran.r-project.org")# add lib.loc if needed
        lapply(pkgs, library, character.only = TRUE)
}

0

Déjame compartir un poco de locura:

c("ggplot2","ggsci", "hrbrthemes", "gghighlight", "dplyr") %>%  # What will you need to load for this script?
  (function (x) ifelse(t =!(x %in% installed.packages()), 
    install.packages(x[t]),
    lapply(x, require))) 
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.