Maneira elegante de verificar se há pacotes ausentes e instalá-los?

336

Parece que estou compartilhando muito código com os co-autores atualmente. Muitos deles são usuários R iniciantes / intermediários e não percebem que precisam instalar pacotes que ainda não possuem.

Existe uma maneira elegante de ligar installed.packages(), comparar com as que estou carregando e instalando, se estiver faltando?

Maiasaura
fonte
11
@krlmlr E a resposta aceita está desatualizada e requer revisão? Funciona para mim (para alguns testes rápidos) abaixo R version 3.0.2 (2013-09-25) x86_64-w64-mingw32/x64 (64-bit).
Brian Diggs
11
@ BrianDiggs: Apareceram pelo menos três pacotes que solucionam esse problema, apenas um é mencionado abaixo. Existe ainda mais - eis a questão.
precisa saber é o seguinte
2
@krlmlr Parece haver um problema irônico de galinha e ovo ao usar um pacote para garantir que outros tenham os pacotes necessários. Mas certamente vale a pena ter alguém que os conheça escrever uma resposta.
Brian Diggs
2
@BrianDiggs: Iniciar esse pacote de verificação de instalação é um incômodo necessário, mas pequeno. A menos, claro, a funcionalidade encontra seu caminho em base... ;-)
krlmlr

Respostas:

304

Sim. Se você possui sua lista de pacotes, compare-a com a saída installed.packages()[,"Package"]e instale os pacotes ausentes. Algo assim:

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 outra forma:

Se você colocar seu código em um pacote e torná-lo dependente, ele será instalado automaticamente quando você instalar o pacote.

Shane
fonte
11
Eu acho que a sintaxe correcta é: if(length(new.packages)>0) {install.packages(new.packages)}
5
@psql, Shine está certo, pois "> 0" está "implícito" dentro da condição if. execute isto para verificá-lo:new.packages <- c(1,2) length(new.packages) if(length(new.packages)){print("hello!")}else{print("oh no!")}
Andrea Cirillo 22/01
7
O documento do installed.packages afirma: "Isso pode ser lento quando milhares de pacotes estão instalados, portanto, não use isso para descobrir se um pacote nomeado está instalado (use system.file ou find.package) ..."
Thomas Materna 11/05
2
De acordo com Thomas, este seria um melhor desempenho com requireem vez de verificarinstalled.packages
Matthew
11
packratfoi feito para isso. É um sistema de gerenciamento de pacotes reproduzível. Dessa maneira, o processo é errado e mexe com o ambiente de outra pessoa e não é reproduzível. O Packrat possui sua própria pasta e ambiente para as bibliotecas compartilhadas. rstudio.github.io/packrat
mtelesha
231

Dason K. e eu temos o pacote pacman que pode fazer isso muito bem. A função p_loadno pacote faz isso. A primeira linha é apenas para garantir que o pacman esteja instalado.

if (!require("pacman")) install.packages("pacman")
pacman::p_load(package1, package2, package_n)
Tyler Rinker
fonte
11
Qual é o status do pacote? Não consigo ver no C-RAN.
MERose
4
@MERose pacman está agora no CRAN cran.r-project.org/web/packages/pacman/index.html
Tyler Rinker
6
Instalei agora e funciona maravilhosamente; deve fazer parte da base!
AndyF 16/09
3
A única maneira de melhorar seria se ele checasse /e, se encontrado, instalasse / carregasse no github automaticamente.
ataque aéreo
4
@NealBarsch, se você quer dizer que if (!require("pacman")) install.packages("pacman")existe uma função no pacman chamada p_boot()que faz essa linha automaticamente e copia para a área de transferência.
Tyler Rinker
72

Você pode apenas usar o valor de retorno de require:

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

Eu uso libraryapós a instalação, porque ela emitirá uma exceção se a instalação não tiver sido bem-sucedida ou se o pacote não puder ser carregado por algum outro motivo. Você torna isso mais robusto e reutilizável:

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

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

A desvantagem desse método é que você deve passar o nome do pacote entre aspas, o que você não faz de verdade require.

Livius
fonte
4
Você pode simplificar sua vida muito usando character.only = TRUEnos require, mas então eu acho que não há nada para diferenciar a sua resposta da minha.
Simon O'Hanlon 9/11
Parece bom, mas não parece funcionar, pelo menos para mim. Quando tentei a versão robusta disso, recebo duas mensagens de erro, pois R não sabe como lidar com "return True" e "return eval" por algum motivo. Então, eu realmente gostaria de uma função como esta que carrega um pacote, se presente na minha biblioteca, e instala (e depois carrega) o pacote. Idealmente, eu usaria isso como padrão para carregar pacotes. Pelo menos parece que faria sentido fazer isso e economizaria algum tempo.
Fabian Habersack
23
if (!require('ggplot2')) install.packages('ggplot2'); library('ggplot2')

"ggplot2" é o pacote. Ele verifica se o pacote está instalado, se não está. Em seguida, ele carrega o pacote independentemente de qual ramificação foi realizada.

user6784955
fonte
21

Essa solução pega um vetor de caracteres dos nomes dos pacotes e tenta carregá-los ou instalá-los se o carregamento falhar. Ele se baseia no comportamento de retorno de requirefazer isso porque ...

require retorna (invisivelmente) uma lógica indicando se o pacote necessário está disponível

Portanto, podemos simplesmente ver se conseguimos carregar o pacote necessário e, se não, instalá-lo com dependências. Então, dado um vetor de caractere de pacotes que você deseja carregar ...

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" ) )
Simon O'Hanlon
fonte
Você não gostaria de ligar requirenovamente após a instalação?
precisa
@krlmlr Não, porque para que a ifdeclaração seja avaliada, ela deve primeiro avaliar require, cujo efeito colateral é carregar o pacote, se estiver disponível!
Simon O'Hanlon
11
SimonO101: Acho que krlmlr significa na instrução if, após a chamada para install.packages, pois isso não carregaria realmente esse pacote. Mas (para @krlmlr) suspeito que a intenção é que esse fragmento de código seja chamado apenas uma vez; você não escreveria isso toda vez que exigisse o pacote. Em vez disso, você deve executá-lo uma vez antes do tempo e depois ligar requirecomo de costume, conforme necessário.
Aaron deixou o Stack Overflow em
@ Aaron ah sim ok, entendo o que você quer dizer e sim sua interpretação está correta. Vou editá-lo um pouco para ficar mais explícito sobre o carregamento após a instalação.
Simon O'Hanlon
11
não seria melhor fazer requireuma ligação para o segundo para libraryque ele falhe ruidosamente se ainda não conseguir anexar o pacote por algum motivo?
kabdulla
18

Muitas das respostas acima (e duplicatas desta pergunta) dependem da installed.packagesmá forma. A partir da documentação:

Isso pode ser lento quando milhares de pacotes estão instalados; portanto, não use isso para descobrir se um pacote nomeado está instalado (use system.file ou find.package) nem para descobrir se um pacote é utilizável (chame exigir e verifique o valor de retorno) nem para encontrar detalhes de um pequeno número de pacotes (use packageDescription). Ele precisa ler vários arquivos por pacote instalado, o que será lento no Windows e em alguns sistemas de arquivos montados em rede.

Portanto, uma abordagem melhor é tentar carregar o pacote usando ee requireinstalando se o carregamento falhar ( requireretornará FALSEse não for encontrado). Eu prefiro esta implementação:

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 pode ser usado assim:

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

Dessa forma, ele carrega todos os pacotes, depois volta e instala todos os pacotes ausentes (que, se você quiser, é um local útil para inserir um prompt para perguntar se o usuário deseja instalar pacotes). Em vez de chamar install.packagesseparadamente para cada pacote, ele passa o vetor inteiro de pacotes desinstalados apenas uma vez.

Aqui está a mesma função, mas com uma caixa de diálogo do Windows que pergunta se o usuário deseja instalar os pacotes ausentes

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)
        }
    }
}
Mateus
fonte
Esta é uma maneira bastante elegante, muito melhor que a aceita. Vou incluí-lo na minha biblioteca pessoal. Obrigado.
Bing
15

Embora a resposta de Shane seja realmente boa, para um dos meus projetos eu precisava remover as mensagens de saída, avisos e instalar pacotes automaticamente . Finalmente consegui obter 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)
}

Usar:

libraries <- c("ReadImages", "ggplot2")
for(library in libraries) 
{ 
    if(!UsePackage(library))
    {
        stop("Error!", library)
    }
}
Juan Antonio Cano
fonte
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)
Brian Spiering
fonte
6

Este é o objetivo do pacote rbundler : fornecer uma maneira de controlar os pacotes instalados para um projeto específico. No momento, o pacote trabalha com a funcionalidade devtools para instalar pacotes no diretório do seu projeto. A funcionalidade é semelhante ao empacotador de Ruby .

Se o seu projeto é um pacote (recomendado), tudo o que você precisa fazer é carregar o rbundler e empacotar os pacotes. A bundlefunção examinará o DESCRIPTIONarquivo do seu pacote para determinar quais pacotes agrupar.

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

Agora os pacotes serão instalados no diretório .Rbundle.

Se o seu projeto não é um pacote, você pode falsificá-lo criando um DESCRIPTIONarquivo no diretório raiz do seu projeto com um campo Depends que lista os pacotes que você deseja instalar (com informações opcionais da versão):

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

Aqui está o repositório do github para o projeto, se você estiver interessado em contribuir: rbundler .

Erik Shilts
fonte
5

Certo.

Você precisa comparar 'pacotes instalados' com 'pacotes desejados'. Isso é muito parecido com o que eu faço com o CRANberries, pois preciso comparar 'pacotes conhecidos armazenados' com 'pacotes atualmente conhecidos' para determinar pacotes novos e / ou atualizados.

Então faça algo como

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

Para obter todos os pacotes conhecidos, chame os pacotes atualmente instalados e compare-os a um determinado conjunto de pacotes de destino.

Dirk Eddelbuettel
fonte
5

Use packratpara que as bibliotecas compartilhadas sejam exatamente iguais e não alterem o ambiente de outras pessoas.

Em termos de elegância e melhores práticas, acho que você está fundamentalmente fazendo isso da maneira errada. O pacote packratfoi projetado para esses problemas. É desenvolvido pelo RStudio por Hadley Wickham. Em vez de terem que instalar dependências e possivelmente atrapalhar o sistema de ambiente de alguém, packratusa seu próprio diretório e instala todas as dependências dos seus programas lá e não toca no ambiente de alguém.

Packrat é um sistema de gerenciamento de dependências para R.

As dependências do pacote R podem ser frustrantes. Você já teve que usar tentativa e erro para descobrir quais pacotes R você precisa instalar para que o código de outra pessoa funcionasse - e ficou com esses pacotes instalados globalmente para sempre, porque agora você não tem certeza se precisa deles ? Você já atualizou um pacote para que o código de um de seus projetos funcione, apenas para descobrir que o pacote atualizado faz com que o código de outro projeto pare de funcionar?

Criamos o packrat para resolver esses problemas. Use o packrat para tornar seus projetos R mais:

  • Isolado: a instalação de um pacote novo ou atualizado para um projeto não interromperá os outros projetos e vice-versa. Isso porque o packrat fornece a cada projeto sua própria biblioteca de pacotes privada.
  • Portátil: transporte facilmente seus projetos de um computador para outro, mesmo em diferentes plataformas. O Packrat facilita a instalação dos pacotes dos quais seu projeto depende.
  • Reproduzível: O Packrat registra as versões exatas dos pacotes dos quais você depende e garante que essas versões exatas sejam as instaladas onde quer que você vá.

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

mtelesha
fonte
4

A seguinte função simples funciona como um 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)  
    }

(não o meu, encontrei isso na web há algum tempo e o estava usando desde então. não tenho certeza da fonte original)

Anish Sugathan
fonte
4

Eu uso a seguinte função para instalar o pacote se require("<package>")sair com o erro do pacote não encontrado. Ele consultará os repositórios - CRAN e Bioconductor quanto a pacotes ausentes.

Adaptado do trabalho 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)))
  }
}

Exemplo:

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

PS: update.packages(ask = FALSE)& biocLite(character(), ask=FALSE)atualizará todos os pacotes instalados no sistema. Isso pode levar um longo tempo e considerá-lo uma atualização completa do R, que pode não ser garantida o tempo todo!

Samir
fonte
Poderia ser melhorado verificando se os pacotes estão realmente disponíveis no cran ou bc. Também deve usar a biblioteca no final para gerar um erro se a instalação falhar ou se um pacote não existir. Veja minha versão aprimorada chamada loadpack()em raw.githubusercontent.com/holgerbrandl/datautils/master/R/…
Holger Brandl
4

Você pode simplesmente usar a setdifffunção para obter os pacotes que não estão instalados e depois instalá-los. Na amostra abaixo, verificamos se os pacotes ggplot2e Rcppestão instalados antes de instalá-los.

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

Em uma linha, o acima pode ser escrito como:

install.packages(setdiff(c("ggplot2", "Rcpp"), rownames(installed.packages())))
Alex Essilfie
fonte
Eu uso a mesma abordagem. Também podemos usar em installed.packages()[,'Package']vez de rownames(installed.packages()).
Scudelletti
3

Eu implementei a função para instalar e carregar pacotes R necessários silenciosamente. A esperança pode ajudar. Aqui está o 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);
Pratik Patil
fonte
3

A próxima versão do RStudio (1.2), já disponível como uma prévia, incluirá um recurso para detectar pacotes library()e require()chamadas ausentes e solicitar ao usuário que os instale:

Detectar pacotes R ausentes

Muitos scripts R são abertos com chamadas library()e require()para carregar os pacotes necessários para serem executados. Se você abrir um script R que faça referência a pacotes que você não instalou, o RStudio agora oferecerá a instalação de todos os pacotes necessários em um único clique. Não há mais digitação install.packages()repetida até os erros desaparecerem!
https://blog.rstudio.com/2018/11/19/rstudio-1-2-preview-the-little-things/

Isso parece abordar a preocupação original do OP particularmente bem:

Muitos deles são usuários R iniciantes / intermediários e não percebem que precisam instalar pacotes que ainda não possuem.

Aurèle
fonte
2

Em relação ao seu principal objetivo "instalar bibliotecas que elas ainda não possuem" e independentemente de usar "instllaed.packages ()". A função a seguir mascara a função original de require. Ele tenta carregar e verificar o pacote nomeado "x", se não estiver instalado, instale-o diretamente, incluindo dependências; e, finalmente, carregá-lo normalmente. você renomeia o nome da função de 'require' para 'library' para manter a integridade. A única limitação é que os nomes dos pacotes devem ser citados.

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

Portanto, você pode carregar e instalar o pacote da maneira antiga de R. require ("ggplot2") require ("Rcpp")

GeoObserver
fonte
Se você não gostar mais da sua resposta, não a vandalize - apenas exclua-a.
quer
Bem, eu tentei, mas não consegui. Eu acho que minha extensão NoScript do FF está desativando-a ou não tenho os direitos e os créditos para excluir minha própria resposta. LoL No entanto, acho que Livius está bem perto da minha resposta, sem mascarar. Obrigado Michael Petrotta. para a notificação.
GeoObserver
Você deve ver um deletelink acima desses comentários. Caso contrário, e você ainda deseja excluir, use o flaglink, selecione "outro" e explique a um moderador que deseja remover a resposta.
precisa
2

Bastante básico.

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

Pensei em contribuir com o que eu uso:

testin <- function(package){if (!package %in% installed.packages())    
install.packages(package)}
testin("packagename")
Ben
fonte
2
source("https://bioconductor.org/biocLite.R")
if (!require("ggsci")) biocLite("ggsci")
Shicheng Guo
fonte
2

Usando a família lapply e a abordagem de função anônima, você pode:

  1. Tente anexar todos os pacotes listados.
  2. Instale apenas ausente (usando ||avaliação lenta).
  3. Tente anexar novamente aqueles que estavam faltando na etapa 1 e instalados na etapa 2.
  4. Imprima o status de carregamento final de cada pacote ( 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 
Georgie Shimanovsky
fonte
1

Eu uso o seguinte, que verificará se o pacote está instalado e se as dependências foram atualizadas e, em seguida, carrega o pacote.

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

Aqui está o meu código:

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)
Edward Tyler
fonte
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 }
ruemorgue
fonte
1
library <- function(x){
  x = toString(substitute(x))
if(!require(x,character.only=TRUE)){
  install.packages(x)
  base::library(x,character.only=TRUE)
}}

Isso funciona com nomes de pacotes não citados e é bastante elegante (consulte a resposta do GeoObserver)

sn
fonte
1

No meu caso, eu queria um liner que pudesse ser executado a partir da linha de comando (na verdade, através de um Makefile). Aqui está um exemplo de instalação de "VGAM" e "feather" se eles ainda não estiverem 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")'

De dentro de R seria apenas:

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

Não há nada aqui além das soluções anteriores, exceto que:

  • Eu mantenho isso em uma única linha
  • Eu codifico o reposparâmetro (para evitar pop-ups perguntando sobre o espelho para usar)
  • Eu não me preocupo em definir uma função para ser usada em outro lugar

Observe também o importante character.only=TRUE(sem ele, o requiretentaria carregar o pacote p).

user3780389
fonte
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)
}
KVemuri
fonte
0

Deixe-me compartilhar um pouco de loucura:

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))) 
lf_araujo
fonte