learnxinyminutes-docs/ruby.html.markdown

546 lines
12 KiB
Markdown
Raw Normal View History

2013-06-28 23:57:57 +04:00
---
language: ruby
2013-07-04 09:59:13 +04:00
filename: learnruby.rb
2013-07-03 23:39:43 +04:00
contributors:
- ["David Underwood", "http://theflyingdeveloper.com"]
2013-07-04 09:53:12 +04:00
- ["Joel Walden", "http://joelwalden.net"]
- ["Luke Holder", "http://twitter.com/lukeholder"]
2013-08-12 22:53:00 +04:00
- ["Tristan Hume", "http://thume.ca/"]
2013-08-14 02:47:52 +04:00
- ["Nick LaMuro", "https://github.com/NickLaMuro"]
- ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
2014-03-11 01:05:49 +04:00
- ["Ariel Krakowski", "http://www.learneroo.com"]
- ["Dzianis Dashkevich", "https://github.com/dskecse"]
2014-11-11 04:45:17 +03:00
- ["Levi Bostian", "https://github.com/levibostian"]
2015-03-19 13:08:27 +03:00
- ["Rahil Momin", "https://github.com/iamrahil"]
2014-03-11 01:05:49 +04:00
2013-06-28 23:57:57 +04:00
---
```ruby
# This is a comment
=begin
This is a multiline comment
No-one uses them
You shouldn't either
=end
# First and foremost: Everything is an object.
2013-06-28 23:57:57 +04:00
# Numbers are objects
3.class #=> Fixnum
3.to_s #=> "3"
2013-06-28 23:57:57 +04:00
# Some basic arithmetic
1 + 1 #=> 2
8 - 1 #=> 7
10 * 2 #=> 20
35 / 5 #=> 7
2**5 #=> 32
2013-06-28 23:57:57 +04:00
2013-07-30 11:28:40 +04:00
# Arithmetic is just syntactic sugar
# for calling a method on an object
1.+(3) #=> 4
10.* 5 #=> 50
# Special values are objects
nil # Nothing to see here
true # truth
false # falsehood
nil.class #=> NilClass
true.class #=> TrueClass
false.class #=> FalseClass
2013-06-28 23:57:57 +04:00
# Equality
1 == 1 #=> true
2 == 1 #=> false
# Inequality
1 != 1 #=> false
2 != 1 #=> true
# apart from false itself, nil is the only other 'falsey' value
!nil #=> true
!false #=> true
!0 #=> false
2013-06-28 23:57:57 +04:00
# More comparisons
2013-06-30 02:04:37 +04:00
1 < 10 #=> true
1 > 10 #=> false
2 <= 2 #=> true
2 >= 2 #=> true
2013-06-28 23:57:57 +04:00
2015-03-05 02:56:23 +03:00
# Logical operators
true && false #=> false
true || false #=> true
!true #=> false
# There are alternate versions of the logical operators with much lower
# precedence. These are meant to be used as flow-control constructs to chain
# statements together until one of them returns true or false.
# `do_something_else` only called if `do_something` succeeds.
do_something() and do_something_else()
# `log_error` only called if `do_something` fails.
do_something() or log_error()
2015-03-05 02:56:23 +03:00
# Strings are objects
'I am a string'.class #=> String
"I am a string too".class #=> String
2013-06-28 23:57:57 +04:00
placeholder = 'use string interpolation'
2013-06-28 23:57:57 +04:00
"I can #{placeholder} when using double quoted strings"
#=> "I can use string interpolation when using double quoted strings"
2013-06-28 23:57:57 +04:00
# Prefer single quoted strings to double quoted ones where possible
# Double quoted strings perform additional inner calculations
2014-03-11 02:06:44 +04:00
# Combine strings, but not with numbers
'hello ' + 'world' #=> "hello world"
'hello ' + 3 #=> TypeError: can't convert Fixnum into String
'hello ' + 3.to_s #=> "hello 3"
2013-06-28 23:57:57 +04:00
# print to the output
puts "I'm printing!"
# Variables
x = 25 #=> 25
x #=> 25
2013-06-28 23:57:57 +04:00
# Note that assignment returns the value assigned
# This means you can do multiple assignment:
x = y = 10 #=> 10
x #=> 10
y #=> 10
# By convention, use snake_case for variable names
snake_case = true
# Use descriptive variable names
path_to_project_root = '/good/name/'
path = '/bad/name/'
# Symbols (are objects)
2013-07-04 10:03:25 +04:00
# Symbols are immutable, reusable constants represented internally by an
# integer value. They're often used instead of strings to efficiently convey
# specific, meaningful values
:pending.class #=> Symbol
status = :pending
status == :pending #=> true
status == 'pending' #=> false
status == :approved #=> false
2013-06-28 23:57:57 +04:00
# Arrays
# This is an array
2013-08-14 02:42:03 +04:00
array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
2013-06-28 23:57:57 +04:00
# Arrays can contain different types of items
[1, 'hello', false] #=> [1, "hello", false]
2013-06-28 23:57:57 +04:00
# Arrays can be indexed
# From the front
array[0] #=> 1
array[12] #=> nil
# Like arithmetic, [var] access
# is just syntactic sugar
# for calling a method [] on an object
array.[] 0 #=> 1
array.[] 12 #=> nil
2013-06-28 23:57:57 +04:00
# From the end
array[-1] #=> 5
# With a start index and length
array[2, 3] #=> [3, 4, 5]
2013-06-28 23:57:57 +04:00
# Or with a range
array[1..3] #=> [2, 3, 4]
# Add to an array like this
2013-06-28 23:57:57 +04:00
array << 6 #=> [1, 2, 3, 4, 5, 6]
# Or like this
array.push(6) #=> [1, 2, 3, 4, 5, 6]
2013-06-28 23:57:57 +04:00
2015-03-19 13:07:42 +03:00
# Check if an item exists in an array
array.include?(1) #=> true
# Hashes are Ruby's primary dictionary with keys/value pairs.
# Hashes are denoted with curly braces:
hash = { 'color' => 'green', 'number' => 5 }
hash.keys #=> ['color', 'number']
# Hashes can be quickly looked up by key:
hash['color'] #=> 'green'
hash['number'] #=> 5
# Asking a hash for a key that doesn't exist returns nil:
hash['nothing here'] #=> nil
# Since Ruby 1.9, there's a special syntax when using symbols as keys:
new_hash = { defcon: 3, action: true }
new_hash.keys #=> [:defcon, :action]
# Check existence of keys and values in hash
new_hash.has_key?(:defcon) #=> true
new_hash.has_value?(3) #=> true
# Tip: Both Arrays and Hashes are Enumerable
2013-07-04 09:53:12 +04:00
# They share a lot of useful methods such as each, map, count, and more
2013-06-28 23:57:57 +04:00
# Control structures
if true
'if statement'
2013-06-28 23:57:57 +04:00
elsif false
'else if, optional'
2013-06-28 23:57:57 +04:00
else
'else, also optional'
2013-06-28 23:57:57 +04:00
end
for counter in 1..5
puts "iteration #{counter}"
end
#=> iteration 1
#=> iteration 2
#=> iteration 3
#=> iteration 4
#=> iteration 5
2013-08-12 23:05:00 +04:00
# HOWEVER, No-one uses for loops.
# Instead you should use the "each" method and pass it a block.
# A block is a bunch of code that you can pass to a method like "each".
2013-08-14 02:46:33 +04:00
# It is analogous to lambdas, anonymous functions or closures in other
# programming languages.
2013-08-12 23:05:00 +04:00
#
# The "each" method of a range runs the block once for each element of the range.
# The block is passed a counter as a parameter.
# Calling the "each" method with a block looks like this:
2013-06-28 23:57:57 +04:00
(1..5).each do |counter|
puts "iteration #{counter}"
end
#=> iteration 1
#=> iteration 2
#=> iteration 3
#=> iteration 4
#=> iteration 5
2013-08-12 22:53:00 +04:00
# You can also surround blocks in curly brackets:
(1..5).each { |counter| puts "iteration #{counter}" }
2013-08-12 22:53:00 +04:00
2013-08-12 23:05:00 +04:00
# The contents of data structures can also be iterated using each.
2013-08-12 22:53:00 +04:00
array.each do |element|
puts "#{element} is part of the array"
end
hash.each do |key, value|
puts "#{key} is #{value}"
end
2013-06-28 23:57:57 +04:00
counter = 1
while counter <= 5 do
puts "iteration #{counter}"
counter += 1
2013-06-28 23:57:57 +04:00
end
#=> iteration 1
#=> iteration 2
#=> iteration 3
#=> iteration 4
#=> iteration 5
grade = 'B'
2013-06-28 23:57:57 +04:00
case grade
when 'A'
puts 'Way to go kiddo'
2013-06-28 23:57:57 +04:00
when 'B'
puts 'Better luck next time'
2013-06-28 23:57:57 +04:00
when 'C'
puts 'You can do better'
2013-06-28 23:57:57 +04:00
when 'D'
puts 'Scraping through'
2013-06-28 23:57:57 +04:00
when 'F'
puts 'You failed!'
else
puts 'Alternative grading system, eh?'
end
2014-03-11 01:05:49 +04:00
#=> "Better luck next time"
# cases can also use ranges
grade = 82
case grade
when 90..100
puts 'Hooray!'
when 80...90
puts 'OK job'
else
puts 'You failed!'
2014-03-11 01:05:49 +04:00
end
#=> "OK job"
# exception handling:
2014-11-11 04:45:17 +03:00
begin
# code here that might raise an exception
raise NoMemoryError, 'You ran out of memory.'
rescue NoMemoryError => exception_variable
puts 'NoMemoryError was raised', exception_variable
rescue RuntimeError => other_exception_variable
puts 'RuntimeError was raised now'
2015-03-05 02:56:23 +03:00
else
2014-11-11 04:45:17 +03:00
puts 'This runs if no exceptions were thrown at all'
2015-03-05 02:56:23 +03:00
ensure
2014-11-11 04:45:17 +03:00
puts 'This code always runs no matter what'
end
2014-03-11 01:05:49 +04:00
2013-06-28 23:57:57 +04:00
# Functions
def double(x)
x * 2
end
# Functions (and all blocks) implicitly return the value of the last statement
2013-06-28 23:57:57 +04:00
double(2) #=> 4
# Parentheses are optional where the result is unambiguous
double 3 #=> 6
double double 3 #=> 12
def sum(x, y)
2013-06-28 23:57:57 +04:00
x + y
end
# Method arguments are separated by a comma
sum 3, 4 #=> 7
sum sum(3, 4), 5 #=> 12
2013-06-28 23:57:57 +04:00
# yield
# All methods have an implicit, optional block parameter
# it can be called with the 'yield' keyword
def surround
puts '{'
yield
puts '}'
end
surround { puts 'hello world' }
2013-06-28 23:57:57 +04:00
# {
# hello world
# }
# You can pass a block to a function
# "&" marks a reference to a passed block
def guests(&block)
block.call 'some_argument'
end
# You can pass a list of arguments, which will be converted into an array
# That's what splat operator ("*") is for
def guests(*array)
array.each { |guest| puts guest }
end
# Define a class with the class keyword
class Human
2013-08-08 14:17:10 +04:00
# A class variable. It is shared by all instances of this class.
@@species = 'H. sapiens'
2013-08-08 14:17:10 +04:00
# Basic initializer
def initialize(name, age = 0)
2013-08-08 14:17:10 +04:00
# Assign the argument to the "name" instance variable for the instance
@name = name
# If no age given, we will fall back to the default in the arguments list.
@age = age
end
# Basic setter method
def name=(name)
@name = name
end
# Basic getter method
def name
@name
end
# The above functionality can be encapsulated using the attr_accessor method as follows
attr_accessor :name
# Getter/setter methods can also be created individually like this
attr_reader :name
attr_writer :name
2013-08-08 14:17:10 +04:00
# A class method uses self to distinguish from instance methods.
# It can only be called on the class, not an instance.
def self.say(msg)
puts msg
2013-08-08 14:17:10 +04:00
end
def species
@@species
end
end
# Instantiate a class
jim = Human.new('Jim Halpert')
dwight = Human.new('Dwight K. Schrute')
# Let's call a couple of methods
jim.species #=> "H. sapiens"
jim.name #=> "Jim Halpert"
jim.name = "Jim Halpert II" #=> "Jim Halpert II"
jim.name #=> "Jim Halpert II"
dwight.species #=> "H. sapiens"
dwight.name #=> "Dwight K. Schrute"
# Call the class method
Human.say('Hi') #=> "Hi"
# Variable's scopes are defined by the way we name them.
# Variables that start with $ have global scope
$var = "I'm a global var"
defined? $var #=> "global-variable"
# Variables that start with @ have instance scope
@var = "I'm an instance var"
defined? @var #=> "instance-variable"
# Variables that start with @@ have class scope
@@var = "I'm a class var"
defined? @@var #=> "class variable"
# Variables that start with a capital letter are constants
Var = "I'm a constant"
defined? Var #=> "constant"
# Class is also an object in ruby. So class can have instance variables.
# Class variable is shared among the class and all of its descendants.
# base class
class Human
@@foo = 0
def self.foo
@@foo
end
def self.foo=(value)
@@foo = value
end
end
# derived class
class Worker < Human
end
Human.foo # 0
Worker.foo # 0
Human.foo = 2 # 2
Worker.foo # 2
# Class instance variable is not shared by the class's descendants.
class Human
@bar = 0
def self.bar
@bar
end
def self.bar=(value)
@bar = value
end
end
class Doctor < Human
end
Human.bar # 0
Doctor.bar # nil
module ModuleExample
def foo
'foo'
end
end
# Including modules binds their methods to the class instances
# Extending modules binds their methods to the class itself
class Person
include ModuleExample
end
class Book
extend ModuleExample
end
Person.foo # => NoMethodError: undefined method `foo' for Person:Class
Person.new.foo # => 'foo'
Book.foo # => 'foo'
Book.new.foo # => NoMethodError: undefined method `foo'
# Callbacks are executed when including and extending a module
module ConcernExample
def self.included(base)
base.extend(ClassMethods)
base.send(:include, InstanceMethods)
end
module ClassMethods
def bar
'bar'
end
end
module InstanceMethods
def qux
'qux'
end
end
end
class Something
include ConcernExample
end
Something.bar # => 'bar'
Something.qux # => NoMethodError: undefined method `qux'
Something.new.bar # => NoMethodError: undefined method `bar'
Something.new.qux # => 'qux'
2013-07-04 09:53:12 +04:00
```
2014-03-11 01:05:49 +04:00
## Additional resources
- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges.
2014-03-11 01:05:49 +04:00
- [Official Documentation](http://www.ruby-doc.org/core-2.1.1/)
- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online.
- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.