janitor remove_empty() in R: Drop Blank Rows and Columns

The remove_empty() function in janitor deletes rows and columns of a data frame that are entirely NA in a single call. It accepts a cutoff to drop near-empty cases, handles rows and columns in one pass, and slots cleanly between data import and analysis.

remove_empty(df)                                   # drop fully empty rows AND cols
remove_empty(df, which = "rows")                   # rows only
remove_empty(df, which = "cols")                   # columns only
remove_empty(df, which = c("rows", "cols"))        # both, explicit
remove_empty(df, cutoff = 0.5)                     # drop if >=50% NA
remove_empty(df, quiet = FALSE)                    # print removed counts
df |> janitor::remove_empty()                      # pipe-friendly
remove_constant(df)                                # drop single-value cols

What remove_empty() does in one sentence

remove_empty() strips rows and columns from a data frame when every value in them is NA, returning a smaller data frame with the same column types. It pairs naturally with clean_names() as the second step in an import recipe, removing the empty header rows and trailing blank columns that spreadsheets often add.

The function is most useful immediately after reading data from Excel, where shape often does not match content. A 50-row sheet can ship with 200 blank rows and 5 padding columns; remove_empty() collapses it back to the real data without manual indexing.

Syntax

remove_empty() takes a data frame plus which, cutoff, and quiet arguments. Defaults remove fully empty rows and columns silently.

The full signature:

remove_empty(dat, which = c("rows", "cols"), cutoff = 1, quiet = TRUE)

Only dat is required. The default which = c("rows", "cols") prunes both axes; cutoff = 1 requires a row or column to be 100% NA before it is dropped.

Six common patterns

1. Drop fully empty rows and columns

With no arguments, remove_empty() walks rows first, then columns, removing anything that is entirely NA. The notes, blank columns and the two trailing NA rows are gone in one call.

2. Rows only

Pass which = "rows" to skip column pruning. Useful when the column layout is fixed (e.g., a survey export) but trailing rows must go.

3. Columns only

The mirror case: pass which = "cols" to prune unused fields while keeping every row, even partially missing ones. Common when you want to inspect row-level patterns before deciding which rows to discard.

4. Cutoff for near-empty data

cutoff is a fraction between 0 and 1. A value of 0.5 drops columns (or rows) where 50% or more of values are NA. Use this when "real" data demands some minimum density.

5. Verbose mode with quiet = FALSE

quiet = FALSE prints a message before each removal step. Helpful in interactive cleanup; turn it off in scripts that should run silently.

6. Remove constant columns with a sibling helper

remove_constant() is the companion function for columns that are not NA but carry zero information because every value is identical. Often paired with remove_empty() for full uninformative-column cleanup.

remove_empty() vs drop_na() vs filter()

Three tools sit in this space; the choice depends on whether you target shape, a specific column, or a condition.

When to use which:

• Use remove_empty() for shape cleanup right after import (rows AND columns).
• Use drop_na() when you need rows that are complete on a specific subset of columns.
• Use filter() when missingness logic is conditional on one column's value or a derived expression.

Common pitfalls

Pitfall 1: forgetting to assign the result. remove_empty(df) returns a new data frame, it does not modify df in place. Capture the output: df <- remove_empty(df) or chain it inside a pipeline.

Pitfall 2: blank strings are not NA. A column of "" (empty character strings) is NOT considered empty by remove_empty(). Convert with df[df == ""] <- NA first, or use readr::read_csv(..., na = c("", "NA")) at import time.

Pitfall 3: order matters when you run both axes manually. Calling remove_empty(df, "rows") then remove_empty(df, "cols") can give a different result than running both at once, because the first call may turn a near-empty column into a fully empty one. Use the default which = c("rows", "cols") when you want consistent behavior.

Try it yourself

Related janitor functions

After mastering remove_empty(), look at:

• remove_constant(): drop columns where every value is identical (zero information)
• clean_names(): rewrite column names to clean snake_case, usually run just before
• get_dupes(): surface duplicated rows by one or more columns
• compare_df_cols(): spot column type or name mismatches across two data frames
• tidyr::drop_na(): drop rows missing values in a specific column or subset

For a fuller tour of the package, see the janitor package guide. The package's official reference lives at sfirke.github.io/janitor.

FAQ

What does janitor remove_empty() do?

remove_empty() deletes rows and columns from a data frame that contain only NA values. By default it prunes both axes in a single call, returning a smaller data frame with the same types and column order. It is most useful right after reading data from Excel or CSV files where trailing blank rows and unused columns are common, and pairs naturally with clean_names() as the second step of a tidy import pipeline.

How do I drop only rows or only columns with remove_empty()?

Pass the which argument: remove_empty(df, which = "rows") prunes rows only, remove_empty(df, which = "cols") prunes columns only, and which = c("rows", "cols") (the default) prunes both. The argument accepts a single string or a character vector, and the order does not matter; janitor always cleans rows before columns under the hood for consistent results.

Can remove_empty() drop rows or columns that are mostly but not fully empty?

Yes. Use the cutoff argument, a fraction between 0 and 1. cutoff = 0.5 drops any row or column where at least 50% of values are NA. The default cutoff = 1 requires 100% NA (fully empty). Lower the cutoff when you want to prune sparse columns that contribute little signal, but inspect the result first to confirm meaningful data is not lost.

Does remove_empty() treat empty strings as missing?

No. remove_empty() only checks for NA values; empty strings "" and sentinel codes like -99 are treated as real data. Convert them to NA first, for example with df[df == ""] <- NA or na_if(x, -99), before calling remove_empty(). Many R analysts handle this at import time by passing na = c("", "NA", "-99") to readr::read_csv() so the cleanup is automatic.

What is the difference between remove_empty() and remove_constant()?

remove_empty() drops rows or columns where every value is NA; remove_constant() drops columns where every value is identical (whether NA, zero, or any repeated literal). The two solve different problems: empty data has no information because it is missing, constant data has no information because it does not vary. Run remove_empty() first to clear true blanks, then remove_constant() to strip uninformative single-value columns.