Guía Completa de Estructuras de Control, Funciones, Creación de Funciones, Estilo de Código y Reglas de Alcance en R
Maestría en Ciencias Actuariales
Por: Doctor Roberto Enrique Chang López
En este artículo, exploraremos conceptos esenciales en R, como las estructuras de control, funciones, creación de funciones, estilo de código y reglas de alcance. Cada sección incluirá explicaciones detalladas y ejemplos prácticos para que puedas aplicar estos conceptos en tus proyectos.
Estructuras de Control en R
Las estructuras de control son fundamentales para dirigir el flujo de un programa. En R, las estructuras de control más comunes son `if`, `else`, `for`, `while`, y `repeat`.
1. Condicionales: `if` y `else`
```r
x <- 5
if (x > 3) {
print(“x es mayor que 3”)
} else {
print(“x no es mayor que 3”)
}
```
2. Bucles: `for`
```r
for (i in 1:5) {
print(i)
}
```
3. Bucles: `while`
```r
i <- 1
while (i <= 5) {
print(i)
i <- i + 1
}
```
4. Bucles: `repeat`
```r
i <- 1
repeat {
print(i)
i <- i + 1
if (i > 5) {
break
}
}
```
Funciones en R
Las funciones son bloques de código reutilizables que realizan una tarea específica. En R, puedes usar funciones predefinidas o crear tus propias funciones.
1. Uso de Funciones Predefinidas
```r
#Función predefinida: sqrt()
sqrt(16) #Devuelve 4
```
2. Creación de Funciones Propias
```r
#Definir una función
mi_funcion <- function(a, b) {
resultado <- a + b
return(resultado)
}
#Llamar a la función
mi_funcion(3, 4) Devuelve 7
```
Creación de Funciones en R
Crear funciones en R es sencillo y permite modularizar el código. Aquí hay algunos ejemplos:
1. Función sin Argumentos
```r
saludar <- function() {
print(“Hola, Mundo!”)
}
saludar()# Imprime “Hola, Mundo!”
```
2. Función con Argumentos
```r
multiplicar <- function(x, y) {
return(x y)
}
multiplicar(3, 5) #Devuelve 15
```
3. Función con Argumentos por Defecto
```r
elevar <- function(base, exponente = 2) {
return(base^exponente)
}
elevar(3) Devuelve 9 (3²)
elevar(3, 3) Devuelve 27 (3³)
```
4. Función con Argumentos Variables
```r
sumar <- function(…) {
numeros <- c(…)
return(sum(numeros))
}
sumar(1, 2, 3, 4) #Devuelve 10
```
Estilo de Código en R
Un buen estilo de código es crucial para mantener el código limpio y legible. Aquí tienes algunas prácticas recomendadas:
1. Nombres de Variables y Funciones
Usa nombres descriptivos y sigue una convención consistente, como `snake_case` o `camelCase`.
```r
#Ejemplo de snake_case
mi_variable <- 10
#Ejemplo de camelCase
miVariable <- 10
```
2. Indentación y Espaciado
Indentación consistente mejora la legibilidad.
```r
#Correcto
if (x > 0) {
print(“Positivo”)
} else {
print(“Negativo o cero”)
}
#Incorrecto
if(x>0){
print(“Positivo”)
}else{
print(“Negativo o cero”)
}
```
3. Comentarios
Usa comentarios para explicar el propósito del código.
```r
#Esto es un comentario
resultado <- x + y Sumar x e y
```
Reglas de Alcance en R
El alcance de una variable determina dónde puede ser utilizada. R utiliza reglas de alcance léxico.
1. Alcance Global
Las variables definidas fuera de cualquier función tienen alcance global.
```r
x <- 10 Variable global
mi_funcion <- function() {
print(x) Accede a la variable global
}
mi_funcion() Imprime 10
```
2. Alcance Local
Las variables definidas dentro de una función tienen alcance local y no son accesibles fuera de esa función.
```r
mi_funcion <- function() {
y <- 5 Variable local
print(y)
}
mi_funcion() Imprime 5
print(y) Error: objeto ‘y’ no encontrado
```
3. Reglas de Alcance Léxico
R busca variables primero en el entorno local, luego en el entorno global y finalmente en los entornos padres.
```r
x <- 10 Variable global
mi_funcion <- function() {
x <- 5 Variable local
print(x)
}
mi_funcion() Imprime 5
print(x) Imprime 10
```
Conclusión
En este artículo, hemos cubierto aspectos esenciales de R que todo programador debe conocer: estructuras de control, funciones, creación de funciones, estilo de código y reglas de alcance. Estos conceptos son fundamentales para escribir código eficiente y legible.