mycsg SASnR 7100_select_variables

Introduction

Lesson 1300 Subset variables introduced the basics of select() — bare names, minus signs, starts_with(), ends_with().
The tidy-select mini-language goes much further: type-based selection with where(), position helpers like everything() and last_col(), regex selection with matches(), lenient vs strict character-vector selection via any_of() / all_of(), and set operators (&, |, !) that combine all of the above.
This lesson walks twelve progressively richer scenarios on a single extended CLASS dataset (we added subj_id, three score columns, and an enrolled logical) so every helper has something to grab.
Naming convention for this lesson. Every scenario stores its result in a dataset named scenario01, scenario02, … When a single concept needs two or more related expressions (e.g. all_of vs any_of), we use suffixed names: scenario06a, scenario06b. Run the line, then type the scenario name on its own to print and inspect the result.
The final scenario is a teaser: the same tidy-select vocabulary you learn here is what powers across() inside mutate() and summarise() — one language, used everywhere a dplyr/tidyr verb takes a column-spec argument.
This lesson has no SAS counterpart by design — it is an R-only deep dive into tidy-select. A base R variant is included to show the contrast: most of what is one short helper in tidyverse is a grepl() + sapply() + bracket-subscript expression in base.

Create the selection practice dataset

Build the same extended CLASS dataset before comparing tidyselect and base R selection patterns.
The extra score and logical columns are intentional, so type-based and pattern-based selectors have something realistic to work on.

R (tidyverse)+

library(tidyverse)

class <- tribble(
  ~subj_id, ~Name,     ~Sex, ~Age, ~Height, ~Weight, ~score1, ~score2, ~score3, ~enrolled,
  "S001",  "Alfred",  "M",  14,   69.0,    112.5,   85,      78,      92,      TRUE,
  "S002",  "Alice",   "F",  13,   56.5,     84.0,   91,      88,      95,      TRUE,
  "S003",  "Barbara", "F",  13,   65.3,     98.0,   73,      80,      77,      FALSE,
  "S004",  "Carol",   "F",  14,   62.8,    102.5,   88,      85,      90,      TRUE,
  "S005",  "Henry",   "M",  14,   63.5,    102.5,   79,      82,      81,      FALSE,
  "S006",  "James",   "M",  12,   57.3,     83.0,   95,      93,      89,      TRUE
)

We start by building an extended CLASS dataset using tribble(). The extra columns are deliberate: subj_id gives us a character column besides Name and Sex, score1/score2/score3 exercise num_range(), and enrolled gives us a logical column for where(is.logical).
Every scenario below stores its result in a named dataset (scenario01, scenario02, …). After running each line, type the scenario name on its own to print and confirm the column set matches the description before moving on.

Select, drop, and reorder columns

Start with the everyday cases: keep a contiguous range, drop known variables, and move one important variable to the front.
Run each scenario and confirm the output columns are in the expected order.

R (tidyverse)+

# 1. Bare names and a column-range (Name through Age, inclusive)
scenario01 <- class %>% select(Name:Age)

# 2. Negative selection on a vector of names
scenario02 <- class %>% select(-c(Height, Weight))

# 3. everything() to reorder - put Name first, keep the rest in original order
scenario03 <- class %>% select(Name, everything())

scenario01 — column range: select(Name:Age) reads as “every column from Name through Age in their existing order”. Confirm scenario01 contains Name, Sex, Age. Range selection is position-based; reordering the source frame changes what is in the range.
scenario02 — negative on a vector: select(-c(Height, Weight)) drops both. Equivalent to select(-Height, -Weight) but reads better when the list is long.
scenario03 — everything() for reordering: putting everything() after a name pulls that name to the front and keeps the rest in original order. Confirm: Name is first, all other columns follow unchanged.

Use right-edge, numbered, and named-list selectors

These examples cover selectors that depend on column position, repeated numbered names, or a character vector of requested variables.
Compare strict and lenient name matching carefully because that is the key behavioral difference in this block.

R (tidyverse)+

# 4. last_col() - pick from the right edge
scenario04 <- class %>% select(last_col(), last_col(offset = 1))

# 5. num_range() for numbered columns like score1, score2, score3
scenario05 <- class %>% select(num_range("score", 1:3))

# 6. all_of() vs any_of() - selecting from a character vector
wanted      <- c("Name", "Sex", "Age")
scenario06a <- class %>% select(all_of(wanted))            # strict - errors if a name is missing
scenario06b <- class %>% select(any_of(c(wanted, "nope"))) # lenient - silently ignores "nope"

scenario04 — last_col(): grabs columns from the right edge. last_col() is the rightmost; last_col(offset = 1) is one to its left. Useful when the last column has a known role (e.g. a derived flag) but the rest of the frame is variable in width.
scenario05 — num_range(): num_range("score", 1:3) picks score1, score2, score3. Cleaner than typing them out, and the integer vector can be a variable so you can drive selection from data.
scenario06a / scenario06b — all_of() vs any_of(): both take a character vector. all_of() is strict — if one name is not in the frame, it errors. any_of() is lenient — missing names are silently skipped. The distinction matters when you are programming with dplyr and the column list is dynamic.

Select by pattern and column type

Move from explicitly named columns to rule-based selection using regular expressions and type predicates.
These are the patterns that scale when incoming datasets have many columns.

R (tidyverse)+

# 7. matches() - full regex on column names
scenario07 <- class %>% select(matches("^score[0-9]$"))

# 8. where() with a type predicate
scenario08a <- class %>% select(where(is.character))
scenario08b <- class %>% select(where(is.numeric))
scenario08c <- class %>% select(where(is.logical))

# 9. where() with a custom lambda - numeric columns whose mean exceeds 80
scenario09 <- class %>% select(where(\(x) is.numeric(x) && mean(x, na.rm = TRUE) > 80))

scenario07 — matches(): a full regular-expression match. ^score[0-9]$ picks score1..score9 but excludes a hypothetical score_total. Use starts_with() when a simple prefix is enough; reach for matches() only when you need real regex.
scenario08a / 08b / 08c — where() + type predicate: the type filter that has no clean base R equivalent. where(is.character) applies is.character() to every column and keeps the ones that return TRUE. Confirm: scenario08b returns Age through score3; scenario08c returns just enrolled.
scenario09 — where() with a lambda: the predicate can be any function that returns a single TRUE/FALSE. The \(x) ... form is base R’s shorthand for an anonymous function. Here we keep only numeric columns whose mean exceeds 80 — that excludes Age and Height but keeps Weight (mean ~97) and the score columns.

Combine selectors, rename, and reuse selection inside operations

Finish by combining selection rules, renaming as part of selection, and reusing the same selection language inside column-wise operations.
This is where tidyselect becomes more than a column picker: it becomes a reusable grammar for transformations.

R (tidyverse)+

# 10. Set operators - combine helpers with & | !
scenario10a <- class %>% select(where(is.numeric) & !ends_with("t"))
scenario10b <- class %>% select(starts_with("score") | starts_with("Height"))

# 11. Rename while selecting (new_name = old_name)
scenario11 <- class %>% select(age_years = Age, height_in = Height)

# 12. across() teaser - the same tidy-select drives column-wise mutate/summarise
scenario12a <- class %>% mutate(across(where(is.numeric), \(x) round(x, 1)))
scenario12b <- class %>% summarise(across(starts_with("score"), mean))

scenario10a / 10b — set operators: tidy-select helpers can be combined with &, |, and !. scenario10a keeps numeric columns whose names do NOT end in t — that drops Height and Weight, keeps Age and the scores. scenario10b ORs two prefix helpers together. This composes type and name conditions in one expression, which is impossible with keep= / drop= in SAS.
scenario11 — rename while selecting: select(age_years = Age) picks Age and renames it in one step. Compare to rename(), which renames without subsetting. If you want to rename in place without dropping anything, rename() is the right verb.

scenario12a / 12b — the across() teaser: this is the payoff. The same tidy-select language you just learned drives column-wise operations inside mutate() and summarise().
scenario12a reads as “for every numeric column, replace it with itself rounded to one decimal”. The first argument to across() is a tidy-select expression — anything legal inside select() is legal there.
scenario12b collapses score1/score2/score3 to their column means in a single row.
Take-away: investing time in tidy-select is high-leverage — the vocabulary is reused across select(), rename_with(), relocate(), pivot_longer(), across() inside mutate/summarise/filter, and many more verbs. A dedicated lesson on across() follows in the 7000 series.

Happy learning!

Search lessons

Introduction

Create the selection practice dataset

Select, drop, and reorder columns

Use right-edge, numbered, and named-list selectors

Select by pattern and column type

Combine selectors, rename, and reuse selection inside operations