Введение в Ruby, настоящий объектно-ориентированный язык программирования

Ruby — это объектно-ориентированный серверный язык сценариев общего назначения. Первоначальной целью Ruby было создание настоящего объектно-ориентированного языка сценариев, которого в то время, по мнению создателя Ruby, Юкихиро «Маца» Мацумото, не существовало. Этот язык также был разработан, чтобы быть простым и легким в использовании, с объектной системой в качестве ядра языка, а не реализованной как просто функция языка. Это означает, что все в языке является объектом, и каждый объект может быть изменен. Это дает программисту возможность расширять поведение базового языка. Из-за этой простоты Ruby ориентирован на использование и точку зрения разработчика, а не системы, с которой он работает. Ruby допускает «простой в реализации» синтаксис, сохраняя при этом объектно-ориентированную архитектуру программирования. Ruby — это динамический язык, поэтому в нем нет системы типов, хотя ее можно реализовать с помощью RBS, который является более современной системой типизации, похожей на TypeScript.

«Люди разные. Люди выбирают разные критерии. Но если среди многих альтернатив есть лучший способ, я хочу поощрять его, делая его удобным. Вот что я пытался сделать». -Юкихиро Мацумото

Этот блог будет посвящен синтаксису Ruby, поэтому мы начнем с обсуждения ключевого слова «puts», которое выведет ваши данные на консоль. В качестве альтернативы вы также можете использовать ключевое слово «печать», и оно будет вести себя аналогично.

Комментарии и переменные, а также запись в консоль:

puts "Hey"     # prints => Hey
print "Planet" # prints => Planet!! 
puts "!!"

Вы можете инициировать комментарий с помощью символа «#» для однострочного комментария или «=begin» и «=end» для многострочного комментария.

# this is a single line comment 
=begin
this
is a 
multiple line comment
=end

Для переменных соглашение об именах чувствительно к регистру и может начинаться с букв или «_», а затем они могут включать буквы, цифры или другое «_». Основное соглашение гласит, что нужно начинать со слова в нижнем регистре, затем все дополнительные слова также пишутся в нижнем регистре, а затем каждое из них отделяется символом подчеркивания. Ключевого слова для переменной нет, но если вам нужна константа, вы можете написать переменную заглавными буквами, а если вам нужна глобальная переменная, вы можете обозначить ее знаком доллара.

my_example_variable

Существуют приемы приведения и преобразования простых типов данных с использованием методов «.to_i», «.to_f» и «.to_s», которые означают «в целое», «в плавающую» и «в строку» соответственно. . Это известно как литье и преобразование. Это работает, потому что каждое значение в Ruby считается «экземпляром» объекта, поэтому вы можете связывать методы с этими значениями для управления этими объектами.

 puts 3.14.to_i # to INT # prints => 3
 puts 3.to_f # to float  # prints => 3.0
 puts 3.0.to_s # to string # prints => 3.0

Строки:

Строки в ruby ​​имеют нулевой индекс и записываются в кавычках, их можно сохранять в переменную и манипулировать ими разными способами, будь то доступ к строковым символам или методы, встроенные в Ruby.

greeting = "howdy"
#indexed:   01234
puts greeting.length  # prints => 5
puts greeting[0]      # prints => h
puts greeting.include? "dy" # prints => true
puts greeting.include? "r"  # prints => false
puts greeting[1,3] # prints => owd
#first number is starting index and the second is the length of #chars you wanna grab

Как вы можете видеть выше, мы нашли длину строки, используя ее свойство «.length». Мы можем получить доступ к индексу через скобки. «.include?» метод вернет логическое значение в зависимости от того, введены ли следующие символы после «?» присутствуют в строке или нет. С помощью скобочной нотации мы также можем получить доступ к индексу с первой позиции, а второе переданное число будет обозначать, сколько дополнительных символов нужно включить в вывод.

Номера:

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

puts 2 * 3 # prints => 6
puts 2**3 # prints => 8
puts 31 % 3 # prints => 1

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

num = -40.8
puts num.abs()  # prints => 40.8
puts num.round() # prints => 40
puts Math.log(0) # prints => -Infinity
puts Math.sqrt(144) # prints => 12

Существует классический синтаксис стиля «+=», который добавит любое значение к текущему значению, как если бы это значение уже существовало на этой стороне операнда.

num = 30
num += 20 
puts num # prints => 50

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

Массивы:

Массивы в Ruby ведут себя очень похоже на другие скриптовые языки, в том смысле, что они имеют нулевой индекс, а доступ к значениям массивов можно получить с помощью записи в квадратных скобках. Существуют также встроенные методы, такие как «.push», которые можно использовать для управления массивами и их значениями. Вы даже можете получить доступ к значениям в каждом индексе или к нескольким различным индексированным значениям с помощью обозначения скобок.

animals = []
animals.push("walrus")
animals.push("falcon")
animals.push("panda")
puts animals  # prints => walrus falcon panda 
puts animals.reverse # prints => panda falcon walrus
puts animals.sort # prints => panda falcon walrus
puts animals.include? "walrus" # prints => true
puts animals[0] # prints => walrus
animals.push(5)
puts animals[1..5] # prints => falcon panda 5

Работа с массивами в Ruby проста в реализации и эффективна для вашей программы. Если вы пришли из языка программирования, такого как JavaScript, большая часть манипуляций с массивами будет для вас очень похожей.

Пользовательский ввод:

Пользовательский ввод — это когда вы хотите, чтобы пользователь ввел что-то в ваше приложение, чтобы ваша программа отреагировала на это. Ключевое слово gets является ключевым для этого типа поведения в Ruby. Использование этого ключевого слова, связанного с переменной, предложит пользователю ввести значение в поле, указанное разработчиком, и все, что будет введено, программа сохранит в переменной, на которую воздействует ключевое слово «gets». Это ключевое слово «gets» добавляет в вашу программу некоторые встроенные динамические функции.

Функции:

Функции в Ruby объявляются с помощью ключевого слова «def», а затем имени, за которым следуют его параметры. Ключевое слово end указывает на закрытие тела функции, а тело содержит желаемую функциональность внутри, а также все необходимые возвраты для результата.

def add_nums(num1, num2=45)
    return num1 + num2
end
sum = add_nums(4, 10)
puts sum # prints => 40

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

Условные:

Условные операторы будут выполнять определенные строки кода в Ruby на основе логического значения, в которое разрешается условие. Вы можете инициировать их с помощью ключевого слова «если» и в скобках указать условие, которое вы хотите проверить. Вы также можете использовать «elsif» и «else», чтобы связать эти условия вместе.

is_cool = true
is_smart = true
if (is_cool and is_smart)
  puts "You are Royce"
elsif is_cool and !is_smart
  puts "You are a computer"
else
  puts "You are somethin else"
end
# prints You are Royce

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

Объекты и классы:

На самом деле все считается объектом в Ruby, поскольку это полностью интегрированный объектно-ориентированный язык программирования. Примитивные типы данных на самом деле не существуют внутри, даже если они являются объектами.

class Show
  attr_accessor :title, :creator
def watchShow()
    puts "Watching #{self.title} created by #{self.creator}"
  end
end
movie1 = Show.new()
movie1.title = "Twin Peaks"
movie1.creator = "David Lynch"
movie1.watchShow() # prints => Watching Twin Peaks created by David                       #                                                              Lynch
puts movie1.title  # prints => Twin Peaks

Итак, мы инициируем класс с помощью ключевого слова «класс», а затем имени указанного класса. Определение атрибутов выполняется с помощью «attr_accessor», за которым следуют атрибуты, которые вы хотите добавить в свой класс. Эти атрибуты требуют двоеточия перед ними и разделяются запятой. Затем у нас есть определенный метод класса, в котором используется ключевое слово «я», чтобы обозначить, что мы действуем на атрибут в этом блоке классов. Затем мы можем присвоить значения этим атрибутам после запуска нового экземпляра класса Show, который мы создали, а затем вызвать любые методы или атрибуты, чтобы увидеть, что мы сконструировали.

Это большая часть основ, за исключением циклов, словарей и нескольких других ключевых вещей, к которым я, возможно, вернусь и добавлю позже. Это должно дать каждому хорошее представление о том, с чего начать создание приложения с использованием Ruby в любом качестве. Этот упрощенный язык очень мощный, особенно благодаря знаменитому фреймворку «Ruby on Rails», который придает языку еще большую модульность.

Источники: