r language assignment operator

Secure Your Spot in Our Statistical Methods in R Online Course Starting on September 9 (Click for More Info)

Assignment Operators in R (3 Examples) | Comparing = vs. ＜- vs. ＜＜-

On this page you’ll learn how to apply the different assignment operators in the R programming language .

The content of the article is structured as follows:

Let’s dive right into the exemplifying R syntax!

Example 1: Why You Should Use ＜- Instead of = in R

Generally speaking, there is a preference in the R programming community to use an arrow (i.e. ＜-) instead of an equal sign (i.e. =) for assignment.

In my opinion, it makes a lot of sense to stick to this convention to produce scripts that are easy to read for other R programmers.

However, you should also take care about the spacing when assigning in R. False spacing can even lead to error messages .

For instance, the following R code checks whether x is smaller than minus five due to the false blank between ＜ and -:

A properly working assignment could look as follows:

However, this code is hard to read, since the missing space makes it difficult to differentiate between the different symbols and numbers.

In my opinion, the best way to assign in R is to put a blank before and after the assignment arrow:

As mentioned before, the difference between ＜- and = is mainly due to programming style . However, the following R code using an equal sign would also work:

In the following example, I’ll show a situation where ＜- and = do not lead to the same result. So keep on reading!

Example 2: When ＜- is Really Different Compared to =

In this Example, I’ll illustrate some substantial differences between assignment arrows and equal signs.

Let’s assume that we want to compute the mean of a vector ranging from 1 to 5. Then, we could use the following R code:

However, if we want to have a look at the vector x that we have used within the mean function, we get an error message:

Let’s compare this to exactly the same R code but with assignment arrow instead of an equal sign:

The output of the mean function is the same. However, the assignment arrow also stored the values in a new data object x:

This example shows a meaningful difference between = and ＜-. While the equal sign doesn’t store the used values outside of a function, the assignment arrow saves them in a new data object that can be used outside the function.

Example 3: The Difference Between ＜- and ＜＜-

So far, we have only compared ＜- and =. However, there is another assignment method we have to discuss: The double assignment arrow ＜＜- (also called scoping assignment).

The following code illustrates the difference between ＜- and ＜＜- in R. This difference mainly gets visible when applying user-defined functions .

Let’s manually create a function that contains a single assignment arrow:

Now, let’s apply this function in R:

The data object x_fun1, to which we have assigned the value 5 within the function, does not exist:

Let’s do the same with a double assignment arrow:

Let’s apply the function:

And now let’s return the data object x_fun2:

As you can see based on the previous output of the RStudio console, the assignment via ＜＜- saved the data object in the global environment outside of the user-defined function.

Video & Further Resources

I have recently released a video on my YouTube channel , which explains the R syntax of this tutorial. You can find the video below:

The YouTube video will be added soon.

In addition to the video, I can recommend to have a look at the other articles on this website.

• R Programming Examples

In summary: You learned on this page how to use assignment operators in the R programming language. If you have further questions, please let me know in the comments.

assignment-operators-in-r How to use different assignment operators in R – 3 R programming examples – R programming language tutorial – Actionable R programming syntax in RStudio

Subscribe to the Statistics Globe Newsletter

Get regular updates on the latest tutorials, offers & news at Statistics Globe. I hate spam & you may opt out anytime: Privacy Policy .

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Post Comment

I’m Joachim Schork. On this website, I provide statistics tutorials as well as code in Python and R programming.

Statistics Globe Newsletter

Get regular updates on the latest tutorials, offers & news at Statistics Globe. I hate spam & you may opt out anytime: Privacy Policy .

Related Tutorials

Extract Names of List Elements in R (2 Examples)

Force R to Show Scientific Notation (2 Examples)

Assignment Operators

Description.

Assign a value to a name.

There are three different assignment operators: two of them have leftwards and rightwards forms.

The operators <- and = assign into the environment in which they are evaluated. The operator <- can be used anywhere, whereas the operator = is only allowed at the top level (e.g., in the complete expression typed at the command prompt) or as one of the subexpressions in a braced list of expressions.

The operators <<- and ->> are normally only used in functions, and cause a search to be made through parent environments for an existing definition of the variable being assigned. If such a variable is found (and its binding is not locked) then its value is redefined, otherwise assignment takes place in the global environment. Note that their semantics differ from that in the S language, but are useful in conjunction with the scoping rules of R . See ‘The R Language Definition’ manual for further details and examples.

In all the assignment operator expressions, x can be a name or an expression defining a part of an object to be replaced (e.g., z[[1]] ). A syntactic name does not need to be quoted, though it can be (preferably by backtick s).

The leftwards forms of assignment <- = <<- group right to left, the other from left to right.

value . Thus one can use a <- b <- c <- 6 .

Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) The New S Language . Wadsworth & Brooks/Cole.

Chambers, J. M. (1998) Programming with Data. A Guide to the S Language . Springer (for = ).

assign (and its inverse get ), for “subassignment” such as x[i] <- v , see [<- ; further, environment .

Popular Tutorials

Popular examples, learn python interactively, r introduction.

• R Reserved Words
• R Variables and Constants

R Operators

• R Operator Precedence and Associativitys

R Flow Control

• R if…else Statement

R ifelse() Function

• R while Loop
• R break and next Statement
• R repeat loop
• R Functions
• R Return Value from Function
• R Environment and Scope
• R Recursive Function

R Infix Operator

• R switch() Function

R Data Structures

• R Data Frame

R Object & Class

• R Classes and Objects
• R Reference Class

R Graphs & Charts

• R Histograms
• R Pie Chart
• R Strip Chart

R Advanced Topics

• R Plot Function
• R Multiple Plots
• Saving a Plot in R
• R Plot Color

Related Topics

R Operator Precedence and Associativity

R Program to Add Two Vectors

In this article, you will learn about different R operators with the help of examples.

R has many operators to carry out different mathematical and logical operations. Operators perform tasks including arithmetic, logical and bitwise operations.

• Type of operators in R

Operators in R can mainly be classified into the following categories:

• Arithmetic Operators
• Relational Operators
• Logical Operators
• Assignment Operators
• R Arithmetic Operators

These operators are used to carry out mathematical operations like addition and multiplication. Here is a list of arithmetic operators available in R.

Let's look at an example illustrating the use of the above operators:

• R Relational Operators

Relational operators are used to compare between values. Here is a list of relational operators available in R.

Let's see an example for this:

• Operation on Vectors

The above mentioned operators work on vectors . The variables used above were in fact single element vectors.

We can use the function c() (as in concatenate) to make vectors in R.

All operations are carried out in element-wise fashion. Here is an example.

When there is a mismatch in length (number of elements) of operand vectors, the elements in the shorter one are recycled in a cyclic manner to match the length of the longer one.

R will issue a warning if the length of the longer vector is not an integral multiple of the shorter vector.

• R Logical Operators

Logical operators are used to carry out Boolean operations like AND , OR etc.

Operators & and | perform element-wise operation producing result having length of the longer operand.

But && and || examines only the first element of the operands resulting in a single length logical vector.

Zero is considered FALSE and non-zero numbers are taken as TRUE . Let's see an example for this:

• R Assignment Operators

These operators are used to assign values to variables.

The operators <- and = can be used, almost interchangeably, to assign to variables in the same environment.

The <<- operator is used for assigning to variables in the parent environments (more like global assignments). The rightward assignments, although available, are rarely used.

Check out these examples to learn more:

• Add Two Vectors
• Take Input From User
• R Multiplication Table

Table of Contents

• Introduction

Sorry about that.

R Tutorials

Programming

Blog of Ken W. Alger

Just another Tech Blog

Assignment Operators in R – Which One to Use and Where

Assignment Operators

R has five common assignment operators:

Many style guides and traditionalists prefer the left arrow operator, <- . Why use that when it’s an extra keystroke?  <- always means assignment. The equal sign is overloaded a bit taking on the roles of an assignment operator, function argument binding, or depending on the context, case statement.

Equal or “arrow” as an Assignment Operator?

In R, both the equal and arrow symbols work to assign values. Therefore, the following statements have the same effect of assigning a value on the right to the variable on the left:

There is also a right arrow, -> which assigns the value on the left, to a variable on the right:

All three assign the  value of forty-two to the  variable   x .

So what’s the difference? Are these assignment operators interchangeable? Mostly, yes. The difference comes into play, however, when working with functions.

The equal sign can also work as an operator for function parameters.

x <- 42 y <- 18 function(value = x-y)

History of the <- Operator

The S language also didn’t have == for equality testing, so that was left to the single equal sign. Therefore, variable assignment needed to be accomplished with a different symbol, and the arrow was chosen.

There are some differences of opinion as to which assignment operator to use when it comes to = vs <-. Some believe that = is more clear. The <- operator maintains backward compatibility with S.  Google’s R Style Guide recommends using the <- assignment operator, which seems to be a pretty decent reason as well. When all is said and done, though, it is like many things in programming, it depends on what your team does.

Share this:

• Click to share on Twitter (Opens in new window)
• Click to share on LinkedIn (Opens in new window)
• Click to email a link to a friend (Opens in new window)
• Click to print (Opens in new window)

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Notify me of follow-up comments by email.

Notify me of new posts by email.

This site uses Akismet to reduce spam. Learn how your comment data is processed .

Introduction

• R installation
• Working directory
• Getting help
• Install packages

Data structures

Data Wrangling

• Sort and order
• Merge data frames

Programming

• Creating functions
• If else statement
• apply function
• sapply function
• tapply function

Import & export

• Read TXT files
• Import CSV files
• Read Excel files
• Read SQL databases
• Export data
• plot function
• Scatter plot
• Density plot
• Tutorials Introduction Data wrangling Graphics Statistics See all

R operators

There are several operators in R, such that arithmetic operators for math calculations, logical, relational or assignment operators or even the popular pipe operator. In this tutorial we will show you the R operators divided into operator types. In addition, we will show examples of use of every operator.

Arithmetic operators

The R arithmetic operators allows us to do math operations , like sums, divisions or multiplications, among others. The following table summarizes all base R arithmetic operators.

In the next block of code you will find examples of basic calculations with arithmetic operations with integers.

You can also use the basic operations with R vectors of the same length . Note that the result of these operations will be a vector with element-wise operation results.

Furthermore, you can use those arithmetic operators with matrix objects, besides the ones designed for this type of object (matrix multiplication types). Check our tutorial about matrix operations to learn more.

Logical / boolean operators

In addition, boolean or logical operators in R are used to specify multiple conditions between objects. These comparisons return TRUE and FALSE values.

Relational / comparison operators in R

Comparison or relational operators are designed to compare objects and the output of these comparisons are of type boolean. To clarify, the following table summarizes the R relational operators.

For example, you can compare integer values with these operators as follows.

If you compare vectors the output will be other vector of the same length and each element will contain the boolean corresponding to the comparison of the corresponding elements (the first element of the first vector with the first element of the second vector and so on). Moreover, you can compare each element of a matrix against other.

Assignment operators in R

The assignment operators in R allows you to assign data to a named object in order to store the data .

Note that in almost scripting programming languages you can just use the equal (=) operator. However, in R it is recommended to use the arrow assignment ( <- ) and use the equal sign only to set arguments.

The arrow assignment can be used as left or right assignment, but the right assignment is not generally used. In addition, you can use the double arrow assignment, known as scoping assignment, but we won’t enter in more detail in this tutorial, as it is for advanced users. You can know more about this assignment operator in our post about functions in R .

In the following code block you will find some examples of these operators.

If you need to use the right assignment remember that the object you want to store needs to be at the left, or an error will arise.

There are some rules when naming variables. For instance, you can use letters, numbers, dots and underscores in the variable name, but underscores can’t be the first character of the variable name.

Reserved words

There are also reserved words you can’t use, like TRUE , FALSE , NULL , among others. You can see the full list of R reserved words typing help(Reserved) or ?Reserved .

However, if for some reason you need to name your variable with a reserved word or starting with an underscore you will need to use backticks:

Miscellaneous R operators

Miscellaneous operators in R are operators used for specific purposes , as accessing data, functions, creating sequences or specifying a formula of a model. To clarify, the next table contains all the available miscellaneous operators in R.

In addition, in the following block of code we show several examples of these operators:

Infix operator

You can call an operator as a function . This is known as infix operators. Note that this type of operators are not generally used or needed.

Pipe operator in R

The pipe operator is an operator you can find in several libraries, like dplyr . The operator can be read as ‘AND THEN’ and its purpose is to simplify the syntax when writing R code. As an example, you could subset the cars dataset and then create a summary of the subset with the following code:

Explore and discover thousands of packages, functions and datasets

Learn how to plot your data in R with the base package and ggplot2

PYTHON CHARTS

Learn how to create plots in Python with matplotlib, seaborn, plotly and folium

Related content

Convert objects to numeric with as.numeric()

Introduction to R

Use the as.numeric function in R to coerce objects to numeric and learn how to check if an object is numeric with is.numeric

Obtain HELP in R of PACKAGES and FUNCTIONS ✅ Download FREE R BOOKS and MANUALS, view DEMOS, EXAMPLES, R vignettes, datasets info and find ONLINE resources

head and tail functions in R

R introduction

The head and tail functions in R are useful to show the first or last elements or rows of an R object

Try adjusting your search query

👉 If you haven’t found what you’re looking for, consider clicking the checkbox to activate the extended search on R CHARTS for additional graphs tutorials, try searching a synonym of your query if possible (e.g., ‘bar plot’ -> ‘bar chart’), search for a more generic query or if you are searching for a specific function activate the functions search or use the functions search bar .

assignOps: Assignment Operators

Assignment Operators

Description.

Assign a value to a name.

There are three different assignment operators: two of them have leftwards and rightwards forms.

The operators <- and = assign into the environment in which they are evaluated. The operator <- can be used anywhere, whereas the operator = is only allowed at the top level (e.g., in the complete expression typed at the command prompt) or as one of the subexpressions in a braced list of expressions.

The operators <<- and ->> are normally only used in functions, and cause a search to be made through parent environments for an existing definition of the variable being assigned. If such a variable is found (and its binding is not locked) then its value is redefined, otherwise assignment takes place in the global environment. Note that their semantics differ from that in the S language, but are useful in conjunction with the scoping rules of R . See ‘The R Language Definition’ manual for further details and examples.

In all the assignment operator expressions, x can be a name or an expression defining a part of an object to be replaced (e.g., z[[1]] ). A syntactic name does not need to be quoted, though it can be (preferably by backticks).

The leftwards forms of assignment <- = <<- group right to left, the other from left to right.

value . Thus one can use a <- b <- c <- 6 .

Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) The New S Language . Wadsworth & Brooks/Cole.

Chambers, J. M. (1998) Programming with Data. A Guide to the S Language . Springer (for = ).

assign (and its inverse get ), for “subassignment” such as x[i] <- v , see [<- ; further, environment .

R Package Documentation

Browse r packages, we want your feedback.

Add the following code to your website.

REMOVE THIS Copy to clipboard

For more information on customizing the embed code, read Embedding Snippets .

Assignment Operators in R

R provides two operators for assignment: <- and = .

Understanding their proper use is crucial for writing clear and readable R code.

Using the <- Operator

For assignments.

The <- operator is the preferred choice for assigning values to variables in R.

It clearly distinguishes assignment from argument specification in function calls.

Readability and Tradition

• This usage aligns with R’s tradition and enhances code readability.

Using the = Operator

The = operator is commonly used to explicitly specify named arguments in function calls.

It helps in distinguishing argument assignment from variable assignment.

Assignment Capability

• While = can also be used for assignment, this practice is less common and not recommended for clarity.

Mixing Up Operators

Potential confusion.

Using = for general assignments can lead to confusion, especially when reading or debugging code.

Mixing operators inconsistently can obscure the distinction between assignment and function argument specification.

• In the example above, x = 10 might be mistaken for a function argument rather than an assignment.

Best Practices Recap

Consistency and clarity.

Use <- for variable assignments to maintain consistency and clarity.

Reserve = for specifying named arguments in function calls.

Avoiding Common Mistakes

Be mindful of the context in which you use each operator to prevent misunderstandings.

Consistently using the operators as recommended helps make your code more readable and maintainable.

Quiz: Assignment Operator Best Practices

Which of the following examples demonstrates the recommended use of assignment operators in R?

• my_var = 5; mean(x = my_var)
• my_var <- 5; mean(x <- my_var)
• my_var <- 5; mean(x = my_var)
• my_var = 5; mean(x <- my_var)
• The correct answer is 3 . my_var <- 5; mean(x = my_var) correctly uses <- for variable assignment and = for specifying a named argument in a function call.

Operators are used in R to perform various operations on variables and values. Among the most commonly used ones are arithmetic and assignment operators.

The following R code uses an arithmetic operator for multiplication, * , to calculate the product of two numbers, along with the assignment operator, <- to store the result in the variable x .

Operators in R can be organized into the following groups:

• Arithmetic operators for traditional mathematical evaluations such as addition and subtraction.
• Assignment operators for assigning values to variables.
• Comparison operators for testing equality between values.
• Logical operators for evaluating the “truthiness” of values against one another.
• Miscellaneous operators for various tasks including vectors and sequencing.

Arithmetic operators

R supports the following arithmetic operators:

• Addition, + , which returns the sum of two numbers.
• Subtraction, - , which returns the difference between two numbers.
• Multiplication, * , which returns the product of two numbers.
• Division, / , which returns the quotient of two numbers.
• Exponents, ^ , which returns the value of one number raised to the power of another.
• Modulus, %% , which returns the remainder of one number divided by another.
• Integer Division, %/% , which returns the integer quotient of two numbers.

Assignment operators

R uses the following assignment operators:

• <- assigns a value to a variable from right to left.
• -> assigns a value to a variable left to right.
• <<- is a global version of <- .
• ->> is a global version of -> .
• = works the same way as <- , but its use is discouraged.

Comparison operators

R has the following comparison operators:

• Equal, == , which returns TRUE if two values are equal.
• Not equal, != , which returns TRUE if two values are not equal.
• Less than, < , which returns TRUE if left value is less than right value.
• Less than or equal to, <= , which returns TRUE if left value is less than or equal to right value.
• Greater than, > , which returns TRUE if left value is greater than right value.
• Greater than or equal to, >= , which returns TRUE if left value is greater than or equal to right value.

Logical operators

R has the following logical operators:

• Element-wise AND, & , for comparing each element and returning TRUE if both elements are TRUE .
• Logical AND, && , which returns TRUE if both values are TRUE , only evaluates as many elements as necessary.
• Element-wise OR, | , for comparing each element and returning TRUE if either element is TRUE .
• Logical OR, || , which returns TRUE if either value is TRUE , only evaluates as many elements as necessary.
• Logical NOT, ! , which returns TRUE if the associated statement is FALSE .

Note: The long form of AND and OR ( && and || ) are preferred for if statements as the short form can produce a vector value.

Miscellaneous operators

R uses the following miscellaneous operators:

• The : operator creates a sequence of numbers from the left argument to the right one.
• The %in% operator returns TRUE if the left argument is in the vector to the right.
• The %*% operator performs matrix multiplication on two matrices.

All contributors

• StevenSwiniarski

Looking to contribute?

• Learn more about how to get involved.
• Edit this page on GitHub to fix an error or make an improvement.
• Submit feedback to let us know how we can improve Docs.

Learn R on Codecademy

Computer science.

UC Business Analytics R Programming Guide

Assignment & evaluation.

The first operator you’ll run into is the assignment operator. The assignment operator is used to assign a value. For instance we can assign the value 3 to the variable x using the <- assignment operator. We can then evaluate the variable by simply typing x at the command line which will return the value of x . Note that prior to the value returned you’ll see ## [1] in the command line. This simply implies that the output returned is the first output. Note that you can type any comments in your code by preceding the comment with the hashtag ( # ) symbol. Any values, symbols, and texts following # will not be evaluated.

Interestingly, R actually allows for five assignment operators:

The original assignment operator in R was <- and has continued to be the preferred among R users. The = assignment operator was added in 2001 primarily because it is the accepted assignment operator in many other languages and beginners to R coming from other languages were so prone to use it. However, R uses = to associate function arguments with values (i.e. f(x = 3) explicitly means to call function f and set the argument x to 3. Consequently, most R programmers prefer to keep = reserved for argument association and use <- for assignment.

The operators <<- is normally only used in functions which we will not get into the details. And the rightward assignment operators perform the same as their leftward counterparts, they just assign the value in an opposite direction.

Overwhelmed yet? Don’t be. This is just meant to show you that there are options and you will likely come across them sooner or later. My suggestion is to stick with the tried and true <- operator. This is the most conventional assignment operator used and is what you will find in all the base R source code…which means it should be good enough for you.

Lastly, note that R is a case sensitive programming language. Meaning all variables, functions, and objects must be called by their exact spelling:

R Data Structures

R statistics, r operators.

Operators are used to perform operations on variables and values.

In the example below, we use the + operator to add together two values:

R divides the operators in the following groups:

• Arithmetic operators
• Assignment operators
• Comparison operators
• Logical operators
• Miscellaneous operators

R Arithmetic Operators

Arithmetic operators are used with numeric values to perform common mathematical operations:

R Assignment Operators

Assignment operators are used to assign values to variables:

Note: <<- is a global assigner. You will learn more about this in the Global Variable chapter .

It is also possible to turn the direction of the assignment operator.

x <- 3 is equal to 3 -> x

Advertisement

R Comparison Operators

Comparison operators are used to compare two values:

R Logical Operators

Logical operators are used to combine conditional statements:

R Miscellaneous Operators

Miscellaneous operators are used to manipulate data:

Note: You will learn more about Matrix multiplication and matrices in a later chapter.

COLOR PICKER

Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail: [email protected]

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail: [email protected]

Top Tutorials

Top references, top examples, get certified.

• TutorialKart
• SAP Tutorials
• Salesforce Admin
• Salesforce Developer
• Visualforce
• Informatica
• Kafka Tutorial
• Spark Tutorial
• Tomcat Tutorial
• Python Tkinter

Programming

• Bash Script
• Julia Tutorial
• CouchDB Tutorial
• MongoDB Tutorial
• PostgreSQL Tutorial
• Android Compose
• Flutter Tutorial
• Kotlin Android

Web & Server

• Selenium Java
• R Tutorials
• R Script File
• R Working Directory
• R Data Types
• R Variables

R Operators

• R if statement
• R if-else statement
• ADVERTISEMENT
• R if-else-if statement
• R switch statement
• R repeat loop
• R while loop
• R break statement
• R Functions
• R – Concatenate strings
• R – String length
• R – Substring
• R – Convert string to uppercase
• R – Convert string to lowercase
• Create Vectors
• R – Create Vector
• R – Logical Vectors
• R – Integer Vectors
• R – Double Vectors
• R – Character Vectors
• Access Vectors
• R – Vector length
• R – Access items in Vector
• R – Iterate over items of Vector
• R – Delete items at specific indices from Vector
• R – Sort Vector
• Vector Operations
• R – Vector Arithmetic Operations
• R – Get Type of Vector
• R – Reverse Vector
• R – Vector Recycling
• Vector Checks
• R – Check if specific item is present in Vector
• R – Check if type of Vector is Logical
• R – Check if type of Vector is Integer
• R – Check if type of Vector is Double
• R – Check if type of Vector is Character
• Conversions
• R – Convert Logical Vector into Integer Vector
• R – Convert Character Vector into Integer Vector
• List Basics
• R – Create empty List
• R – Create empty List of specific length
• R – Create List
• R – Name elements of List
• R – Access elements of List
• R – List length
• R – Append item to List
• R – Loop through items in List
• List Transformations
• R – Reverse List
• List Checks
• R – Check if List is empty
• R – Check if specific item is present in List
• One or More Lists
• R – Join Lists
• List Conversions
• R – Convert List to Vector
• R – Convert List to Data Frame
• R – Create Matrix
• R – Check if R object is a Matrix
• R – Get element at given row, column of Matrix
• R – Get specific row of Matrix
• R – Get specific column of Matrix
• R – Get multiple rows of Matrix
• R – Get multiple columns of Matrix
• R – Matrix multiplication
• R – Transpose Matrix
• R – Inverse Matrix
• R – Correlation Matrix
• Create Data Frame
• R – Create empty Data Frame
• R – Create Data Frame
• Read Elements / Rows / Columns
• R – Access element at (i,j) in Data Frame
• Rows / Columns
• R – Get number of rows in Data Frame
• R – Get number of columns in Data Frame
• R – Add row to Data Frame
• R – Add column to Data Frame
• R – Remove row(s) in Data Frame
• R – Delete duplicate rows in Data Frame
• R – Remove NA Rows in Data Frame
• R – Delete column(s) in Data Frame
• R – Reset row numbers of Data Frame
• R – Replace NA with 0 in Data Frame
• R – Rename column(s) of Data Frame
• R – Sort Data Frame by column
• R – Filter Data Frame with NA rows
• R – Convert Data Frame to Matrix
• R – Convert Matrix to Data Frame
• Transformations
• R – Apply function for each row in Data Frame
• Two or More Data Frames
• R – Combine Data Frames
• R – Compare Data Frames
• Import / Export
• R – Import Excel to Data Frame
• R – Structure of Data Frame
• R – Summary of Data Frame
• R Date and Time
• ❯ R Tutorial
• ❯ R Operators

R Operators – Arithmetic, Relational, Logical, Assignment

R Tutorial – We shall learn about R Operators – Arithmetic, Relational, Logical, Assignment and some of the Miscellaneous Operators that R programming language provides.

There are four main categories of Operators in R programming language. They are shown in the following picture :

We shall learn about these operators in detail with Example R programs.

R Arithmetic Operators

Arithmetic Operators are used to accomplish arithmetic operations. They can be operated on the basic data types Numericals, Integers, Complex Numbers. Vectors with these basic data types can also participate in arithmetic operations, during which the operation is performed on one to one element basis.

An example for each of the arithmetic operator on Numerical values is provided below.

r_op_arithmetic.R

An example for each of the arithmetic operator on Vectors is provided below.

r_op_arithmetic_vector.R

R Relational Operators

Relational Operators are those that find out relation between the two operands provided to them. Following are the six relational operations R programming language supports.The output is boolean (TRUE or FALSE) for all of the Relational Operators in R programming language.

An example for each of the relational operator on Numberical values is provided below.

r_op_relational.R

An example for each of the relational operator on Vectors is provided below.

r_op_relational_vector.R

R Logical Operators

Logical Operators in R programming language work only for the basic data types logical, numeric and complex and vectors of these basic data types.

An example for each of the logical operators on Numerical values is provided below.

r_op_logical.R 

An example for each of the logical operators on Vectors is provided below.

r_op_logical_vector.R

R Assignment Operators

Assignment Operators are those that help in assigning a value to the variable.

An example for each of the assignment operators is provided below.

r_op_assignment.R

R Miscellaneous Operators

These operators does not fall into any of the categories mentioned above, but are significantly important during R programming for manipulating data.

An example for each of the Miscellaneous operators is provided below.

r_op_misc.R

In this  R Tutorial , we have learnt about R Operators – R Arithmetic Operators, R Relational Operators, R Logical Operators, R Assignment Operators, R Miscellaneous Operators with example R commands and R script files.

Popular Courses by TutorialKart

App developement, web development, online tools.

R news and tutorials contributed by hundreds of R bloggers

Difference between assignment operators in r.

Posted on January 27, 2014 by Kun Ren in R bloggers | 0 Comments

[social4i size="small" align="align-left"] --> [This article was first published on The blog of Kun Ren , and kindly contributed to R-bloggers ]. (You can report issue about the content on this page here ) Want to share your content on R-bloggers? click here if you have a blog, or here if you don't.

For R beginners, the first operator they use is probably the assignment operator <- . Google's R Style Guide suggests the usage of <- rather than = even though the equal sign is also allowed in R to do exactly the same thing when we assign a value to a variable. However, you might feel inconvenient because you need to type two characters to represent one symbol, which is different from many other programming languages.

As a result, many users ask Why we should use <- as the assignment operator?

Here I provide a simple explanation to the subtle difference between <- and = in R.

First, let's look at an example.

The above code uses both <- and = symbols, but the work they do are different. <- in the first two lines are used as assignment operator while = in the third line does not serves as assignment operator but an operator that specifies a named parameter formula for lm function.

In other words, <- evaluates the the expression on its right side ( rnorm(100) ) and assign the evaluated value to the symbol (variable) on the left side ( x ) in the current environment. = evaluates the expression on its right side ( y~x ) and set the evaluated value to the parameter of the name specified on the left side ( formula ) for a certain function.

We know that <- and = are perfectly equivalent when they are used as assignment operators.

Therefore, the above code is equivalent to the following code:

Here, we only use = but for two different purposes: in the first and second lines we use = as assignment operator and in the third line we use = as a specifier of named parameter.

Now let's see what happens if we change all = symbols to <- .

If you run this code, you will find that the output are similar. But if you inspect the environment, you will observe the difference: a new variable formula is defined in the environment whose value is y~x . So what happens?

Actually, in the third line, two things happened: First, we introduce a new symbol (variable) formula to the environment and assign it a formula-typed value y~x . Then, the value of formula is provided to the first paramter of function lm rather than, accurately speaking, to the parameter named formula , although this time they mean the identical parameter of the function.

To test it, we conduct an experiment. This time we first prepare the data.

Basically, we just did similar things as before except that we store all vectors in a data frame and clear those numeric vectors from the environment. We know that lm function accepts a data frame as the data source when a formula is specified.

Standard usage:

Working alternative where two named parameters are reordered:

Working alternative with side effects that two new variable are defined:

Nonworking example:

The reason is exactly what I mentioned previously. We reassign data to data and give its value to the first argument ( formula ) of lm which only accepts a formula-typed value. We also try to assign z~x+y to a new variable formula and give it to the second argument ( data ) of lm which only accepts a data frame-typed value. Both types of the parameter we provide to lm are wrong, so we receive the message:

From the above examples and experiments, the bottom line gets clear: to reduce ambiguity, we should use either <- or = as assignment operator, and only use = as named-parameter specifier for functions.

In conclusion, for better readability of R code, I suggest that we only use <- for assignment and = for specifying named parameters.

To leave a comment for the author, please follow the link and comment on their blog: The blog of Kun Ren . R-bloggers.com offers daily e-mail updates about R news and tutorials about learning R and many other topics. Click here if you're looking to post or find an R/data-science job . Want to share your content on R-bloggers? click here if you have a blog, or here if you don't.

Copyright © 2022 | MH Corporate basic by MH Themes

Never miss an update! Subscribe to R-bloggers to receive e-mails with the latest R posts. (You will not see this message again.)

• Data Visualization
• Statistics in R
• Machine Learning in R
• Data Science in R
• Packages in R

What are the Differences Between “=” and “<-" Assignment Operators in R?

In programming, assignment operators are essential tools for storing values in variables. In R, a statistical computing language, both “=” and “<-” are used as assignment operators, but they are not the same. Understanding their differences can enhance your coding practice and improve your code’s readability and functionality.

Basic Understanding of Assignment Operators in R

In R Programming Language assignment operators are used to assign values to variables. The two primary operators for this purpose are “=” and “<-“. While they can often be used interchangeably, subtle differences are important to understand.

The “=” Operator

The “=” operator is commonly used for assignments within function calls. It is more intuitive for those coming from other programming languages like C, Java, or Python.

Here, the variable x is assigned the value 10 using the “=” operator.

The “<-” Operator

The “<-” operator is the traditional assignment operator in R. It is specifically designed for assignment operations and is considered a best practice by many R programmers for regular variable assignments.

In this example, the variable y is assigned the value 20 using the “<-” operator.

Key Differences Between “=” and “<-” Assignment Operators

While both operators perform the basic function of assigning values to variables, they have different implications and best-use scenarios.

Best Practices

To ensure clarity and avoid potential issues, it is recommended to follow these best practices:

• Use “<-” for Variable Assignments: Stick to “<-” for general variable assignments to align with R community conventions and enhance code readability.
• Use “=” within Function Calls: Use “=” when specifying arguments within function calls to differentiate between parameter setting and general variable assignment.
• Consistency: Be consistent in your use of assignment operators throughout your code to maintain clarity and reduce the likelihood of errors.

Both “=” and “<-” are valid assignment operators in R, but they serve slightly different purposes and contexts. The “=” operator is typically used within function calls, while the “<-” operator is preferred for general assignments. Understanding these differences can help you write cleaner, more readable, and less error-prone R code.

Please Login to comment...

Similar reads, improve your coding skills with practice.

What kind of Experience do you want to share?

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

R assignment operators

I was checking R assignment operators and trying to understand how they work, so I wrote the following code:

Up to the line, where somevar9 is being used, everything seems in line with expectations. However, I don't get why I'm getting the errors like Error in -> ("stuff9", somevar9) : could not find function "->" and Error in ->> ("stuff11", somevar11) : could not find function "->>" . Should they not exist for the -> and ->> operators to work? Thanks in advance!

• 2 I think when the R parser comes across a -> b it calls '<-'("b", a) and when it comes across a ->> b it calls '<<-'("b", a) . –  Allan Cameron Commented Jan 27, 2022 at 14:03
• Yeah, I am not an expert so won't answer, but backing up what @Allan Cameron put, you can see the existence of these functions by typing <- and <<- and the opposite trying -> ->> . –  caldwellst Commented Jan 27, 2022 at 14:05
• 1 Colin Fay 's article provides some interesting follow-up questions about legacy operators := and _ . For example, %% -less infix operators are possible. Also worth to have a look at their precedence –  Donald Seinen Commented Jan 27, 2022 at 14:50
• x = y <- 15 - I did not know you could do this! Thanks a lot for sharing the article @DonaldSeinen! –  abudis Commented Jan 27, 2022 at 14:57

When the R parser comes across a -> b it calls '<-'("b", a) and when it comes across a ->> b it calls '<<-'("b", a)

We can see this explicitly if we do the following:

Created on 2022-01-27 by the reprex package (v2.0.1)

• Nice thanks! Makes sense. I think the expr function is a part of rlang package, so I checked it with bquote like this: as.call(bquote(a ->> 1)) –  abudis Commented Jan 27, 2022 at 14:09
• 1 @abudis you're right. I've changed it to base R's quote –  Allan Cameron Commented Jan 27, 2022 at 14:12

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged r or ask your own question .

• Featured on Meta
• We've made changes to our Terms of Service & Privacy Policy - July 2024
• Bringing clarity to status tag usage on meta sites
• Feedback requested: How do you use tag hover descriptions for curating and do...

Hot Network Questions

• What's the airplane with the smallest ratio of wingspan to fuselage width?
• Who is affected by Obscured areas?
• Implications of the statement: "Note that it is very difficult to remove Rosetta 2 once it is installed"
• Extrude Individual Faces function is not working
• How can I prove both series are equal?
• Can science inform philosophy?
• Venus’ LIP period starts today, can we save the Venusians?
• Sci-fi book with a part-human, part-machine protagonist who lives for centuries to witness robots gain sentience and wage war on humans
• Unexpected behaviour during implicit conversion in C
• In compound nouns is there a way to distinguish which is the subject or the object?
• Assign variable a value and copy this value to the clipboard
• Löb’s paradox in first-order logic
• If I purchase a house through an installment sale, can I use it as collateral for a loan?
• shell script to match a function in a file and replace it with another function in another file
• Definition of the electric field
• Has technology regressed in the Alien universe?
• Finding a Linear Algebra reading topic
• Giant War-Marbles of Doom: What's the Biggest possible Spherical Vehicle we could Build?
• Can I travel with regional trains from operators other than DB if I can "use any train" due to a schedule change?
• Short story or novella where a man's wife dies and is brought back to life. The process is called rekindling. Rekindled people are very different
• Genus 0 curves on surfaces and the abc conjecture
• How can I cover all my skin (face+neck+body) while swimming outside (sea or outdoor pool) to avoid UV radiations?
• chess game: loading images for the rooks
• Joined Progression (all possible ones)