You probably are itching to get started on some real R code. Here, you get to do exactly that. Get ready to get your hands dirty and dive into the programming world!
Saying hello to the world
Programming books typically start with a very simple program. Often, this first program creates the message “Hello world!”. In R, hello world program consists of one line of code.
Start a new R session, type the following in your console, and press Enter:
> print(“Hello world!”)
R responds immediately with this output:
[1] “Hello world!”
You can collapse input and output into a single block of code, like this:
> print(“Hello world!”) [1] “Hello world!”
Doing simple math
Type the following in your console to calculate the sum of five numbers:
> 1 + 2 + 3 + 4 + 5 [1] 15
The answer is 15, which you can easily verify for yourself. You may think that there’s an easier way to calculate this value, though — and you’d be right.
Using vectors
A vector is the simplest type of data structure in R. The R manual defines a vector as “a single entity consisting of a collection of things”. A collection of numbers, for example, is a numeric vector — the first five integer numbers form a numeric vector of length 5.
To construct a vector, type into the console:
> c(1, 2, 3, 4, 5) [1] 1 2 3 4 5
In constructing your vector, you have successfully used a function in R. In programming language, a function is a piece of code that takes some inputs and does something specific with them. In constructing a vector, you tell the c() function to construct a vector with the first five integers. The entries inside the parentheses are referred to as arguments.
You also can construct a vector by using operators. An operator is a symbol you stick between two values to make a calculation. The symbols +, -, *, and / are all operators, and they have the same meaning they do in mathematics. Thus, 1+2 in R returns the value 3, just as you’d expect.
One very handy operator is called sequence, and it looks like a colon (:). Type the following in your console:
> 1:5 [1] 1 2 3 4 5
That’s more like it. With three keystrokes, you’ve generated a vector with the values 1 through 5. To calculate the sum of this vector, type into your console:
> sum(1:5) [1] 15
While quite basic, this example shows you that using vectors allows you to do complex operations with a small amount of code.
Storing and calculating values
Using R as a calculator is very interesting but perhaps not all that useful. A much more useful capability is storing values and then doing calculations on these stored values. Try this:
> x <- 1:5 > x [1] 1 2 3 4 5
In these two lines of code, you first assign the sequence 1:5 to an object called x. Then you ask R to print the value of x by typing x in the console and pressing Enter.
In R, the assignment operator is , which you type in the console by using two keystrokes: the less-than symbol () followed by a hyphen (-). The combination of these two symbols represents assignment. It’s good practice to always surround the with spaces. This makes your code much easier to read and understand.
In addition to retrieving the value of a variable, you can do calculations on that value. Create a second variable called y, and assign it the value 10. Then add the values of x and y, as follows:
> y <- 10 > x + y [1] 11 12 13 14 15
The values of the two variables themselves don’t change unless you assign a new value to either of them. You can check this by typing the following:
> x [1] 1 2 3 4 5 > y [1] 10
Now create a new variable z, assign it the value of x + y, and print its value:
> z <- x + y > z [1] 11 12 13 14 15
Variables also can take on text values. You can assign the value “Hello” to a variable called h, for example, by presenting the text to R inside quotation marks, like this:
> h <- “Hello” > h [1] “Hello”
You must enter text or character values to R inside quotation marks — either single or double. R accepts both. So both h “Hello” and h ‘Hello’ are examples of valid R syntax.
You can use the c() function to combine numeric values into vectors. This technique also works for text:
> hw <- c(“Hello”, “world!”) > hw [1] “Hello” “world!”
You use the paste() function to concatenate multiple text elements. By default, paste() puts a space between the different elements, like this:
> paste(“Hello”, “world!”) [1] “Hello world!”
Talking back to the user
You can write R scripts that have some interaction with a user. To ask the user questions, you can use the readline() function. In the following code snippet, you read a value from the keyboard and assign it to the variable yourname:
> h <- “Hello” > yourname <- readline(“What is your name? “) What is your name? Andrie > paste(h, yourname) [1] “Hello Andrie”
This code seems to be a bit cumbersome, however. Clearly, it would be much better to send these three lines of code simultaneously to R and get them evaluated in one go.
