GeeksforGeeks App
Open App
Browser
Continue

# R Variables

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.

### 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.

### R Variables Syntax

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

## R

 `# R program to illustrate``# Initialization of variables` `# using equal to operator``var1 = ``"hello"``print``(var1)` `# using leftward operator``var2 <- ``"hello"``print``(var2)` `# using rightward operator``"hello"` `-> var3``print``(var3)`

Output

```[1] "hello"
[1] "hello"
[1] "hello"```

## 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:

### 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.

Syntax

`class(variable) `

Example

## R

 `var1 = ``"hello"``print``(``class``(var1))`

Output

`[1] "character"`

### 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

` ls() `

Example

## R

 `# using equal to operator``var1 = ``"hello"` `# using leftward operator``var2 <- ``"hello"` `# using rightward operator``"hello"` `-> var3` `print``(``ls``())`

Output:

`[1] "var1" "var2" "var3"`

### 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

` rm(variable) `

Example

## R

 `# using equal to operator``var1 = ``"hello"` `# using leftward operator``var2 <- ``"hello"` `# using rightward operator``"hello"` `-> var3` `# Removing variable``rm``(var3)``print``(var3)`

Output

```Error in print(var3) : object 'var3' not found
Execution halted ```

## 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:

### 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.

## R

 `# R program to illustrate``# usage of global variables` `# global variable``global = 5` `# global variable accessed from``# within a function``display = ``function``(){``print``(global)``}``display``()` `# changing value of global variable``global = 10``display``()`

Output

```[1] 5
[1] 10```

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.

### 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.

## R

 `# R program to illustrate``# usage of local variables` `func = ``function``(){``# this variable is local to the``# function func() and cannot be``# accessed outside this function``age = 18   ``print``(age)``}` `cat``(``"Age is:\n"``)``func``()`

Output

```Age is:
[1] 18```

Difference between local and global variables in R

1. 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.
2. 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.
3. 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.
4. 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.

My Personal Notes arrow_drop_up