Assignment operators in R
Assignment stores data or operations in named objects in R programming. In R, variables, functions, and other items are objects. The leftward operators <- and = are commonly used for assignment. The most commonly used assignment operator in R is the <- operator, which consists of a less-than symbol and minus sign. It is used to create new objects (e.g., a <-1), save function results (e.g., dice <- sample(die, size = 2, replace = TRUE)), and modify existing object values. This update can overwrite an object or change individual elements by combining the operator with indexing (e.g., vec <- 1000).
The = symbol, a quite new addition to the language, functions similarly to <- for assignment. It is frequently confused with the equality logical comparison operator, ==. Important distinction: = assigns a value, while == compares two values. To avoid misunderstanding, the R community recommends using <- for general assignments. Some style guides recommend using = only for named argument values in function calls. R also has a less common rightward assignment operator, -> (e.g., c(TRUE,1) -> var.3), which assigns the left value to the right object. In advanced programming, R has superassignment operators such <<- for writing to variables in a parent environment and assign() for assigning objects to specific environments.
The Primary Assignment Operator: <-
The most commonly used assignment operator in R is <-, which saves data into a named R object. All entities in R, including variables and functions, are objects. The <- operator is a visual arrow that directs a value into the storing object by combining a less-than symbol (<) and a minus sign (-) without space. It creates new objects by assigning a value a number, a sequence like 1:6, the output of a function, or even a function definition to a name. For example, the command die <- 1:6 generates an object named die with numbers from 1 to 6.
RStudio’s environment pane displays created objects. This operator overwrites pre-existing data in an object of the same name without warning, which is crucial. Checking object names with ls() or the environment pane helps prevent data loss. The <- operator can efficiently modify values within an existing object, beyond just creating it. It works with R’s indexing notation to select and assign values to vector, matrix, and data frame members.
This is a key part of R data manipulation, allowing focused changes like logical test values or NA settings. Instead of modifying global objects, <- assigns a value to a local variable within a function’s temporary runtime context, preventing unwanted behaviors. To alter a global object in a function, use assign() with the envir parameter. Coding style guides suggest using <- instead of = due to its simplicity and widespread use.
Key applications of the <- operator include
Creating new objects: Since data and functions are objects in R, generating new objects is essential to storing and manipulating data. To create an object, assign a value to a unique name (identifier). The <- operator is the most common way for assigning values, however the equals sign = and rightward arrow -> can also be used. Case-sensitive R distinguishes my_object from My_Object. Object names can contain letters, numerals, periods (.), and underscores (_) and must start with a letter or period.
Storing function results: Storing function results in a R object is essential in R programming. You can print a function’s output to the console, but it’s transient and will be lost unless you save it. To store output, assign the function’s return value to a named object using the assignment operator (<-). This lets you keep intermediate results for multi-step calculations or analysis. You may simulate a two-dice roll and save the result by assigning the sample function output.
Overwriting existing objects: Assigning new data to an existing object name in R overwrites its prior data. This procedure is powerful and risky since it happens without warning or permission. When you reassign a variable, it changes the object in active memory but not disk data. This means the old value of an object is wiped and replaced by the new one. To illustrate, if you run my_number <- 1 and then <- 999, the object will now contain 999 and lose the original value of 1.
Modifying values in place: Modifying values in place in R lets you update data in a vector, matrix, or data frame without generating a new object. In the core technique, R’s value selection system is combined with an assignment operator like <-. First, index the element(s) you want to update, then use the assignment operator to overwrite them with a new value. You can alter the first element of a vector named vec to 1000 using the command vec <- 1000.
The same approach applies to numerous values, allowing for simultaneous replacements or arithmetic operations on subsets (e.g., vec[4:6] <- vec[4:6] + 1). R will automatically expand the object to accommodate a value assigned to an empty index. To remove columns or entries from data frames and lists, assign NULL (e.g., deck2$new <- NULL).
Example:
# 1. Creating new objects
my_number <- 10
My_Number <- 20
print(my_number)
print(My_Number)
dice_roll <- sample(1:6, size = 2, replace = TRUE)
print(dice_roll)
my_number <- 999
print(my_number)
vec <- c(5, 10, 15, 20, 25, 30)
vec[1] <- 1000
vec[4:6] <- vec[4:6] + 1
print(vec)
deck2 <- data.frame(a = 1:3, b = 4:6)
deck2$b <- NULL
print(deck2) Output:
[1] 10
[1] 20
[1] 3 5
[1] 999
[1] 1000 10 15 21 26 31
a
1 1
2 2
3 3The Equals Sign Operator: =
In R, the equals sign (=) is an assignment operator used to store data in an object, functioning identically to the more popular <- operator. A more recent addition to the language, the = operator is one of three available for assignment, alongside <- and ->. However, its use for general assignment is often discouraged to avoid confusion. It is critical to distinguish the single equals sign (=) for assignment from the double equals sign (==), which is a binary operator that tests for equality between two objects.
Accidentally using = in place of == is a common of programming errors because it will assign a value rather than perform a comparison. For these reasons, a strong community convention, reflected in various coding style guides, is to favor the <- operator for all general assignments. The recommended practice is to reserve the = operator exclusively for specifying values for named arguments within function calls, such as myfunction(arg1=value1).
Comparison, Style, and Community Preference
Although <- and = are interchangeable for top-level assignments, the R community strongly recommends <-. Key reasons for this preference:
Clarity and Unambiguity: In R programming, the <- operator is preferred over the equals symbol (=) for assignment due to clarity and unambiguity. While the two operators are frequently functionally similar for top-level assignments, the = operator’s numerous responsibilities can confuse novice users. The visual similarity between = and ==, the logical comparison operator for equality, causes much of this uncertainty. Using a = b in a conditional statement assigns b to a, not tests if an is equal to b, which is a common programming blunder.
Historical Consistency: The <- assignment operator in R is favored due to its historical congruence with the S language. R was inspired by AT&T’s statistical language S, often known as GNU S. Thus, R adopted many of S’s syntactical conventions and methods, including the S3 object system from version 3 of S. The most common assignment operator is the <-, whereas the = sign is a more recent addition to the language.
Using <- assures compliance with known practices and existing code from experienced statisticians and programmers in S and R. Due to this historical precedent, many users, programmers, and style guides prohibit using = for generic object assignment. This tradition is reinforced to avoid confusion with the logical comparison operator ==.
Style Guides: R style guides and coding recommendations give code better readability, maintainability, reproducibility, and error-resistance. Most conventions suggest using the <- operator for assignments and saving the = sign for function calls with named arguments. My preference for <- is due to the potential misunderstanding caused by the usage of = in numerous contexts. Bioconductor’s coding guidelines include utilizing 4 spaces for indentation (no tabs), keeping lines under 80 characters, and using camelCaps for variable and function names. These requirements also require a space after a comma and around binary operators like ==, but no space around = for named parameters in functions.
Other Assignment Operators
R offers less common assignment operators for completeness.
Rightward Assignment (->):R offers a rightward assignment operator, ->, in addition to the usual leftward (<- and =) operators. The value or expression on the left is assigned to the object named on the right using this operator. The instruction 10 -> x assigns 10 to x. This operator works with many data types and expressions. In c(TRUE,1) -> var.3, you can assign a vector to an object or reassign a variable depending on an operation involving itself, such 5*x -> x. The list it as an assignment operator in R, alongside <- and =.
Superassignment (<<- and ->>): R’s superassignment operators <<- and ->> are advanced tools for assigning values to objects in a parent environment, rather than the current one. Unlike the conventional assignment operator <-, the superassignment operator <<- is designed to “write upstairs” instead of creating or modifying objects locally. R does not generate a local variable named x when executing an expression like x <<- value in a function. It searches up the hierarchy of environments from the current environment to its parent, then the parent of the parent, etc. and adjusts x in the first environment it finds.
If the search finds no x variable in the global environment, it creates one. Closures, functions that modify variables in their enclosing (origin) environment, require this behavior. Although assign can achieve the same result by providing the environment (e.g., assign(“deck”,…, envir = parent.env(environment())), <<- offers a more direct syntax. The ability to edit non-local variables to cause side effects is powerful, but it can make programs harder to comprehend and debug.
To assign values to objects in R, use both <- and =. However, it is advised to use <- for object assignments and = for function call arguments. Avoiding assignment-logical comparison mistakes and improving code readability are the benefits of this practice.