← SASnRWorking with missing values (NA) in R

Introduction

Missing values are pervasive in clinical data — a visit not done, a lab not drawn, a code reported as “UNK” that should be NA. This lesson is the R-only deep dive on handling them end to end.
Seven blocks, working from foundations to real-world patterns: (1) what NA is and how to check for it, (2) how NA behaves in arithmetic and logical ops, (3) how to assign NA — one cell, a logical mask, a sentinel sweep across many columns, (4) how to replace NA with a value, a fallback chain, or a carried-forward observation, (5) how to count NAs per column, per row, and across a chosen subset of variables, (6) how to drop rows with NAs, and (7) how NA is introduced when datasets are joined together.
We use one tiny clinical-flavoured dataset throughout — demo with subject id, demographics, and baseline/visit scores — with NAs scattered through several columns so every scenario has something to work on.
Dataset-first style. In the tidyverse variant, almost every scenario operates on demo through a pipe and stores the result as a tibble — not as a bare vector or scalar. Pure language-behaviour demos that have no natural data-frame form (the typed NAs, the four short-circuit cases) are wrapped into small reference tibbles so the result of every scenario is still inspectable as a dataset.
Naming convention for this lesson. Every scenario stores its result in a dataset named scenario01, scenario02, … numbered sequentially across all seven blocks. After running each line, type the scenario name on its own to print and confirm the changed cells before moving on. Two language-behaviour demo lines (the filter(Sex == NA) trap in scenario05 and the no-na.rm summarise(mean_weight = mean(Weight)) in scenario06) are deliberately left unassigned — they exist to be seen interactively right before the correct version.
This is an R-exclusive lesson by design. The base R variant covers the same scenarios using base R’s vector and bracket-subscript idioms so you can see the tidyverse helpers side-by-side with what they replace.

Create sample dataset with missing values

Create the small clinical-flavoured demo dataset used by every later missing-value scenario.
Run this first so each block can be tested independently without rebuilding the whole lesson.

R (tidyverse)+

library(tidyverse)

# -- Sample dataset with NAs scattered through ---------------------------------
demo <- tribble(
  ~subj_id, ~Sex, ~Age, ~Height, ~Weight, ~baseline_score, ~visit_score,
  "S001",   "M",  14,   69.0,    112.5,   NA,              78,
  "S002",   "F",  13,   56.5,    NA,      80,              88,
  "S003",   NA,   13,   65.3,    98.0,    73,              NA,
  "S004",   "F",  14,   NA,      102.5,   88,              85,
  "S005",   "M",  NA,   63.5,    102.5,   79,              NA,
  "S006",   "M",  12,   57.3,    83.0,    NA,              NA
)

We build demo with tribble() so the NA pattern is visible at a glance — Sex is missing for S003, Age for S005, Height for S004, Weight for S002, baseline_score for S001 and S006, visit_score for S003, S005, S006.
Almost every scenario below is a pipe starting from demo (or from a small reference tibble where a data-frame form is artificial) and returns a tibble assigned to scenarioNN. Two lines are deliberately bare — the filter(Sex == NA) trap in scenario05 and the no-na.rm summarise(mean_weight = mean(Weight)) in scenario06 — placed right before the correct version so the contrast is visible.

Block 1: NA basics

Start with the core missing-value checks: typed NAs, column flags, full-frame checks, and the common == NA trap.
Print each scenario and confirm which cells or rows are marked missing.

R (tidyverse)+

# === Block 1: NA basics =======================================================

# 1. Typed NAs - a small reference tibble of NA forms and their underlying types
scenario01 <- tibble(
  na_form = c("NA", "NA_integer_", "NA_real_", "NA_character_"),
  type    = c(typeof(NA), typeof(NA_integer_), typeof(NA_real_), typeof(NA_character_))
)

# 2. is.na() on a column - add a TRUE/FALSE flag column to demo
scenario02 <- demo %>% mutate(Weight_missing = is.na(Weight))

# 3. is.na() on every column - convert demo to a frame of TRUE/FALSE
scenario03 <- demo %>% mutate(across(everything(), is.na))

# 4. anyNA() per column - one-row summary tibble
scenario04 <- demo %>% summarise(across(everything(), anyNA))

# 5. The == NA trap in a filter context vs is.na()
demo %>% filter(Sex == NA)            # zero rows - bare demo, the trap
scenario05 <- demo %>% filter(is.na(Sex))

Block 1 — NA basics.
scenario01 — typed NAs as a tibble. NA by itself is logical. When you need to put NA into an integer or character vector explicitly, use NA_integer_, NA_real_, NA_character_. This matters in if_else() and case_when(), which are strict about types — mixing NA (logical) with character branches throws an error; NA_character_ does not. scenario01 is a two-column tibble that you can print to see each NA form and its underlying type.
scenario02 — is.na() inside mutate. Adds a TRUE/FALSE flag column Weight_missing to demo. This is the tidyverse way to keep the row context while marking missingness — useful when you want to count, filter, or group by it later.
scenario03 — is.na() across the whole frame. mutate(across(everything(), is.na)) rewrites every column as TRUE/FALSE. The shape is preserved — you get a tibble of the same dimensions, but all logical. Useful raw material for the counting block.
scenario04 — anyNA() per column. summarise(across(everything(), anyNA)) returns one row with one column per source variable, each holding a single TRUE/FALSE.
scenario05 — the == NA trap. filter(Sex == NA) (bare line) returns zero rows — comparing anything to NA is itself unknown. Always use is.na() to test for missingness; scenario05 stores the correct filter. This trap is the most common source of “why does my filter return zero rows”.

Block 2: NA in computation

Observe how missing values propagate through arithmetic and logical expressions.
The goal is to see when NA is sticky and when logical short-circuiting can decide the answer anyway.

R (tidyverse)+

# === Block 2: NA in computation ===============================================

# 6. Sticky arithmetic - summarise mean of Weight, with and without na.rm
demo %>% summarise(mean_weight = mean(Weight))            # NA - bare demo
scenario06 <- demo %>% summarise(mean_weight = mean(Weight, na.rm = TRUE))

# 7. Logical short-circuiting - four cases as a reference tibble
scenario07 <- tibble(
  expression = c("NA & FALSE", "NA | TRUE", "NA & TRUE", "NA | FALSE"),
  result     = c(NA & FALSE,   NA | TRUE,   NA & TRUE,   NA | FALSE)
)

Block 2 — NA in computation.
scenario06 — arithmetic is sticky. A single NA poisons sums, means, sds, products. The bare summarise(mean_weight = mean(Weight)) shows that — the result is NA. scenario06 stores the corrected one-row tibble computed with na.rm = TRUE. Confirm the two differ.
scenario07 — logical short-circuiting as a tibble. NA & FALSE is FALSE because the result is FALSE regardless of what the NA hides — the AND has already been decided. NA | TRUE is TRUE for the symmetric reason. But NA & TRUE is NA because the missing value could swing it either way. scenario07 bundles all four cases into a labelled two-column tibble so you can scan the expression and its result side by side.

Block 3: Assigning NA

Practice intentionally assigning missing values at one cell, by a logical condition, and across multiple columns.
Pay close attention to typed NA constants because strict functions care about the target column type.

R (tidyverse)+

# === Block 3: Assigning NA ====================================================

# 8. Single cell - mutate + if_else on row_number() to blank Weight for row 1
scenario08 <- demo %>% mutate(Weight = if_else(row_number() == 1, NA_real_, Weight))

# 9. Conditional mask - mutate + if_else to turn Age < 13 into NA
scenario09 <- demo %>% mutate(Age = if_else(Age < 13, NA_real_, Age))

# 10. na_if() on a column inside a tibble - turn sentinel "UNK" into NA
codes      <- tibble(code = c("Y", "N", "UNK", "Y", "UNK"))
scenario10 <- codes %>% mutate(code_clean = na_if(code, "UNK"))

# 11. Multi-column sweep - na_if() across every character column
scenario11 <- demo %>% mutate(across(where(is.character), ~ na_if(.x, "UNK")))

# 12. Numeric sentinel sweep - na_if() across all numeric columns
scenario12 <- demo %>% mutate(across(where(is.numeric), ~ na_if(.x, -99)))

Block 3 — assigning NA.
scenario08 — single cell, tidyverse style. Instead of demo$Weight[1] <- NA, we use mutate(Weight = if_else(row_number() == 1, NA_real_, Weight)). row_number() inside mutate yields 1..n, so the condition is TRUE only for the first row. NA_real_ is required because Weight is a double — NA alone is logical and if_else would refuse to coerce.
scenario09 — logical mask via if_else. Turns Age < 13 into NA. With our data only S006 (Age = 12) qualifies; S005 stays NA because Age < 13 with NA on the left returns NA, and if_else propagates NA through — so the missing stays missing rather than being mishandled.
scenario10 — na_if() inside a tibble. A tiny reference tibble codes with a single column. mutate(code_clean = na_if(code, "UNK")) adds a cleaned column where every “UNK” is now NA. Most commonly used to convert sentinel strings (“UNK”, “.”, “Missing”) into honest NAs.
scenario11 / scenario12 — multi-column sweep. The real power play. across(where(is.character), ~ na_if(.x, "UNK")) applies na_if() to every character column in one expression. Same for numeric with -99. This is what replaces a long manual loop you might write in SAS to clean a load of imported variables.

Block 4: Replacing NA

Replace missing values with defaults, fallback columns, and carried-forward values.
These examples are common when preparing analysis-ready clinical datasets.

R (tidyverse)+

# === Block 4: Replacing NA ====================================================

# 13. replace_na() inside mutate - fill one column with a default
scenario13 <- demo %>% mutate(Weight = replace_na(Weight, 0))

# 14. replace_na() on a frame - named list maps column to fill-value
scenario14 <- demo %>% replace_na(list(Sex = "Unknown", Weight = 0, baseline_score = 0))

# 15. coalesce() - first non-NA across columns, row by row
scenario15 <- demo %>% mutate(any_score = coalesce(visit_score, baseline_score))

# 16. fill() - LOCF (down)
scenario16 <- demo %>% fill(Sex, Weight, .direction = "down")

# 17. fill() - NOCB (up)
scenario17 <- demo %>% fill(Sex, Weight, .direction = "up")

# 18. if_else() - swap NA for an explicit value
scenario18 <- demo %>% mutate(Sex = if_else(is.na(Sex), "U", Sex))

Block 4 — replacing NA.
scenario13 — replace_na() inside mutate. mutate(Weight = replace_na(Weight, 0)) rewrites just one column, leaving the rest of the tibble untouched. Use this form when you want a single-column default in the middle of a pipeline.
scenario14 — replace_na() on a frame. The named-list form fills different columns with different defaults in one pass — very clean for “NA Sex becomes Unknown, NA Weight becomes 0, NA baseline_score becomes 0”.
scenario15 — coalesce(). The fallback chain — for each row, take the first non-NA across the listed columns. coalesce(visit_score, baseline_score) means “use visit_score, but fall back to baseline_score if visit_score is missing”. Generalises to any number of columns.
scenario16 / scenario17 — fill(). Last Observation Carried Forward (LOCF, .direction = "down") and Next Observation Carried Backward (NOCB, .direction = "up"). Common in clinical work for sparse longitudinal data. If you need LOCF only within subject, pipe through group_by(subj_id) first.
scenario18 — if_else(). Explicit substitute. Stricter than base ifelse() — types must match across branches, so use NA_character_ not NA when the true/false branches are characters.

Block 5: Counting NA

Count missingness by column, by row, by a selected subset of variables, and across the whole frame.
Use these checks as quick data-quality summaries before modeling or reporting.

R (tidyverse)+

# === Block 5: Counting NA =====================================================

# 19. Per-column NA counts (missingness profile)
scenario19 <- demo %>% summarise(across(everything(), ~ sum(is.na(.x))))

# 20. Per-column NA percent
scenario20 <- demo %>% summarise(across(everything(), ~ mean(is.na(.x))))

# 21. Per-row NA count - across the whole row
scenario21 <- demo %>% mutate(n_missing = rowSums(across(everything(), is.na)))

# 22. Per-row NA count - across a chosen subset of variables
scenario22 <- demo %>% mutate(
  n_score_missing = rowSums(is.na(across(c(baseline_score, visit_score))))
)

# 23. Total NA count in the frame, wrapped as a one-row tibble
scenario23 <- tibble(total_na = sum(is.na(demo)))

Block 5 — counting NA.
scenario19 / scenario20 — per-column profile. summarise(across(everything(), ~ sum(is.na(.x)))) returns a one-row tibble with one column per source variable, value = count of NAs. Swap sum for mean and you get the proportion (because TRUE/FALSE coerce to 1/0). This is the missingness report you would put at the top of an EDA document.
scenario21 — per-row total. rowSums(across(everything(), is.na)) — for each subject, count how many of their cells are NA. scenario21 is demo with an extra n_missing column appended.
scenario22 — per-row, subset of columns. rowSums(is.na(across(c(baseline_score, visit_score)))) — how many of the two scores are missing per subject. Confirm: S003 and S005 each have one missing score, S006 has both missing.
scenario23 — grand total as a tibble. sum(is.na(demo)) would return a bare scalar; we wrap it in tibble(total_na = ...) so the result is still a printable dataset and the convention is preserved.

Block 6: Dropping rows with NA

Drop rows with missing values using broad and targeted rules.
Confirm the row counts after each step because complete-case filtering can remove far more data than expected.

R (tidyverse)+

# === Block 6: Dropping rows with NA ===========================================

# 24. drop_na() - drop a row if ANY column is NA
scenario24 <- demo %>% drop_na()

# 25. drop_na() - only when the chosen column is NA
scenario25 <- demo %>% drop_na(visit_score)

# 26. drop_na() - on multiple chosen columns
scenario26 <- demo %>% drop_na(baseline_score, visit_score)

# 27. filter(!is.na()) - explicit on one column
scenario27 <- demo %>% filter(!is.na(visit_score))

Block 6 — dropping rows.
scenario24 — drop_na() with no arguments. Drops a row if any column in it is NA. This is aggressive — on demo, every row has at least one NA, so scenario24 is empty. Confirm and consider whether that’s really what you want before using it on a real dataset.
scenario25 / scenario26 — drop_na() with column names. The right tool 90% of the time — “drop subjects who do not have a visit_score”. You name the columns whose NAs you care about; NAs elsewhere are left alone. Pass several names to require non-missing values in all of them.
scenario27 — filter(!is.na(...)). Same result as drop_na(visit_score) for a single column, written more explicitly. Use this form when you want the intent visible in the pipeline.

Block 7: NA introduced across datasets

Show how joins introduce missing values when a subject has no matching row in the lookup dataset.
Compare the left-join plus is.na() pattern with the direct unmatched-record pattern.

R (tidyverse)+

# === Block 7: NA introduced across datasets ===================================

demo_simple <- demo %>% select(subj_id, Sex, Age)
visits <- tribble(
  ~subj_id, ~vs_status,
  "S001",   "done",
  "S002",   "done",
  "S004",   "done"
)

# 28. left_join leaves NA in joined columns for unmatched rows
scenario28 <- demo_simple %>% left_join(visits, by = "subj_id")

# 29. Count subjects who missed the visit (NA after the join)
scenario29 <- scenario28 %>% summarise(missed = sum(is.na(vs_status)))

# 30. Filter to the rows that did not match
scenario30 <- scenario28 %>% filter(is.na(vs_status))

# 31. anti_join() - same question without going through NA
scenario31 <- demo_simple %>% anti_join(visits, by = "subj_id")

Block 7 — NA across datasets.
scenario28 — left_join introduces NA. We build a tiny visits table containing only S001, S002, S004. A left_join keeps every row of demo_simple and fills vs_status with NA for S003, S005, S006 — the subjects with no matching row in visits. This is the standard clinical pattern: subject lookup table is sparse, joined dataset is dense, NA marks “not done”.
scenario29 — count the missed visits. summarise(missed = sum(is.na(vs_status))) after the join answers “how many subjects do not appear in the visits table”. Three.
scenario30 — filter to the missed visits. filter(is.na(vs_status)) — returns S003, S005, S006.
scenario31 — anti_join(). The same question without taking the NA detour. demo_simple %>% anti_join(visits, by = "subj_id") returns subjects in demo_simple with no match in visits — the same three rows. If your goal is just to identify unmatched subjects, anti_join is the cleaner expression; if you need their data alongside the join result, the left_join + is.na() form is right.
Take-away. NA is a first-class value in R with its own propagation rules. Mastering this lesson (typed NAs, is.na vs ==, na.rm, na_if/replace_na/coalesce/fill, rowSums(is.na(across(...))), drop_na, and join-induced NA) covers ~95% of the missing-value patterns you will hit in clinical work.

Happy learning!

Search lessons

Introduction

Create sample dataset with missing values

Block 1: NA basics

Block 2: NA in computation

Block 3: Assigning NA

Block 4: Replacing NA

Block 5: Counting NA

Block 6: Dropping rows with NA

Block 7: NA introduced across datasets