Идиоматический Ruby: написание красивого кода

Ruby — прекрасный язык программирования.

Согласно с Рубинофициальная веб-страница Ruby — это:

«динамический язык программирования с открытым исходным кодом с упором на простоту и производительность. У него элегантный синтаксис, который легко читать и легко писать».

Руби был создан Юкихиро Мацумото, японский инженер-программист. С 2011 года он был главным дизайнером и инженером-программистом Ruby в Героку.

Мацумото часто говорил, что он пытается** сделать Ruby естественным, а не простым**, таким образом, чтобы он отражал жизнь.

«Рубин прост внешне, но очень сложен внутри, как и наше человеческое тело» — Юкихиро Мацумото.

Я чувствую то же самое по отношению к Руби. Это сложный, но очень естественный язык программирования с красивым и интуитивно понятным синтаксисом.

Благодаря более интуитивно понятному и быстрому коду мы можем создавать более качественное программное обеспечение. В этом посте я покажу вам, как я выражаю свои мысли (или код) с помощью Ruby, используя фрагменты кода.

Выражение моих мыслей с помощью методов массива

карта

Использовать карта способ упростить ваш код и получить то, что вы хотите.

Метод** map** возвращает новый массив с результатами однократного запуска блока для каждого элемента в перечислении.

Давай попробуем:

an_array.map { |element| element * element }

Просто как тот.

Но когда вы начинаете программировать на Ruby, легко всегда использовать каждый итератор.

каждый итератор, как показано ниже

user_ids = []
users.each { |user| user_ids << user.id }

Можно упростить с карта в одной красивой строке кода:

user_ids = users.map { |user| user.id }

Или еще лучше (и быстрее):

user_ids = users.map(&:id)

Выбирать

И когда вы привыкли кодировать с помощью картаиногда ваш код может выглядеть так:

even_numbers = [1, 2, 3, 4, 5].map { |element| element if element.even? } 
even_numbers = even_numbers.compact 

ноль также объект. Использовать компактный способ удалить все ноль объекты.

И та-да, вы выбрали все четные числа.

Миссия выполнена.

Давай, мы можем сделать лучше, чем это! Вы слышали о Выбрать метод из перечисляемого модуля?

[1, 2, 3, 4, 5].select { |element| element.even? }

Всего одна линия. Простой код. Легко понять.

Бонус

[1, 2, 3, 4, 5].select(&:even?)

Образец

Представьте, что вам нужно получить случайный элемент из массива. Вы только начали изучать Ruby, поэтому вашей первой мыслью будет: «Давайте воспользуемся случайный метод», и вот что происходит:

[1, 2, 3][rand(3)]

Ну, мы можем понять код, но я не уверен, что он достаточно хорош. А что, если мы воспользуемся перемешивать метод?

[1, 2, 3].shuffle.first

Хм. Я на самом деле предпочитаю использовать перемешивать над ранд. Но когда я обнаружил образец метод, это имело гораздо больше смысла:

[1, 2, 3].sample

Действительно, очень просто.

Довольно естественно и интуитивно понятно. Мы просим образец из массива, и метод возвращает его. Теперь я счастлив.

А вы?

Выражение моих мыслей с помощью синтаксиса Ruby

Как я уже говорил, мне нравится, как Ruby позволяет мне кодировать. Это действительно естественно для меня. Я покажу части прекрасного синтаксиса Ruby.

Неявный возврат

Любой оператор в Ruby возвращает значение последнего вычисленного выражения. Простой пример — метод **getter**. Мы вызываем метод и ожидаем взамен какое-то значение.

Посмотрим:

def get_user_ids(users)
  return users.map(&:id)
end

Но, как мы знаем, Ruby всегда возвращает последнее вычисленное выражение. Зачем использовать возвращаться утверждение?

def get_user_ids(users)
  users.map(&:id)
end

После использования Ruby в течение 3 лет я чувствую себя прекрасно, используя почти все методы без возвращаться утверждение.

Несколько заданий

Ruby позволяет мне одновременно назначать несколько переменных. Когда вы начинаете, вы можете кодировать так:

def values
  [1, 2, 3]
end

one   = values[0]
two   = values[1]
three = values[2]

Но почему бы не назначить несколько переменных одновременно?

def values
  [1, 2, 3]
end

one, two, three = values

Довольно круто.

Методы, которые задают вопросы (также называемые предикатами)

Одна особенность, которая привлекла мое внимание, когда я изучал Ruby, была вопросительный знак (?) метод, также называемый **методами **предикатов. Сначала это было странно видеть, но теперь это имеет такой смысл. Вы можете написать такой код:

movie.awesome 

Хорошо… в этом нет ничего плохого. Но давайте воспользуемся знаком вопроса:

movie.awesome? 

Этот код гораздо более выразителен, и я ожидаю, что ответ метода вернет либо истинный или же ЛОЖЬ ценность.

Метод, который я обычно использую, это Любые? Это как спросить у массива, есть ли в нем Любыевещь внутри него.

[].any? 
[1, 2, 3].any? 

Интерполяция

Для меня интерполяция строк более интуитивно понятна, чем конкатенация строк. Период. Давайте посмотрим на это в действии.

Пример конкатенации строк:

programming_language = "Ruby"
programming_language + " is a beautiful programming_language" 

Пример интерполяции строк:

programming_language = "Ruby"
"#{programming_language} is a beautiful programming_language" 

Я предпочитаю интерполяцию строк.

Что вы думаете?

Оператор если

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

def hey_ho?
  true
end

puts "let’s go" if hey_ho?

Довольно приятно кодировать так.

Чувствуется действительно естественно.

Метод try (с включенным режимом Rails)

пытаться метод вызывает метод, указанный символом, передавая ему любые аргументы и/или указанный блок. Это похоже на Руби Объект#отправить. В отличие от этого метода, ноль будет возвращен, если принимающий объект является ноль объект или НилКласс.

С использованием если и если заявление условия:

user.id unless user.nil?

Используя метод **попробовать**:

user.try(:id)

Начиная с Ruby 2.3, мы можем использовать оператор безопасной навигации Ruby** (&.)** вместо метода Rails **try **.

user&.id

Двойная вертикальная черта равна (||=)/запоминание

Эта функция настолько ПРОХЛАДНАЯ. Это похоже на кэширование значения в переменной.

some_variable ||= 10
puts some_variable 

some_variable ||= 99
puts some_variable 

Вам не нужно использовать если заявление когда-либо. Просто используйте double pipe equals (||=) и это сделано.

Просто и легко.

Статический метод класса

Один из способов написания классов Ruby — это определение **статического **метода (метода класса).

GetSearchResult.call(params)

Простой. Красивый. Интуитивно понятный.

Что происходит на заднем плане?

class GetSearchResult
  def self.call(params)
    new(params).call
  end

  def initialize(params)
    @params = params
  end

  def call
    
  end
end

автовызов метод инициализирует экземпляр, и этот объект вызывает метод **call **. Шаблон проектирования интерактора использует его.

Геттеры и сеттеры

Для того же Получитьрезультат поиска class, если мы хотим использовать параметры, мы можем использовать @params

class GetSearchResult
  def self.call(params)
    new(params).call
  end

  def initialize(params)
    @params = params
  end

  def call
    
    @params 
  end
end

Мы определяем **сеттер **и геттер:

class GetSearchResult
  def self.call(params)
    new(params).call
  end

  def initialize(params)
    @params = params
  end

  def call
    
    params 
  end

  private

  def params
    @params
  end

  def params=(parameters)
    @params = parameters
  end
end

Или мы можем определить attr_reader, автор_атрибута, или же attr_accessor

class GetSearchResult
  attr_reader :param

  def self.call(params)
    new(params).call
  end

  def initialize(params)
    @params = params
  end

  def call
    
    params 
  end
end

Хороший.

Нам не нужно определять добытчик а также сеттер методы. Просто код стал проще, как раз то, что нам нужно.

Нажмите

Представьте, что вы хотите определить Создать пользователя метод. Этот метод создаст экземпляр, установит параметры, сохранит и вернет пользователя.

Давай сделаем это.

def create_user(params)
  user       = User.new
  user.id    = params[:id]
  user.name  = params[:name]
  user.email = params[:email]
  
  user.save
  user
end

Простой. Здесь нет ничего плохого.

Итак, теперь давайте реализуем это с помощью нажмите метод

def create_user(params)
  User.new.tap do |user|
    user.id    = params[:id]
    user.name  = params[:name]
    user.email = params[:email]
    
    user.save
  end
end

Вам просто нужно беспокоиться о пользовательских параметрах, и нажмите метод вернет вам пользовательский объект.

Вот и все

Мы узнали, что я пишу идиоматический Ruby, кодируя с помощью

Мы также узнали, насколько красивый и интуитивно понятный Ruby работает еще быстрее.

И все, ребята! Я буду обновлять и включать более подробную информацию в мой блог. Идея состоит в том, чтобы поделиться отличным контентом, а сообщество помогает улучшить этот пост! ☺

Я надеюсь, что вы, ребята, оцените содержание и научились программировать красивый код (и лучшее программное обеспечение).

Если вы хотите пройти полный курс Ruby, изучить реальные навыки программирования и создавать проекты, попробуйте Один месяц Ruby Bootcamp. Увидимся там ☺

Этот пост появился первым здесь на моем Публикация «Ренессанс Девелопер».

Получайте удовольствие, продолжайте учиться и всегда продолжайте программировать!

Мой Середина, Твиттер, Гитхаб & LinkedIn. ☺

Похожие записи

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *