Como posso carregar um monte de pacotes de uma só vez sem digitar novamente o comando require repetidamente? Eu tentei três abordagens, todas com falhas e queimaduras.

Basicamente, quero fornecer um vetor de nomes de pacotes para uma função que os carregue.

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

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

Várias permutações de suas funções propostas funcionam - mas apenas se você especificar o character.onlyargumento TRUE. Exemplo rápido:

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

O pacote CRAN pacman que eu mantenho (criado com Dason Kurkiewicz) pode fazer isso:

Então o usuário pode fazer:

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

e se o pacote estiver ausente, p_loadfaça o download do CRAN ou do Bioconductor.

Isso deve fazer o truque:

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

(O ponto principal é que o argsargumento em do.call(what, args) deve ser uma lista - mesmo que tenha apenas um único elemento!)

Para alguém que deseja instalar e carregar pacotes simultaneamente, deparei-me com essa função a partir deste link

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

Uma opção alternativa vem do pacote easypackages. Uma vez instalado, você pode carregar pacotes da maneira mais intuitiva:

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

O pacote também inclui uma função para instalar vários pacotes:

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

Referência aqui .

Você pode simplesmente usar o pacote lubripack e instala novos pacotes ordenadamente e, em seguida, carrega todos eles em uma linha.

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

Aqui está a saída depois de executar o código acima no RStudio.

Como instalar o pacote:

Execute o código abaixo para baixar o pacote e instalá-lo no GitHub. Não é necessário ter uma conta GitHub.

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

Com base na solução de daroczig, se você não quiser especificar uma lista como entrada, poderá usar

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

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

... que é mais curto que

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

Eu uso a seguinte função:

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

Isso tenta carregar e, se falhar, é instalado e tente carregar novamente.

Eu acho que o código que o @daroczig forneceu pode ser melhorado, substituindo o requirecom librarye envolvendo a lapplychamada dentro da invisible()função. Portanto, o código aprimorado terá a seguinte aparência:

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

Este código foi aprimorado porque:

1. library()geralmente é preferível ao require()carregamento de pacotes, porque o primeiro gera um erro se o pacote não estiver instalado, enquanto o último apenas fornece um aviso. Além disso, require()chama library(), então por que não usar library()diretamente!

   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. O objeto de lista retornado e impresso pela lapply()chamada não é significativo nesse caso, portanto, faz sentido tornar a saída invisível. Digamos que você use o R Notebook para seu trabalho de análise, o uso da invisible()função suprimirá o conteúdo do objeto de lista e evitará a confusão no arquivo do notebook renderizado.

Ligeira modificação da resposta de Tyler Rinker para adicionar um cheque para instalar e carregar o pacman:

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

Eu gosto da solução p_load porque evita citações!