-
Notifications
You must be signed in to change notification settings - Fork 2
/
02-Rstudio.Rmd
273 lines (174 loc) · 23.6 KB
/
02-Rstudio.Rmd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
# Introducción a RStudio {#RStudio}
## El entorno y los paneles
RStudio es un entorno de desarrollo para el lenguaje de programación en R de código libre, contiene potentes herramientas para facilitar el desarrollo de procesos matemáticos, estadísticos, llevar un control de versiones, fácil visualización, modificación e implementación de las rutinas en R, además entre sus potentes herramientas incluye Rmarkdown, el cual fue desarrollado para crear documentos interactivos, para facilitar la transmisión de ideas entre los desarrolladores de R sin tener que preocuparse por tener que desarrollar la documentación con diversos programas, pero por el momento nos enfocaremos solo en conocer el entorno de desarrollo de RStudio.
En la siguiente imagen se puede observar la interfaz completa para RStudio.
Rstudio se compone por 4 secciones, las cuales están divididas en 12 importantes paneles que pueden ser configurados a las necesidades de cada persona.
### Panel de código
El panel de código es básicamente imprescindible, nos permitirá estar trabajando con todos nuestros scripts, ejecutarlos, en este panel además de permitirnos escribir nuestro código para salvarlo y después utilizarlo, cuenta con resaltado de sintaxis para los scripts de **R**, para que en el aspecto visual podamos ir identificando posibles errores al momento; para modificar el resaltado de sintaxis, tamaño de letra y otros aspectos de este panel solo es necesario presionar `[ALT] + [T]` o presionar en la barra de herramientas seleccionar `Tools` y presionar `[ALT] + [G]` o directamente en `Global Options...`, seleccionamos `Appearance` y nos saldrá la siguiente ventana:
En esta ventana podremos controlar el resaltado de sintaxis para hacerlo lo más visualmente atractivo para nosotros, así como el tamaño y la fuente que deseamos utilizar, Para aplicar los cambios una vez que nos encontremos satisfechos solo se ha de presionar el botón `[OK]`, si queremos descartar todos los cambios que se realizaron en ese momento (si no se ha presionado `[Apply]` u `[OK]`), se ha de presionar el botón `[Cancel]` y para ir observando los cambios al momento se ha de presionar el botón `[Apply]`.
| Identificador | Uso o significado |
|---------------|-----------------------------------------------------------------------------------------------------------|
| 1 | Pestaña de trabajo actual. |
| 2 | Abrir el código en una ventana independiente. |
| 3 | Guardar el archivo del código actual. |
| 4 | Si esta seleccionado, el código será ejecutado cada vez que se guarde el archivo. |
| 5 | Buscar o Reemplazar una parte del código. |
| 6 | Herramientas para el código. |
| 7 | Genera un reporte del código actual en base a los comentarios en el código (No recomendable). |
| 8 | Ejecutar la línea de código seleccionada. |
| 9 | Se vuelve a ejecutar el bloque ejecutado anteriormente. |
| 10 | Ejecutar todo el código con el comando `source(...)`. |
| 11 | Despliega una ventana para ayudar en la navegación del código (Ideal para navegar entre grandes scripts). |
Además de tener todas estás funcionalidades a la mano, también es posible acceder a algunas de ellas de manera rápida a través del teclado como se puede observar en la siguiente tabla.
| Comando | Uso |
|---------------------------|-----------------------------------------------------------------------------|
| [Control] + [Shift] + [A] | Formatea el código de **R** que se encuentre seleccionado. |
| [Tab] | Abre la opción de auto-completado en función a lo que se va escribiendo. |
| [Control] + [Enter] | Ejecutar la línea que se encuentre seleccionada (pueden ser varias). |
| [Control] + [S] | Salvar el archivo en el que se está trabajando. |
| [F1] | Acceder a la ayuda del comando que se está escribiendo o esté seleccionado. |
### Panel de Consola
Este panel es la consola bien conocida de **R**, donde podremos interactuar directamente con ella o a través del panel de código.
Existe un comando que nos servirá de ayuda en caso de que ocupemos abortar la ejecución actual de **R** `[CONTROL] + [C]`. Además de que al igual que el Panel de código, el panel de consola cuenta con auto-completado, podemos ir escribiendo un comando y con la tecla `[TAB]` podemos acceder al auto-completado y en caso de tener dudas podemos usar la tecla `[F1]` para acceder de manera rápida a la ayuda.
### Panel de entorno
Dentro los paneles del lado derecho, podemos observar el panel de entorno, el trabajo de este panel es mostrar los datos que nosotros estamos trabajando en **R** para no perder de vista si ya hemos creado una variable o si dicha variable contiene los datos que debe contener, para poder sacar el máximo provecho a este panel deberemos de considerar lo siguiente:
- Nos muestra nuestras variables.
- Permite limpiar la entorno con un solo clic (en vez de escribir el comando `rm(list=ls())`, RStudio lo hace por nosotros).
- Permite importar bases de datos en distintos formatos (La primera vez requerirá instalar algunos paquetes).
De manera superficial, este panel en la mayoría de los casos nos puede servir para dar una vista rápida al entorno y saber si la o las variables que creamos ya existen o si nos falta ejecutar alguna parte de nuestro código, ahora veremos más a detalle las opciones que nos ofrece este panel.
| Identificador | Uso o significado |
|---------------|----------------------------------------------------------------------------------------------------------------------------------------------|
| 1 | Cargar un área de trabajo. |
| 2 | Guardar el área de trabajo actual. |
| 3 | Importar una nueva base de datos (desde SPSS, CSV, Excel y otros). |
| 4 | Limpiar el área de trabajo actual (Entorno). |
| 5 | Alternar la vista de los datos entre modo lista y modo tabla. |
| 6 | Mostrar los datos creados por varios entornos (Entorno global o a nivel de paquetes). |
| 7 | Permite filtrar y buscar algún objeto de interés por su nombre. |
| 8 | Así se muestra un vector. |
| 9 | Así se muestra una matriz y un dataframe, la diferencia se encuentra en que al crear un dataframe aparece un botón para desplegar sus datos. |
| 10 | Muestra los datos que contiene una matriz o un dataframe específico. |
### Panel de historial
El panel del historial es otro panel bastante simple, su importancia radica en que cada vez que un comando es ejecutado irá a parar a este panel, así que sin importar cuantas veces cerremos RStudio, ese historial seguirá ahí, si en algún momento queremos volver a buscar un comando podremos encontrarlo aquí, para conocer más a detalle este panel tenemos las siguientes opciones:
| Identificador | Uso o significado |
|---------------|-----------------------------------------------------|
| 1 | Cargar un historial. |
| 2 | Guardar el historial en un archivo. |
| 3 | Mandar al panel de consola el comando seleccionado. |
| 4 | Mandar al panel de código el comando seleccionado. |
| 5 | Remover los comandos seleccionados del historial. |
### Panel de Construcción
Posiblemente el panel menos utilizado, solo aparece cuando estamos construyendo un paquete para **R** y su trabajo es construirlo para poder realizar pruebas en el entorno de R, de manera muy superficial tenemos las siguientes opciones:
| Identificador | Uso o significado |
|---------------|----------------------------------------------------------------------------------------------------------------|
| 1 | Construir o recargar el paquete. |
| 2 | Revisar que el paquete este correctamente instalado (entre otras pequeñas funciones). |
| 3 | Diversas opciones que permiten hacer pruebas, empaquetar los paquetes para distribución entre otras funciones. |
### Panel de Control de versiones (Git)
Un panel bastante importante para los que ocupan trabajar con varias versiones de un mismo archivo o los que trabajan en el desarrollo de paquetes para **R**, hablar del control de versiones y cómo implementarlo en GitHub es agregar otro curso dentro de este curso, por lo que no nos saldremos del alcance y rescataremos las partes más importantes para aquellos que ya saben utilizar el controlador de versiones git.
La imagen anterior es una muestra de del uso de este panel y las opciones que se muestran se describen a continuación
| Identificador | Uso o significado |
|---------------|------------------------------------------------------------------------------|
| 1 | Muestra las diferencias entre la antigua versión de un archivo y su nueva versión. |
| 2 | Comenta los archivos seleccionados (staged) para guardar una nueva versión de ellos. |
| 3 | Recupera las últimas modificaciones del repositorio realizadas en otras computadoras. |
| 4 | Sube al repositorio las últimas modificaciones "comentadas (ver identificador 2)" en la máquina. |
| 5 | Muestra un historial de las modificaciones realizadas. |
| 6 | Otras opciones (Ignorar un archivo seleccionado o revertir la modificación) |
| 7 | Rama (branch) a la que se desea subir las modificaciones del archivo. |
| 8 | Recargar el panel. |
| 9 | Caja para seleccionar los archivos a comentar (ver identificador 2), ignorar o revertir (ver identificador 7) |
| 10 | El estado en el cuál se encuentra el archivo, (M es Modificado, ? es que aún no se encuentra en el repositorio, A significa que se agregará al repositorio y D es que se elimina del repositorio. |
| 11 | Es el archivo que está siendo supervisado por el controlador de versiones. |
### Panel de archivos
Volviendo a los paneles sencillos, este panel hace la función de explorador de archivos, para evitar la necesidad de estar abriendo y cerrando esta aplicación, podremos navegar hasta la carpeta de nuestro archivo de interés o si estamos trabajando por proyectos, veremos que esta ventana se actualiza directamente a la carpeta donde está 'hospedada' el proyecto, sin duda es de mayor utilidad de esta forma, pero antes de hablar sobre los proyectos en RStudio, veremos un par de paneles más.
La imagen anterior es la vista que comúnmente se obtiene donde las carpetas que todos conocemos (Descargas, Documentos, Escritorio, etc.) son las que nos muestra **RStudio**, algunas de las opciones más importantes son las siguientes:
| Identificador | Uso o significado |
|---------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1 | Crear una nueva carpeta en el directorio de trabajo actual. |
| 2 | Seleccionar algún archivo o carpeta para realizar alguna de las operaciones de los identificadores siguientes. |
| 3 | Eliminar el archivo o carpeta seleccionado. |
| 4 | Renombrar el archivo o carpeta seleccionado. |
| 5 | Opciones varias, Copiar o Mover el archivo seleccionado, seleccionar la carpeta actual como directorio de trabajo (reemplaza al comando `setwd(...)`) , entre otras opciones. |
### Panel de gráficos 
La función del panel de gráficos es mostrarnos en este espacio los gráficos que se vayan creando en el entorno de **R** para una rápida consulta y navegación entre ellos, pero se debe de tener cuidado, si el espacio dejado para este panel es muy pequeño, cuando se intente crear un gráfico, **RStudio** regresará un error.
Las opciones más importantes en el panel son las siguientes:
| Identificador | Uso o significado |
|---------------|------------------------------------------------------|
| 1 | Ir a la gráfica anterior o siguiente. |
| 2 | Realizar Zoom a la gráfica actual. |
| 3 | Exportar la gráfica actual. |
| 4 | Remover la gráfica actual. |
| 5 | Limpiar el entorno de todas las gráficas realizadas. |
| 6 | Publicar la gráfica en _RPubs_. |
| 7 | Volver a cargar el panel. |
### Panel de Paquetes
Sin duda un panel que tendrá mucha utilidad, permite conocer de manera rápida los paquetes que tenemos instalados y actualizarlos de ser necesario.
Dentro de las opciones de este panel tenemos:
| Identificador | Uso o significado |
|---------------|------------------------------------------------------------------------|
| 1 | Instalar uno o varios paquetes. |
| 2 | Actualizar todos los paquetes que tengan una nueva versión disponible. |
| 3 | Buscar un paquete. |
| 4 | Actualizar el panel. |
### Panel de ayuda
Otro panel sencillo y de gran utilidad, aquí se mostrará la documentación de alguna función, paquete o sobre Rstudio, se puede acceder a él de manera sencilla al estar en el panel de código y tener seleccionada la función o paquete y presionar la tecla [F1], dentro de las características de este panel tenemos
| Identificador | Uso o significado |
|---------------|------------------------------------------------------------------------------------------|
| 1 | Navegar entre las paginas consultadas. |
| 2 | Ir a la página inicial de ayuda. |
| 3 | Imprimir la hoja de ayuda actual. |
| 4 | Mostrar el panel en una ventana separada (por si no nos ajusta el tamaño de la ventana). |
| 5 | Buscar ayuda con un paquete o función especifico. |
### Panel de visualización
La función de este panel es mostrarnos la versión web cuando estamos trabajando con documentos en RMarkdown.
Por ejemplo, este documento está diseñado en RMarkdown, por lo que se muestra en el panel de la siguiente manera:
Las opciones de este panel son reducidas pues es como un navegador de internet pero solo para nuestro documento, por lo que las opciones que tiene son las siguientes:
| Identificador | Uso o significado |
|---------------|----------------------------------------------------------------|
| 1 | Remover la vista actual. |
| 2 | Remover todas las vistas. |
| 3 | Abrir la vista actual en nuestro navegador web predeterminado. |
## Proyectos
Un proyecto en **RStudio** es una carpeta que el programa reconoce como un espacio de trabajo de **R**, donde dependiendo de las especificaciones iniciales, se puede mantener las versiones del proyecto, crear un paquete para **R**, una aplicación web con la librería shiny, entre otras cosas útiles, pero siempre manteniendo el orden de los trabajos ya que además de mantener organizados los códigos, RStudio permite recuperar las pestañas abiertas sin importar si se cambió de proyecto, **RStudio** fue cerrado o si se apagó el sistema operativo.
Para crear un nuevo proyecto, tenemos nuestro entorno de una forma muy parecida a la siguiente
En la parte superior derecha está el botón para crear un nuevo proyecto
Si accedemos al botón podremos ver las siguientes opciones, [New Project] desplegará una ventana para ayudarnos a escoger entre varias opciones.
Las opciones son las siguientes:
Si lo que buscamos es crear un nuevo proyecto desde cero, entonces seleccionaremos [New Directory], por otro lado, si ya tenemos una carpeta con nuestros archivos de R, se puede escoger la opción [Existing Directory], la cual tomará una carpeta normal y la adecuará a nuestro entorno de Rstudio, si se cuenta con la experiencia de haber trabajado con anterioridad con un programa de control de versiones como git o SVN y alguno de ellos está disponible en la máquina, se podrá utilizar la tercera opción, la cual nos ayudará a mantener aún más organizado nuestro código.
Empezaremos creando un proyecto vacío.
Tenemos varias opciones, como será un proyecto para trabajar los ejercicios de R usaremos la primera opción.
En la ventana de «Crear un nuevo proyecto» podremos escoger el nombre de nuestra carpeta y donde se creará, además nos da dos opciones para integrar nuestro control de versiones git, una vez creado nuestro nuevo proyecto, obsérvese que, automáticamente se asigna el directorio de trabajo hacia la ruta donde se ha creado nuestro proyecto, eso te confirma en el panel de archivos, que ahora muestra solamente nuestro archivo de proyecto `.Rproj` el cual, si es eliminado, se pierde el entorno de trabajo en **RStudio**.
Si en vez de crear un nuevo directorio, queremos usar una ruta ya existente, podemos usar la opción de crear proyecto desde un directorio existente, con lo cual podremos buscar la ruta con el botón [Browse] y convertir esa carpeta a un Proyecto de RStudio.
Para poder cambiar entre proyectos, solo basta con seleccionar el proyecto, en este caso, los disponibles en la siguiente imagen solo es "DiplomadoR", pero en caso de tener varios proyectos se podrá seleccionar entre los existentes, en caso de que no aparezca, podemos usar el botón [Open Project...] el cual nos dejará buscar la carpeta en la cual está el archivo `.Rproj`, o en caso de que no queramos usar ningún proyecto, para hacer pruebas o alguna otra cosa, basta con cerrar el proyecto abierto con el botón [Close Project].
