Want to share your content on R-bloggers? click here if you have a blog, or here if you don't.

In computer programming, a variable is a named memory location where data is stored. For example,

`x = 13.8`

Here, x is the variable where the data 13.8 is stored. Now, whenever we use x in our program, we will get 13.8.

```x = 13.8

# print variable
print(x)```

Output

` 13.8`

As you can see, when we print x we get 13.8 as output.

## Rules to Declare R Variables

As per our requirements, we can use any name for our variables. However, there are certain rules that need to be followed while creating a variable:

• A variable name in R can be created using letters, digits, periods, and underscores.
• You can start a variable name with a letter or a period, but not with digits.
• If a variable name starts with a dot, you can’t follow it with digits.
• R is case sensitive. This means that age and Age are treated as different variables.
• We have some reserved words that cannot be used as variable names.

Note: In earlier versions of R programming, the period `.` was used to join words in a multi-word variable such as first.name, my.age, etc. However, nowadays we mostly use `_` for multi-word variables For example, first_name, my_age, etc.

## Types of R Variables

Depending on the type of data that you want to store, variables can be divided into the following types.

### 1. Boolean Variables

It stores single bit data which is either `TRUE` or `FALSE`. Here, `TRUE` means yes and `FALSE` means no. For example,

```a = TRUE

print(a)
print(class(a))```

Output

``` TRUE
 "logical"```

Here, we have declared the boolean variable a with the value `TRUE`. Boolean variables belong to the logical class so `class(a)` returns `"logical"`.

### 2. Integer Variables

It stores numeric data without any decimal values. For example,

```A = 14L

print(A)
print(class(A))```

Output

``` 14
 "integer"```

Here, `L` represents integer value. In R, integer variables belong to the integer class so, `class(a)` returns `"integer"`.

### 3. Floating Point Variables

It stores numeric data with decimal values. For example,

```x = 13.4

print(x)
print(class(x))```

Output

``` 13.4
 "numeric"```

Here, we have created a floating point variable named x. You can see that the floating point variable belongs to the `numeric` class.

### 4. Character Variables

It stores a single character data. For example,

```alphabet = "a"

print(alphabet)
print(class(alphabet))```

Output

``` "a"
 "character"```

Here, we have created a character variable named alphabet. Since character variables belong to the character class, `class(alphabet)` returns `"character"`.

### 5. String Variables

It stores data that is composed of more than one character. We use double quotes to represent string data. For example,

```message = "Welcome to Programiz!"

print(message)
print(class(message))```

Output

``` "Welcome to Programiz!"
 "character"```

Here, we have created a string variable named message. You can see that the string variable also belongs to the `character` class.

## Changing Value of Variables

Depending on the conditions or information passed into the program, you can change the value of a variable. For example,

```message = "Hello World!"
print(message)

# changing value of a variable
message <- "Welcome to Programiz!"

print(message)```

Output

``` "Hello World!"
 "Welcome to Programiz!"```

In this program,

• `"Hello World!"` - initial value of message
• `"Welcome to Programiz!"` - changed value of message

You can see that the value of a variable can be changed anytime.

## R Constants

Constants are those entities whose values aren't meant to be changed anywhere throughout the code. In R, we can declare constants using the `<-` symbol. For example,

```x <- "Welcome to Programiz!"
print(x)```

Output

` "Welcome to Programiz!"`

Here, `"Welcome to Programiz!"` is a string constant.

Note: Constants are also known as scalars.

## Types of R Constants

In R, we have the following types of constants.

• The five types of R constants - `numeric`, `integer`, `complex`, `logical`, `string`.
• In addition to these, there are 4 specific types of R constants - `Null`, `NA`, `Inf`, `NaN`.

Let's discuss each of these types one by one.

### 1. Integer Constants

Integer constants are the integer values we use in our code. These constants end with the letter `L`. For example,

```x <- 15L
print(typeof(x))
print(class(x))```

Output

``` "integer"
 "integer"```

Here, `15L` is a constant which has been assigned to x. You can see that the type and class of the constant is `integer`.

We can use different types of integer constants in our code. For example,

```# hexadecimal value
x <- 0x15L
print(x)

# exponential value
x <- 1e5L
print(x)```

Output

``` 21
 100000```

### 2. Numeric Constants

In R programming, numeric constants can be integers (`4`), floating-point numbers (`0.55`), or exponential numbers (`3e-3`). For example,

```z <- 3e-3
print(z)  # 0.003
print(class(z))  # "numeric"

y <- 3.4
print(y)  # 3.4
print(class(z))  # "numeric"```

Output

``` 0.003
 "numeric"
 3.4
 "numeric"```

### 3. Logical Constants

Logical constants in R are either `TRUE` or `FALSE`. For example,

```x <- TRUE
y <- FALSE
print(x)
print(y)```

Output

``` TRUE
 FALSE```

Note: We can also use a single character to create logical constants. For example,

```x <- T
print(x) # TRUE```

### 4. String Constants

String constants are the string data we use in our code. For example,

```message <- "Welcome to Programiz!!"
print(message)```

Output

` "Welcome to Programiz!!"`

### 5. Complex Constants

A complex constant is data that contains a real and an imaginary part (denoted by the suffix `i`). For example,

```y <- 3.2e-1i
print(y)
print(typeof(y))```

Output

``` 0+0.32i
 "complex"```

Note: Complex constants can only be purely imaginary. For example,

```y <- 3i
print(y)    # 0+3i
print(typeof(y))  # "complex"```

## Special R Constants

R programming also provides 4 special types of constants.

• `NULL` - to declare an empty R object. For example,

```x <- NULL
print(x)  # NULL
print(typeof(x))  # "NULL"```
• `Inf/-Inf` - represents positive and negative infinity. For example,

```# result is too big so it represents positive infinity
a <- 2^2020
print(a)   # Inf

# result is too big
# represents negative infinity
b <- -2^2020
print(b)    # -Inf```
• `NaN` (Not a Number) - represents undefined numerical value. For example,

```print(0/0)      # NaN
print(Inf/Inf)  # NaN```
• `NA` - represents value which is not available. For example,

`print(NA + 20) # NA`

## Built-In R Constants

R programming provides some predefined constants that can be directly used in our program. For example,

```# print list of uppercase letters
print(LETTERS)

# print list of lowercase letters
print(letters)

# print 3 letters abbreviation of English months
print(month.abb)

# print numerical value of constant pi
print(pi)```

Output

```  "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S"
 "T" "U" "V" "W" "X" "Y" "Z"
 "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
 "t" "u" "v" "w" "x" "y" "z"
 "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"
 3.141593```

In the above example, we have used the following built-in constants:

• `LETTERS` - to display a list of all uppercase letters
• `letters` - to display a list of all small letters
• `month.abb` - to print 3 letter abbreviations of all English months
• `pi` - to print the numerical value of the constant pi