• Хешове
• Методи
• Обекти
• Класове

• Сряда ще пием бира вместо лекция
• Началото е (ориентировъчно) 19:30
• Мястото е "Мазе" (бившия „Бар на края на вселената“) на Графа до Алабин и Христо Белчев
• Присъствието ви не е задължително, но ще се радваме да се видим
• Има събитие във Фейсбук - отбележете, ако ще идвате

• Публикувано е първото предизвикателство
• Имате време до сряда на обяд
• Малко, но забавно
• За въпроси, вижте съответната тема във форумите

• Миналия път говорихме малко за open-source и pull request-и
• Искаме да ви направим малка демонстрация

• Получихме малко обратна връзка за този спор
• Къде е истината?
• Често може да се появи в един хубав спор (дебат)
• Различните гледни точки са важни
• Не приемайте нищо наготово - мислете, бъдете критични, имайте мнение
• Критичното мислене от ваша страна е страшно важно

Вашата навременна обратна връзка е много важна за нас. Имате поне няколко начина да ни споделите какво мислите:

1. Пуснете тема във форума на курса
2. Имейл до fmi@ruby.bg
3. Псевдо-анонимно – "един приятел ми сподели..."
4. Говорете с нас по време на междучасието, след лекциите, на по бира...

• Вече има 30-ина предадени решения, на повечето съм оставил бележки
• Който е предал решение рано, има привилегията да получи нашето мнение и да си го коригира
• Имахте шанс да пробвате да ровите сами в една слабо позната технология
• Днес ще ви покажем още неща, които ще ви помогнат
• Преди това, малко бележки

• Задължително прочетете ръководството по стил
• При нас тези неща имат силата на закон
• Казахме го вече, но все пак има решения, които са подредени като крем-супа
• Пак напомняме, ще взимаме точки при системното им неспазване
• Настройте си редактора - да показва trailing whitespace, интервали и табулации; да идентира правилно
• Запазвам си правото да не коментирам решения, които са просто изсипана купчина символи

• Именуване – полагайте големи усилия, когато го правите; нека ви стане навик
• tmp е епитома на лошите имена
• Лоши са и data, result, array, hash – прекалено общи
• Лоши са size1, size2 – със сигурност има някаква друга разлика между тях
• Лоши са a, b, c, f, x, y, s и всички други букви
• Има малко изключения на горното (например i, когато се използва като индексна променлива)
• В много ситуации може да избегнете създаването на променлива съвсем

• С неща от типа на curr, prev, el, elem, num не печелите нищо, но губите много
• Стремете се да спазвате Clarity over brevity

If you work hard at being clear in your naming, you’ll also rarely need to write comments for the code. Comments are generally only needed when you failed to be clear enough in naming. Treat them as a code smell.

— DHH

В контекста на метод, проверяващ дали число е просто:

middle = Math.sqrt(self)

upper_limit = Math.sqrt(self)

• divider означава "разделител, преграда, ..."
• divisor е делител
• Точният превод е важен
• Ползвайте речник, когато не сте сигурни

• Спазване на конвенциите
• Стремеж към подходящи имена
• Прост и ясен дизайн

My guiding light is Kent Beck's rules of Simple Design (източник):

1. The code must first be correct (as defined by tests);
2. then it should be a clear statement of the design (what J.B.Rainsberger calls "no bad names");
3. then it should contain no duplication (of text, of ideas, or of responsibility);
4. and finally it must be the smallest code that meets all of the above.

It's time to stop refactoring when the code makes a reasonable stab at meeting those goals, and when any further changes would add no further benefit.

• В Ruby (core и stdlib) има много класове и модули
• В тях има много готова функционалност
• Преоткриването на колелото има и педагогически елемент, но...
• Когато пишете задачи, ви насърчаваме да търсите и ползвате тази функционалност

Започнете да се запознавате с документацията на следните класове/модули:

• Enumerable
• Array
• Hash
• String
• Numeric
• Integer
• Fixnum
• Float
• Rational

Какво прави <=> (наричан the space shuttle operator)?

Какво извежда следният код и защо?

puts 'foo' == 'foo', 'foo'.equal? 'foo'
puts [] == [],       [].equal? []
puts 42 == 42,       42.equal? 42
puts :foo == :foo,   :foo.equal? :foo

Итерира се с #each, както всичко останало в Ruby:

primes = [2, 3, 5, 7, 11]

primes.each { |n| puts n }

primes.each do |n|
  puts n
end

• По конвенция, фигурни скоби се ползват, когато целият блок е на един ред
• do/end се ползва, когато блокът е няколко реда
• Това е конвенцията, която ще спазваме и ние

next прескача изпълнението до края на блока и продължава със следващия елемент, ала continue в C/Java.

break прекъсва итерацията и продължава изпълнението след блока.

numbers.sort.each do |number|
  next if number.odd?
  break if number > 100

  puts number
end

• Важна част в програмирането на Ruby
• Майсторското овладяване е задължително!
• Още: хеш таблици, асоциативен списък, речник, map

• Класът е Hash, но има и литерален синтаксис – {}
• Дефинират се така: {1 => :one, 2 => :two}
• Ключовете трябва да могат да се хешират: числа, низове, символи, списъци
• По възможност, ключовете трябва да са immutable
• От Ruby 1.9 насам редът на ключовете се запазва

Долните два реда произвеждат еднакви хешове. Второто е 1.9+ синтаксис и ще предпочитаме него по конвенция (когато може):

{:one => 1, :two => 2}
{one: 1, two: 2}

Има интересна врътка при извикването на методи, за която ще споменем малко по-натам.

• И като цяло всичко, що може да се обхожда (т.е. е Enumerable)
• Ползват се постоянно
• Трябва да ги владеете много добре
• Това е едва върхът на айсберга

Дефинирането става с ключовата дума def. Резултатът от функцията е последният оценен израз, ако няма return някъде по-рано.

def factorial(n)
  if n == 1
    1
  else
    factorial(n - 1) * n
  end
end

В Ruby няма tail recursion оптимизация. Този код яде стек.

• В Ruby няма такова нещо като "глобална функция"
• def винаги дефинира метод в някакъв клас
• Ако def не е в дефиниция на клас, отива като private метод на Object
• puts е пример за нещо такова, както и методите, които дефинирате в irb
• Дефинирането на методи в Object е удачно само за кратки скриптове
• Отвъд тях, дефинирането на методи в Object е ужасно лош стил

За да добавите метод в съществуващ клас, например Array, просто "отваряте" класа и дефинирате метода:

class Array
  def fourty_second
    self[41]
  end
end

list     = []
list[41] = 'The Universe'

list.fourty_second # "The Universe"

Можете да излезете от функция с return:

def includes?(array, element)
  array.each do |item|
    return true if item == element
  end
  false
end

Разбира се, такава функция е излишна. Може да ползвате array.include?(element).

Параметрите в Ruby могат да имат стойности по подразбиране:

def order(drink, size = 'large')
  "A #{size} #{drink}, please!"
end

order 'tea'             # "A large tea, please!"
order 'coffee', 'small' # "A small coffee, please!"

• Стойностите по подразбиране могат да бъдат всякакъв израз
• "Всякакъв израз" включва и извикване на друга функция
• Оценяват се на всяко извикване
• Сложни изрази за аргументи по подразбиране са лош стил

Методите в ruby могат да вземат променлив брой аргументи. Параметърът се означава със * и при извикване на функцията съдържа списък от аргументите.

def say_hi(name, *drinks)
  "Hi, I am #{name} and I enjoy: #{drinks.join(', ')}"
end

say_hi 'Mityo', 'coffee', 'tea', 'water' # "Hi, I am Mityo and I enjoy: coffee, tea, water"

Параметърът за променлив брой аргументи може да е на всяка позиция в дефиницията:

def something(*a, b, c)
end

def something(a, *b, c)
end

Очевидно, може да има само един такъв параметър във функция.

Когато последният аргумент е хеш, може да изтървете фигурните скоби около него. Долните редове правят едно и също:

def order(drink, preferences)
end

order 'Latte', {:size => 'grande', :syrup => 'hazelnut'}
order 'Latte', :size => 'grande', :syrup => 'hazelnut'
order 'Latte', size: 'grande', syrup: 'hazelnut'

Така Ruby симулира извикане на функция с наименовани аргументи. Последният ред работи при версия 1.9+

Често ще видите код в този вид:

def order(drink, preferences = {})
end

order 'Latte'
order 'Latte', size: 'grande', syrup: 'hazelnut'

Така preferences е незадължителен и няма нужда да го подавате, ако нямате предпочитания.

Този "трик" с хешовете се ползва много, понякога прекалено много. Той има и ред недостатъци:

• За да ползвате стойност, трябва да я достъпите през променлива (например preferences[:size])
• Задаването на стойности по подразбиране е криво и може да се прави само в тялото на метода
• Например така: preferences[:size] ||= 'grande'
• Или така: preferences = {size: 'grande', syrup: 'hazelnut'}.merge(preferences)
• Проверката за задължителни keyword args става пак ръчно
• Проверката дали някой не ви е подал "излишни" и непознати ключови думи за аргументи – пак ръчно

Горните недостатъци и нуждата водят до появата на истински keyword arguments в Ruby 2.0.

def order(drink, size: 'grande', syrup: nil)
  message = "You ordered a #{size} #{drink}"
  message << " with a #{syrup} syrup" if syrup
  message
end

order 'Latte'                       # "You ordered a grande Latte"
order 'Latte', syrup: 'hazelnut'    # "You ordered a grande Latte with a hazelnut syrup"
order 'Latte', filling: 'chocolate' # error: ArgumentError

• Ако има стойност по подрзбиране, тя се задава редом с дефиницията на метода
• Ползвате стойността на аргумента директно, няма нужда от отделна променлива
• Непознати ключови думи, подадени като аргументи, предизвикват грешка
• Липсващи и задължителни ключови думи за аргументи също предизвикват грешка

Името на метод може да завършва на ?. Това се ползва, за методи, които връщат лъжа или истина (предикати):

def even?(n)
  n % 2 == 0
end

even? 2
even? 3

Това е само конвенция.

Името на метод може да завършва на !. Това се ползва, когато методът има две версии с различно поведение:

numbers = [4, 1, 3, 2, 5, 0]

numbers.sort   # връща нов списък
numbers.sort!  # променя списъка на място

В случая, "по-опасният" метод завършва на удивителна.

Ако имате само една версия на метод с такова име, не слагайте удивителна.

Анонимни функции в Ruby се дефинират с lambda. Имат три начина на извикване:

pow = lambda { |a, b| a ** b }

pow.call 2, 3
pow[2, 3]
pow.(2, 3)

За нещастие, не може да извиквате така: double(2). Това е несъвместимо с изтърваването на скобите при извикването на метод.

Може и така:

double = lambda do |x|
  x * 2
end

Важи стандартната конвенция за { } и do/end.

От 1.9 има по-симпатичен синтаксис за ламбди:

say_hi = lambda { puts 'Hi there!' }
double = lambda { |x| x * 2 }
divide = lambda { |a, b| a / b }

say_hi = -> { puts 'Hi there' }
double = ->(x) { x * 2 }
divide = ->(a, b) { a / b }

Всеки метод може да приеме допълнителен аргумент, който е "анонимна функция". Може да го извикате от метода с yield:

def twice
  yield
  yield
end

twice { puts 'Ruby rocks!' }

Блокът може да приема аргументи:

def sequence(first, last, step)
  current = first
  while current < last
    yield current
    current += step
  end
end

sequence(1, 10, 2) { |n| puts n }
# Извежда 1, 3, 5, 7, 9

yield се оценява до стойността на блока:

def calculate
  result = yield(2)
  "The result for 2 is #{result}"
end

calculate { |x| x ** 2 } # "The result for 2 is 4"

Или как можем да напишем filter:

def filter(array)
  result = []
  array.each do |item|
    result << item if yield item
  end
  result
end

filter([1, 2, 3, 4, 5]) { |n| n.odd? } # [1, 3, 5]

block_given? ще ви каже дали методът е извикан с блок:

def i_can_haz_block
  if block_given?
    puts 'yes'
  else
    puts 'no'
  end
end

i_can_haz_block                  # no
i_can_haz_block { 'something' }  # yes

Ако имате ламбда, която искате да подадете като блок, може да ползвате &:

is_odd = lambda { |n| n.odd? }

filter([1, 2, 3, 4, 5], &is_odd)
filter([1, 2, 3, 4, 5]) { |n| n.odd? }

Горните са (почти) еквиваленти. Има малка разлика в някои други случаи.

Ако искате да вземете блока като обект, има начин:

def invoke_with(*args, &block)
  block.call *args
end

invoke_with(1, 2) { |a, b| puts a + b }

Може и така:

def make_block(&block)
  block
end

doubler = make_block { |n| n * 2 }
doubler.call 2 # 4

• Следващото събиране няма да е във ФМИ, а на "по бира"
• Сряда, 16 октомври, в Maze
• Кажете, че ще идвате в събитието във Фейсбук
• Успех със задачата и предизвикателството и до сряда!

• http://fmi.ruby.bg/
• @rbfmi