There are several ways to find out the type of the data. The easiest is to use typeof(x) function. It returns type or storage mode of any object in R.

x <- 5 typeof(x)

You can also use index 0 of the variable (more on indexes later):

x[0]

You can use class(x) function, although this one has deeper meaning when it comes to objects in R:

class(x)

Notice that sometimes names of the types or even types differ when using different ways of retrieving them. Try to check those types.

In R, the most primary structure is a vector. Even basic types are stored in this form. You can see it when trying to print any value:

myVal <- "text" myVal

You can notice that before the displayed value there is [1] printed.

Vectors can only contain data of the same type. The easiest way to create a vector containing more elements, is to use c function (which stand for combine):

myVector <- c('Anna', 'John', 'Eva') myVector

For sequential values you can use : operator:

myVector <- 1:20 myVector

myVector <- letters[1:5] myVector

For initialisation of default values, just use type name. Default value for numeric types is 0, for string - '', for logical - 'F'. For example, the command:

myVector <- numeric(10) myVector

creates 10-elements vector with all set to 0.

Lists are special kind of vectors that allow to store elements of different types, including vectors, lists and more complex elements. And this is basically the main reason why they are used in R.

You can create list using list function. The following instruction creates 3-elements list:

myList <- list(5, 'abc', c(1, 2, 3)) myList

You may have noticed that printing a list shows that every element is indexed by double square brackets. Every element of a list is a vector. We will talk about indexing later.

As you may expect, the type of a list is list:

typeof(myList)

Both vectors and lists can have named elements. To illustrate it you can create and display a vector using names:

myVector <- c(a=1, b=2, c=3) myVector

The same is also available for the list:

myList <- list(a="a", b="b", c="c") myList

With named elements vector's elements have proper headers. When using names on elements of the list no double brackets are shown, there are names after the sign $ shown.

Both vectors and lists are indexed starting from 1 (0 index is reserved for storing the type). To access specific elements you can use bot [] and [[]] brackets.

The rule is that single brackets are to access the specific elements and double are to access a value. Vectors elements are vectors themselves, so you can use any type of brackets to get an element:

x <- 1:10 x[4] x[[4]]

For lists, elements are lists, so usage of specific brackets makes a difference:

l <- as.list(1:10) l[4] l[[4]]

When using named elements there are more possibilities to explore. Basically you can use a name achieved from an external function and the use it when accessing specific elements.

elemName <- 'b'

For vectors accessing the value could be achieved in the following name:

y <- c(a='a', b='b', c='c') y[elemName] y[[elemName]]

And for lists:

m <- list(a='a', b='b', c='c') m[elemName] m[[elemName]]

With lists we also get easy way to get to the named elements. Using $ symbol. Notice that this time you cannot use calculated elemName value

m$b

Matrix is a structure similar to the table with the limitation it can only contain elements of the same type.

The simplest way to construct a matrix is to use matrix function:

A <- matrix(c(1,2,3,4,5)) A

This command will create one column matrix filled with values from 1 to 5. If you check the type of the matrix it will be simple numeric.

typeof(A)

If you want to create matrix with more than one column, you need to use ncol and/or nrow parameters:

B <- matrix(c(1,2,3,4,5,6), ncol=3, nrow=2) B

If number of the elements doesn't fit ncol*nrow R will try to figure it out by either cutting of some elements or filling the missing values by using the collection from the beginning. This case you will get some warnings.

C <- matrix(c(1,2,3,4,5,6,7), ncol=3, nrow=2) C

D <- matrix(c(1,2,3,4), ncol=3, nrow=2) D

Data frames are structures used the most frequently in R world. They are structured in a way tables are in relational databases.

This means they have columns and rows, but columns can differ on the containing type. Of course all the values of the same column must be of the same type.

The simplest way to create a data frame is to just list columns:

dataFrame <- data.frame(col1=c(1,2,3), col2=c('a','b','c')) dataFrame

If you try to find out the type of the created data frame it will be a list:

typeof(dataFrame)