• Търсене на константи
• Класовете като обекти
• Символи към proc обекти
• case в Ruby
• Замразяване на низове

Малко въпроси

Какво правят alias и alias_method? Каква е разликата между двете?

Какъв ще е резултатът от кода по-долу? Защо?

answer = 42

universe = proc do
  def say_answer
    puts "The answer is: #{answer}"
  end

  say_answer
end

Какво ще изведе на екрана следният код:

FOOD = 'muffin'
module Cake
  FOOD = 'fruit'
end
module Dessert
  FOOD = ::Cake
  module Cake
    FOOD = 'chocolate'
  end
end

puts FOOD
module Dessert
  puts Cake::FOOD
  module Cake
    puts Cake::FOOD
    puts ::Cake::FOOD
    puts Dessert::FOOD
  end
  puts FOOD
end
puts Dessert::FOOD::FOOD

Отговорът

FOOD = 'muffin'
module Cake
  FOOD = 'fruit'
end
module Dessert
  FOOD = ::Cake
  module Cake
    FOOD = 'chocolate'
  end
end

puts FOOD                #=> muffin
module Dessert
  puts Cake::FOOD        #=> chocolate
  module Cake
    puts Cake::FOOD      #=> chocolate
    puts ::Cake::FOOD    #=> fruit
    puts Dessert::FOOD   #=> Cake
  end
  puts FOOD              #=> Cake
end
puts Dessert::FOOD::FOOD #=> fruit

Какво ще съдържат променливите след присвояването:

foo, (bar,), (larodi, *qux, answer), *others = 1, [2, 3], [1, 2, 3, 42]

• Той е достъпен със синтаксиса ::
• Също така, той се намира в Object
• Тоест, Object::FOO и ::FOO в (почти) всички случаи са едно и също
• Кога може да не са?
• ::Object::FOO и ::FOO са едно и също винаги

• Понякога познаването на вътрешната имплементация помага за разбирането
• Всяка константа-клас или модул си има хеш-таблица с вложените непосредствено в нея константи
• Root scope-ът се пази в константата Object
• Така работи влагането и така работи constant resolution-ът

Можете да видите тази "таблица" през constants:

module MyLibrary
  class Object
  end
end

MyLibrary.constants         # => [:Object]
MyLibrary::Object == Object # => false

class Foo::Bar
  # In the Bar scope, but not in the Foo scope
end

• Съществува понятието "текущ scope"
• Той се гледа, ако използвате "релативен" път до дадена константа
• Сменя се с ключовите думи class и module

В този пример:

class Foo::Bar
  Larodi
end

• Създаваме константа (клас) Bar и я записваме в таблицата с константи на Foo
• Foo трябва да съществува предварително; може да бъде или модул, или клас
• Константата Larodi ще се търси в таблицата на Bar и след това в root scope-а
• Няма да се търси в таблицата на Foo

module A::B
  module C::D
    Foo # Where does Ruby look for Foo?
  end
end

1. В таблицата на D
2. В таблицата на B
3. В root scope-а (т.е. в таблицата на Object)

Задайте ги сега!

Следните два реда са (почти) еквивалентни:

name = proc { |object| object.name }
name = :name.to_proc

%w(foo plugh larodi).map { |s| s.length } # => [3, 5, 6]
%w(foo plugh larodi).map(&:length)        # => [3, 5, 6]

Всъщност, малко по-сложно е:

block = proc { |obj, *args| obj.method_name *args }
block = :method_name.to_proc

[{a: 1}, {b: 2}, {c: 3}].reduce { |a, b| a.merge b } # => {:a=>1, :b=>2, :c=>3}
[{a: 1}, {b: 2}, {c: 3}].reduce(&:merge)             # => {:a=>1, :b=>2, :c=>3}

[1, 2, 3, 4].reduce { |sum, b| sum + b } # => 10
[1, 2, 3, 4].reduce(&:+)                 # => 10

• Ползва се често
• Дори да не го ползвате често, трябва да знаете как работи

['Foo', :bar, 3].map(&:to_s).map(&:upcase)

• Всеки обект в Ruby има метод send
• Може да ползвате send, за да викате произволни методи на този обект
• Дори private или protected такива
• Ползвайте public_send, ако искате да не прекрачвате този праг
• Например:

3.send :+, 4                # => 7
3.public_send :+, 4         # => 7

3.send :puts, 'Ruby magic!' # Ruby magic!
3.public_send :puts, 'wow'  # => error: NoMethodError

???

• Знаем, че всичко в Ruby е обект
• Класовете не правят изключение
• Можем да викаме методи на тях (напр. String.methods)
• Обектите тип "клас" си имат клас (String.class) и той е Class
• Тоест, са негови инстанции

Долното работи:

a_hash_class = Hash
a_hash_class.new # => {}

• Можем да създаваме динамично обекти тип "клас" с Class.new
• Тези класове се наричат анонимни класове
• Абсолютно аналогично е за модули
• Module.new ще създаде инстанция на анонимен модул

anonymous_class = Class.new
anonymous_class.new # => #<#<Class:0x002b4f24590b20>:0x002b4f24590aa8>
Class.new.new       # => #<#<Class:0x002b4f24590530>:0x002b4f245904e0>
Module.new          # => #<Module:0x002b4f245900f8>

Можем да подадем блок на Class.new:

duck = Class.new do
  def quack_to(creature_name)
    "Quack, #{creature_name}, quack!"
  end
end

duck.new.quack_to("swan") # => "Quack, swan, quack!"

class Person
end

• С оглед на това, class е просто синтаксис, който прави обект от тип "клас"
• Припомняме за scope gate-овете – class е scope gate, докато блоковете не са
• Освен да създаде обект, class го присвоява и на константа
• Тоест, примерът по-горе може да се разглежда като присвояване на константа
• А "имената" на класове са просто константи, сочещи към някакъв обект

Когато присвоим анонимен клас на константа, попадаме в специален случай:

Person = Class.new

Class.new           # => #<Class:0x002ba7326dbe10>
Person = Class.new  # => Person

Module.new          # => #<Module:0x002ba7326db578>
Larodi = Module.new # => Larodi

?!?

• Миналия път ви показахме един от начините да дефинирате такъв
• Този начин не е единствен и не е "каноничният"

Неканоничният и праволинеен начин за дефиниране на класов метод:

module Snake
  class Level
    def Level.load(level_data)
      # Code
    end
  end
end

Този начин е еквивалентен на предишния слайд:

module Snake
  class Level
    def self.load(level_data)
      # Code
    end
  end
end

Това работи, понеже:

• Тялото на класа е изпълним код
• Както във всеки друг контекст в Ruby, и там имаме self
• self и Snake::Level в тялото на класа реферират към един и същ обект

Използва се при нужда да се дефинират няколко класови метода:

module Snake
  class Level
    class << self
      def load(level_data)
        # Code
      end
    end
  end
end

• Какъв е този синтаксис и защо работи, ще си говорим по-нататък

• Първият начин не се ползва (def ClassName.method_name() end)
• При дефиниране на един, максимум два класови метода, ползваме втория начин
• При дефиниране на повече от един класов метод, обикновено ползваме третия начин

Преди да продължим със следващата тема.

В Ruby има "switch". Казва се case.

def quote(name)
  case name
  when 'Yoda'
    puts 'Do or do not. There is no try.'
  when 'Darth Vader'
    puts 'The Force is strong with this one.'
  when 'R2-D2'
    puts 'Beep. Beep. Beep.'
  else
    puts 'Dunno what to say'
  end
end

Забележете индентацията.

• Няма fall-through. Не се пише break
• Ако нито един when не мине, изпълнява се else
• Ако нито един when не мине и няма else, не става нищо
• case е израз, което значи, че връща стойност

На какво ще се оцени следният код?

case 'Wat?'
when 'watnot' then puts "I'm on a horse."
end

case не сравнява с ==. Може да напишете следното:

def qualify(age)
  case age
  when 0..12
    'still very young'
  when 13..19
    'a teenager! oh no!'
  when 33
    'the age of jesus'
  when 90..200
    'wow. that is old!'
  else
    'not very interesting'
  end
end

case сравнява с ===. Няколко класа го имплементират:

• Range
• Regexp
• Class
• Списъкът не е изчерпателен...
• По подразбиране се оценява като ==

Ruby позволява да обедините проверката за няколко възможни стойности в един when, дори да не са от един и същи тип.

case number
when (42+0i)  then 'This is too complex for me!'
when 42, 42.0 then 'This is more like it!'
end

• Можете да слагате и цели изрази в when
• Изпуска се параметърът след case, например:

thing = 42
case
when thing == 1 then 1
else 'no_idea'
end

• Не го правете.
• Ако ви се налага, ползвайте обикновени if-ове

Сега е моментът.

• Замразяването става с Object#freeze (Мутира обекта!)
• Реално превръща mutable-обекти в immutable
• Можете да проверите дали обект е замразен с Object#frozen?
• Веднъж замразен, даден обект не може да бъде размразен
• Не можете да променяте вече замразени обекти (workaround е да направите dup)
• Често се ползва, когато присвоявате mutable-типове на константи

Тъй като низовете в Ruby са mutable, всяко срещане на низ = нов обект:

''.object_id                 # => 23775293466780
''.object_id                 # => 23775293466240
''.object_id == ''.object_id # => false

• Това е performance проблем
• Символите го решават, но те не са заместител на низове

class HTTP
  attr_reader :method
  METHOD_POST = 'POST'

  def post?
    method == METHOD_POST
  end
end

Това е досадно. Затова в Ruby 2.1 има и по-добро решение.

''.freeze.object_id                        # => 23589015467900
''.freeze.object_id                        # => 23589015467900
''.freeze.object_id == ''.freeze.object_id # => true

• Границата между freeze-нати низове и символи се размива в последните версии на Ruby
• И символите вече се garbage collect-ват

• "Chunky bacon".freeze се оптимизира от Ruby и връща един и същи обект
• Ако вече има такъв обект, с такова съдържание, той ще бъде преизползван
• Важи само при първо дефиниране на низ с литерален синтаксис

• От Ruby 2.3 има начин да замразим всички стрингове в даден rb файл
• Това става с магическия коментар # frozen_string_literal: true
• Слага се в началото на файла
• Всички стрингове, дефинирани в този файл са замразени при създаване
• Внимавайте - може да счупи работата ви с някои библиотеки

• Полезно и интересно е да знаете за оптимизацията
• Не замразявайте низове под път и над път заради това
• Това е микро-оптимизация, а те не са добра идея
• Замразявайте неща, ако ви е страх от промени :)

• На теория невъзможно
• Действителността се разминава с теорията
• Не го правете (освен за ескперименти и debugging)
• Вързано за C имплементацията на интерпретатора
• Има ограничения

require 'fiddle'

class Object
  def unfreeze
    Fiddle::Pointer.new(object_id * 2)[1] &= ~(1 << 3)
  end
end

script = 'Do you want to build a castle of ice?'.freeze
script.frozen? # => true
script.unfreeze
script[/castle of ice/] = 'snowman'
script.frozen? # => false
script # => "Do you want to build a snowman?"

• Wut?

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