Introduction To Ruby
The Basics
Selection
Iteration
Moving On
Introduction To Ruby
Variables
Choosing A Name
In Ruby, variables should be written with lower case characters and cannot include spaces or symbols. An underscore can be used to separate words if more than one word is needed to describe what is being stored. The following are reserved words, part of the Ruby language and should not be used as variable names,
| BEGIN | END | alias | and |
| begin | break | case | def |
| defined? | do | else | elsif |
| end | ensure | false | for |
| if | module | next | nil |
| not | or | redo | rescue |
| retry | return | self | super |
| then | true | undef | unless |
| until | when | while | yield |
Data Types
Ruby is a dynamically typed language. That means that the Ruby interpreter works out the data type from the context. You do not need to declare a variable in Ruby or specify its data type as you would in Visual Basic or C#.
Numbers
The following hierarchy chart shows the different ways that Ruby understands numbers.
Integer
There are two types of integer in Ruby, Fixnum and Bignum. In most cases, Fixnum is used for any whole number (positive or negative) that can be stored in binary with 31 bits. Larger numbers are stored using the Bignum class. Ruby performs this conversion automatically. Operations using Fixnum are substantially quicker than those using Bignum, particularly when the numbers get very large.
The following examples show how you might make a variable store an integer,
# positive integer
age = 42
puts "age"
puts age
puts age.class
puts
# negative integer
temperature = -15
puts "temperature"
puts temperature
puts temperature.class
puts
# integer using separators
pocket_cube_positions = 3_674_160
puts "pocket_cube_positions"
puts pocket_cube_positions
puts pocket_cube_positions.class
puts
# integer in binary
binary_num = 0b1111_1111
puts "binary_num"
puts binary_num
puts binary_num.class
puts
# integer in hexadecimal
hex_num = 0xFF
puts "hex_num"
puts hex_num
puts hex_num.class
puts
# integer in octal
oct_num = 0377
puts "oct_num"
puts oct_num
puts oct_num.class
puts
# larger number
cube_positions = 43_252_003_274_489_856_000
puts "cube_positions"
puts cube_positions
puts cube_positions.class
puts
gets
Copy this example to a text file and save as a Ruby program. When you run it, you should get the following output,
When you put the variable name in quotes, the interpreter assumes that you want to output the word and not the value stored by the variable name. Any underscores are ignored - they are there to make it easier for a programmer to read the source code. Numbers assigned using different number bases are output in denary. The .class method returns the class that the number belongs to. This is a useful way to find out how Ruby is understanding the data type of your variable.
Float
Float is named after the method that computers use to store decimal numbers, called floating point numbers. To make a float, you need to make sure that there is a decimal point in the value you assign to a variable and that there are digits either side of the decimal point. The following example illustrates this point,
# positive float
age = 42.5
puts "age"
puts age
puts age.class
puts
# negative float
temperature = -15.3
puts "temperature"
puts temperature
puts temperature.class
puts
# also a float
x = 0.5
puts "x"
puts x
puts x.class
puts
# one more
y = 10.0
puts "y"
puts y
puts y.class
puts
gets
Complex
The Complex class is used to store complex numbers. A complex number comes in the following form,
a + b i
In the above number, a and b are real numbers. The letter i represents what is called the imaginary part of the number. The letter i stands for the square root of -1.
Some examples of complex numbers are,
3 + 2i
2.4 + 0.5i
0 + 5i
The following Ruby example uses complex numbers,
# 1 + 2i
x = Complex(1,2)
# 2 + i
y = Complex(2,1)
# add x and y
z = x + y
puts z
puts z.class
gets
BigDecimal
Floating point numbers are stored in binary. Whereas the place values to the right of the decimal point in denary are powers of 10, in binary they are powers of 2. This leads to rounding errors. For most cases, the float data type offers sufficient precision, there are some scenarios (like financial calculations) where it is better to use the BigDecimal class.
To make a BigDecimal in Ruby, you write,
x = BigDecimal("0.1")
Rational
A rational number is any number that can be expressed as the quotient of two integers. This means that you can write the number as a fraction a/b where b is not zero. You can do this for any integer, but not all decimal numbers. Some numbers, like the square root of 2, are irrational. When the decimal part of the number is written out, it carries on forever without repeating. PI and e are also irrational numbers.
You can make a Rational in Ruby with,
r = Rational(1,100)
This would make the rational number 1/100, or 0.01.
Strings
The string data type is used to store text - character data. The following example demonstrates several ways to assign strings to variables,
# single quotes
t = 'Some text'
tt = 'A single quote, \', displayed inside single quotes'
ttt = 'Some text written
over more than one line.'
puts t
puts tt
puts ttt
puts
# double quotes
d = "Text in double quotes."
dd = "It's easier to use the apostrophe inside double quotes."
ddd = "Ruby expression in double quotes - #{d}"
puts d
puts dd
puts ddd
gets
Constants
Constants are not variables. We use constants when we want to be able to refer to a value by name in our program but know that we won't need to change that value. In Ruby,constants need to begin with a capital letter. For example,
PI = 3.14