Sintaxis de R

El vocabulario específico del lenguaje de R se refiere comúnmente como “sintaxis de R” o simplemente “sintaxis R”. Este término hace referencia a las reglas y estructuras gramaticales que rigen la escritura del código en R.

El vocabulario de RStudio y R incluye palabras clave, funciones, operadores y constructores de datos que se utilizan para realizar análisis de datos, estadísticas y otras tareas relacionadas con datos. Algunos ejemplos de términos comunes en la sintaxis de R incluyen:

#1. Variables: Nombres que almacenan datos.
#2. Funciones: Conjuntos de instrucciones para realizar tareas específicas.
#3. Operadores: Símbolos utilizados para realizar operaciones matemáticas o lógicas.
#4. Estructuras de control: Instrucciones que controlan el flujo de ejecución, como if-else, for, while, etc.
#5. Objetos: Tipos de datos, como vectores, matrices, data frames, listas, etc.
#6. Paquetes (librerías): Conjuntos de funciones adicionales que amplían las capacidades de R.

Variables y tipos de datos

En R, las variables son elementos fundamentales que se utilizan para almacenar y manipular datos. En R, puedes asignar valores a variables y luego realizar operaciones y cálculos con esas variables. Aquí hay una descripción de cómo trabajar con variables y los tipos de datos más comunes en R:

  1. Asignación de variables: Para asignar un valor a una variable en R, puedes utilizar el operador <- o el operador =. Por ejemplo:
mi_variable <- 30
otra_variable = "Hello, World"

  1. Nombres de variables: Los nombres de las variables en R deben comenzar con una letra (mayúscula o minúscula) o un punto (pero no se recomienda comenzar con un punto), seguido de letras, números o puntos. Evita usar nombres de variables que sean palabras reservadas en R.

  2. Tipos de datos: R es un lenguaje de programación con tipado dinámico, lo que significa que no es necesario declarar explícitamente el tipo de una variable. R asigna automáticamente un tipo de datos a una variable en función del valor que le asignas. Algunos tipos de datos comunes en R incluyen: Numeric (numérico): Para números reales o enteros. Ejemplo: mi_numero <- 3.14

#Character (caracteres): Para texto. Ejemplo: 
mi_texto <- "Hello"

#Logical (lógico): Para valores booleanos TRUE o FALSE. Ejemplo: 
mi_logico <- TRUE

#Integer (entero): Para números enteros. Ejemplo: 
mi_entero <- 30L

#Factor: Utilizado para representar datos categóricos.

#Date (fecha): Para fechas. Ejemplo: 
mi_fecha <- as.Date("2023-09-27")

#Time (hora): Para horas. Ejemplo: 
mi_hora <- as.POSIXct("2023-09-27 14:30:00")
  1. Comprobación y conversión de tipos de datos: Puedes verificar el tipo de una variable utilizando la función class(). Si necesitas convertir un tipo de datos a otro, puedes usar funciones como as.numeric(), as.character(), as.logical(), etc.
mi_numero <- 30
class(mi_numero)  
## [1] "numeric"
mi_numero <- as.character(mi_numero)  
class(mi_numero)  
## [1] "character"
  1. Vectores: R es muy orientado a vectores. Puedes crear vectores que contengan múltiples valores del mismo tipo de datos. Por ejemplo
mi_vector <- c(1, 2, 3, 4, 5)

Estos son conceptos básicos para trabajar con variables y tipos de datos en R. Con estas herramientas, puedes realizar análisis de datos y cálculos de manera efectiva en este lenguaje.

Operadores matemáticos

En R, puedes utilizar una variedad de operadores matemáticos para realizar operaciones aritméticas en números. Aquí tienes una lista de los operadores matemáticos más comunes en R:

  1. Suma (+): El operador + se utiliza para sumar dos valores.
a <- 5
b <- 3
resultado_suma = a + b
resultado_suma
## [1] 8
  1. Resta (-): El operador - se utiliza para restar el segundo valor del primero.
a <- 10
b <- 4
resultado_resta = a - b
resultado_resta
## [1] 6
  1. Multiplicación (): El operador “” se utiliza para multiplicar dos valores.
a <- 6
b <- 7
resultado_multiplicacion = a * b
resultado_multiplicacion
## [1] 42
  1. Division (/): El operador / se utiliza para dividir el primer valor por el segundo.
a <- 20
b <- 5
resultado_division = a / b
resultado_division
## [1] 4
  1. Exponente (^): El operador ^ se utiliza para elevar el primer valor a la potencia del segundo.
a <- 2
b <- 3
resultado_exponente = a ^ b
resultado_exponente
## [1] 8
  1. Módulo (%%): El operador %% se utiliza para calcular el residuo de la división del primer valor por el segundo.
a <- 10
b <- 3
resultado_modulo = a %% b
resultado_modulo
## [1] 1
  1. División entera (%/%): El operador %/% se utiliza para calcular la división entera del primer valor por el segundo.
a <- 10
b <- 3
resultado_div_entera = a %/% b
resultado_div_entera
## [1] 3

Operadores Relacionales

En R, los operadores relacionales se utilizan para comparar dos valores y determinar si una relación es verdadera o falsa. Estos operadores se utilizan principalmente en expresiones condicionales y son fundamentales para la programación y la toma de decisiones. Aquí tienes una lista de los operadores relacionales en R:

  1. Igualdad(==): Comprueba si dos valores son iguales y devuelve TRUE si lo son, FALSE en caso contrario. Por ejemplo:
5 == 5  
## [1] TRUE
5 == 6 
## [1] FALSE
  1. Desigualdad(!=):Comprueba si dos valores son diferentes y devuelve TRUE si lo son, FALSE en caso contrario. Por ejemplo:
5 != 5 
## [1] FALSE
5 != 6 
## [1] TRUE
  1. Mayor que (>): Comprueba si un valor es mayor que otro y devuelve TRUE si lo es, FALSE en caso contrario. Por ejemplo:
5 > 3  
## [1] TRUE
5 > 7  
## [1] FALSE
  1. Menor que (<): Comprueba si un valor es menor que otro y devuelve TRUE si lo es, FALSE en caso contrario. Por ejemplo:
5 < 7 
## [1] TRUE
5 < 3  
## [1] FALSE
  1. Mayor o igual que (>=): Comprueba si un valor es mayor o igual que otro y devuelve TRUE si lo es, FALSE en caso contrario. Por ejemplo:
5 >= 5 
## [1] TRUE
5 >= 8 
## [1] FALSE
  1. Menor o igual que (<=): Comprueba si un valor es menor o igual que otro y devuelve TRUE si lo es, FALSE en caso contrario. Por ejemplo:
5 <= 7  
## [1] TRUE
5 <= 3 
## [1] FALSE

Operadores lógicos

En R, los operadores lógicos se utilizan para combinar o evaluar expresiones lógicas y son fundamentales para la toma de decisiones en programación y análisis de datos. Aquí tienes una lista de los operadores lógicos en R:

  1. Operador lógico AND (& o &&): &: Realiza una operación AND elemento por elemento entre dos vectores lógicos y devuelve un vector lógico que indica si ambos elementos correspondientes son TRUE. &&: Realiza una operación AND entre los primeros elementos de dos vectores lógicos y devuelve un solo valor lógico que indica si ambos son TRUE. Ejemplos:
TRUE & TRUE   
## [1] TRUE
TRUE & FALSE  
## [1] FALSE
  1. Operador lógico OR (| o ||): |: Realiza una operación OR elemento por elemento entre dos vectores lógicos y devuelve un vector lógico que indica si al menos uno de los elementos correspondientes es TRUE. ||: Realiza una operación OR entre los primeros elementos de dos vectores lógicos y devuelve un solo valor lógico que indica si al menos uno de ellos es TRUE. Ejemplos:
TRUE | FALSE  
## [1] TRUE
FALSE | FALSE 
## [1] FALSE
  1. Operador lógico NOT (!): Realiza una negación lógica de un valor lógico y devuelve su opuesto. Si el valor es TRUE, devuelve FALSE, y si el valor es FALSE, devuelve TRUE. Ejemplos:
!TRUE   
## [1] FALSE
!FALSE  
## [1] TRUE
  1. Operador de igualdad lógica (==): Comprueba si dos valores son iguales y devuelve TRUE si lo son, FALSE en caso contrario. Ejemplos:
TRUE == TRUE   
## [1] TRUE
TRUE == FALSE  
## [1] FALSE
  1. Operador de desigualdad lógica (!=): Comprueba si dos valores son diferentes y devuelve TRUE si lo son, FALSE en caso contrario. Ejemplos:
TRUE != TRUE   
## [1] FALSE
TRUE != FALSE  
## [1] TRUE

Tipos de datos integrados

  1. Números enteros (integer): Representan números enteros, es decir, números sin decimales. Se crean utilizando la función as.integer() o simplemente escribiendo el número sin decimales. Ejemplo:
x <- 5L
  1. Números en coma flotante (numeric o double): Representan números con decimales. Los números en R se almacenan generalmente como números en coma flotante de doble precisión. Ejemplo:
y <- 3.14
  1. Caracteres (character): Representan cadenas de texto. Se definen utilizando comillas simples (’) o dobles (“). Ejemplo:
texto <- "Hola, mundo!"
  1. Factores (factor): Son utilizados para representar variables categóricas o factores. Los factores son útiles en análisis estadísticos y gráficos. Ejemplo:
genero <- factor(c("Masculino", "Femenino", "Masculino", "Femenino"))
  1. Valores lógicos (logical): Representan valores lógicos o booleanos, es decir, TRUE o FALSE. Ejemplo:
es_verdadero <- TRUE
es_falso <- FALSE
  1. Valores especiales (special): R incluye varios valores especiales, como NA (Not Available, que representa datos faltantes o ausentes), NaN (Not a Number, que representa resultados indefinidos en cálculos) e Inf (infinito positivo). Ejemplo:
valor_faltante <- NA
  1. Vectores (vector): Los vectores son secuencias unidimensionales de datos del mismo tipo. Pueden ser de tipo numérico, de caracteres, lógicos, etc. Ejemplo:
mi_vector <- c(1, 2, 3, 4, 5)
  1. Listas (list): Las listas pueden contener elementos de diferentes tipos, incluyendo otros vectores, listas o incluso funciones. Ejemplo:
mi_lista <- list(nombre = "Juan", edades = c(25, 30, 35))
mi_lista
## $nombre
## [1] "Juan"
## 
## $edades
## [1] 25 30 35
  1. Matrices (matrix): Son arreglos bidimensionales que contienen elementos del mismo tipo. Se crean con la función matrix(). Ejemplo:
mi_matriz <- matrix(1:9, nrow = 3, ncol = 3)
mi_matriz
##      [,1] [,2] [,3]
## [1,]    1    4    7
## [2,]    2    5    8
## [3,]    3    6    9
  1. Data frames (data.frame): Son estructuras bidimensionales que pueden contener diferentes tipos de datos en sus columnas. Son similares a las tablas de una base de datos. Ejemplo:
datos <- data.frame(nombre = c("Juan", "María", "Luis"), edad = c(25, 30, 35))
datos
##   nombre edad
## 1   Juan   25
## 2  María   30
## 3   Luis   35

Cadenas

  1. Definir una cadena de texto: Puedes definir una cadena de texto utilizando comillas simples (’) o comillas dobles (“). Aquí hay ejemplos de ambas formas:
cadena1 <- 'Esto es una cadena de texto en comillas simples.'
cadena2 <- "Esto es una cadena de texto en comillas dobles."
  1. Concatenar cadenas: Puedes combinar cadenas de texto utilizando la función paste():
cadena1 <- "Hola,"
cadena2 <- "mundo!"
cadena_combinada <- paste(cadena1, cadena2)
cadena_combinada
## [1] "Hola, mundo!"
  1. Longitud de una cadena: Puedes conocer la longitud de una cadena utilizando la función nchar():
cadena <- "Ejemplo"
longitud <- nchar(cadena)
longitud
## [1] 7
  1. Subcadenas: Para extraer una parte de una cadena, puedes usar la notación de corchetes. Por ejemplo, para obtener los primeros tres caracteres de una cadena:
cadena <- "Ejemplo"
subcadena <- cadena[1:3]
  1. Reemplazar parte de una cadena: Puedes reemplazar parte de una cadena utilizando la función sub() o gsub(). Por ejemplo, para reemplazar “E” por “X” en una cadena:
cadena <- "Ejemplo"
nueva_cadena <- sub("E", "X", cadena)
nueva_cadena
## [1] "Xjemplo"
  1. Comparar cadenas: Puedes comparar cadenas utilizando operadores relacionales como ==, !=, <, >, etc.
cadena1 <- "Hola"
cadena2 <- "Hola"
resultado <- cadena1 == cadena2
resultado
## [1] TRUE
  1. Cadenas multilínea: Puedes crear cadenas multilínea utilizando comillas dobles (“):
cadena_multilinea <-"Esta
es una cadena
con multiples lineas
en R."
  1. Interpolación de cadenas: Puedes insertar valores de variables dentro de una cadena utilizando paste() o el operador de interpolación $:
nombre <- "Juan"
edad <- 30
mensaje <- paste("Mi nombre es", nombre, "y tengo", edad, "años.")
mensaje
## [1] "Mi nombre es Juan y tengo 30 años."