Синтаксический сахар

В Ruby для одного и того же действия можно найти десяток вариантов решения проблемы, причем не изменяя принцип работы программы. Знание и применение синтаксического сахара позволяет сократить кол-во написанного кода, а также получить от других разработчиков уважение и почет.

Сокращаем блок кода до минимума

мы знаем, что записать блок кода мы можем c помощью { |x| ... } и do |x| ... end, но часто бывает так, что код внутри блока может состоять из вызова 1 метода у параметра. В таких случаях мы можем превратить запись arr.map {|x| x.some_method } в эквивалентную ей arr.map(&:some_method).

words = ["dog", "magic", "service"]
p words.map {|word| word.capitalize}

p words.map(&:capitalize) # работает точно так же как и пример выше, просто короче записывается

Proc => Блок => Proc

Кроме того знак & может служить способом перевода Proc в блок кода добавляя & перед самим proc

func = proc {|x| puts x }

# распечает в консоль все ёлементы массив
[1, 5, 2, 0].each(&func)

Также мы можем превратить наш proc в блок кода, добавив & перед названием аргумента

def map_val(val, &func)
  func.call(val)
end

# вместо передачи proc мы объявляем его как блок кода
puts map_val(100) {|x| x + 1 }

Скобки не нужны

По ходу курса мв привыкли писать наши методы с помощью скобок def method(arg), но на самом деле скобки в ruby не являются обязательным атрибутам,с соответсвенно мы можем записать метод в формате def method arg.

Важно не комбинируйте между собой разные стили написания скобок. Если вы пишете вашу программу без них, то пишите и дальше, если с ними, то пишите всю программу с их использованием. В таком случае вам не придется каждый раз привыкать глазами к новому стилю.

Записать, только если ранее не было записано

Возможно вы уже сталкивались с необходимостью проверять каждый раз на nil переменную перед тем как записать в нее значение и выглядело это следующим образом:

var = nil
if var.nil?
  var = 10
end

на самом деле такую запись можно заметно сократить до:

var = nil 
var ||= 10
puts var # = 10
var ||= 20
puts var # = 10

метод []

При работе с массивами или хэш таблицей мы сталкивались с обращением к значению по индексу или ключу с помощью arr[index], но на самом деле такая запись доступна для собственных классов тоже

class MyHash
  @hash = {}

  def [](key)
    @hash.[key]
  end

  def []=(key, value)
    @hash.[key] = value
  end
end

my_hash = MyHash.new
my_hash[:hello] = 'world'
puts my_hash[:hello] # = world

Если можно обойтись без цикла, значит лучше без него

Циклы являются самыми старыми конструкцйиями любого языка, но с прошествием времени появились такие методы как .each, .map, .select, которые на данный момент являются более предпочтительным вариантом записи. Конечно в 100% случаев нельзя обойтись только ими, поэтому если в вашей программе проще и чище обойтись циклом, значит не стоит пытаться придумать как обойтись без них.

Задание refactoring

arr = [1, -2, 3, -4, 5]
result = arr.select { |x| x >= 0 }
puts result

arr = ["a", "b", "c"]
puts arr.map { |x| x.upcase }

hash = {name: "John", age: 30}
result = []
hash.each { |k, v| result << "#{k}: #{v}" }
puts result

Сделайте этот код более чище с помощью синтаксического сахара