assignment of variable in r

assign: Assign a Value to a Name

Description.

Assign a value to a name in an environment.

a variable name, given as a character string. No coercion is done, and the first element of a character vector of length greater than one will be used, with a warning.

a value to be assigned to x .

where to do the assignment. By default, assigns into the current environment. See ‘Details’ for other possibilities.

the environment to use. See ‘Details’.

should the enclosing frames of the environment be inspected?

an ignored compatibility feature.

This function is invoked for its side effect, which is assigning value to the variable x . If no envir is specified, then the assignment takes place in the currently active environment.

If inherits is TRUE , enclosing environments of the supplied environment are searched until the variable x is encountered. The value is then assigned in the environment in which the variable is encountered (provided that the binding is not locked: see lockBinding : if it is, an error is signaled). If the symbol is not encountered then assignment takes place in the user's workspace (the global environment).

If inherits is FALSE , assignment takes place in the initial frame of envir , unless an existing binding is locked or there is no existing binding and the environment is locked (when an error is signaled).

There are no restrictions on the name given as x : it can be a non-syntactic name (see make.names ).

The pos argument can specify the environment in which to assign the object in any of several ways: as -1 (the default), as a positive integer (the position in the search list); as the character string name of an element in the search list; or as an environment (including using sys.frame to access the currently active function calls). The envir argument is an alternative way to specify an environment, but is primarily for back compatibility.

assign does not dispatch assignment methods, so it cannot be used to set elements of vectors, names, attributes, etc.

Note that assignment to an attached list or data frame changes the attached copy and not the original object: see attach and with .

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

<- , get , the inverse of assign() , exists , environment .

Run the code above in your browser using DataLab

ProgrammingR

Beginner to advanced resources for the R programming language

• Search for:

Assign in r – How to use R’s assign function to assign values to a variable name

Sometimes in programming, it is helpful to have alternative ways of doing things. Not only can this provide for some variety in your code, but sometimes it can also make it more readable. It turns out that the R programming language has three separate ways to assign values to a variable. Knowing all three will help you to be able to read any R program that you find.

Description

R programming has three ways of assigning values to a variable. They are =, <-, and the assign function. The assign function has the basic format of assign(“variable”, value) where “variable” is the name of the variable receiving the values, note that it needs to be in quotes, and “value” is the value being assigned to that variable. While under most circumstances they work the same, they do have differences. The assign function has the advantage that it will show up in a text search of the program when you are looking for assign, while the two operators will not show up in such a search. In practice it differs little from the assign operators of = and <-, but it does resemble similar functions from other languages.

Explanation

The assign function has two required arguments, two are optional arguments you are likely to use, and two arguments that exist to maintain compatibility. The two required arguments are the variable and the value being assigned to it. The two optional arguments are the “pos” which indicates the environment the object is assigned to and ‘inherits” is a Boolean that indicates whether or not to restrict the object to the current environment. The two compatibility arguments are “envir” which selects the environment of the object and “immediate” which is unused and exists only for compatibility reasons. The assign function takes the variable name and assigns the indicated value to it within the specified environmental conditions. These arguments give the assign function more flexibility than the assign operators, making it a particularly useful function under the right conditions.

Here we have four code examples that show different situations where the assign function is being used. It needs to be noted that this function can be used with any values that the assign operators can use.

> assign(“x”, 17) > x [1] 17

In this example, we illustrate the most basic use of the assign function. In this case, we are simply assigning a value to a single variable.

> assign(“x”, c(“a”, “b”, “c”, “d”, “e”, “f”, “g”)) > x [1] “a” “b” “c” “d” “e” “f” “g”

In this example, we illustrate the creation of a vector using the combine function.

> assign(“x”, c(“a”, “b”, “c”, “d”, “e”, “f”, “g”)) > assign(“y”, 1:7) > assign(“df”, data.frame(x,y)) > df x y 1 a 1 2 b 2 3 c 3 4 d 4 5 e 5 6 f 6 7 g 7

In this example, we illustrate the creation of a data frame using the data frame function in its simplest form. It is easy to see how using this function to create more complex data frames could become problematic and rather cumbersome.

> for(i in 1:5) { + assign(paste0(“x_”, i), i) + } > x_1 [1] 1 > x_2 [1] 2 > x_3 [1] 3 > x_4 [1] 4 > x_5 [1] 5

In this example, we illustrate how to use the assign function along with the paste0 function to create multiple variables with different values.

Application

The main application of the assign function is to assign values to variables. However, this function has additional arguments that give it increased environmental flexibility, allowing you to control whether or not the object that you are creating is restricted to a particular environment. This makes the assign function more powerful in some ways than the assign operators . As a result, an important application of this function is to be able to assign values to variables under circumstances where the program needs to decide on the fly the environmental limitations of the object being created. If you need this flexibility, that is the time to use the assign function. The other situation where this function comes in handy would be if you were creating code that is designed to be as searchable as possible because the word “assign” is a search term that someone is likely to use.

The assign function may at first glance seem redundant, but its additional arguments give it added flexibility over the assign operators. As a result, this function can actually be a useful tool. This flexibility makes it a powerful tool that you will probably find more useful as you get more experience with it.

Creating new variables

Use the assignment operator <- to create new variables. A wide array of operators and functions are available here.

(To practice working with variables in R, try the first chapter of this free interactive course .)

Recoding variables

In order to recode data, you will probably use one or more of R's control structures .

Renaming variables

You can rename variables programmatically or interactively.

Variable types in R

R supports a diverse range of variable types, each tailored to handle specific data forms:

• Numeric: These represent numbers and can be either whole numbers or decimals.
• Character: This type is for textual data or strings.
• Logical: These are binary and can take on values of TRUE or FALSE.
• Factor: Ideal for categorical data, factors can help in representing distinct categories within a dataset.
• Date: As the name suggests, this type is used for date values.

When creating new variables, it's essential to ensure they are of the appropriate type for your analysis. If unsure, you can use the class() function to check a variable's type.

Checking and changing variable types

Ensuring your variables are of the correct type is crucial for accurate analysis:

• Checking Variable Type: The class() function can help you determine the type of a variable.
• Changing Variable Type: If you need to convert a variable from one type to another, R provides functions like as.numeric(), as.character(), and as.logical().

Variable scope

Understanding the scope of a variable is essential:

• Global Variables: These are accessible throughout your entire script or session.
• Local Variables: These are confined to the function or environment they are created in and can't be accessed outside of it. When creating new variables, especially within functions, always be mindful of their scope to avoid unexpected behaviors.

Using variables with functions

Variables play a central role when working with functions:

• Passing Variables: You can provide variables as arguments to functions, allowing for dynamic computations based on variable values.
• Storing Function Outputs: Functions can return values, and you can assign these values to new or existing variables for further analysis.

Variable operations

Depending on their type, you can perform various operations on variables:

• Arithmetic Operations: For numeric variables, you can carry out standard mathematical operations like addition, subtraction, multiplication, and division.
• String Operations: For character variables, operations like concatenation allow you to combine multiple strings into one.

Recoding involves changing the values of a variable based on certain conditions. For instance, you might want to group ages into categories like "young", "middle-aged", and "senior". R offers various control structures to facilitate this process. When recoding, always ensure that the new categories or values make logical sense and serve the purpose of your analysis.

There might be instances where you'd want to rename variables for clarity or consistency. R provides two primary ways to rename variables:

• Interactively: You can use the fix() function to open a data editor where you can rename variables directly.
• Programmatically: There are various packages and functions in R that allow you to rename variables within your script. When renaming, ensure that the new names are descriptive and adhere to R's variable naming conventions.

Frequently Asked Questions (FAQs) about Variables in R

A: Both <- and = can be used for assignment in R. However, <- is the more traditional and preferred method, especially in scripts and functions. The = operator is often used within function calls to specify named arguments.

A: You can use the class() function to determine the type or class of a variable. This function will return values like "numeric", "character", "factor", and so on, depending on the variable's type.

A: R provides type conversion functions like as.numeric(), as.character(), and as.logical(). You can use these functions to convert a variable to the desired type.

A: Recoding refers to the process of changing or transforming the values of a variable based on certain criteria. For instance, converting a continuous age variable into age categories (e.g., "young", "middle-aged", "senior") is an example of recoding.

A: R offers multiple ways to rename variables. You can do it interactively using the fix() function, which opens a data editor. Alternatively, there are various R packages and functions that allow for programmatic renaming of variables.

A: Yes, variable names in R are case-sensitive. This means that myVariable, MyVariable, and myvariable would be treated as three distinct variables.

A: It's not recommended to use spaces in variable names in R. Instead, you can use underscores (_) or periods (.) to separate words in variable names, like my_variable or my.variable.

A: You can use the rm() function followed by the variable name to remove it from your workspace. It's a good practice to clear unnecessary variables to free up memory.

A: Local variables are confined to the function or environment they are created in and can't be accessed outside of it. In contrast, global variables are accessible throughout your entire script or R session.

A: You can use the ls() function to list all the variables currently present in your workspace.

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.

Variable Assignment in R

In R we operate with variables. A variable can be seen as a container for a value. To get a better conceptual understanding of this, you can go through the following and code-along in your own R -session.

Assigning a Value to a Variable

• In R , we state values directly in the chunk or the console, e.g.:

Here, we just state 3 , so R simply “throws” that right back at you!

Now, if want to “catch” that 3 we have to assign it to a variable, e.g.:

• Notice how now we “catch” the 3 and nothing is “thrown” back to you, because we now have the 3 stored in x :

Updating the Value of a Variable

• Now, we can of course use x moving forward, e.g. by adding 2 :
• Notice how this does not change x and the result is simply “thrown” right-back-at-ya
• If we wanted to update x by adding 2 , we would have to “catch” the result as before:
• Now, we have updated x :

Use one Variable in the Creation of Another

• Analogue, we can create a new variable using x:
• Again, this does not change x
• But rather the result is now stored in y
• In R , we use the assignment operator <- to perform assignment
• Variables are not change in place, but needs to be stored
• Note, this also applies to running e.g. a dplyr -pipeline, where we do not change the dataset by running the pipeline, but we must store the result of the pipeline

Before continuing, make sure that you are on track with the above concepts!

• Create a new variable my_age containing… You guessed it!
• Add 0.5 to the variable (I.e. your age, when you’re done with this course)
• Check the value of my_age , did you remember to assign, thereby updating?

Pipeline Example

• Let us create some example sequence data:
• Notice, that our data creation is just “thrown” back at us, we forgot something!
• Now, we have stored the data in the variable my_dna_data

Note here, that a variable can as we saw before with x and y store a single value, e.g.  2 , but here, we are storing a tibble -object in the variable my_dna_data and in that tibble -object, we have a variable sequence , which contains some randomly generated dna.

But what if we wanted to add a new variable to the tibble -object, which is the lenght of each of the dna-sequences?

Nice! Let’s see that data again then:

Wait! What? Where is the variable we literally just created?

We forgot something… We did not update the my_dna_data , let’s fix that:

• Note, nothing is “trown” back at us! Let’s verify, that we did indeed update the my_dna_data :

Did it make sense? Check yourself, add a new variable to my_dna_data called sequence_capital by using the function str_to_upper()

That’s it - Hope it helped and remember… Bio data science in R is really fun!

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 .

R Data Structures

R statistics, r variables, creating variables in r.

Variables are containers for storing data values.

R does not have a command for declaring a variable. A variable is created the moment you first assign a value to it. To assign a value to a variable, use the <- sign. To output (or print) the variable value, just type the variable name:

From the example above, name and age are variables , while "John" and 40 are values .

In other programming language, it is common to use = as an assignment operator. In R, we can use both = and <- as assignment operators.

However, <- is preferred in most cases because the = operator can be forbidden in some context in R.

Character variables can be declared by either using single or double quotes:

Print / Output Variables

Compared to many other programming languages, you do not have to use a function to print/output variables in R. You can just type the name of the variable:

However, R does have a print() function available if you want to use it. This might be useful if you are familiar with other programming languages, such as Python , which often use a print() function to output variables.

And there are times you must use the print() function to output code, for example when working with for loops (which you will learn more about in a later chapter):

Conclusion: It is up to your if you want to use the print() function or not to output code. However, when your code is inside an R expression (for example inside curly braces {} like in the example above), use the print() function if you want to output the result.

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.

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

assign Function in R (2 Examples)

In this tutorial, I’ll illustrate how to assign values to a variable name using the assign() function in R .

Table of contents:

Sound good? Great, here’s how to do it…

Definition & Basic R Syntax of assign Function

Definition: The assign R function assigns values to a variable name.

Basic R Syntax: Please find the basic R programming syntax of the assign function below.

In the remaining article, I’ll show you two examples for the application of the assign function in the R programming language.

Example 1: Using assign Function to Create New Vector

In Example 1, I’ll show how to use the assign() command to assign numeric values to a new vector object.

Within the assign function, we have to specify the name of the new vector (i.e. “x”) and the values we want to store in this vector object (i.e. five numeric values ranging from 1 to 5):

Let’s have a look at our new data object x:

As you can see based on the previous output of the RStudio console, we have saved a numeric sequence from 1 to 5 in a new variable called x.

Example 2: Using assign & paste0 Functions Dynamically in for-Loop

In Example 2, I’ll show how to use the assign function in combination with the paste0 function to create new variable names within a for-loop dynamically.

Within the assign function, we are using paste0 to create new variable names combining the prefix “x_” with the running index i:

Let’s have a look at the output variables:

Video, Further Resources & Summary

Have a look at the following video of my YouTube channel. I explain the contents of this article in the video:

The YouTube video will be added soon.

In addition, you might have a look at the related tutorials on this homepage .

• for-Loop in R
• paste & paste0 R Functions
• R Functions List (+ Examples)
• The R Programming Language

In this R tutorial you learned how to create new data objects using assign() . In case you have further questions, let me know in the comments section.

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 .

2 Comments . Leave new

You are very welcome Hong!

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

Force R to Show Scientific Notation (2 Examples)

Apply Function to Each List Element in R (3 Examples)

How to Use the assign() Function in R

• Apr 23, 2024

The assign() function is used to assign value to variable in R.

The following method in R shows how you can do it with syntax.

Method: Use assign() Function

The following examples shows how to use assign() function in R.

Use assign() Function to Single Variable

Let’s see how we can use assign value to variable using assign() function:

The output shows value 52 assign to var1 variable.

Use assign() Function to Vector

Using assign() function you can assign values to vector:

Here the output shows values assign to vect1 variable.

Use assign() Function to Multiple Variable

You can use assign() function to assign values to multiple variables:

As we can see using assign() function with for loop we assing values to five variables.

Working with Data in R

Chapter 5 creating variables.

This section focuses on the creation of new variables for your analysis as part of an overall strategy of cleaning your data. Often times, data will come to you coded in a certain way, but you want to transform it to make it easier to work with. Our analyses often focus on linear changes in a given variable, but data is typically not coded in such a way to represent those types of differences. We’ll explore that more below.

Some of the tools we need to practice with aren’t directly related to creating new variables or cleaning the data we have, but just understanding what issues there might be. Before you start analysis it’s necessary to step back and observe your data. Understand how the different values are coded and what you might need to do. So, each step below both focuses on figuring out what to do with our data, as well as doing it .

We’ll use the same file I was using in the earlier chapter on loading data , but we’ll load it in from GitHub so that it’s straightforward for anyone to access and use. Notice that we’re using the same read.csv() command, because that is how the file is saved even thought it’s located on the interwebs.

5.1 Using ifelse

We’ll save the file as a new object called ‘dat’ and start by taking a look at the top few lines with head() to get a feel for whats in the data.

The first few columns are what could be called administrative. They’re unique identifiers for the different observations, the timing of the survey they’ve taken, and a bit of other information. So for now we don’t need to pay much attention to MONTH, HWTFINL, CPSID, PERNUM, WTFINL, or CPSIDP.

The next few columns are concerned with different geographies we have for the observations. This data is for individuals, but we also know the individuals region (REGION), state (STATEFIP and STATECENSUS), and metropolitan area (METRO and METAREA). We’ll talk about those more in a later chapter on AGGREGATION, but we don’t need to worry about them at the moment.

So let’s start looking by looking at AGE. Age is the rare variable that typically comes “finished” for us. Sometimes, we don’t need to make any changes to get it ready for analysis.

We can use the command is.numeric() to check whether the column AGE is numeric, and TRUE tells us that is correct. Age is numeric, which is what we would expect. We can check the summary statistics for it just to make sure everything looks as we expect.

That looks right to me. So AGE is ready to go if we want to use it as a numeric variable. We’ll talk more later about what we can do if we want to look at people based on their generations or categories of their age, rather than just using the years they’ve been alive as a variable.

What about the variable SEX? Let’s see what values we have in the column using the table() command. Table gives us a count of how many observations of each type we have.

Okay, so we have 1’s and 2’s. One issue is that we don’t know what those mean. We have more 2’s than 1’s, but we don’t know whether Male’s were coded as 1’s or 2’s so these values have no meaning to us at the moment. We need to look at the code book for the data to understand what those values represent about respondents. It’s really useful to look through the code book before you start using your data, because most of the questions we’re asking in this section could be answered by just reading it… but reading instructions is boring, so I usually skip it as long as I can. What does the code book tell us about the variable SEX?

1’s are Male and 2’s are Female. We can leave the variable as is and remember those values, or we can also create a new variable that’s named either Male or Female so that we know the gender of respondents a little more easily. To do that we can use the command ifelse().

Great, now anyone that was coded as a 1 in the column SEX is now coded as a 1 in the column Male. That isn’t a huge change, but now we can more intuitively know the gender of respondents by just looking at the column Male. We could also create a variable called Female for respondents that were 2’s for SEX.

It really doesn’t matter whether we create a column called Male or Female. They have the same information, just coded a little differently. And we wouldn’t need to create both, since if we have 1 we know everything the second variable tells us.

We’re going to use ifelse() statements a lot to get the data into the exact structure we want, so let’s take a closer look at it.

An ifelse statement reads a bit like a sentence. We’re asking R to determine which of two things is true, either the variable SEX equals 2 or it doesn’t. If it does equal 2 (dat$SEX==2), then we want the new variable we’re creating named Female to take the value 1 (the first of two options we’re giving). If the column SEX doesn’t equal 2, then the new variable should take the value 0. As a result, our new variable Female is a series of 0’s and 1’s.

An ifelse command has 3 essential parts. 1. What should it to see if it is true, 2. what should it do if that is true, 3. What should it do if that isn’t true. We need to supply the command with something to check, and two things to do depending on whether that is true or not.

The numerical operator in an ifelse statement is really important. Here we wanted to determine if the value of SEX was 2. We can use any numerical operator though. The table below displays common numerical operators and what they’re asking about for different variables. I’ll demonstrate more of these below.

So we used two examples of equals above. Let’s see how ‘doesn’t equal’ (!=) works out.

Exactly the same. We can either ask R to code all of the observations that are 2’s, or all of the observations that aren’t 1’s and we get the same essential result.

We can also use the greater than/lesser than with SEX because it’s a numerical variable.

If the values is equal to or less than 2 we coded the observation as a 1 in Female above, or we could code the observations that are equal to or less than 1 as 1 if the variable is Male. That’s a little more silly though since we only have two observations. Above we’ve been practicing creating dichotomous or dummy variables, which are variables which take two values. Either the new variable is a 1 or a 0 depending on the value of something else. We can also create categorical variables with words as our new values. Below we’re going to ask whether the column SEX is equal to 1, and if so make the new variable take the value “Male”, and otherwise give it the value “Female”.

If our original data was coded as words, we can use the equal to operator to create new variables as well.

And round and round we go. If the data is coded as words, we can only use the equal to/not qual to operator, because it wouldn’t make sense to be “greater than” a word like male or blue or fish. You’ll also need to be really careful with spelling. R will only code a value as 1 if the values in the column match what you write exactly.

Below I’m going to make a small typo and write “Mal” instead of “Male”. What do you think is going to happen?

All of the observations are coded as 0. Why? I asked R to code anything that had the value “Mal” as a 1. Being that nothing in the column Gender is coded “Mal” everything is coded as 0. That’s why it’s important to be careful checking the values that your column has before using ifelse and to see the values your new variable has afterwards.

5.2 Lesser and Greater Than

Let’s go back to AGE to better show the utility of the “greater than” and “lesser than” operators". Let’s say we want to create a variable that takes the value of 1 if the person is over the age of 65. We’re not interested in just linear changes in Age as a person gets older, we’re intereted in differences between generations maybe.

It looks like 22235 respondents were over that age. What if we wanted to create a variable that takes the value of 1 if they’re under the age of 18?

We can also use multiple numerical operators in the same ifelse. Let’s say we want to create a variable that specifies if a person is a millennial. Millennials were born between 1981 and 1996, so for a survey from 2018 they would be between the ages of 22 and 37. We can combine multiple numerical operators with either the and (&) or an or (|). (Tip: the straight line | is near the enter key on your keyboard, the ampersand (&) is above the 7). The ifelse statement below is going to look and see if something is BOTH under or equal to 37 years old AND equal to or over the age of 22.

If we wanted to create a variable for someone that was either under 18 or over 65 we can do that with the or statement.

You’ll notice that this new variable youngORold has exactly as many 1’s as the two we created earlier did for over 65 and under 18. That should be correct since we asked if the observations is EITHER under 18 OR over 65.

Let’s make it a little more complicated and move to our next variable: RACE. What values do we have there?

So we’re going to have to turn back to our code book to figure out what any of that means.

We wouldn’t want to use this variable as is. It’s great that it offers the level of detail that it does, but looking at the table above and the code book we don’t want to leave people in as narrow of categories as it offers. So what we want to do typically is take the information in that column and create a few new variables with broader categories.

Here we face a challenge that you’ll encounter often in working with individual survey responses. How narrow or broad do you want to be in coding their race/ethnicity? That question can obviously be fraught with ethical challenges, and I don’t want to dismiss them in setting them aside. Right now we’re focus on figuring out how to get our data into a condition where it’s ready for analysis.

We don’t want people to be individually identifiable by any of the values we have in the survey. For instance, there’s only one person that is coded as “White-American Indian-Asian-Hawaiian/Pacific Islander”; that becomes a really narrow category then.

Generally, individuals are grouped into larger categories, and most typically those would be White, Black, Asian, Latino/Latina (if it’s available) and Other/Mixed Race. Sometimes American Indians are included as a separate category, other times they’re grouped in with “Other”. When you have small numbers of a given category it becomes really difficult to estimate differences between them and larger groups, and so sometimes you’re just forced to combine with another category. Let’s start by coding Whites, Blacks, and American Indians below since those are the first three categories shown in our code book.

This is a good moment to say that in creating new variable names you want to do two things: make it recognizable for yourself and short. The more characters you include, the more you will have to type later when you use it. But if I just name the variable for Whites “W” I might not remember what that is later. It’s a balancing act. Some names just become intuitive from practice. I didn’t make up the name AmInd for American Indians, it’s something I’ve seen elsewhere in data so I learned to use it myself. So make sure your new variable names are concise and clea.

What do we want to do with those that are coded as “Asian only” (651) and “Hawaiian/Pacific Islander only” (652). Do we want to combine them or leave them separate? Honestly, that is going to be determined by your research question and how central differences between different racial groups are for your analysis, as well as the amount of data you have. Here, I’ll code them both ways just for extra practice.

What that leaves is a lot of categorizations for either Other or combinations of different races. Again, it’s possible that your research will dictate that these should be left separate, but often we’ll want to combine those into a single category. Here we can do that by just asking whether the variable RACE is greater than 800.

5.3 Stacking ifelse

Above we have created 7 new variables denoting people’s races (although we created Asian in a few different ways) as a series of 0’s and 1’s. We can also create a new variable using words for the categories like we did in the variable Gender above by stacking ifelse() statements. Let’s jump into creating the first two values so we can talk in more detail about what we’re doing.

In the first statement we ask if RACE equals 100, and set those values equal to “White” in our new variable. For the values that aren’t 100 we set them equal to NA, because we’ll fill their values in later. With the second ifelse() we set the values of 200 equal to “Black”, but we don’t want to overwrite the ones we made “White” in the first command for those that don’t equal 200 we want to leave them with their previous value of RACE2. That becomes more important as we stack on more values, and we want to create all of this within a single variable (Race2).

We would probably rather have 5 separate dummy variables if we were using this for a regression. But if we’re just creating a graph for this variable, it’s easier if they’re all just included in one column.

Thus, you might use one strategy for the graph you include in a paper, and then use a different set of variables (that have equivalent information later in your analyses). The strategies you’ll use in creating new variables will always be indicated by the analysis you’re attempting to conduct.

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

R Variables – Creating, Naming and Using Variables in R

A variable is a memory allocated for the storage of specific data and the name associated with the variable is used to work around this reserved block.

The name given to a variable is known as its variable name . Usually a single variable stores only the data belonging to a certain data type. 

The name is so given to them because when the program executes there is subject to change hence it varies from time to time.

Variables in R

R Programming Language is a dynamically typed language, i.e. the R Language Variables are not declared with a data type rather they take the data type of the R-object assigned to them.

This feature is also shown in languages like Python and PHP.

Creating Variables in R Language

Let’s look at ways of declaring and initializing variables in R language:

R supports three ways of variable assignment:

• Using equal operator- operators use an arrow or an equal sign to assign values to variables.
• Using the leftward operator- data is copied from right to left.
• Using the rightward operator- data is copied from left to right.

Syntax for creating R Variables

Types of Variable Creation in R:

Using equal to operators   variable_name = value   using leftward operator  variable_name <- value   using rightward operator   value -> variable_name

Creating Variables in R With Example

Let’s look at the live example of creating Variables in R:

Nomenclature of R Variables

The following rules need to be kept in mind while naming a R variable: 

• A valid variable name consists of a combination of alphabets, numbers, dot(.), and underscore(_) characters. Example: var.1_ is valid
• Apart from the dot and underscore operators, no other special character is allowed. Example: var$1 or var#1 both are invalid
• Variables can start with alphabets or dot characters. Example: .var or var is valid
• The variable should not start with numbers or underscore. Example: 2var or _var is invalid.
• If a variable starts with a dot the next thing after the dot cannot be a number. Example: .3var is invalid
• The variable name should not be a reserved keyword in R. Example: TRUE, FALSE,etc.

Important Methods for R Variables 

R provides some useful methods to perform operations on variables. These methods are used to determine the data type of the variable, finding a variable, deleting a variable, etc. Following are some of the methods used to work on variables:

1. class() function 

This built-in function is used to determine the data type of the variable provided to it.

The R variable to be checked is passed to this as an argument and it prints the data type in return.

2. ls() function 

This built-in function is used to know all the present variables in the workspace.

This is generally helpful when dealing with a large number of variables at once and helps prevents overwriting any of them.

Syntax  

3. rm() function 

This is again a built-in function used to delete an unwanted variable within your workspace.

This helps clear the memory space allocated to certain variables that are not in use thereby creating more space for others. The name of the variable to be deleted is passed as an argument to it.

Syntax 

Example  

Scope of Variables in R programming

The location where we can find a variable and also access it if required is called the scope of a variable . There are mainly two types of variable scopes:

1. Global Variables

Global variables are those variables that exist throughout the execution of a program. It can be changed and accessed from any part of the program.

As the name suggests, Global Variables can be accessed from any part of the program.

• They are available throughout the lifetime of a program.
• They are declared anywhere in the program outside all of the functions or blocks.

Declaring global variables

Global variables are usually declared outside of all of the functions and blocks. They can be accessed from any portion of the program.

In the above code, the variable ‘ global’ is declared at the top of the program outside all of the functions so it is a global variable and can be accessed or updated from anywhere in the program.

2. Local Variables

Local variables are those variables that exist only within a certain part of a program like a function and are released when the function call ends. Local variables do not exist outside the block in which they are declared, i.e. they can not be accessed or used outside that block.

Declaring local variables 

Local variables are declared inside a block.

Difference between local and global variables in R

• Scope A global variable is defined outside of any function and may be accessed from anywhere in the program, as opposed to a local variable.
• Lifetime A local variable’s lifetime is constrained by the function in which it is defined. The local variable is destroyed once the function has finished running. A global variable, on the other hand, doesn’t leave memory until the program is finished running or the variable is explicitly deleted.
• Naming conflicts If the same variable name is used in different portions of the program, they may occur since a global variable can be accessed from anywhere in the program. Contrarily, local variables are solely applicable to the function in which they are defined, reducing the likelihood of naming conflicts.
• Memory usage Because global variables are kept in memory throughout program execution, they can eat up more memory than local variables. Local variables, on the other hand, are created and destroyed only when necessary, therefore they normally use less memory.

We have covered the concept of “ Variables in R ” to give you overview of R variables. How to create variables in R?, how to use variables in R? and all the other questions have been answered in this article.

Hope you find it helpful, and implement it in your projects.

Please Login to comment...

Similar reads.

• R-Variables
• California Lawmakers Pass Bill to Limit AI Replicas
• Best 10 IPTV Service Providers in Germany
• Python 3.13 Releases | Enhanced REPL for Developers
• IPTV Anbieter in Deutschland - Top IPTV Anbieter Abonnements
• Content Improvement League 2024: From Good To A Great Article

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.

Global variables in R

I am poking into the manuals, I wanted to ask the community: How can we set global variables inside a function?

• global-variables
• variable-assignment

3 Answers 3

As Christian's answer with assign() shows, there is a way to assign in the global environment. A simpler, shorter (but not better ... stick with assign) way is to use the <<- operator, ie

inside the function.

• 60 This approach actually does not save in global environment, but instead in the parent scope. Sometimes parent scope will be the same as the global environment, though in some cases with lots of nested functions it won't. –  LunaticSoul Commented Jun 25, 2015 at 14:42
• 6 Why is assign preferred to <<- ? –  Jasha Commented Apr 24, 2019 at 19:01
• 5 @Jasha <<- will search up the chain of enclosures up to the global environment and assign to the first matching variable it finds. Hypothetically, if you have a function f() nested in a closure g() and a exists in g() , then using a <<- in f() will assign to a in g() , not to the global environment. Oftentimes, this is what you want, however. –  Bob Commented Aug 12, 2019 at 0:02

I found a solution for how to set a global variable in a mailinglist posting via assign :

• 1 see also the accepted answer of this post: stackoverflow.com/questions/3969852/… for updating dataframes within a function –  user1420372 Commented Nov 7, 2019 at 23:58
• What if the function is within mclapply ? –  Ömer An Commented Feb 21 at 6:54

What about .GlobalEnv$a <- "new" ? I saw this explicit way of creating a variable in a certain environment here: http://adv-r.had.co.nz/Environments.html . It seems shorter than using the assign() function.

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

• The Overflow Blog
• Where does Postgres fit in a world of GenAI and vector databases?
• Mobile Observability: monitoring performance through cracked screens, old...
• Featured on Meta
• Announcing a change to the data-dump process
• Bringing clarity to status tag usage on meta sites
• What does a new user need in a homepage experience on Stack Overflow?
• Staging Ground Reviewer Motivation
• Feedback requested: How do you use tag hover descriptions for curating and do...

Hot Network Questions

• Image Intelligence concerning alien structures on the moon
• How to count mismatches between two rows, column by column R?
• I overstayed 90 days in Switzerland. I have EU residency and never got any stamps in passport. Can I exit/enter at airport without trouble?
• Historical U.S. political party "realignments"?
• How specific does the GDPR require you to be when providing personal information to the police?
• Is it possible to accurately describe something without describing the rest of the universe?
• Parody of Fables About Authenticity
• How did Oswald Mosley escape treason charges?
• Trying to install MediaInfo Python 3.13 (Ubuntu) and it is not working out as expected
• Maximizing the common value of both sides of an equation
• Why did the Fallschirmjäger have such terrible parachutes?
• Why is the movie titled "Sweet Smell of Success"?
• How do we reconcile the story of the woman caught in adultery in John 8 and the man stoned for picking up sticks on Sabbath in Numbers 15?
• What prevents a browser from saving and tracking passwords entered to a site?
• Which hash algorithms support binary input of arbitrary bit length?
• Has the US said why electing judges is bad in Mexico but good in the US?
• How to disable Google Lens in search when using Google Chrome?
• How much easier/harder would it be to colonize space if humans found a method of giving ourselves bodies that could survive in almost anything?
• Book or novel about an intelligent monolith from space that crashes into a mountain
• Writing an i with a line over it instead of an i with a dot and a line over it
• What unique phenomena would be observed in a system around a hypervelocity star?
• Background for the Elkies-Klagsbrun curve of rank 29
• Journal keeps messing with my proof
• Rings demanding identity in the categorical context