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)
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 means yes and
FALSE means no. For example,
a = TRUE print(a) print(class(a))
 TRUE  "logical"
Here, we have declared the boolean variable a with the value
TRUE. Boolean variables belong to the logical class so
2. Integer Variables
It stores numeric data without any decimal values. For example,
A = 14L print(A) print(class(A))
 14  "integer"
L represents integer value. In R, integer variables belong to the integer class so,
3. Floating Point Variables
It stores numeric data with decimal values. For example,
x = 13.4 print(x) print(class(x))
 13.4  "numeric"
Here, we have created a floating point variable named x. You can see that the floating point variable belongs to the
4. Character Variables
It stores a single character data. For example,
alphabet = "a" print(alphabet) print(class(alphabet))
 "a"  "character"
Here, we have created a character variable named alphabet. Since character variables belong to the character class,
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))
 "Welcome to Programiz!"  "character"
Here, we have created a string variable named message. You can see that the string variable also belongs to the
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)
 "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.
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)
 "Welcome to Programiz!"
"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 -
- In addition to these, there are 4 specific types of R constants -
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))
 "integer"  "integer"
15L is a constant which has been assigned to x. You can see that the type and class of the constant is
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)
 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"
 0.003  "numeric"  3.4  "numeric"
3. Logical Constants
Logical constants in R are either
FALSE. For example,
x <- TRUE y <- FALSE print(x) print(y)
 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)
 "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))
 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)
 "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