Ruby is an interpreted language, dynamically, reflective, semi-Functional and Object Orientated scripting language written in C. Ruby is said to be semi-Functional because it supports higher-order functions (aka lambdas) and closures (aka blocks). Ruby was created by Yukihiro "Matz" Matsumoto and was first released in 1995.

Matz's goal was to combine powerful features from various other programming languages, and create a programming language maximized for developer happiness; as opposed to computational efficiency. Ruby's Object Model mirrors that of Smalltalk, the syntax shares some similarities with Bash, Perl, Python, and the scoping rules for closures was taken from LISP.

Basics

Development Environment

Your first program

Code

#!/usr/bin/ruby puts "Hello world\n"

Explanation

Variables and Data Types

Local

A local variable is a variable that can only be used within the block it was initialized in. It can be created by making an object that starts with a lowercase letter or an underscore.

foo = 'bar'

Global

Global variables can be accessed from anywhere within the entire program. They can be created by prefixing your variable the the '$' symbol. Editting the assignment of a global variable will change the status of that variable globally and is generally avoided when writing Ruby scripts.

$woot = 1337

Instance

Instance variables begin with the '@' symbol. Creating an uninitialzed instance will have a nil value.

>> @instance
=> nil
>> @instance = 'ohdae'
=> "ohdae"

Class

Class variables are shared by all methods within that class. These are created by using two '@' symbols at the beginning of your variable. Trying to initialize a class variable outside of a class will throw an error.

>> @@classvar
NameError: uninitialized class variable @@classvar in Object
	from (irb):5
	from :0
>> class Blackhat
>>   @@classvar = 'ohhai'

Pre-defined

Certain variables are pre-defined into Ruby. The values of these variables cannot be changed.

self nil true false

Scalars

Arrays

An array is a group of objects, very similar to lists in Python. The items or objects inside an array are indexed on a non-negative zero-index. The objects inside of a Ruby array can be any mixture of variables. Creating an array can be done in a few different ways. You do not need to specifically declare your variable as an array during initialization, for example if you give Ruby a list of comma separated values inside brackets, Ruby will recgonize this as an array and use it as such from that point forward.

>> my_array = Array.new
=> []
>> my_array_two = []
=> []
>> array_three = ["item", 5, foo, "Item2", "Strings can go here too"]
=> ["item", 5, "bar", "Item2", "Strings can go here too"]
>> array_three[0]
=> "item"
>> array_three[1]
=> 5

You will notice the item 'foo' is printed as "bar" because we defined this earlier in this page.

Hashes or Associative Arrays

References and Pointers

Casting

Boolean Logic

Operators

Statements

Helper natives

Bitwise Manipulations

Loops

While

Until

For

Iterators

User Input

CGI & Eruby

Command-line Options

STDIN / Standard Input

User-defined

Functions

Objects

Helpful Libraries

USqlite

require 'sqlite'
class Usqlite
    attr_accessor :link, :config, :a_rows, :rows, :result, :data
    def initialize(config, *args) 
        return nil unless defined? config
        @config = config
        @link = SQLite::Database.new(@config["sqlitefile"]) or exit("cannot open sqlite database")
    end
    def queryItem(query)
        return @link.get_first_value(query)
    end
    def queryRow(query)
        @link.results_as_hash = true
        @link.execute(query) do |row|
            @data = row
            return row
        end
    end
    def sqlQuery(query)
        @result = @link.query(query)
    end
    def sqlFetch() 
        @link.results_as_hash = true
        return @data if (@data = @results.next)
    end
    def sqlInsert(query)
        @a_rows = 0
        @link.query(query) do |result|
           @a_rows++
           result.next
        end
    end
end

Ruby

Contents