Missing and Special Values

The manuals keep the four notions apart, and so must you. An Introduction to R introduces NA in the section on missing values: when a value is not available in the statistical sense, a place in the vector is reserved for it with the special value NA; any operation on an NA becomes an NA, because if the specification of an operation is incomplete the result cannot be known; and is.na(x) is the function that finds them (An Introduction to R: Missing values). The R Language Definition adds that this is the statistical sense of "missing" and must not be confused with the missing property of a function argument that was not supplied (The R Language Definition: NA handling); that other meaning is on Functions. NULL has its own subsection in the Language Definition: a special object used whenever it is necessary to indicate that an object is absent, and it should not be confused with a vector or list of zero length (The R Language Definition: NULL).

Source: The R Language Definition: NA handling

The first script puts the four side by side on the shelf. The page counts of "A Map of Salt" and "Ten Winters" are unknown, so their cells are NA; the vector still has 16 elements and each unknown keeps its place. NULL, on the other hand, has no place at all: c(10, NULL, 30) is a vector of length 2, because NULL contributes no elements. The last lines show the consequence for testing: is.na() of a NULL is an empty logical vector, not FALSE, so it cannot be used as a test for NULL (the condition of an if would be a zero-length condition; see Zero-length vectors).

Source: An Introduction to R: Missing values

Source: An Introduction to R: Missing values

Source: The R Language Definition: NULL

Source: R documentation: NA

NA is a reserved word, a logical constant of length 1 that contains a missing-value indicator, and it can be coerced to any other vector type except raw. There are also constants for the other atomic types that support missing values: NA_integer_, NA_real_, NA_complex_ and NA_character_. The help page documents that all five are reserved words in the language (R documentation: NA). The reason there are several is that an atomic vector has one type, so the missing value inside it must have that type too. The Language Definition points out the one case in which the difference matters to a user: the default NA is logical, so a bare NA used as an index triggers logical rather than numeric indexing (see Where missing values come from).

The first block shows the five constants and how a vector keeps its type when an NA joins it: c(1L, NA) is still integer, c("a", NA) is still character, because the logical NA is the lowest type in the coercion order and is promoted to the type of the other elements. The second block is the most common confusion: the character NA is not the string "NA". A vector c("NA", NA) holds a string with two letters and a missing value; is.na() finds only the second, nchar() reports 2 for the first and NA for the second, and printing without quotes shows the missing one as <NA> to tell them apart (the Introduction to R mentions this printing). Real data brings the string case from files: read.csv() treats the text NA as a missing value in every column, including text columns (its na.strings argument defaults to "NA"), which is how the country code of Namibia becomes a missing value; na.strings = character(0) keeps it as text. The block after the empty year of the shelf shows both reads (the script builds the data with a text string, so no file is needed).

Source: R documentation: NA

Source: The R Language Definition: NA handling

Source: R documentation: NA

Source: R documentation: typeof

Source: R documentation: read.table

The type of an NA is visible to identical(), which compares the type as well as the value, and to the is.*() functions: identical(NA, NA_integer_) is FALSE even though both print as NA, and is.numeric(NA) is FALSE because the plain NA is logical. That is why code that must return a typed missing value spells it out. The book() helper of the shelf scenario has author = NA_character_ and year = NA_integer_ as defaults, which is what lets validate_book() and new_book() check types with is.character() and is.integer(); and vapply() needs a template of the right type, as in vapply(x, f, NA_real_), where the NA_real_ is only a way of writing a length-one double (see The apply Family and Functionals).

Source: R documentation: identical

Coercion keeps the missingness and changes the type: as.integer(NA), as.character(NA) and as.numeric(NA_character_) are all missing values of the new type, and as.character(NA) is NA_character_, never the string "NA". rep(NA_real_, 3L) is the idiom for a double vector that is to be filled later; character(2L) is two empty strings, not two missing values, and numeric(3L) is three zeros, which silently look like data. The last block shows the one type with no missing value: as.raw(NA) is 00 with a warning, because a byte cannot be unknown (the Language Definition says there is no NA for raw vectors).

Source: R documentation: NA

Source: R documentation: vector

Source: R documentation: raw

Finally, the help page recommends is.na<- as the safer way to set elements to missing, because it behaves sensibly for classes such as factors (is.na() versus == NA shows it). See Atomic Vectors and Types for the six atomic types and the coercion hierarchy.

NaN ("not a number") and the infinities come from the floating-point arithmetic of the computer, not from R, and R follows IEEE 754 for doubles. Dividing a nonzero double by zero gives Inf or -Inf; log(0) is -Inf; a computation that overflows, such as exp(1000), is Inf; and an operation with no defined result (0/0, Inf - Inf, Inf * 0) is NaN. The Language Definition says that NaN exists only in the double type and in the real or imaginary components of the complex type (The R Language Definition: NA handling). An integer has no way to store either: integer division by zero is NA (5L %/% 0L), while the double 5 %/% 0 is Inf and 5 %% 0 is NaN, as described on Numbers and Arithmetic.

A function called outside its domain returns NaN and says so with the warning NaNs produced, which is the same warning for sqrt(-1) and log(-1). It is a warning because the result is a legitimate NaN, so the computation continues; the script catches it to print its text.

Source: R documentation: Arithmetic

Source: R documentation: MathFun

The four predicates are summarised by the next block. They answer different questions: is.na() is TRUE for NA and for NaN, is.nan() is TRUE only for NaN, is.finite() is TRUE only for ordinary numbers (it is FALSE for NA, NaN and both infinities), and is.infinite() is TRUE only for the infinities. Be careful with the direction of the relation: every NaN is NA as far as is.na() is concerned, but an NA is not a NaN, so is.nan(NA) is FALSE. If you need to tell the cases apart, test is.nan() first, or use is.na(x) & !is.nan(x) for “a true NA”.

Source: R documentation: is.finite

Source: R documentation: is.finite

The help page for NA warns about one more difference between the two. A numerical computation that mixes an NA and a NaN (for example NA_real_ + NaN) may give either, depending on the platform and the compiler, and the help page says this is not guaranteed and may change on future CPUs, so this page does not print such a result and your code should not depend on it (R documentation: NA). Test for both with is.na() and do not rely on which of the two a mixed computation yields.

Comparisons follow the same rule as NA: NaN is not comparable, even to itself, so NaN == NaN is NA. The infinities, in contrast, are ordinary values that can be compared, so Inf == Inf is TRUE and Inf > 1e308 is TRUE; max() and range() return them without complaint, which is why a -Inf or Inf in a result is a clue that a maximum or minimum was taken over an empty vector (see Zero-length vectors). Three rules hold for every argument, NA and NaN included, because the answer does not depend on the unknown: NA^0 is 1, 1^NA is 1, and Inf^0 is 1, as documented on the help page of the arithmetic operators. NA * 0, in contrast, is NA, not 0: R applies no algebraic shortcut to an unknown, only the documented rules.

Source: R documentation: Comparison

Source: R documentation: Arithmetic

is.finite() and is.infinite() accept any vector: they return FALSE for strings (a string is not a finite number), TRUE for finite integers and logicals, and logical(0) for NULL. Converting loses the distinction: as.integer(NaN) is NA, and as.integer(Inf) is an NA with the warning NAs introduced by coercion to integer range, because an integer cannot hold it; as.character() keeps the spellings "NaN", "Inf" and "-Inf" but turns NA into NA_character_. is.nan() is defined for numbers; on a string or NULL it returns FALSE or logical(0), and on a list it is an error.

Source: R documentation: is.finite

Source: R documentation: integer

NULL is the one object of the type NULL. It has length 0, no attributes and no modifiable properties, and there is only one NULL in R, to which every reference points. It is what R returns when there is nothing to return: a function whose body is empty or that ends with an if without a taken branch, a for loop, invisible(NULL), a missing list component. It is also how you ask for something to be removed (x$a <- NULL, rownames(m) <- NULL) and how you say that an argument has no value (f(data = NULL)). The first block shows the type and the family resemblance to the empty vector and the empty list: they all have length 0 but they are three different objects, identical(NULL, list()) and identical(NULL, logical(0)) are FALSE, and NULL is the only one for which is.null() is TRUE.

R 4.4.0 changed one of these relationships: is.atomic(NULL) is now FALSE, because NULL is not an atomic vector. The NEWS entry notes that strict backward compatibility for old code means replacing is.atomic(foo) by is.null(foo) || is.atomic(foo), which should happen sparingly (R NEWS: Changes in R 4.4.0). In the same release NCOL(NULL) became 0 instead of 1, for consistency with cbind() (NROW and NCOL below).

Source: R documentation: NULL

Source: R documentation: NULL

NULL vanishes when it is combined: c(1, NULL, 3) is a vector of two elements, c(NULL, NULL) is NULL, and unlist() drops the NULL components of a list. R 4.1.0 made c() remove NULL arguments before dispatching to methods, which simplified the writing of c() methods, while keeping the NULL when it is the first argument for backward compatibility (R NEWS: Changes in R 4.1.0). That behaviour is useful for building a result by appending (out <- NULL followed by out <- c(out, x)), though growing a vector one element at a time is slow for large inputs (see Vectorisation and Iteration).

Extracting from NULL never fails: NULL[1L], NULL[[1L]], NULL$a and NULL[["a"]] are all NULL. That is why x$misspelled returns NULL instead of an error and a typo in a component name surfaces later, as a zero-length condition (Conditions that are not one TRUE or FALSE). The one exception, from R 4.3.0, is the empty subscript: NULL[[]] is an error, like x[[]] (R NEWS: Changes in R 4.3.0). You cannot set an attribute on NULL: attr(nothing, "unit") <- "pages" and names(nothing) <- "a" stop with attempt to set an attribute on NULL, and the same assignment written directly on the constant fails earlier with invalid (NULL) left side of assignment. Arithmetic and comparison on NULL give a zero-length vector of the type of the operation (NULL + 1 is numeric(0), NULL == 1 is logical(0)), which is one more way to end up with a condition of length zero.

Source: R documentation: c

Source: R documentation: Extract

Source: The R Language Definition: NULL

Source: R documentation: NULL

The Introduction to R states the rule in one sentence: x == NA is quite different from is.na(x), because NA is not a value but a marker for a quantity that is not available, so the comparison asks whether an unknown is equal to another unknown, which is undecidable and therefore NA (An Introduction to R: Missing values). The result of x == NA is a vector of the length of x made only of NA, whatever x holds. Using it as an index returns a vector of NA values, summing it gives NA, and using it in an if is an error. The default lintr linters flag x == NA (equals_na_linter) for this reason, which is why the first block has # nolint comments: it is showing the mistake on purpose.

Source: An Introduction to R: Missing values

is.na() is the test. It returns a logical vector of the same length (copying the names, dim and dimnames of its argument), so which(is.na(x)) gives the positions, x[is.na(x)] the missing elements, sum(is.na(x)) the number of them and mean(is.na(x)) the proportion, because TRUE counts as 1. The next block finds the one book without a year (row 7, "Garden of Small Fires") and shows the proportion of unknown page counts, 2 of 16. When the result must be a single TRUE or FALSE for an if, remember that a comparison involving an NA is itself NA: if (first_year < 2000L) stops with missing value where TRUE/FALSE needed when the year is unknown, and if (NA) stops with the same message. Decide what an unknown should do and say it: if (is.na(first_year)) handles it first, or isTRUE(first_year < 2000L) folds the unknown into FALSE.

Source: R documentation: NA

Source: R documentation: Control

Source: R documentation: Logic

There is one place where NA is compared with NA and found equal on purpose, and it is the set of lookup functions. The Language Definition notes that an NA value will match another NA in match(), and NaN matches only NaN (The R Language Definition: NA handling). So NA %in% books$year is TRUE and match(NA, books$year) is 7, and unique(), duplicated() and table(useNA = "ifany") all treat NA as a value that can repeat. The linter flags x %in% NA as well, since anyNA(x) or is.na(x) say it better. A data frame has an is.na() method that returns a logical matrix with the dimensions and dimnames of the frame, so colSums(is.na(books)) is the count of unknowns by column (0 for the titles, 1 for the year, 2 for the pages), and which(is.na(books), arr.ind = TRUE) gives the row and column of every one of them. complete.cases() and anyNA() give whole-row and whole-object answers.

Source: R documentation: match

Source: R documentation: colSums

Source: R documentation: complete.cases

Absence is not the same as an empty value. The ISBN of "Rivers of Glass" is the empty string "", which is a perfectly good string of length zero: is.na("") is FALSE, sum(is.na(books$isbn)) is 0, and the missing ISBN is found by books$isbn == "" or !nzchar(books$isbn). Whether the empty string should count as missing is a decision about the data; Filling and recoding shows how to turn it into a real NA when reading or afterwards. The last block sets a value to missing: x[2L] <- NA assigns, and the replacement function is.na<- takes an index and sets those elements to the NA of the vector’s type, which for a character vector is NA_character_; the help page adds that it behaves differently for factors (R documentation: NA).

Source: R documentation: nchar

Source: R documentation: NA

The questions that are asked most often have exactly one correct spelling:

Source: R documentation: NA

A missing value enters a computation from a short list of places, and knowing the list helps to find the one that put it there. Data entry is the obvious source: an empty field in a CSV file becomes NA in numeric, logical and date columns (the year of "Garden of Small Fires", the page counts of the two books with a blank, the unreturned loans), and a text that cannot be parsed becomes NA with a warning. The rest are R’s own rules, and the script below shows them in turn:

Source: The R Language Definition: Indexing by vectors

Source: The R Language Definition: NA handling

Source: R documentation: Extract

Source: R documentation: Extract

Source: R documentation: merge

Source: R documentation: integer

The subsetting rules are the subject of Subsetting and Indexing; the rows of a data frame are on Data Frames.

The rule of the manuals is that numeric and logical calculations with NA generally return NA, because the result would depend on a value nobody knows. The exceptions are the cases where the answer would be the same whatever the unknown was, and R does implement those: FALSE & NA is FALSE and TRUE | NA is TRUE (The R Language Definition: NA handling). It is Kleene’s three-valued logic, with NA as the third value "unknown". The first block shows arithmetic and comparison (every one is NA), and the second the logic operators, which are worth learning as a table:

Source: R documentation: Logic

The same logic extends to the summaries any() and all(): any(c(NA, TRUE)) is TRUE because one TRUE is enough whatever the unknown is, while any(c(NA, FALSE)) is NA; all(c(NA, FALSE)) is FALSE and all(c(NA, TRUE)) is NA. The scalar operators && and || evaluate left to right and stop as soon as the answer is known, so FALSE && NA is FALSE and TRUE || NA is TRUE, but NA && TRUE is NA; a guard of the form isTRUE(x) && ... or !is.na(x) && ... keeps the unknown out of the condition (see Operators and Precedence for the length-one rule and its errors).

Source: R documentation: Arithmetic

Source: R documentation: Logic

Source: R documentation: Logic

na.rm is an argument of one function. When the missing values have to be removed from the data itself, R has two families of tools. na.omit() returns the object without the missing observations, and records what it removed in an attribute called na.action, of class omit, that holds the positions (or, for a data frame, the row names) of the dropped elements. The attribute is the reason the printed vector from na.omit() shows an attr(,"na.action") section: the object is still a numeric vector that every function can use, and as.vector() or c() strips the attribute when it is in the way. complete.cases() returns the logical vector that says which rows are complete, for any mix of vectors, matrices and data frames of the same length, and is the better choice when you want to keep control of the subsetting: books[complete.cases(books), ] is what na.omit(books) returns, without the attribute. If the arguments differ in length it stops with not all arguments have the same length.

Source: R documentation: na.fail

For one vector, mean(x, na.rm = TRUE) and mean(na.omit(x)) give the same number. For several variables they are different operations, and the difference is the reason to know both. na.rm = TRUE is applied variable by variable, so each statistic uses all the values that variable has; na.omit() on a data frame performs listwise deletion, which drops a row when any of its variables is missing, so every statistic is computed on the same rows. On the shelf, colMeans(books[c("year", "pages")], na.rm = TRUE) uses 15 years and 14 page counts, while colMeans(na.omit(...)) uses the 13 rows that have both, and the means differ (1998.73 and 268.21 against 1996.23 and 281.46). Neither is wrong; they answer different questions, and a correlation or a regression needs the second, which is what the use = "complete.obs" argument of cor() and the default of lm() do.

Source: R documentation: mean

Source: R documentation: na.fail

Source: R documentation: complete.cases

Removing is not the only option and it is rarely a neutral one: dropping rows changes what the data represent. When a missing value has to be given a value, three tools do the job in base R, and all of them take a logical vector from is.na() to say where. ifelse(is.na(x), fill, x) is vectorised and returns a new vector; replace(x, is.na(x), fill) is the same without the wrapper (replace() is x[list] <- values written as a function); and the assignment x[is.na(x)] <- fill modifies in place. The fill can be a constant or a statistic of the known values (mean(x, na.rm = TRUE), median(x, na.rm = TRUE)). Which one is correct is a statistical question that R cannot answer: filling a page count with zero tells the next function that the book has no pages, and filling with the mean shrinks the variance. tidyr::replace_na() and dplyr::coalesce() do the same job for data frames and are named in prose only (see tidyr, purrr and stringr and The tidyverse and dplyr).

ifelse() returns NA where its test is NA, so a classification such as long or short based on a page count leaves the two unknown books unclassified, and the second form of the example says explicitly what to do with them. The type of the fill matters: replace(books$pages, is.na(books$pages), 0) turns an integer column into a double one, because 0 is a double, and filling the year with "unknown" turns the column into a character vector, and every number in it into a string, which is why the fill value for an integer column is written 0L and why a placeholder text does not belong inside a numeric column.

Source: R documentation: ifelse

Source: R documentation: mean

Source: R documentation: ifelse

Source: R documentation: replace

The opposite recoding is turning a placeholder into a real NA. The shelf has an empty ISBN "" for "Rivers of Glass"; replace(books$isbn, books$isbn == "", NA) makes it missing (the logical NA is coerced to NA_character_ because the vector is character), and is.na(x) <- !nzchar(x) does the same through the replacement function. The better moment is on reading: read.csv() and read.table() take na.strings, a character vector of the texts that mean missing, and na.strings = c("NA", "") reads the empty ISBN as NA. A code such as -99 for "not recorded", which old data files use, is converted in the same way by na.strings = "-99". Reading is covered by Reading and Writing Text Data.

Source: R documentation: read.table

Source: R documentation: read.table

Dates carry their missing values like any other vector. The impossible loan date 2025-02-30 in loans.csv becomes NA when parsed with an explicit format (the scenario does that with as.Date(format = "%Y-%m-%d")), and without a format as.Date("2025-02-30") is an error, character string is not in a standard unambiguous format, because it tries the standard formats on the first non-missing element and none fits. as.Date(NA) is a missing Date, and a Date vector combined with NA stays a Date. The seven loans still out have an NA return date; subtracting dates keeps the NA (a difftime with 8 missing values, the seven unreturned loans and the one with the impossible loan date), and the overdue count, which compares the lengths with loan_days, must use na.rm = TRUE or which() as in How NA propagates: the result is the 25 returned loans that exceeded 21 days, while for the unreturned ones the days out are measured against shelf_today. Dates are on Dates and Times.

Source: R documentation: as.Date

Base R has no function for "last observation carried forward", the fill that time-series data often needs, but the index trick of the last block does it: seq_along(x) * !is.na(x) is the position where the value is known and 0 where it is not, cummax() carries the last known position forward, and indexing with it repeats the known value. A leading NA gives the index 0, which [ drops, so a vector that starts with an unknown needs a guard. Packages offer ready-made versions of this and of interpolation.

Source: R documentation: cumsum

NULL is not a value that a vector can hold, but a list can hold it as a component, and that creates a trap that has its own entry in the R FAQ. The question is how to set a component of a list to NULL. The answer in R FAQ 7.1 is to use x[i] <- list(NULL), and not to set x[i] or x[[i]] to NULL, because that removes the component from the list (R FAQ 7.1: How can I set components of a list to NULL?). The same entry notes that for dropping the row names of a matrix rownames(x) <- NULL is the easier way. The script runs the experiment on a list with three named components: x[["b"]] <- NULL and x$b <- NULL remove b, so the list has two components; x["b"] <- NULL removes it as well, which is the case the FAQ warns about; and only x["b"] <- list(NULL) leaves a component named b whose value is NULL, so the list still has three components, x$b is NULL, is.null(x$b) is TRUE and "b" %in% names(x) is TRUE.

Source: R FAQ 7.1: How can I set components of a list to NULL?

Source: R FAQ 7.1: How can I set components of a list to NULL?

Source: R FAQ 7.1: How can I set components of a list to NULL?

Source: R documentation: list

The last row of the table is the second half of the trap: an absent component and a component that holds NULL look the same through $ and [[, both returning NULL, so is.null(x$b) cannot tell them apart. The test that can is on the names: "b" %in% names(x), or exists("b", where = x). The block also shows x[["b", exact = TRUE]], the form that never partial-matches: $ does partial matching on lists, so x$b can return a component named bar when no b exists (see Lists and Subsetting and Indexing).

Source: R documentation: Extract

Lists that hold NULL come from functions that sometimes return nothing. lapply() over a list returns a list that has a NULL where the function returned NULL; sapply() then cannot simplify the result and returns the list unchanged, which makes its return type depend on the data; and vapply() stops with an error that names the problem, values must be length 1,\n but FUN(X[[1]]) result is length 0. unlist() drops the NULL elements, which is sometimes what you want and sometimes hides a bug. To find or remove the empty components use vapply(x, is.null, logical(1L)) or lengths(x) == 0L (which also catches character(0) and list()), and Filter(Negate(is.null), x) or x[lengths(x) > 0L] to keep the others; the names are preserved either way.

Source: R documentation: lapply

Source: R documentation: Filter

Starting a result as NULL and growing it is a common idiom, and its behaviour was made consistent in R 4.0.0: res <- NULL; res$a <- 1 gives a list, and so does res[["a"]] <- 1 and res[[1L]] <- "x", since N <- NULL; N[[1]] <- val turns N into a list also when val has length one (R NEWS: Changes in R 4.0.0); out <- c(out, x) gives a vector. So start with list() or vector("list", n) when you want a list and with numeric(0) or character(0) when you want a vector, rather than relying on what NULL becomes.

Source: R NEWS: Changes in R 4.0.0

The book objects of the scenario are lists of six fields of length 1 where a field that is unknown is NA, never NULL: new_book() and validate_book() rely on that, and b$pages is NA_integer_ with is.null(b$pages) being FALSE. Asking for a field that does not exist (b$notes) is NULL. The last lines show what happens when a NULL gets in through the back door: b$year <- NULL removes the field, and validate_book(b) then stops with missing value where TRUE/FALSE needed, which is a misleading message for a missing field. The reason is that is.na(NULL) is logical(0), !logical(0) is logical(0), and logical(0) && ... is NA (see Conditions that are not one TRUE or FALSE), so the if receives an NA. A validator should check the field names before the values.

In a data frame the same two operators do the two jobs: df$b <- NULL removes a column and df$c <- NA creates a column of logical NA, with the type logical, to be replaced by a typed vector later. df["a"] <- NULL on the last remaining column leaves a frame with 3 rows and no columns. See Data Frames.

Source: R documentation: NULL

Source: R documentation: data.frame

Taking a default when something is NULL is so common (an optional argument, an absent list component, a missing option) that R 4.4.0 added an operator for it: L %||% R is the idiom for if (!is.null(L)) L else R (R NEWS: Changes in R 4.4.0; documented with the control-flow operators in R documentation: Control). The right operand is evaluated only when the left one is NULL, like ||. The operator tests for NULL and only for NULL: NA %||% "default" is NA, character(0) %||% "default" is character(0) and list() %||% "default" is list(), because none of them is NULL. For a missing value in a book field, b$genre %||% "unclassified" is NA, while b$notes %||% "no notes" is the default, and the safe test for the field is is.na(b$genre). Code that supports R older than 4.4.0 defines the helper itself (the function fallback() in the script is one possible definition) and loses nothing when it runs on a newer R, though a package that defines its own %||% masks the base one inside its namespace.

Source: R documentation: Control

Source: R documentation: Control

Source: R documentation: Control

Source: R documentation: Control

Source: R documentation: Reduce

A zero-length vector is a vector with no elements, and unlike NULL it has a type: character(0), integer(0), numeric(0), logical(0) and the empty list(). They are what a filter returns when nothing matches (x[x > 5], which(...), books$title[books$pages > 1000L & !is.na(books$pages)]), what an index of 0 selects (books$year[0L]), and what most functions return when given NULL. A data frame with no rows prints as <0 rows>, and a name that is not in a frame gives NULL. The Language Definition says that NULL is not to be confused with a vector or list of zero length (The R Language Definition: NULL), and the next table is the practical difference between the three neighbours.

Source: R documentation: NULL

Source: R documentation: vector

Functions on an empty input follow the mathematics of the empty set, and a few of the results are surprising until the rule is seen. sum(integer(0)) is 0 and prod(numeric(0)) is 1, the identity elements of addition and multiplication; any(logical(0)) is FALSE and all(logical(0)) is TRUE (the "vacuous truth", for which no counter-example exists); mean(numeric(0)) is NaN, because it computes 0/0; median(numeric(0)) and var(numeric(0)) are NA. The ones that return empty things return a typed one: nchar(character(0)) is integer(0), toupper(character(0)) is character(0), cumsum(numeric(0)) is numeric(0). Two functions deserve a warning label. sapply() of an empty input returns list() instead of a typed empty vector, because it has no result to simplify, while vapply() returns the empty vector of its template type, so use vapply() whenever the input can be empty (see The apply Family and Functionals); and paste0("pages: ", integer(0)) is "pages: " and not character(0), because a zero-length argument is treated as the empty string, unless recycle0 = TRUE is given, an argument added in R 4.0.1 (R NEWS: Changes in R 4.0.1).

The loop variable of a for over an empty sequence is never set and the body runs zero times, provided that the sequence is a proper empty one: seq_along(NULL) and seq_len(0L) are integer(0), whereas 1:length(x) is 1:0, which counts down to 0 and runs the body twice (see Control Flow).

Source: R documentation: sum

The condition of an if or a while must be a single TRUE or FALSE, and everything else is an error whose text depends on what the condition was instead. These are the messages, each captured from R 4.6.1 in the script that follows:

Source: R NEWS: Changes in R 4.2.0 and 4.3.0

The first two rows are the subject of this page. A NULL or an empty vector in a condition is the condition of length zero, and the cause is nearly always upstream: books$pagez (a typo) is NULL, NULL > 300L is logical(0), and if (logical(0)) stops with argument is of length zero; but filtering the right column on a title that does not exist gives the same message. Both messages mean that the value has no answer, and you should know before the if whether you expect exactly one answer. while reports the same two messages.

A zero-length operand of && or || is not an error in R 4.6.1: logical(0) && TRUE is NA, and logical(0) || TRUE is TRUE, as if the empty operand were an NA. So an if whose condition has a zero-length operand on the left of && reports missing value where TRUE/FALSE needed, not the length-zero message, which is the confusing error that validate_book() showed above. A NULL or a string is a different matter and is an error in && and ||, with the invalid 'x' type message.

Source: R documentation: Control

Source: R documentation: Control

Source: R documentation: Logic

Older tutorials and answers are right about the basics and wrong or out of date about a few details. When one of them disagrees with this page, the table says why.

Source: R NEWS: Changes in R 4.0.0 to 4.4.0

For the full list of changes by release see What’s New and Migrating Older Code.