El analizar números como forma de vida es indispensable para el mundo moderno ya que, de una u otra manera, todo tiene una cercana relación con las matemáticas. Así, si volteamos a cualquier lado en nuestro entorno, nos encontraremos con que están los contadores haciendo impuestos, los financieros revisando la bolsa, nuestro gobierno buscando recursos económicos, las redes sociales contando caracteres, los deportes tomando estadísticas, etc. Podríamos seguir enumerando profesiones, oficios y actividades y todo nos llevaría a la misma conclusión: Los números son de vital importancia en nuestra vida diaria.
En este mundo globalizado, la competencia en ciertos aspectos de la vida no es justa, quizás ni siquiera leal o sencillamente no se nos permitió elegir. Tal como sucedió con Excel, la aplicación desarrollada por Microsoft que nos permite de manera sencilla analizar, almacenar y organizar datos en una hoja de cálculo generando soluciones para todos aquellos que requerimos trabajar con números.
Pero, ¿qué sucede cuando la necesidad de análisis de datos supera las capacidades de Excel? La primera respuesta que tendremos es entrar en pánico, ya que hasta hace unas semanas, el autor del presente, desconocía que hay una vida después del software de Microsoft. Por fortuna, en el día a día podemos encontrar orientación de varios tipos, a mí por ejemplo, me han presentado el software denominado R, el cual hasta ahora, ha demostrado capacidades de análisis superiores a las de Excel.
¿Qué es R? Es un software desarrollado por Bell Laboratories, el cual de manera sencilla se puede describir como un lenguaje computacional desarrollado particularmente para la informática estadística y el desarrollo de gráficos especializados. R cuenta con la particularidad de proporcionar una amplia gama de modelos estadísticos -clasificaciones, agrupaciones, modelos lineales, modelos no lineales, pruebas estadísticas básicas, entre otros-.
Todo lo anterior suena increíble, pero existe un pequeño inconveniente. Un gran porcentaje de la información que se maneja en el mundo de los negocios y algunos otros, se encuentra contenida en el formato estándar de Excel (.xls o .xlsx) el cual por simple lógica resulta incompatible con R.
Afortunadamente, el tiempo de incompatibilidad entre marcas, versiones y software ya quedó en el pasado y, por lo tanto, importar y exportar archivos de Excel a la plataforma de R, es una realidad. Pero para tales efectos, R requiere de un complemento, el cual se encuentra contenido en el software denominado xlsx, el cual le permite leer, escribir y editar archivos que de origen hayan sido guardados en Excel.
Por medio del presente, se dará una breve guía de uso del software xlsx, para aquellos que al día de hoy se inician en el uso de R y requieren trabajar con datos contenidos en un archivo de Excel.
Considerando que el usuario ya cuenta con R, el paso básico recae en la descarga y posterior instalación del programa xlsx desde la plataforma de R.
Como paso inicial, se tendrá que abrir un R Script (Ctrl + Shift + N), para posteriormente ejecutar el siguiente comando (Ctrl + Enter):
##install.packages ("xlsx")Al ejecutar el comando de referencia, la consola tomará nota de la descarga solicitada y nos mostrará el progreso del proceso mediante la siguiente información:
install.packages("xlsx")
Installing package into 'C:/Users/ThinkP /Documents/R/win-library/3.3'
(as 'lib' is unspecified)
also installing the dependencies 'rJava', 'xlsxjars'
trying URL 'https://cran.rstudio.com/bin/windows/contrib/3.3/rJava_0.9-8.zip'
Content type 'application/zip' length 713967 bytes (697 KB)
downloaded 697 KB
trying URL 'https://cran.rstudio.com/bin/windows/contrib/3.3/xlsxjars_0.6.1.zip'
Content type 'application/zip' length 9485184 bytes (9.0 MB)
downloaded 9.0 MB
trying URL 'https://cran.rstudio.com/bin/windows/contrib/3.3/xlsx_0.5.7.zip'
Content type 'application/zip' length 401439 bytes (392 KB)
downloaded 392 KB
package 'rJava' successfully unpacked and MD5 sums checked
package 'xlsxjars' successfully unpacked and MD5 sums checked
package 'xlsx' successfully unpacked and MD5 sums checked
The downloaded binary packages are in
C:\Users\ThinkP\AppData\Local\Temp\RtmpCee5aj\downloaded_packagesEl siguiente paso, será invocar el software, mediante la siguiente instrucción:
##library("xlsx")
Como es del conocimiento popular los archivos que son guardados en Excel, son guardados con las extensiones .xls y .xlsx -dependiendo de la versión que el usuario tenga-. Para tales efectos, los comandos a ejecutar para llevar a cabo la lectura de los archivos de Excel son los siguientes:
##Read.xls()
##Read.xlsx2()Los comandos antes mencionados, son utilizados por R para estar en posibilidad de leer toda clase de datos contenidos en los archivos de Excel, como ejemplo de la ejecución de dichos comandos, se muestran los siguientes:
read.xlsx(file, sheetIndex, sheetName=NULL, rowIndex=NULL, startRow=NULL, endRow=NULL, colIndex=NULL, as.data.frame=TRUE, header=TRUE, colClasses=NA, keepFormulas=FALSE, encoding="unknown", ...)
read.xlsx2(file, sheetIndex, sheetName=NULL, startRow=1, colIndex=NULL, endRow=NULL, as.data.frame=TRUE, header=TRUE, colClasses="character", ...)En donde los argumentos dados en los comandos, son los siguientes:
file Archivo a leerse
sheetIndex Número de la hoja en el archivo
sheetName Nombre de la hoja en el archivo
rowIndex Vector numérico que indica las filas que desea extraer. Si NULL, todas las filas encontradas se extraerán, a menos que se especifique startRow o endRow
colIndex Vector numérico que indica las columnas que desea extraer. Si NULL, se extraerán todas las columnas encontradas
as.data.frame Valor lógico que indica si el resultado debe ser coaccionado en un archivo data.frame. Si FALSE, el resultado es una lista con un elemento para cada columna.
Header Valor lógico que indica si la primera fila correspondiente al primer elemento del vector rowIndex contiene los nombres de las variables.
ColClasses Para read.xlsx un vector de caracteres que representa la clase de cada columna. Si el vector de caracteres es nombrado, los valores no especificados se toman como NA.
KeepFormulas Valor lógico que indica si las fórmulas de Excel deben mostrarse como texto en R y no evaluadas antes de introducirlas.
Encoding Codificación para las cadenas de entrada.
StartRow Número que especifica el índice de la fila inicial. Para read.xlsx este argumento sólo está activo si rowIndex es NULL.
EndRow Número que especifica el índice de la última fila a tirar. Si es NULL, lea todas las filas de la hoja. Para read.xlsx este argumento sólo está activo si rowIndex es NULL.
... Otros argumentos a data.frameA continuación, un ejemplo de la aplicación del comando bajo análisis:
library(xlsx)
file <- system.file("tests", "test_import.xlsx", package = "xlsx")
res <- read.xlsx(file, 1) # read first sheet
head(res[, 2010:2016])La edición de datos es también una necesidad para los usuarios de R, en virtud de lo anterior, al igual que en el apartado que antecede, existe un comando para la edición, el cual está contenido en las funciones write.xlsx () y write.xlsx2 () mismas que son utilizadas para exportar datos de R a un libro de Excel.
Los formatos de estas dos funciones son:
##write.xlsx(x, file, sheetName="Sheet1",
##col.names=TRUE, row.names=TRUE, append=FALSE)
##write.xlsx2(x, file, sheetName="Sheet1",
##col.names=TRUE, row.names=TRUE, append=FALSE)En donde los argumentos dados en los comandos, son los siguientes:
X Marco de datos que se escribirá en el libro
File Ruta al archivo de salida
SheetName Cadena de caracteres a utilizar para el nombre de la hoja.
Col.names, row.names Valor lógico que especifica si los nombres de columnas / nombres de filas de x deben escribirse en el archivo
Append Valor lógico que indica si se debe añadir x a un archivo existenteA continuación, un ejemplo de la aplicación del comando bajo análisis:
library(xlsx)
write.xlsx(INPC, file="myworkbook.xlsx",
sheetName="INPC")Ahora bien, considerando que lo que queremos hacer en nuestro software R no es solamente ver archivos de Excel, será necesarío también prestar atención a ciertos comandos que harán más fácil nuestro andar por la mágia de R.
A continuación de se mencionarán aquellas funciones que se consideran de importancia:
Comando:
##S3 method for class GCellStyleG cs1 + objectArgumentos:
cs1 Objeto CellStyle
object Objeto a adicionar - CellStyle, DataFormat, Alignment, Border, Fill, Font, o CellProtection objectEjemplo:
cs <- CellStyle(wb) +
Font(wb, heightInPoints=20, isBold=TRUE, isItalic=TRUE, name="Courier New", color="orange") +
Fill(backgroundColor="lavender", foregroundColor="lavender", pattern="SOLID_FOREGROUND") +
Alignment(h="ALIGN_RIGHT")Comando:
##addDataFrame(x, sheet, col.names=TRUE, row.names=TRUE, startRow=1, startColumn=1, colStyle=NULL, colnamesStyle=NULL, rownamesStyle=NULL, showNA=FALSE, characterNA="", byrow=FALSE)Argumentos
x Marco de datos
sheet Hoja
Col.name Valor lógico que indica si los nombres de columnas de x deben escribirse junto con x en el archivo
Row.names Valor lógico que indica si los nombres de fila de x deben escribirse junto con x en el archivo
StartRow Valor numérico para la fila de inicio.
StartColumn Valor numérico para la columna de inicio.
ColStyle Lista de CellStyle. Si el nombre del elemento de lista es el número de columna, se utilizará para establecer el estilo de la columna. Las columnas del tipo Date y POSIXct se denominan automáticamente aunque colSyle = NULL.
ColnamesStyle Objeto CellStyle para personalizar el encabezado de la tabla.
RownamesStyle Objeto CellStyle para personalizar los nombres de fila (si row.names = TRUE).
ShowNA Valor booleano para controlar cómo NA se muestran en la hoja. Si FALSO, los valores NA serán representados como celdas en blanco.
CharacterNA Valor de cadena para controlar cómo se mostrará el carácter NA en la hoja de cálculo.
Byrow Valor lógico que indica si el data.frame debe ser agregado a la hoja en forma de fila sabio.Ejemplo:
wb <- createWorkbook()
sheet <- createSheet(wb, sheetName="addDataFrame1")
data <- data.frame(mon=month.abb[1:10], day=1:10, year=2000:2009, date=seq(as.Date("1999-01-01"), by="1 year", length.out=10), bool=c(TRUE, FALSE), log=log(1:10),
rnorm=10000*rnorm(10),
datetime=seq(as.POSIXct("2011-11-06 00:00:00", tz="GMT"), by="1 hour", length.out=10))
cs1 <- CellStyle(wb) + Font(wb, isItalic=TRUE) # rowcolumns cs2 <- CellStyle(wb) + Font(wb, color="blue")
cs3 <- CellStyle(wb) + Font(wb, isBold=TRUE) + Border() # header addDataFrame(data, sheet, startRow=3, startColumn=2, colnamesStyle=cs3,
rownamesStyle=cs1, colStyle=list('2'=cs2, '3'=cs2))Comando:
##addHyperlink(cell, address, linkType=c("URL", "DOCUMENT", "EMAIL", "FILE"), hyperlinkStyle=NULL)Argumentos:
Cel Objeto Cell.
Dirección Cadena que apunta al recurso.
LinkType Tipo del recurso.
HyperlinkStyle Objeto CellStyle. Si NULL se crea un estilo de celda predeterminado, fuente azul subrayada.Ejemplo:
wb <- createWorkbook()
sheet1 <- createSheet(wb, "Sheet1")
rows <- createRow(sheet1, 1:10) # 10 rows cells <- createCell(rows, colIndex=1:8) # 8 columns
cat("Add hyperlinks to a cell") cell <- cells[[1,1]]
address <- "http://poi.apache.org/" setCellValue(cell, "click me!") addHyperlink(cell, address)Comando:
#Alignment(horizontal=NULL, vertical=NULL, wrapText=FALSE, rotation=0, indent=0)Argumentos:
Horizontal Valor de carácter que especifica la alineación horizontal. Los valores válidos provienen de constantes HALIGN_STYLES_.
Vertical Valor de carácter que especifica la alineación vertical. Los valores válidos provienen de VALIGN_STYLES_ constante.
WrapText Lógico que indica si el texto debe ser envuelto.
Rotación Valor numérico que indica los grados que desea girar el texto en la celda.
Indent Valor numérico que indica el número de espacios que desea sangrar el texto en la celda.Ejemplo:
<- Alignment(h="ALIGN_CENTER", rotation=90)Comando:
#Border(color="black", position="BOTTOM", pen="BORDER_THIN")Argumentos:
Color Vector de caracteres especificando el color de la fuente. Se puede utilizar cualquier nombre de color devuelto por colores. O, un carácter hexadecimal, p. "# FF0000" para el rojo.
Position Vector de caracteres que especifica la posición del borde. Los valores válidos son "BOTTOM", "LEFT", "TOP", "DERECHA".
Pen Escribe un vector de caracteres que especifica el estilo de la pluma. Los valores válidos vienen de constantes BORDER_STYLES_.
x Objeto MargenEjemplo:
border <- Border(color="red", position=c("TOP", "BOTTOM"), pen=c("BORDER_THIN", "BORDER_THICK"))Comando:
##createCell(row, colIndex=1:5)
##getCells(row, colIndex=NULL, simplify=TRUE) setCellValue(cell, value, richTextString=FALSE, showNA=TRUE) getCellValue(cell, keepFormulas=FALSE, encoding="unknown")Argumentos:
Row Lista de objetos de fila.
ColIndex Vector numérico que especifica el índice de columnas. Simplificar un valor lógico. Si es TRUE, el resultado no se mostrará en la lista. Valor una variable R de longitud uno.
RichTextString Valor lógico que indica si el valor debe insertarse en la celda de Excel como texto enriquecido.
ShowNA Valor lógico. Si TRUE la celda contendrá el valor "# N / A", si FALSE se saltarán. El valor predeterminado se eligió para seguir siendo compatible con las versiones anteriores de la función.
KeepFormulas Valor lógico. Si TRUE las fórmulas se devuelven como caracteres en lugar de ser evaluadas explícitamente.
Encoding Valor de carácter para establecer la codificación, por ejemplo "UTF-8".
Cell Objeto Cell.Ejemplo:
file <- system.file("tests", "test_import.xlsx", package = "xlsx") wb <- loadWorkbook(file)
sheets <- getSheets(wb)
sheet <- sheets[[GmixedTypesG]] # get second sheet rows <- getRows(sheet) # get all the rows
cells <- getCells(rows) # returns all non empty cells values <- lapply(cells, getCellValue) # extract the values
# write the months of the year in the first column of the spreadsheet ind <- paste(2:13, ".2", sep="")
mapply(setCellValue, cells[ind], month.name)
####################################################################
# make a new workbook with one sheet and 5x5 cells wb <- createWorkbook()
sheet <- createSheet(wb, "Sheet1")
rows <- createRow(sheet, rowIndex=1:5) cells <- createCell(rows, colIndex=1:5)
# populate the first column with Dates
days <- seq(as.Date("2013-01-01"), by="1 day", length.out=5) mapply(setCellValue, cells[,1], days)Comando:
##CellBlock(sheet, startRow, startColumn, noRows, noColumns, create=TRUE)
##is.CellBlock( cellBlock )
##CB.setColData(cellBlock, x, colIndex, rowOffset=0, showNA=TRUE, colStyle=NULL)
##CB.setRowData(cellBlock, x, rowIndex, colOffset=0, showNA=TRUE, rowStyle=NULL)
##CB.setMatrixData(cellBlock, x, startRow, startColumn, showNA=TRUE, cellStyle=NULL)
##CB.setFill( cellBlock, fill, rowIndex, colIndex) CB.setFont( cellBlock, font, rowIndex, colIndex ) CB.setBorder( cellBlock, border, rowIndex, colIndex)Argumentos:
Sheet Objeto de hoja.
StartRow Valor numérico para la fila de inicio. StartColumn un valor numérico para la columna de inicio. RowOffset un valor numérico para la fila de inicio. ColOffset un valor numérico para la columna inicial.
ShowNA Valor lógico. Si se establece en FALSE, los valores NA se dejarán como celdas vacías. NoRows un valor numérico para especificar el número de filas para el bloque. NoColumns un valor numérico para especificar el número de columnas para el bloque.Ejemplo:
wb <- createWorkbook()
sheet <- createSheet(wb, sheetName="CellBlock")
cb <- CellBlock(sheet, 7, 3, 1000, 60) CB.setColData(cb, 1:100, 1) # set a column CB.setRowData(cb, 1:50, 1) # set a row
# add a matrix, and style it
cs <- CellStyle(wb) + DataFormat("#,##0.00") x <- matrix(rnorm(900*45), nrow=900) CB.setMatrixData(cb, x, 10, 4, cellStyle=cs)
# highlight the negative numbers in red
fill <- Fill(foregroundColor = "red", backgroundColor="red") ind <- which(x < 0, arr.ind=TRUE)
CB.setFill(cb, fill, ind[,1]+9, ind[,2]+3) # note the indices offset
# set the border on the top row of the Cell Block
border <- Border(color="blue", position=c("TOP", "BOTTOM"), pen=c("BORDER_THIN", "BORDER_THICK"))
CB.setBorder(cb, border, 1:1000, 1)Comando:
##CellBlock(sheet, startRow, startColumn, noRows, noColumns, create=TRUE)
is.CellBlock( cellBlock )
CB.setColData(cellBlock, x, colIndex, rowOffset=0, showNA=TRUE, colStyle=NULL)
CB.setRowData(cellBlock, x, rowIndex, colOffset=0, showNA=TRUE, rowStyle=NULL)
CB.setMatrixData(cellBlock, x, startRow, startColumn, showNA=TRUE, cellStyle=NULL)
CB.setFill( cellBlock, fill, rowIndex, colIndex) CB.setFont( cellBlock, font, rowIndex, colIndex ) CB.setBorder( cellBlock, border, rowIndex, colIndex)Argumentos:
Sheet Objeto de hoja.
StartRow Valor numérico para la fila de inicio. StartColumn un valor numérico para la columna de inicio. RowOffset un valor numérico para la fila de inicio. ColOffset un valor numérico para la columna inicial.
ShowNA Valor lógico. Si se establece en FALSE, los valores NA se dejarán como celdas vacías. NoRows un valor numérico para especificar el número de filas para el bloque. NoColumns un valor numérico para especificar el número de columnas para el bloque.Ejemplo:
wb <- createWorkbook()
sheet <- createSheet(wb, sheetName="CellBlock")
cb <- CellBlock(sheet, 7, 3, 1000, 60) CB.setColData(cb, 1:100, 1) # set a column CB.setRowData(cb, 1:50, 1) # set a row
# add a matrix, and style it
cs <- CellStyle(wb) + DataFormat("#,##0.00") x <- matrix(rnorm(900*45), nrow=900) CB.setMatrixData(cb, x, 10, 4, cellStyle=cs)
# highlight the negative numbers in red
fill <- Fill(foregroundColor = "red", backgroundColor="red") ind <- which(x < 0, arr.ind=TRUE)
CB.setFill(cb, fill, ind[,1]+9, ind[,2]+3) # note the indices offset
# set the border on the top row of the Cell Block
border <- Border(color="blue", position=c("TOP", "BOTTOM"), pen=c("BORDER_THIN", "BORDER_THICK"))
CB.setBorder(cb, border, 1:1000, 1)Comando:
##CellProtection(locked=TRUE, hidden=FALSE)Argumentos:
Locked Lógica indicando que la celda está bloqueada.
Hidden Lógica indicando que la celda está oculta.
X Objeto CellProtection, como devuelto por CellProtection.Ejemplo:
font <- CellProtection(locked=TRUE)Comando
CellStyle(wb, dataFormat=NULL, alignment=NULL, border=NULL, fill=NULL, font=NULL, cellProtection=NULL)
setCellStyle(cell, cellStyle) getCellStyle(cell)Argumentos:
Wb Objeto de libro de trabajo devuelto por createWorkbook o loadWorkbook. DataFormat un objeto
DataFormat Alinee un objeto de alineación.
Border Objeto de borde.
Fill Objeto relleno
Font Objeto Fuente.
CellProtection Objeto CellProtection.
X Objeto CellStyle.
Cell Objeto Cell.
CellStyle Objeto CellStyle.
... Argumentos a CellStyle.default.Ejemplos:
wb <- createWorkbook()
sheet <- createSheet(wb, "Sheet1") rows <- createRow(sheet, rowIndex=1)
cell.1 <- createCell(rows, colIndex=1)[[1,1]] setCellValue(cell.1, "Hello R!")
cs <- CellStyle(wb) +
Font(wb, heightInPoints=20, isBold=TRUE, isItalic=TRUE, name="Courier New", color="orange") +
Fill(backgroundColor="lavender", foregroundColor="lavender", pattern="SOLID_FOREGROUND") +
Alignment(h="ALIGN_RIGHT")
setCellStyle(cell.1, cellStyle1)Comando:
##createCellComment(cell, string="", author=NULL, visible=TRUE) getCellComment(cell)
##removeCellComment(cell)Argumentos:
Cell Objeto Cell.
String Cadena para el comentario.
Author Cadena con el nombre del autor
Visible Valor lógico. Si TRUE el comentario será visible.Ejemplo:
wb <- createWorkbook()
sheet1 <- createSheet(wb, "Sheet1")
rows <- createRow(sheet1, rowIndex=1:10) # 10 rows cells <- createCell(rows, colIndex=1:8) # 8 columns
cell1 <- cells[[1,1]]
setCellValue(cell1, 1) # add value 1 to cell A1
# create a cell comment
createCellComment(cell1, "Cogito", author="Descartes")
# extract the comments
comment <- getCellComment(cell1) stopifnot(comment$getAuthor()=="Descartes") stopifnot(comment$getString()$toString()=="Cogito")Comando:
#DataFormat(x)Argumentos:
X Valor de carácter que especifica el formato de datos.
Df Objeto DataFormat, como devuelto por DataFormat.Ejemplo:
df <- DataFormat("#,##0.00")Comando:
##Fill(foregroundColor="lightblue", backgroundColor="lightblue", pattern="SOLID_FOREGROUND")Argumentos:
foregroundColor Vector de caracteres que especifica el color de primer plano. Pueden utilizarse todos los nombres de color devueltos por colores. O, un carácter hexadecimal, p. "# FF0000" para el rojo.
backgroundColor Un vector de caracteres que especifica el color de primer plano. Pueden utilizarse todos los nombres de color devueltos por colores. O, un carácter hexadecimal, p. "# FF0000" para el rojo.
pattern Un vector de caracteres que especifica el estilo del patrón de relleno. Los valores válidos provienen de constantes FILL_STYLES_.
x Un objeto Fill, como devuelto por Fill.Ejemplo:
fill <- Fill()Comando:
##Font(wb, color=NULL, heightInPoints=NULL, name=NULL, isItalic=FALSE, isStrikeout=FALSE, isBold=FALSE, underline=NULL, boldweight=NULL)Argumentos:
Wb Objeto de libro de trabajo devuelto por createWorkbook o loadWorkbook.
Color Carácter especificando el color de la fuente. Se puede utilizar cualquier nombre de color devuelto por colores. O, un carácter hexadecimal, p. "# FF0000" para el rojo.
HeightInPuntos Valor numérico que especifica la altura de la fuente. Los valores usuales son 10, 12, 14, etc.
Name Valor de carácter para la fuente a utilizar.
IsItalic Lógico que indica que la fuente debe estar en cursiva.
IsStrikeout Lógica que indica que la fuente debe ser stiked fuera.
IsBold Indicación lógica de que la fuente debe estar en negrita.
Underline Valor numérico especificando el grosor del subrayado. Los valores permitidos son 0, 1, 2.
Boldweight Valor numérico que indica el peso en negrita. Normal es 400, la negrita regular es 700.
X Objeto Fuente, como devuelto por Fuente.
... Argumentos se pasan a Font.Ejemplo:
font <- Font(wb, color="blue", isItalic=TRUE)Comando:
##getRanges(wb)
##readRange(range, sheet, colClasses="character") createRange(rangeName, firstCell, lastCell)Argumentos:
Wb Objeto de libro devuelto por createWorksheet o loadWorksheet.
Rango Objeto de rango devuelto por getRanges.
Hoja Objeto de hoja como devuelto por getSheets.
RangeName Carácter que especifica el nombre del nombre a crear.
ColClasses Tipo de columnas admitidas. Solo se admiten números y caracteres.
PrimeroCell Objeto de celda correspondiente a la celda superior izquierda del rango.
LastCell Objeto de celda correspondiente a la celda inferior derecha del rango.Ejemplo:
file <- system.file("tests", "test_import.xlsx", package = "xlsx") wb <- loadWorkbook(file)
sheet <- getSheets(wb)[["deletedFields"]] ranges <- getRanges(wb)
# the call below fails on cran tests for MacOS. You should see the
# FAQ: http://code.google.com/p/rexcel/wiki/FAQ
#res <- readRange(ranges[[1]], sheet, colClasses="numeric") # read it ranges[[1]]$getNameName() # get its name
# see all the available java methods that you can call
.jmethods(ranges[[1]])
# create a new named range
firstCell <- sheet$getRow(14L)$getCell(4L) lastCell <- sheet$getRow(20L)$getCell(7L) rangeName <- "Test2"
# same issue on MacOS
#createRange(rangeName, firstCell, lastCell)Comando:
##addAutoFilter(sheet, cellRange)
##addMergedRegion(sheet, startRow, endRow, startColumn, endColumn) removeMergedRegion(sheet, ind)
##autoSizeColumn(sheet, colIndex)
##createFreezePane(sheet, rowSplit, colSplit, startRow=NULL, startColumn=NULL)
##createSplitPane(sheet, xSplitPos=2000, ySplitPos=2000,Argumentos:
CellRange Cadena que especifica el rango de celdas.
ColIndex Vector numérico que especifica las columnas que desea utilizar en el tamaño automático.
ColSplit Valor numérico para la columna a dividir.
ColWidth Valor numérico para especificar el ancho de la columna. Las unidades están en 1 / 256ths de un ancho de carácter.
Denominador Valor numérico que representa el denomiador de la relación de zoom.
EndColumn Valor numérico para la columna final.
EndRow Valor numérico para la fila final.
Ind Valor numérico que indica la región fusionada que desea eliminar.
Numerator Valor numérico que representa el numerador de la relación de zoom.
Position Caractér. Los valores válidos son "PANE_LOWER_LEFT", "PANE_LOWER_RIGHT", "PANE_UPPER_LEFT", "PANE_UPPER_RIGHT".
RowSplit Valor numérico para la fila para dividir.
Sheet Objeto de hoja de cálculo.
SheetIndex Valor numérico para el índice de hoja de cálculo.
StartColumn Valor numérico para la columna de inicio.
StartRow Valor numérico para la fila de inicio.
XSplitPos Valor numérico para la posición horizontal de split en 1/20 de un punto.
YSplitPos Valor numérico para la posición vertical de split en 1/20 de un punto.
Wb Objeto de libro.Ejemplo:
wb <- createWorkbook()
sheet1 <- createSheet(wb, "Sheet1")
rows <- createRow(sheet1, 1:10) # 10 rows cells <- createCell(rows, colIndex=1:8) # 8 columns
cat("Merge cells \n")
setCellValue(cells[[1,1]], "A title that spans 3 columns") addMergedRegion(sheet1, 1, 1, 1, 3)
cat("Set zoom 2:1 \n") setZoom(sheet1, 200, 100)
sheet2 <- createSheet(wb, "Sheet2")
rows <- createRow(sheet2, 1:10) # 10 rows cells <- createCell(rows, colIndex=1:8) # 8 columns
#createFreezePane(sheet2, 1, 1, 1, 1)
createFreezePane(sheet2, 5, 5, 8, 8)
sheet3 <- createSheet(wb, "Sheet3")
rows <- createRow(sheet3, 1:10) # 10 rows cells <- createCell(rows, colIndex=1:8) # 8 columns createSplitPane(sheet3, 2000, 2000, 1, 1, "PANE_LOWER_LEFT")
# set the column width of first column to 25 characters wide setColumnWidth(sheet1, 1, 25)
# add a filter on the 3rd row, columns C:E addAutoFilter(sheet1, "C3:E3")Comando:
##addPicture(file, sheet, scale=1, startRow=1, startColumn=1)Argumentos:
File Ruta absoluta al archivo de imagen.
Sheet Objeto de hoja de cálculo devuelto por createSheet o subconjunto de getSheets. La imagen se agregará en esta hoja en la posición startRow, startColumn.
Scale Numérico especificando el factor de escala para la imagen.
StartRow Numérico que especifica la fila de la esquina superior izquierda de la imagen.
StartColumn Numérico especificando la columna de la esquina superior izquierda de la imagen.Ejemplo:
file <- system.file("tests", "log_plot.jpeg", package = "xlsx") wb <- createWorkbook()
sheet <- createSheet(wb, "Sheet1")
addPicture(file, sheet)Comando:
##printSetup(sheet, fitHeight=NULL,
##fitWidth=NULL, copies=NULL, draft=NULL, footerMargin=NULL, headerMargin=NULL, landscape=FALSE, pageStart=NULL, paperSize=NULL, noColor=NULL)Argumentos:
Sheet Hoja de trabajo del objeto de hoja de cálculo.
FitHeight Valor numérico para establecer el número de páginas en alto para que se ajuste a la hoja. Ajuste el valor numérico para establecer el número de páginas para que se ajuste a la hoja. Copia el valor numérico para establecer el número de copias.
Draft Lógico indicando si es un borrador o no.
FooterMargin Valor numérico para establecer el margen de pie de página.
HeaderMargin Valor numérico para establecer el margen de encabezado. Paisaje para especificar la orientación del papel.
PageStart Valor numérico desde donde comenzar la numeración de la página.
PaperSize Para establecer el tamaño del papel. Los valores válidos son "A4_PAPERSIZE", "A5_PAPERSIZE", "ENVELOPE_10_PAPERSIZE", "ENVELOPE_CS_PAPERSIZE", "ENVELOPE_DL_PAPERSIZE", "ENVELOPE_MONARCH_PAPERSIZE", "EXECUTIVE_PAPERSIZE", "LE- GAL_PAPERSIZE "," LETTER_PAPERSIZE ".
NoColor Valor lógico para indicar si las impresiones deben ser de color o no.Ejemplos:
wb <- createWorkbook()
sheet <- createSheet(wb, "Sheet1")
ps <- printSetup(sheet, landscape=TRUE, copies=3)Comando:
##readRows(sheet, startRow, endRow, startColumn, endColumn=NULL)Argumento:
Sheet Objeto de hoja de cálculo.
StartRow Valor numérico para la fila de inicio.
EndRow Valor numérico para la fila final. Si NULL lee todas las filas de la hoja.
StartColumn Valor numérico para la columna de inicio.
EndColumn Valor numérico para la columna final. Las celdas vacías se devolverán como "".Ejemplo:
file <- system.file("tests", "test_import.xlsx", package = "xlsx") wb <- loadWorkbook(file)
sheets <- getSheets(wb)
sheet <- sheets[["all"]]
res <- readRows(sheet, startRow=3, endRow=7, startColumn=3, endColumn=10)Comando:
##createRow(sheet, rowIndex=1:5) getRows(sheet, rowIndex=NULL) removeRow(sheet, rows=NULL)
##setRowHeight(rows, inPoints, multiplier=NULL)Argumentos:
Sheet Objeto de hoja de cálculo devuelto por createSheet o subconjunto de getSheets.
RowIndex Vector numérico que especifica el índice de filas a crear. Para getRows, un NULL Valor devolverá todas las filas no vacías.
Rows Lista de objetos de fila.
InPoints Valor numérico para especificar la altura de la fila en puntos.
Multiplier Valor numérico para especificar el múltiplo de la altura de fila predeterminada en puntos. Si se establece este valor, tiene prioridad sobre el argumento inPointsEjemplo:
file <- system.file("tests", "test_import.xlsx", package = "xlsx") wb <- loadWorkbook(file)
sheets <- getSheets(wb)
sheet <- sheets[[2]]
rows <- getRows(sheet) # get all the rows
# see all the available java methods that you can call
.jmethods(rows[[1]])
# for example
rows[[1]]$getRowNum() # zero based index in Java removeRow(sheet, rows) # remove them all
# create some row
rows <- createRow(sheet, rowIndex=1:5)
setRowHeight( rows, multiplier=3) # 3 times bigger rows than the defaultComando:
##readColumns(sheet, startColumn, endColumn, startRow, endRow=NULL, as.data.frame=TRUE, header=TRUE, colClasses=NA,...)Argumentos:
Sheet Objeto de hoja de cálculo.
StartColumn Valor numérico para la columna de inicio.
EndColumn Valor numérico para la columna final.
StartRow Valor numérico para la fila de inicio.
EndRow Valor numérico para la fila final. Si NULL lee todas las filas de la hoja. Si solicita más que las filas existentes en la hoja, el resultado se truncará por el número de fila real.
As.data.frame Valor lógico que indica si el resultado debe ser coaccionado en un archivo data.frame. Si FALSE, el resultado es una lista con un elemento para cada columna.
Header Valor lógico que indica si la primera fila correspondiente al primer elemento del vector rowIndex contiene los nombres de las variables.
ColClasifica Vector de caracteres que representa la clase de cada columna. Reciclado según sea necesario, o si NA se intenta adivinar el tipo de cada columna leyendo la primera fila de datos. Sólo se aceptan los tipos numéricos, de carácter, fecha, POSIX, columna. Cualquier otra cosa se cubrirá a un tipo de carácter. Si la longitud es menor que el número de columnas solicitadas, reproducirlo.
... Otros argumentos para data.frame, por ejemplo stringsAsFactorsEjemplo:
file <- system.file("tests", "test_import.xlsx", package = "xlsx") wb <- loadWorkbook(file)
sheets <- getSheets(wb)
sheet <- sheets[["all"]]
res <- readColumns(sheet, startColumn=3, endColumn=10, startRow=3, endRow=7)
sheet <- sheets[["NAs"]]
res <- readColumns(sheet, 1, 6, 1, colClasses=c("Date", "character", "integer", rep("numeric", 2), "POSIXct"))Comando:
##createSheet(wb, sheetName="Sheet1") removeSheet(wb, sheetName="Sheet1") getSheets(wb)Argumentos:
Wb Objeto de libro devuelto por createWorksheet o loadWorksheet.
SheetName Carácter que especifica el nombre de la hoja de cálculo que se va a crear o quitar.Ejemplos:
file <- system.file("tests", "test_import.xlsx", package = "xlsx") wb <- loadWorkbook(file)
sheets <- getSheets(wb)
sheet <- sheets[[2]] # extract the second sheet
# see all the available java methods that you can call
.jmethods(sheet)
# for example sheet$getLastRowNum()Evidentemente, existen una cantidad importante de comandos a ejecutar, sin embargo, se consideró que los mostrados en el presente son los que pudieran resultar de mayor utilidad para aquellos usuarios que no cuentan con un amplia experiencia usando el Software R, o bien utilizando el paquete xlsx.
No obstante lo anterior, con la práctica, todo es más fácil. Y por tanto, de momento el intentar explicar formulas mucho más avanzadas tendría que ser objeto de otro documento.
Por ahora, solo queda seguir descubriendo los beneficios y bondades del software R, ya que para el trabajo que desarrollamos en nuestro día a día herramientas de este estilo, nos facilitarán en mucho la vida.
Dragulescu, Adrian (20 de febrero de 2015) Package ‘xlsx’ Recuperado de https://cran.r-project.org/web/packages/xlsx/xlsx.pdf