Objects in R Programming

An object is a data entity stored in memory that has:

1. A value (data)
2. A type (numeric, character, list, etc.)
3. Attributes (optional metadata)
4. A class (used in OOP)

Example:

x <- 10

Here:

• x is an object
• 10 is the value
• Type is numeric
• Class is numeric

In R:

• Numbers are objects
• Strings are objects
• Functions are objects
• Data frames are objects

Example:

x <- 5
y <- "R"
f <- function(a) a + 1

Check their classes:

class(x)
class(y)
class(f)

Objects are created using the assignment operator <- (preferred) or =.

a <- 100
b = "Data Science"

Each assignment creates an object in memory.

Object names follow the same rules as variable names.

Rules:

• Must start with a letter or .
• Cannot start with a number
• Case-sensitive
• Cannot be reserved keywords

Valid:

score <- 95
.myObject <- 10

Invalid:

1score <- 95

Objects in R can be categorized based on the data they store.

Atomic Objects

These store a single type of data.

• Numeric
• Integer
• Character
• Logical
• Complex

Example:

x <- 10
y <- TRUE
z <- "R"

Composite Objects

These store multiple values and structures.

Example:

v <- c(1, 2, 3)
m <- matrix(1:6, nrow = 2)
l <- list(1, "R", TRUE)
df <- data.frame(id=1:3, name=c("A","B","C"))

Attributes provide additional information about an object.

Common attributes:

• names
• dim
• class
• levels

Example:

v <- c(a=10, b=20)
attributes(v)

Using attributes()

attributes(v)

Using attr()

attr(v, "names")

Modifying Attributes

attr(v, "comment") <- "Score values"

The class determines how an object behaves in functions.

class(v)

Change class manually:

class(v) <- "myVector"

This is commonly used in S3 OOP.

The str() function displays the internal structure of an object.

str(df)

Output shows:

• Type
• Length
• Attributes
• Data preview

Type of Object

typeof(x)

Class of Object

class(x)

Length of Object

length(v)

Dimensions of Object

dim(m)

R uses copy-on-modify behavior.

x <- c(1,2,3)
y <- x
y[1] <- 100

x remains unchanged until modification.

Some objects (like R6) use reference semantics.

library(R6)

Counter <- R6Class("Counter",
  public = list(
    value = 0,
    inc = function() self$value <- self$value + 1
  )
)

c1 <- Counter$new()
c2 <- c1
c2$inc()
c1$value   # changed

Use ls() to see objects in the current environment.

ls()

Use rm() to delete objects.

rm(x)

Remove multiple objects:

rm(a, b, c)

Remove all objects:

rm(list = ls())

Objects live inside environments.

Common environments:

• Global Environment
• Local Environment
• Package Environment

Check current environment:

environment()

Functions are also objects.

f <- function(x) x * 2
class(f)

Functions can be:

• Passed as arguments
• Returned from other functions
• Stored in lists

Example with vector:

v <- c(10, 20, 30)
for (i in v) {
  print(i)
}

Example with list:

l <- list(1, "R", TRUE)
for (item in l) {
  print(item)
}

student <- list(
  name = "Alice",
  marks = c(80, 85, 90)
)

average <- mean(student$marks)
average

• Confusing type and class
• Modifying reference objects unintentionally
• Forgetting objects are copied on modification
• Removing important objects accidentally using rm()

• Everything in R is an object
• Objects store data, attributes, and class
• Objects live in environments
• Understanding objects is essential for OOP, data analysis, and package development
• Proper object management improves performance and code clarity