R Quick Reference

Analogy categoryAnalogies

This reference condenses the syntax an R user reaches for daily — checking a variable's type, reshaping and filtering data with dplyr, cleaning strings and dates, and running quick statistical summaries — into one scannable page, organized the way you'd actually look things up mid-analysis rather than the order a textbook introduces them. It assumes you already know what each function does conceptually and just need the exact syntax, argument order, or a nudge toward the right function name when you've forgotten it.

🏏

Cricket analogy: A quick reference organized by 'what you look up mid-task' rather than textbook order is like a fielding captain's laminated cheat card listing field placements by bowler and match situation, not by chapter of a coaching manual — you need the setting for a death-over yorker in three seconds, not a lecture.

Data Types and Structures Cheat Sheet

R's core atomic types are logical, integer, double (numeric), character, and the special value NA (which itself has typed variants: NA_integer_, NA_character_); class() and typeof() tell you what you're working with, while str() gives a compact structural overview of any object including nested lists and data frames. The four container types you'll use constantly are the vector (one type, created with c()), the list (mixed types, created with list()), the matrix (2D, one type), and the data.frame or tibble (2D, columns can differ in type) — and is.na(), is.null(), length(), and nrow()/ncol() are the functions you reach for most often to sanity-check any of them before proceeding.

🏏

Cricket analogy: class() and typeof() telling you exactly what an object is, is like checking a player's official registration before a match — is this player registered as a bowler, batter, or all-rounder — before the team sheet is finalized.

x <- c(1L, 2L, NA_integer_)
class(x); typeof(x)     # "integer" "integer"
is.na(x)                # FALSE FALSE TRUE

y <- list(name = "Asha", scores = c(88, 92, 79))
str(y)

df <- data.frame(id = 1:3, score = c(88, 92, NA))
nrow(df); ncol(df)       # 3 2
str(df)

dplyr Verbs and Piping

The five core dplyr verbs cover nearly every wrangling task: filter() keeps rows matching a condition, select() keeps or drops columns, mutate() adds or transforms columns, arrange() sorts rows, and summarise() (typically paired with group_by()) collapses rows into aggregate statistics — all chained with the native pipe |> (or magrittr's %>%) so data |> filter(x > 0) |> group_by(category) |> summarise(avg = mean(value)) reads top to bottom as a sequence of transformations. Two verbs that trip up beginners are mutate() vs summarise() — mutate() preserves the original number of rows while summarise() collapses them — and count(x) as a shortcut for group_by(x) |> summarise(n = n()).

🏏

Cricket analogy: filter(), select(), mutate(), arrange(), and summarise() chained with the pipe are like a five-stage net session — first filter which batters face this bowler, select which drills to run, mutate their stance with a coaching tweak, arrange the batting order, then summarise the session with today's strike rates.

library(dplyr)

sales |>
  filter(region == "West", revenue > 0) |>
  mutate(margin = (revenue - cost) / revenue) |>
  group_by(product_category) |>
  summarise(
    total_revenue = sum(revenue),
    avg_margin = mean(margin),
    n_orders = n(),
    .groups = "drop"
  ) |>
  arrange(desc(total_revenue))

# count() shortcut
sales |> count(product_category, sort = TRUE)

String, Date, and Regex Helpers

The stringr package provides consistent, predictable string functions — all prefixed str_ and taking the string first (str_detect(), str_replace(), str_extract(), str_split(), str_trim(), str_pad()) — as a more reliable alternative to base R's grepl(), gsub(), and substr(), which have inconsistent argument orders and naming. For dates, lubridate's ymd(), mdy(), and dmy() parse common date formats without needing a format string, and functions like floor_date(), wday(), and interval-based time_length() handle the fiddly parts of date arithmetic (leap years, time zones, month-end rollovers) that are easy to get subtly wrong by hand.

🏏

Cricket analogy: stringr's consistent str_ prefix and argument order is like a modern DRS interface with the same button layout for every review type, unlike an older scoring system where each function has its own inconsistent button mapping.

A handy mental model: reach for stringr and lubridate by default for any string or date work in R — they're both part of the tidyverse, follow consistent argument ordering (data first, for piping), and handle edge cases like NA input, timezone conversion, and multi-byte characters far more predictably than the base R functions they replace.

Common Base R and Stats Functions

Beyond the tidyverse, a handful of base R functions come up constantly regardless of which packages you use: seq() and rep() generate sequences and repeated values, which(), any(), and all() are the workhorses for logical vector inspection, table() gives a quick frequency count, and set.seed() before any function involving randomness (sample(), rnorm(), runif()) is what makes a "random" analysis reproducible run to run. For statistics specifically, summary() gives a five-number summary plus mean in one call, cor() computes correlation, and t.test()/lm() remain the fastest way to run a quick hypothesis test or linear model without loading any additional package.

🏏

Cricket analogy: set.seed() before a random sample is like a coin toss being recorded on video before a Test match, so the exact same 'random' outcome can be verified and replayed later if there's a dispute over which team actually won the toss.

set.seed() only guarantees reproducibility for functions that draw from R's random number generator in the exact same order — inserting, removing, or reordering a call to sample(), rnorm(), or similar between two runs of 'the same' script will produce different random draws even with an identical seed, because the RNG's internal state has advanced differently.

Check an object's type with class()/typeof() and its structure with str(); the four core containers are vector, list, matrix, and data.frame/tibble.
The five core dplyr verbs are filter(), select(), mutate(), arrange(), and summarise(), typically chained with the pipe |>.
mutate() preserves row count while summarise() collapses rows into aggregates; count(x) shortcuts group_by(x) |> summarise(n = n()).
stringr (str_detect, str_replace, str_extract) offers more consistent syntax than base R's grepl/gsub/substr.
lubridate's ymd()/mdy()/dmy() parse dates without a format string and correctly handle leap years and time zones.
set.seed() before any random function (sample(), rnorm(), runif()) makes randomness reproducible, but only if the sequence of random calls is identical between runs.
summary(), cor(), t.test(), and lm() give quick statistical summaries and models without loading any additional package.