Copyright © 2008-2018
Robert W. Hasker

Note 2: Basic Ruby

Ruby Basics

(run irb)
Arithmetic: 3 + 4 * 5, 4 ** 3, 1.5 / 23e18, Math.sin(0.5)
Parentheses are optional for functions: Math.sin 0.25
Comparisons: 3 < 5, 3 >= 5, 3 != 4
Assignments: x = 4 - note no need to declare x
- x = x * 2
- x *= 2
Conditions:
- ```
if x > 4
5
else
8
end
```
- ```
if x < 4
  5
elsif x < 50
  9
else
  100
end
```
- note: if returns a value (more like ?: in Java)
- note: end marks the end of the if statement
- note: no semicolons, though they are valid in sequences
  - end of line serves as a terminator
  - can use then with if to put it on single line - avoid
- note: no braces - they're used very differently

Printing: puts

puts "hello"
puts 5.0 / 3
(print is also available; read up online)
can use single quotes on strings: puts 'hello'

difference: " allows embedding expressions:

    x = 42
    puts "#{x} is the meaning of life, the universe, and everything"
    puts "but not #{x / 5.0}"
    puts 'but not #{x / 5.0}'

What is this?
- Known as the "read-eval-print" loop
- Exit: two alternatives: exit, quit
- simple experimentation, testing
Can also type expressions into ruby itself:
```
        ruby
        puts 3 * 4
        Control-D
```
- A program: a file with commands in it
- Running sum.rb at command prompt:
```
        ruby sum.rb
        5
        4
        3
        Control-Z
```
  Control-Z marks the end of input in Dos; use Control-D in Unix.
- Better way to run a program at the command prompt for testing:
```
        d:\> ruby sum.rb < fib100.txt
```
  - Ensures consistency.
  - The file extension is arbitrary: ruby sum.rb < sum.rb works just fine!
  - Note the direction of the "arrow": data is read from the file fib100.txt and given to the program.

Functions and Loops

Defining functions (back in irb):
```
        def max(a, b)
          if a > b
            a
          else
            b
          end
        end
```
- usage: max(3, 8)
- also: max 43, 12
  - but do be cautious about dropping parens - can get you into trouble!

Loops:

        count = 10
        while count >= 1
          puts count
          count -= 1
        end

There are much better ways to do a task like this! More later.

Reading data
- gets: returns next string
- x = gets
- How to read an integer?
  - Strings have an operation to convert to an integer:
```
        "-183".to_i
```
    and a float:
```
        "15.18".to_f
```
  - If there's additional text after the number, it's ignored
    - "-1.5junk".to_f
    - "-1.5junk".to_i
    - a general Ruby principle: do what you can with what you have
- nil works like false in conditions:
```
        if false then 'a' else 'b' end
        if nil then 'a' else 'b' end
```
  - Warning: this is the sort of thing that's easy to ask questions about!
  - 0 is not false!
```
        if 0 then 'a' else 'z' end

        # or...

        !false
        !nil
        !0
```
- Largest item in a non-empty list of integers - note this is a complete program...
  - Uses the fact that gets returns nil when no more input
```
        largest = gets.to_i
        while (str = gets)
          n = str.to_i
          if n >= largest
            largest = n
          end
        end
```

Review

basic Ruby operations (arithmetic, comparisons): what you'd expect with Java experience
- And includes several features from C++!
no type declarations for variables
if statement: always ends
same for while

defining functions:

    def name(...parameters...) body end