adambard/learnxinyminutes-docs
1
1
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-12-28 09:42:35 +03:00
Code Issues Projects Releases Wiki Activity

Merge pull request #3183 from janniks/patch-1

Browse Source 
[ruby/en] Update ruby/en and unify styles
This commit is contained in:
Adam Bard 2018-08-23 22:23:32 -07:00 committed by GitHub
commit 84470bdd1c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 120 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

246
ruby.html.markdown
View File

@ -16,19 +16,20 @@ contributors:
- ["Persa Zula", "http://persazula.com"]
- ["Jake Faris", "https://github.com/farisj"]
- ["Corey Ward", "https://github.com/coreyward"]
- ["Jannik Siebert", "https://github.com/janniks"]
---
```ruby
# This is a comment
# In Ruby, (almost) everything is an object.
# This includes numbers…
# This includes numbers...
3.class #=> Integer
# …strings…
# ...and strings...
"Hello".class #=> String
# …even methods!
# ...and even methods!
"Hello".method(:class).class #=> Method
# Some basic arithmetic
@ -67,7 +68,7 @@ false.class #=> FalseClass
1 != 1 #=> false
2 != 1 #=> true
# apart from false itself, nil is the only other 'falsey' value
# Apart from false itself, nil is the only other 'falsey' value
!!nil #=> false
!!false #=> false
@ -111,33 +112,33 @@ placeholder = 'use string interpolation'
'hello ' + 3.to_s #=> "hello 3"
"hello #{3}" #=> "hello 3"
# Combine strings and operators
# ...or combine strings and operators
'hello ' * 3 #=> "hello hello hello "
# Append to string
# ...or append to string
'hello' << ' world' #=> "hello world"
# print to the output with a newline at the end
# You can print to the output with a newline at the end
puts "I'm printing!"
#=> I'm printing!
#=> nil
# print to the output without a newline
# ...or print to the output without a newline
print "I'm printing!"
#=> I'm printing! => nil
#=> "I'm printing!" => nil
# Variables
x = 25 #=> 25
x #=> 25
# Note that assignment returns the value assigned
# This means you can do multiple assignment:
# 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
# By convention, use snake_case for variable names.
snake_case = true
# Use descriptive variable names
@ -146,7 +147,7 @@ m = '/bad/name/'
# Symbols are immutable, reusable constants represented internally by an
# integer value. They're often used instead of strings to efficiently convey
# specific, meaningful values
# specific, meaningful values.
:pending.class #=> Symbol
@ -158,82 +159,82 @@ status == 'pending' #=> false
status == :approved #=> false
# Strings can be converted into symbols and vice versa:
# Strings can be converted into symbols and vice versa.
status.to_s #=> "pending"
"argon".to_sym #=> :argon
# Arrays
# This is an array
# This is an array.
array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
# Arrays can contain different types of items
# Arrays can contain different types of items.
[1, 'hello', false] #=> [1, "hello", false]
# Arrays can be indexed
# From the front
# Arrays can be indexed.
# From the front...
array[0] #=> 1
array.first #=> 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
# From the end
# ...or from the back...
array[-1] #=> 5
array.last #=> 5
# With a start index and length
# ...or with a start index and length...
array[2, 3] #=> [3, 4, 5]
# Reverse an Array
# ...or with a range...
array[1..3] #=> [2, 3, 4]
# You can reverse an Array.
a = [1,2,3]
a.reverse! #=> [3,2,1]
# Or with a range
array[1..3] #=> [2, 3, 4]
# Like arithmetic, [var] access is just syntactic sugar
# for calling a method '[]' on an object.
array.[] 0 #=> 1
array.[] 12 #=> nil
# Add to an array like this
# You can add to an array...
array << 6 #=> [1, 2, 3, 4, 5, 6]
# Or like this
array.push(6) #=> [1, 2, 3, 4, 5, 6]
# Check if an item exists in an array
# ...and check if an item exists in an array
array.include?(1) #=> true
# Hashes are Ruby's primary dictionary with key/value pairs.
# Hashes are denoted with curly braces:
# 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'
# 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:
# Asking a hash for a key that doesn't exist returns nil.
hash['nothing here'] #=> nil
# When using symbols for keys in a hash, you can use this alternate syntax:
# When using symbols for keys in a hash, you can use an alternate syntax.
new_hash = { defcon: 3, action: true }
hash = { :defcon => 3, :action => true }
hash.keys #=> [:defcon, :action]
new_hash.keys #=> [:defcon, :action]
hash = { defcon: 3, action: true }
hash.keys #=> [:defcon, :action]
# Check existence of keys and values in hash
new_hash.key?(:defcon) #=> true
new_hash.value?(3) #=> true
hash.key?(:defcon) #=> true
hash.value?(3) #=> true
# Tip: Both Arrays and Hashes are Enumerable
# They share a lot of useful methods such as each, map, count, and more
# Tip: Both Arrays and Hashes are Enumerable!
# They share a lot of useful methods such as each, map, count, and more.
# Control structures
# Conditionals
if true
'if statement'
elsif false
@ -242,28 +243,26 @@ else
'else, also optional'
end
# Loops
# In Ruby, traditional `for` loops aren't very common. Instead, these
# basic loops are implemented using enumerable, which hinges on `each`:
# basic loops are implemented using enumerable, which hinges on `each`.
(1..5).each do |counter|
puts "iteration #{counter}"
end
# Which is roughly equivalent to this, which is unusual to see in Ruby:
# Which is roughly equivalent to the following, which is unusual to see in Ruby.
for counter in 1..5
puts "iteration #{counter}"
end
# The `do |variable| ... end` construct above is called a “block”. Blocks are similar
# The `do |variable| ... end` construct above is called a 'block'. Blocks are similar
# to lambdas, anonymous functions or closures in other programming languages. They can
# be passed around as objects, called, or attached as methods.
# be passed around as objects, called, or attached as methods.
#
# The "each" method of a range runs the block once for each element of the range.
# 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.
# You can also surround blocks in curly brackets:
# You can also surround blocks in curly brackets.
(1..5).each { |counter| puts "iteration #{counter}" }
# The contents of data structures can also be iterated using each.
@ -274,8 +273,8 @@ hash.each do |key, value|
puts "#{key} is #{value}"
end
# If you still need an index you can use "each_with_index" and define an index
# variable
# If you still need an index you can use 'each_with_index' and define an index
# variable.
array.each_with_index do |element, index|
puts "#{element} is number #{index} in the array"
end
@ -291,9 +290,9 @@ end
#=> iteration 4
#=> iteration 5
# There are a bunch of other helpful looping functions in Ruby,
# for example "map", "reduce", "inject", the list goes on. Map,
# for instance, takes the array it's looping over, does something
# There are a bunch of other helpful looping functions in Ruby.
# For example: 'map', 'reduce', 'inject', the list goes on.
# Map, for instance, takes the array it's looping over, does something
# to it as defined in your block, and returns an entirely new array.
array = [1,2,3,4,5]
doubled = array.map do |element|
@ -304,6 +303,7 @@ puts doubled
puts array
#=> [1,2,3,4,5]
# Case construct
grade = 'B'
case grade
@ -322,7 +322,7 @@ else
end
#=> "Better luck next time"
# cases can also use ranges
# Cases can also use ranges
grade = 82
case grade
when 90..100
@ -334,9 +334,9 @@ else
end
#=> "OK job"
# exception handling:
# Exception handling
begin
# code here that might raise an exception
# Code here that might raise an exception
raise NoMemoryError, 'You ran out of memory.'
rescue NoMemoryError => exception_variable
puts 'NoMemoryError was raised', exception_variable
@ -354,10 +354,10 @@ def double(x)
x * 2
end
# Methods (and blocks) implicitly return the value of the last statement
# Methods (and blocks) implicitly return the value of the last statement.
double(2) #=> 4
# Parentheses are optional where the interpretation is unambiguous
# Parentheses are optional where the interpretation is unambiguous.
double 3 #=> 6
double double 3 #=> 12
@ -366,15 +366,14 @@ def sum(x, y)
x + y
end
# Method arguments are separated by a comma
# Method arguments are separated by a comma.
sum 3, 4 #=> 7
sum sum(3, 4), 5 #=> 12
# yield
# All methods have an implicit, optional block parameter
# it can be called with the 'yield' keyword
# All methods have an implicit, optional block parameter.
# Tt can be called with the 'yield' keyword.
def surround
puts '{'
yield
@ -383,45 +382,43 @@ end
surround { puts 'hello world' }
# {
# hello world
# }
#=> {
#=> hello world
#=> }
# Blocks can be converted into a `proc` object, which wraps the block
# Blocks can be converted into a 'proc' object, which wraps the block
# and allows it to be passed to another method, bound to a different scope,
# or manipulated otherwise. This is most common in method parameter lists,
# where you frequently see a trailing `&block` parameter that will accept
# the block, if one is given, and convert it to a `Proc`. The naming here is
# convention; it would work just as well with `&pineapple`:
# where you frequently see a trailing '&block' parameter that will accept
# the block, if one is given, and convert it to a 'Proc'. The naming here is
# convention; it would work just as well with '&pineapple'.
def guests(&block)
block.class #=> Proc
block.call(4)
end
# The `call` method on the Proc is similar to calling `yield` when a block is
# present. The arguments passed to `call` will be forwarded to the block as arugments:
# The 'call' method on the Proc is similar to calling 'yield' when a block is
# present. The arguments passed to 'call' will be forwarded to the block as arugments.
guests { |n| "You have #{n} guests." }
# => "You have 4 guests."
# You can pass a list of arguments, which will be converted into an array
# That's what splat operator ("*") is for
# 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
# Destructuring
# Ruby will automatically destructure arrays on assignment to multiple variables:
# Ruby will automatically destructure arrays on assignment to multiple variables.
a, b, c = [1, 2, 3]
a #=> 1
b #=> 2
c #=> 3
# In some cases, you will want to use the splat operator: `*` to prompt destructuring
# of an array into a list:
# of an array into a list.
ranked_competitors = ["John", "Sally", "Dingus", "Moe", "Marcy"]
def best(first, second, third)
@ -430,7 +427,7 @@ end
best *ranked_competitors.first(3) #=> Winners are John, Sally, and Dingus.
# The splat operator can also be used in parameters:
# The splat operator can also be used in parameters.
def best(first, second, third, *others)
puts "Winners are #{first}, #{second}, and #{third}."
puts "There were #{others.count} other participants."
@ -440,21 +437,23 @@ best *ranked_competitors
#=> Winners are John, Sally, and Dingus.
#=> There were 2 other participants.
# By convention, all methods that return booleans end with a question mark
5.even? # false
5.odd? # true
# By convention, all methods that return booleans end with a question mark.
5.even? #=> false
5.odd? #=> true
# And if a method ends with an exclamation mark, it does something destructive
# By convention, if a method name ends with an exclamation mark, it does something destructive
# like mutate the receiver. Many methods have a ! version to make a change, and
# a non-! version to just return a new changed version
# a non-! version to just return a new changed version.
company_name = "Dunder Mifflin"
company_name.upcase #=> "DUNDER MIFFLIN"
company_name #=> "Dunder Mifflin"
company_name.upcase! # we're mutating company_name this time!
# We're mutating company_name this time.
company_name.upcase! #=> "DUNDER MIFFLIN"
company_name #=> "DUNDER MIFFLIN"
# Classes
# Define a class with the class keyword
# You can define a class with the 'class' keyword.
class Human
# A class variable. It is shared by all instances of this class.
@ -462,7 +461,7 @@ class Human
# Basic initializer
def initialize(name, age = 0)
# Assign the argument to the "name" instance variable for the instance
# 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
@ -478,10 +477,10 @@ class Human
@name
end
# The above functionality can be encapsulated using the attr_accessor method as follows
# 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
# Getter/setter methods can also be created individually like this.
attr_reader :name
attr_writer :name
@ -496,13 +495,11 @@ class Human
end
end
# Instantiate a class
# Instantiating of a class
jim = Human.new('Jim Halpert')
dwight = Human.new('Dwight K. Schrute')
# Let's call a couple of methods
# You can call the methods of the generated object.
jim.species #=> "H. sapiens"
jim.name #=> "Jim Halpert"
jim.name = "Jim Halpert II" #=> "Jim Halpert II"
@ -510,30 +507,30 @@ jim.name #=> "Jim Halpert II"
dwight.species #=> "H. sapiens"
dwight.name #=> "Dwight K. Schrute"
# Call the class method
# Calling of a class method
Human.say('Hi') #=> "Hi"
# Variable's scopes are defined by the way we name them.
# Variables that start with $ have global scope
# Variables that start with $ have global scope.
$var = "I'm a global var"
defined? $var #=> "global-variable"
# Variables that start with @ have instance scope
# Variables that start with @ have instance scope.
@var = "I'm an instance var"
defined? @var #=> "instance-variable"
# Variables that start with @@ have class scope
# 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
# 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.
# Class is also an object in ruby. So a class can have instance variables.
# A class variable is shared among the class and all of its descendants.
# base class
# Base class
class Human
@@foo = 0
@ -546,18 +543,17 @@ class Human
end
end
# derived class
# Derived class
class Worker < Human
end
Human.foo # 0
Worker.foo # 0
Human.foo #=> 0
Worker.foo #=> 0
Human.foo = 2 # 2
Worker.foo # 2
# Class instance variable is not shared by the class's descendants.
Human.foo = 2
Worker.foo #=> 2
# A class instance variable is not shared by the class's descendants.
class Human
@bar = 0
@ -573,8 +569,8 @@ end
class Doctor < Human
end
Human.bar # 0
Doctor.bar # nil
Human.bar #=> 0
Doctor.bar #=> nil
module ModuleExample
def foo
@ -582,9 +578,8 @@ module ModuleExample
end
end
# Including modules binds their methods to the class instances
# Extending modules binds their methods to the class itself
# Including modules binds their methods to the class instances.
# Extending modules binds their methods to the class itself.
class Person
include ModuleExample
end
@ -593,13 +588,12 @@ 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'
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)
@ -623,10 +617,10 @@ 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'
Something.bar #=> "bar"
Something.qux #=> NoMethodError: undefined method `qux'
Something.new.bar #=> NoMethodError: undefined method `bar'
Something.new.qux #=> "qux"
```
## Additional resources